diff --git a/.cspell.json b/.cspell.json
new file mode 100644
index 000000000..0e6951f02
--- /dev/null
+++ b/.cspell.json
@@ -0,0 +1,98 @@
+{
+  "version": "0.2",
+  "language": "en",
+  "words": [
+    "autofocused",
+    "behaviour",
+    "behaviours",
+    "Behaviour",
+    "cacheable",
+    "Cantarell",
+    "chainer",
+    "Chainer",
+    "chatbots",
+    "childs",
+    "codexteam",
+    "colspan",
+    "constructables",
+    "contenteditable",
+    "Contenteditable",
+    "contentless",
+    "Contentless",
+    "convertable",
+    "Convertable",
+    "convertible",
+    "Convertible",
+    "cssnano",
+    "cssnext",
+    "Debouncer",
+    "devserver",
+    "editorjs",
+    "Editorjs",
+    "entrypoints",
+    "Flippable",
+    "flippable",
+    "GRAMMARLY",
+    "Gfycat",
+    "hsablonniere",
+    "hspace",
+    "intellij",
+    "keydown",
+    "keydowns",
+    "Kilian",
+    "leftarrow",
+    "licence",
+    "mergeable",
+    "movetostart",
+    "mouseleave",
+    "navigatable",
+    "nofollow",
+    "opencollective",
+    "preconfigured",
+    "radiobutton",
+    "resetors",
+    "rowspan",
+    "Segoe",
+    "selectall",
+    "sometool",
+    "strongs",
+    "stylelint",
+    "textareas",
+    "toolname",
+    "twitterwidget",
+    "typeof",
+    "UPLUCID",
+    "Unmergeable",
+    "rgba",
+    "Roboto",
+    "Fira",
+    "Neue",
+    "grayscale",
+    "Menlo",
+    "Consolas",
+    "viewports",
+    "sonarjs",
+    "Unregisters",
+    "IAPI",
+    "Jamison",
+    "Minzipped",
+    "srcset",
+    "youtu",
+    "Dont",
+    "CONTENTLESS",
+    "autofocusable",
+    "Pettit"
+  ],
+  "ignorePaths": [
+    "dist/**",
+    "node_modules/**",
+    "test-results/**",
+    "cypress/downloads/**"
+  ],
+  "flagWords": [],
+  "ignoreRegExpList": [
+    "/[\\u0080-\\uFFFF]+/",
+    "/\"[A-Za-z0-9]{8,}\"/"
+  ]
+}
+
diff --git a/.cursor/rules/do-not-modify-configs.mdc b/.cursor/rules/do-not-modify-configs.mdc
new file mode 100644
index 000000000..bc24d21d1
--- /dev/null
+++ b/.cursor/rules/do-not-modify-configs.mdc
@@ -0,0 +1,23 @@
+---
+alwaysApply: true
+---
+
+# Rule: DO NOT MODIFY configuration files unless explicitly instructed
+
+## Description
+You MUST **never modify any configuration files** (such as `vite.config.ts`, `tsconfig.json`, `.eslintrc`, `package.json`, `.env`, etc.) **unless explicitly told to do so** in the current request or accompanying instructions.
+
+## Examples
+
+✅ **Allowed**
+- Editing TypeScript source files, tests, or component code.
+- Updating imports, logic, or styles within non-config files.
+- Adding configuration changes **only when explicitly requested** (e.g., “Add a new alias in `vite.config.ts`”).
+
+❌ **Not Allowed**
+- Modifying or creating any config files without explicit instruction.
+- Automatically adding dependencies or changing build/test settings.
+- Altering environment variables or global project settings without being told to.
+
+## Enforcement
+If you believe a configuration change might be required, **ask for confirmation first** before proceeding.
diff --git a/.cursor/rules/fix-problems.mdc b/.cursor/rules/fix-problems.mdc
new file mode 100644
index 000000000..2964987d1
--- /dev/null
+++ b/.cursor/rules/fix-problems.mdc
@@ -0,0 +1,23 @@
+---
+alwaysApply: true
+---
+
+# Fix Problems Policy
+
+## Core Principle
+VERY IMPORTANT: When encountering ANY problem in the code—such as TypeScript errors, linting issues, runtime bugs, accessibility violations, or performance problems—you or any other problem MUST find a proper way to fix it. Do NOT silence, suppress, or avoid the problem using workarounds like `// @ts-ignore`, `any` types, or ignoring linter warnings.
+
+## Preferred Approaches
+- **Refactor for correctness**: Resolve issues by improving the code structure, using precise types, type guards, proper error handling, and best practices.
+- **Investigate root causes**: Use tools like debugging, logging, or code searches to understand why the problem occurs before fixing it.
+- **Align with existing rules**: Follow related policies such as the Fix TypeScript Errors Policy (adapt for other languages), ESLint configurations, and accessibility guidelines.
+- **Test the fix**: After fixing, verify with tests, linting runs (e.g., `yarn lint:fix`), or manual checks to ensure the problem is truly resolved without introducing new issues.
+
+## When to Apply
+- During any code editing, reviewing, or generation task.
+- Proactively scan for and fix problems in affected files using available tools (e.g., read_lints, grep, codebase_search).
+- If a problem persists after reasonable efforts, document it clearly and suggest next steps rather than suppressing it.
+
+## Notes
+- This policy promotes robust, high-quality code that is easier to maintain and less prone to future issues.
+- If unsure how to fix a problem, use tools to gather more information or break it into smaller, solvable parts rather than bypassing it.
diff --git a/.cursor/rules/src/frontend/accessibility.mdc b/.cursor/rules/src/frontend/accessibility.mdc
new file mode 100644
index 000000000..085ff843e
--- /dev/null
+++ b/.cursor/rules/src/frontend/accessibility.mdc
@@ -0,0 +1,119 @@
+---
+alwaysApply: true
+description: Enforce accessibility best practices so all users can use the application
+---
+
+### Accessibility guidance (must follow)
+
+- Semantics first
+  - Prefer semantic HTML (`button`, `a`, `nav`, `main`, `header`, `footer`, `ul/ol/li`, `table/th/td`) over generic `div`/`span`.
+  - Use `button` for actions and `a`/`Link` for navigation. Do not use click handlers on non-interactive elements. If unavoidable, add `role="button"`, `tabIndex={0}`, and keyboard handlers for Enter/Space.
+
+- Keyboard support
+  - All interactive controls must be reachable via Tab and operable via keyboard.
+  - Do not remove focus outlines. If customizing, ensure visible `:focus-visible` styles with sufficient contrast.
+  - Preserve a logical tab order; avoid `tabIndex` > 0.
+
+- Focus management
+  - On opening modals/drawers/popovers: move focus inside, trap focus, and restore focus to the trigger on close.
+  - Provide a skip link to main content (e.g., `href="#main"`) and landmark roles (`<main>`, `<nav>`, `<header>`, `<footer>`).
+
+- Images and media
+  - Every `img` must have an appropriate `alt`. If decorative, use `alt=""` and `aria-hidden="true"`.
+  - Provide captions/subtitles for video/audio when applicable.
+  - For lazy-loaded images with skeletons, mark skeletons `aria-hidden="true"` and set container `aria-busy` while loading.
+
+- Forms
+  - Inputs require visible labels bound via `<label htmlFor>` or `aria-label`/`aria-labelledby`.
+  - Indicate errors with `aria-invalid` and associate helper/error text via `aria-describedby`.
+
+- Live updates and async content
+  - For dynamic status (loading/completion), use `aria-live="polite"` (or `assertive` if critical).
+  - Spinners should have `aria-label` or be hidden (`aria-hidden="true"`) with a separate live region announcing status.
+
+- Headings and structure
+  - Maintain a logical heading hierarchy without skipping levels.
+  - Use list semantics for collections.
+
+- Color and contrast
+  - Ensure WCAG 2.1 AA contrast: 4.5:1 for normal text and 3:1 for large or bold text and UI components, including focus and hover states. When placing text over images, add an overlay or background.
+  - Do not convey information by color alone; add icons/text.
+
+- Motion and reduced motion
+  - Respect `prefers-reduced-motion: reduce`. Disable or simplify non-essential animations.
+  - In React animations, gate effects with `gsap.matchMedia('(prefers-reduced-motion: no-preference)')` and provide a reduced-motion path.
+  - Example usage exists in [AnnouncementsFeedContent.tsx](mdc:src/frontend/src/features/AnnouncementsFeed/ui/AnnouncementsFeedContent.tsx).
+  - Vanilla CSS example using the `prefers-reduced-motion` media query:
+
+```css
+/* Default animations */
+.card {
+  transition: transform 300ms ease, opacity 300ms ease;
+}
+.card:hover {
+  transform: translateY(-4px);
+  opacity: 0.95;
+}
+
+/* Reduced motion: remove transforms and long transitions */
+@media (prefers-reduced-motion: reduce) {
+  * {
+    animation: none !important;
+    transition-duration: 0.01ms !important; /* effectively no transition */
+    scroll-behavior: auto !important;
+  }
+  .card:hover {
+    transform: none;
+    opacity: 1;
+  }
+}
+```
+
+- Tables and data
+  - Use `<th scope>` for headers, provide captions when helpful. Avoid layout tables.
+
+- Testing
+  - Prefer `@testing-library` queries by role/name (`getByRole`, `getByLabelText`) to reflect real accessibility.
+
+### React implementation tips
+
+- Announce route changes by updating `document.title` and placing page content in a `<main id="main">` region.
+- When building composite widgets (tabs, accordions), follow the relevant ARIA patterns (roles, `aria-selected`, `aria-controls`) only when semantics are not achievable with native elements.
+- For card components that wrap links, ensure the entire card is a single focusable link (as with `Link`) and include descriptive link text or `aria-label` if needed.
+
+### Code patterns
+
+```tsx
+// Accessible button vs. link
+<button type="button" onClick={handleAction}>Do action</button>
+<Link to="/path">Go to details</Link>
+
+// Custom interactive element (only if you cannot use <button>)
+<div
+  role="button"
+  tabIndex={0}
+  onKeyDown={(e) => {
+    const isEnter = e.key === 'Enter' || e.code === 'Enter';
+    const isSpace = e.key === ' ' || e.key === 'Spacebar' || e.code === 'Space';
+
+    if (isEnter) {
+      onClick();
+    }
+    if (isSpace) {
+      e.preventDefault();
+    }
+  }}
+  onKeyUp={(e) => {
+    const isSpace = e.key === ' ' || e.key === 'Spacebar' || e.code === 'Space';
+    if (isSpace) {
+      onClick();
+    }
+  }}
+  onClick={onClick}
+/>
+```
+
+### Notes
+
+- Use ARIA to enhance semantics, not replace them. Avoid redundant roles on native elements.
+- If a component is purely decorative (e.g., background clouds), set `aria-hidden="true"` and remove from the tab order.
diff --git a/.cursor/rules/src/frontend/code-style-eslint.mdc b/.cursor/rules/src/frontend/code-style-eslint.mdc
new file mode 100644
index 000000000..578bce50c
--- /dev/null
+++ b/.cursor/rules/src/frontend/code-style-eslint.mdc
@@ -0,0 +1,27 @@
+---
+title: Frontend ESLint Code Style
+alwaysApply: true
+description: Defer all code style decisions to the project's ESLint configuration; do not invent new style rules
+---
+
+### Code Style Source of Truth
+
+- **Always defer to ESLint configuration** for any code style, formatting, or lint rules.
+- **Do not create or enforce custom style rules** beyond what ESLint (and its plugins) already defines in this repo.
+
+### Where the rules live
+
+- Frontend config: [eslint.config.js](mdc:src/frontend/eslint.config.js)
+- AppShell config: [.eslintrc.js](mdc:src/Dodo.KnowledgeBase.Web/appshell/.eslintrc.js)
+
+### How to apply
+
+- When unsure about style (imports order, quote style, indentation, prop ordering, hooks rules, etc.), consult the ESLint configs above and follow them as-is.
+- Prefer using the repo scripts to validate/fix:
+  - `yarn lint`
+  - `yarn lint:fix`
+
+### Notes
+
+- If ESLint and Prettier interact, follow the ESLint-integrated Prettier setup from the configs.
+- For styles-in-JS (e.g., styled-components), follow any ESLint plugin guidance present; do not invent property ordering rules.
diff --git a/.cursor/rules/src/frontend/fix-typescript-errors.mdc b/.cursor/rules/src/frontend/fix-typescript-errors.mdc
new file mode 100644
index 000000000..83b32b715
--- /dev/null
+++ b/.cursor/rules/src/frontend/fix-typescript-errors.mdc
@@ -0,0 +1,22 @@
+---
+alwaysApply: true
+globs: *.ts,*.tsx
+description: Enforce fixing TypeScript errors by improving code quality, not suppressing them
+---
+
+# Fix TypeScript Errors Policy
+
+- **Core Principle**: Always resolve TypeScript errors by refactoring code to be type-safe, rather than suppressing them with `any`, `// @ts-ignore`, or similar workarounds.
+- **Preferred Approaches**:
+  - Use precise types, type guards, discriminated unions, and proper narrowing to eliminate errors.
+  - Avoid the non-null assertion operator (`!`) and `any` types as per project guidelines.
+  - Refactor functions, components, and logic to align with TypeScript's type system.
+- **When to Apply**:
+  - For any TypeScript files (`.ts`, `.tsx`), prioritize fixing errors during edits.
+  - After making changes, run `yarn lint:fix` or similar commands to ensure compliance.
+- **Alignment with Existing Rules**:
+  - This reinforces the ESLint Fix-First Policy: Fix issues flagged by TypeScript/ESLint by improving code, not silencing linters.
+  - Ensure accessibility and best practices are maintained while resolving types.
+- **Notes**:
+  - If a TypeScript error persists after reasonable refactoring, consult the ESLint configuration or seek clarification on intended behavior, but do not suppress it locally.
+  - Promote code that is both type-safe and adheres to React/JS best practices.
diff --git a/.cursor/rules/src/frontend/frontend-simplicity.mdc b/.cursor/rules/src/frontend/frontend-simplicity.mdc
new file mode 100644
index 000000000..e652a2ba1
--- /dev/null
+++ b/.cursor/rules/src/frontend/frontend-simplicity.mdc
@@ -0,0 +1,69 @@
+---
+alwaysApply: true
+globs: "*.ts","*.tsx","*.js","*.jsx","src/frontend/**"
+description: "Frontend development principle: Keep solutions simple and avoid overengineering"
+---
+
+# Frontend Simplicity Principle
+
+When working on frontend tasks, prioritize simple, straightforward solutions over complex implementations.
+
+## Guidelines
+
+### Keep it simple
+- **Prefer basic approaches**: Choose standard patterns over custom abstractions unless there's a clear benefit
+- **Avoid premature optimization**: Don't add complexity for performance gains that haven't been measured
+- **Use existing libraries**: Leverage well-established libraries rather than building custom solutions
+
+### Component design
+- **Single responsibility**: Components should do one thing well
+- **Avoid deep nesting**: Keep component trees shallow and manageable
+- **Prefer composition over inheritance**: Use composition patterns for reusable behavior
+
+### State management
+- **Local state first**: Use local component state before reaching for global state management
+- **Simple patterns**: Prefer useState/useReducer over complex state machines unless necessary
+- **Avoid over-abstraction**: Don't create unnecessary abstractions for simple state logic
+
+### Code organization
+- **Clear naming**: Use descriptive names that explain the purpose
+- **Minimal files**: Avoid splitting simple features across multiple files
+- **Straightforward logic**: Write code that's easy to follow and debug
+
+### When complexity is justified
+Only add complexity when:
+- It solves a measured performance problem
+- It significantly improves user experience
+- It enables critical functionality
+- The team agrees it's necessary
+
+## Examples
+
+```tsx
+// ✅ Simple and clear
+const UserProfile = ({ user }) => {
+  const [isEditing, setIsEditing] = useState(false);
+
+  return (
+    <div>
+      <h2>{user.name}</h2>
+      {isEditing ? (
+        <EditForm onSave={() => setIsEditing(false)} />
+      ) : (
+        <button onClick={() => setIsEditing(true)}>Edit</button>
+      )}
+    </div>
+  );
+};
+
+// ❌ Overcomplicated
+const UserProfile = ({ user }) => {
+  const [state, dispatch] = useReducer(profileReducer, initialProfileState);
+  const editingContext = useContext(EditingContext);
+  const formManager = useFormManager();
+
+  // Complex logic that could be simplified...
+};
+```
+
+Remember: Code is read more than it's written. Choose the solution that future developers can understand quickly.
diff --git a/.cursor/rules/src/frontend/lint-fix-policy.mdc b/.cursor/rules/src/frontend/lint-fix-policy.mdc
new file mode 100644
index 000000000..3001cc45c
--- /dev/null
+++ b/.cursor/rules/src/frontend/lint-fix-policy.mdc
@@ -0,0 +1,24 @@
+---
+alwaysApply: true
+description: Policy for handling ESLint issues by preferring autofix with yarn lint:fix
+---
+
+# Lint Fix Policy
+
+When encountering ANY ESLint problem:
+
+## Core Steps
+1. **ALWAYS try autofix first**: Run `yarn lint:fix` (or the equivalent command for the subproject) to automatically resolve the issue.
+   - For frontend: From the workspace root, run `cd packages/frontend && yarn lint:fix`
+   - If targeting specific files: `cd packages/frontend && yarn eslint "path/to/file.tsx" --fix`
+
+2. **ONLY manual fix if autofix fails**: If `yarn lint:fix` does not resolve the issue, manually edit the code to comply with ESLint rules.
+   - Defer to the ESLint configuration as the source of truth: [eslint.config.js](mdc:eslint.config.js) for frontend.
+   - Do not invent custom style rules; follow ESLint and integrated Prettier setups exactly.
+   - After manual fixes, re-run `yarn lint` to verify resolution.
+
+## Notes
+- Prefer `yarn lint:fix` over ad-hoc formatting to ensure consistency.
+- If ESLint interacts with Prettier, let ESLint enforce the rules.
+- For uncertainty, consult ESLint configs before manual changes.
+- Proactively use this during code edits, reviews, or generations to maintain high-quality code.
diff --git a/.cursor/rules/test/e2e-best-practices.mdc b/.cursor/rules/test/e2e-best-practices.mdc
new file mode 100644
index 000000000..18a5122ec
--- /dev/null
+++ b/.cursor/rules/test/e2e-best-practices.mdc
@@ -0,0 +1,37 @@
+---
+alwaysApply: true
+globs: tests/**/*.spec.ts,tests/**/*.ts
+description: Playwright end-to-end testing patterns and expectations
+---
+# Playwright E2E Tests
+
+- **Use shared fixtures**
+  - Import `test`/`expect` from `[fixtures.ts](mdc:tests/Dodo.KnowledgeBase.Ui/fixtures/fixtures.ts)` so page objects, API helpers, and auth utilities stay consistent.
+  - Prefer the `storedCookies` fixture when a test needs an authenticated context to avoid duplicate login work.
+
+- **Lean on helpers and page objects**
+  - Reuse the page-object classes in `[pages/](mdc:tests/Dodo.KnowledgeBase.Ui/pages)` for interactions; add new methods there instead of ad-hoc selectors in specs.
+  - Wrap navigation, assertions, and Allure metadata with `test.step` via `[utils/helpers.ts](mdc:tests/Dodo.KnowledgeBase.Ui/utils/helpers.ts)` for richer reporting.
+
+- **Prefer resilient, accessible locators**
+  - Target elements by role, label, or text when possible (e.g., `page.getByRole('button', { name: '...' })`) before falling back to CSS/XPath.
+  - Mirror the app’s accessibility requirements—favor semantic selectors over brittle DOM structure hooks.
+
+- **Keep tests focused and deterministic**
+  - Scope each spec to a single feature/flow; move common setup into `test.beforeEach` blocks using helpers.
+
+- **Leverage configuration**
+  - Align new suites with existing Playwright projects defined in `[playwright.config.ts](mdc:playwright.config.ts)`; extend `testMatch` rather than spinning up new configs.
+  - Respect shared `use` options (locale, screenshots, traces) to keep reports uniform.
+
+- **AVOID using mocks unless it's necessary**
+  - When writing tests prefer actual data instead of using mocks to test actual behavior.
+
+- **Do not @allure.id to tests**
+  - Adding @allure.id is handled on the user's side DO NOT add it yourself.
+
+- **Document Allure hierarchy**
+  - Call `Helpers.addAllureHierarchy` at suite setup (see `[auth-tests.spec.ts](mdc:tests/Dodo.KnowledgeBase.Ui/auth-tests.spec.ts)`) so new tests appear correctly in TestOps.
+
+- **Running locally**
+  - Follow the workflow in `[README.md](mdc:README.md#L51)` (`yarn --cwd src/frontend serve` + `yarn e2e:ui`) when validating new specs.
diff --git a/.eslintignore b/.eslintignore
index 54958dac1..26fcd56bf 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -2,3 +2,4 @@ node_modules
 *.d.ts
 src/components/tools/paragraph
 src/polyfills.ts
+dist
diff --git a/.eslintrc b/.eslintrc
deleted file mode 100644
index 4504754c2..000000000
--- a/.eslintrc
+++ /dev/null
@@ -1,58 +0,0 @@
-{
-  "extends": [
-    "codex/ts"
-  ],
-  "globals": {
-    "Node": true,
-    "Range": true,
-    "HTMLElement": true,
-    "HTMLDivElement": true,
-    "Element": true,
-    "Selection": true,
-    "SVGElement": true,
-    "Text": true,
-    "InsertPosition": true,
-    "PropertyKey": true,
-    "MouseEvent": true,
-    "TouchEvent": true,
-    "KeyboardEvent": true,
-    "ClipboardEvent": true,
-    "DragEvent": true,
-    "Event": true,
-    "EventTarget": true,
-    "Document": true,
-    "NodeList": true,
-    "File": true,
-    "FileList": true,
-    "MutationRecord": true,
-    "AddEventListenerOptions": true,
-    "DataTransfer": true,
-    "DOMRect": true,
-    "ClientRect": true,
-    "ArrayLike": true,
-    "InputEvent": true,
-    "unknown": true,
-    "requestAnimationFrame": true,
-    "navigator": true
-  },
-  "rules": {
-    "jsdoc/require-returns-type": "off",
-    "@typescript-eslint/strict-boolean-expressions": "warn",
-    "@typescript-eslint/consistent-type-imports": "error",
-    "@typescript-eslint/consistent-type-exports": "error"
-  },
-  "overrides": [
-    {
-      "files": [
-        "tsconfig.json",
-        "package.json",
-        "tsconfig.*.json",
-        "tslint.json"
-      ],
-      "rules": {
-        "quotes": [1, "double"],
-        "semi": [1, "never"],
-      }
-    }
-  ]
-}
diff --git a/.gitignore b/.gitignore
index 150d50708..e5c4b0391 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,12 +9,13 @@ node_modules/*
 
 npm-debug.log
 yarn-error.log
+.yarn/install-state.gz
 
-test/cypress/screenshots
-test/cypress/videos
+test-results
 
 dist/
 
 coverage/
 .nyc_output/
 .vscode/launch.json
+jscpd-report/
diff --git a/.jscpdrc.json b/.jscpdrc.json
new file mode 100644
index 000000000..d10f6dfc0
--- /dev/null
+++ b/.jscpdrc.json
@@ -0,0 +1,24 @@
+{
+  "threshold": 0,
+  "reporters": ["console", "html", "json"],
+  "ignore": [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/test-results/**",
+    "**/cypress/downloads/**",
+    "**/*.d.ts",
+    "**/yarn.lock",
+    "**/package-lock.json",
+    "**/.git/**"
+  ],
+  "format": [
+    "typescript",
+    "javascript",
+    "css"
+  ],
+  "minLines": 5,
+  "minTokens": 50,
+  "absolute": true,
+  "output": "./jscpd-report"
+}
+
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 5d01b0ef3..eeb501949 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,41 +1,17 @@
 {
-    "cSpell.words": [
-      "autofocused",
-      "Behaviour",
-      "cacheable",
-      "childs",
-      "codexteam",
-      "colspan",
-      "contenteditable",
-      "contentless",
-      "Convertable",
-      "cssnano",
-      "cssnext",
-      "Debouncer",
-      "devserver",
-      "editorjs",
-      "entrypoints",
-      "Flippable",
-      "GRAMMARLY",
-      "hsablonniere",
-      "intellij",
-      "keydown",
-      "keydowns",
-      "Kilian",
-      "mergeable",
-      "movetostart",
-      "nofollow",
-      "opencollective",
-      "preconfigured",
-      "resetors",
-      "rowspan",
-      "selectall",
-      "sometool",
-      "stylelint",
-      "textareas",
-      "twitterwidget",
-      "typeof",
-      "Unmergeable",
-      "viewports"
-    ]
+  "eslint.enable": true,
+  "eslint.validate": [
+    "javascript",
+    "javascriptreact",
+    "typescript",
+    "typescriptreact"
+  ],
+  "eslint.workingDirectories": [{ "mode": "auto" }],
+  "typescript.tsdk": "node_modules/typescript/lib",
+  "typescript.enablePromptUseWorkspaceTsdk": true,
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "always"
+  },
+  "eslint.useFlatConfig": true,
+
 }
diff --git a/.yarnrc.yml b/.yarnrc.yml
new file mode 100644
index 000000000..3186f3f07
--- /dev/null
+++ b/.yarnrc.yml
@@ -0,0 +1 @@
+nodeLinker: node-modules
diff --git a/cypress.config.ts b/cypress.config.ts
deleted file mode 100644
index 58f69cfe7..000000000
--- a/cypress.config.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { defineConfig } from 'cypress';
-import path from 'node:path';
-import vitePreprocessor from 'cypress-vite';
-
-export default defineConfig({
-  env: {
-    NODE_ENV: 'test',
-  },
-  fixturesFolder: 'test/cypress/fixtures',
-  screenshotsFolder: 'test/cypress/screenshots',
-  video: false,
-  videosFolder: 'test/cypress/videos',
-  e2e: {
-    // We've imported your old cypress plugins here.
-    // You may want to clean this up later by importing these.
-    setupNodeEvents(on, config) {
-      on('file:preprocessor', vitePreprocessor({
-        configFile: path.resolve(__dirname, './vite.config.test.js'),
-      }));
-
-      /**
-       * Plugin for cypress that adds better terminal output for easier debugging.
-       * Prints cy commands, browser console logs, cy.request and cy.intercept data. Great for your pipelines.
-       * https://github.com/archfz/cypress-terminal-report
-       */
-      require('cypress-terminal-report/src/installLogsPrinter')(on);
-
-      require('@cypress/code-coverage/task')(on, config);
-    },
-    specPattern: 'test/cypress/tests/**/*.cy.{js,jsx,ts,tsx}',
-    supportFile: 'test/cypress/support/index.ts',
-  },
-  'retries': {
-    // Configure retry attempts for `cypress run`
-    'runMode': 2,
-    // Configure retry attempts for `cypress open`
-    'openMode': 0,
-  },
-});
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 7eff455e3..1ba80a3d2 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -12,7 +12,7 @@
 - `Fix` - codex-notifier and codex-tooltip moved from devDependencies to dependencies in package.json to solve type errors
 - `Fix` - Handle whitespace input in empty placeholder elements to prevent caret from moving unexpectedly to the end of the placeholder
 - `Fix` - Fix the memory leak issue in `Shortcuts` class
-- `Fix` - Fix when / overides selected text outside of the editor
+- `Fix` - Fix when / overrides selected text outside of the editor
 - `DX` - Tools submodules removed from the repository
 - `Improvement` - Shift + Down/Up will allow to select next/previous line instead of Inline Toolbar flipping
 - `Improvement` - The API `caret.setToBlock()` offset now works across the entire block content, not just the first or last node.
@@ -63,7 +63,7 @@
 - `New` – Inline Toolbar has new look 💅
 - `New` – Inline Tool's `render()` now supports [Menu Config](https://editorjs.io/menu-config/) format
 - `New` – *ToolsAPI* – All installed block tools now accessible via ToolsAPI `getBlockTools()` method
-- `New` – *SelectionAPI* – Exposed methods `save()` and `restore()` that allow to save selection to be able to temporally move focus away, methods `setFakeBackground()` and `removeFakeBackground()` that allow to immitate selection while focus moved away
+- `New` – *SelectionAPI* – Exposed methods `save()` and `restore()` that allow to save selection to be able to temporally move focus away, methods `setFakeBackground()` and `removeFakeBackground()` that allow to imitate selection while focus moved away
 - `New` – *BlocksAPI* – Exposed `getBlockByElement()` method that helps find block by any child html element
 - `New` – "Convert to" control is now also available in Block Tunes
 - `New` — Editor.js now supports contenteditable placeholders out of the box. Just add `data-placeholder` or `data-placeholder-active` attribute to make it work. The first one will work like native placeholder while the second one will show placeholder only when block is current.
@@ -85,7 +85,7 @@
 - `Fix` – Unwanted scroll on first typing on iOS devices
 - `Fix` - Unwanted soft line break on Enter press after period and space (". |") on iOS devices
 - `Fix` - Caret lost after block conversion on mobile devices.
-- `Fix` - Caret lost after Backspace at the start of block when previoius block is not convertable
+- `Fix` - Caret lost after Backspace at the start of block when previous block is not convertable
 – `Fix` — Deleting whitespaces at the start/end of the block
 - `Fix` — The problem caused by missed "import type" in block mutation event types resolved
 
diff --git a/docs/api.md b/docs/api.md
index 4c7f708de..bfde79da5 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -197,7 +197,7 @@ It makes following steps:
 
 3. Delete all properties from instance object and set it\`s prototype to `null`
 
-After executing the `destroy` method, editor inctance becomes an empty object. This way you will free occupied JS Heap on your page.
+After executing the `destroy` method, editor instance becomes an empty object. This way you will free occupied JS Heap on your page.
 
 ### Tooltip API
 
diff --git a/docs/block-tunes.md b/docs/block-tunes.md
index 6544bb956..adbb73390 100644
--- a/docs/block-tunes.md
+++ b/docs/block-tunes.md
@@ -21,7 +21,7 @@ At the constructor of Tune's class exemplar you will receive an object with foll
 
 | Parameter | Description |
 | --------- | ----------- |
-| api  | Editor's [API](api.md) obejct |
+| api  | Editor's [API](api.md) object |
 | config | Configuration of Block Tool Tune is connected to (might be useful in some cases) |
 | block | [Block API](api.md#block-api) methods for block Tune is connected to |
 | data | Saved Tune data |
diff --git a/docs/tools-inline.md b/docs/tools-inline.md
index 604a5e4c8..6ed6cae12 100644
--- a/docs/tools-inline.md
+++ b/docs/tools-inline.md
@@ -1,11 +1,11 @@
 # Tools for the Inline Toolbar
 
-Similar with [Tools](tools.md) represented Blocks, you can create Tools for the Inline Toolbar. It will work with 
+Similar with [Tools](tools.md) represented Blocks, you can create Tools for the Inline Toolbar. It will work with
 selected fragment of text. The simplest example is `bold` or `italic` Tools.
 
 ## Base structure
 
-First of all, Tool's class should have a `isInline` property (static getter) set as `true`. 
+First of all, Tool's class should have a `isInline` property (static getter) set as `true`.
 
 After that Inline Tool should implement next methods.
 
@@ -33,7 +33,7 @@ Method does not accept any parameters
 
 #### Return value
 
-type | description | 
+type | description |
 -- | -- |
 `HTMLElement` | element that will be added to the Inline Toolbar |
 
@@ -45,7 +45,7 @@ Method that accepts selected range and wrap it somehow
 
 #### Parameters
 
-name | type | description | 
+name | type | description |
 -- |-- | -- |
 range | Range | first range of current Selection |
 
@@ -61,13 +61,13 @@ Get Selection and detect if Tool was applied. For example, after that Tool can h
 
 #### Parameters
 
-name | type | description | 
+name | type | description |
 -- |-- | -- |
 selection | Selection | current Selection |
 
 #### Return value
 
-type | description | 
+type | description |
 -- | -- |
 `Boolean` | `true` if Tool is active, otherwise `false` |
 
@@ -75,8 +75,8 @@ type | description |
 
 ### renderActions()
 
-Optional method that returns additional Element with actions. 
-For example, input for the 'link' tool or textarea for the 'comment' tool. 
+Optional method that returns additional Element with actions.
+For example, input for the 'link' tool or textarea for the 'comment' tool.
 It will be places below the buttons list at Inline Toolbar.
 
 #### Parameters
@@ -85,7 +85,7 @@ Method does not accept any parameters
 
 #### Return value
 
-type | description | 
+type | description |
 -- | -- |
 `HTMLElement` | element that will be added to the Inline Toolbar |
 
@@ -93,7 +93,7 @@ type | description |
 
 ### clear()
 
-Optional method that will be called on opening/closing of Inline Toolbar. 
+Optional method that will be called on opening/closing of Inline Toolbar.
 Can contain logic for clearing Tool's stuff, such as inputs, states and other.
 
 #### Parameters
@@ -102,17 +102,17 @@ Method does not accept any parameters
 
 #### Return value
 
-Method should not return a value. 
+Method should not return a value.
 
 ### static get sanitize()
 
-We recommend to specify the Sanitizer config that corresponds with inline tags that is used by your Tool. 
-In that case, your config will be merged with sanitizer configuration of Block Tool 
+We recommend to specify the Sanitizer config that corresponds with inline tags that is used by your Tool.
+In that case, your config will be merged with sanitizer configuration of Block Tool
 that is using the Inline Toolbar with your Tool.
 
 Example:
 
-If your Tool wrapps selected text with `<b>` tag, the sanitizer config should looks like this:
+If your Tool wraps selected text with `<b>` tag, the sanitizer config should looks like this:
 
 ```js
 static get sanitize() {
@@ -120,14 +120,14 @@ static get sanitize() {
     b: {} // {} means clean all attributes. true — leave all attributes
   }
 }
-``` 
+```
 
 Read more about Sanitizer configuration at the [Tools#sanitize](tools.md#sanitize)
 
 ### Specifying a title
 
-You can pass your Tool's title via `title` static getter. It can be used, for example, in the Tooltip with 
-icon description that appears by hover. 
+You can pass your Tool's title via `title` static getter. It can be used, for example, in the Tooltip with
+icon description that appears by hover.
 
 ```ts
 export default class BoldInlineTool implements InlineTool {
diff --git a/docs/tools.md b/docs/tools.md
index 7cc4fd210..4fcf6e20c 100644
--- a/docs/tools.md
+++ b/docs/tools.md
@@ -124,10 +124,10 @@ Both methods might be async.
 
 Editor.js handles paste on Blocks and provides API for Tools to process the pasted data.
 
-When user pastes content into Editor, pasted content will be splitted into blocks.
+When user pastes content into Editor, pasted content will be split into blocks.
 
-1. If plain text will be pasted, it will be splitted by new line characters
-2. If HTML string will be pasted, it will be splitted by block tags
+1. If plain text will be pasted, it will be split by new line characters
+2. If HTML string will be pasted, it will be split by block tags
 
 Also Editor API allows you to define your own pasting scenario. You can either:
 
@@ -199,7 +199,7 @@ Pattern will be processed only if paste was on `defaultBlock` Tool and pasted st
 
 > Example
 
-You can handle YouTube links and insert embeded video instead:
+You can handle YouTube links and insert embedded video instead:
 
 ```javascript
 static get pasteConfig() {
@@ -222,7 +222,7 @@ To handle file you should provide `files`  property in your `pasteConfig` config
 | Name | Type | Description |
 | ---- | ---- | ----------- |
 | `extensions` | `string[]` | _Optional_ Array of extensions your Tool can handle |
-| `mimeTypes` | `sring[]` | _Optional_ Array of MIME types your Tool can handle |
+| `mimeTypes` | `string[]` | _Optional_ Array of MIME types your Tool can handle |
 
 Example
 
@@ -456,7 +456,7 @@ class ListTool {
   constructor(){
     this.data = {
       items: [
-        'Fisrt item',
+        'First item',
         'Second item',
         'Third item'
       ],
diff --git a/eslint.config.mjs b/eslint.config.mjs
new file mode 100644
index 000000000..050f75153
--- /dev/null
+++ b/eslint.config.mjs
@@ -0,0 +1,484 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { FlatCompat } from '@eslint/eslintrc';
+import eslintPluginImport from 'eslint-plugin-import';
+import playwright from 'eslint-plugin-playwright';
+import sonarjs from 'eslint-plugin-sonarjs';
+import jest from 'eslint-plugin-jest';
+
+const CLASS_SELECTOR_PATTERN = /(^|\s|[>+~,])\.[_a-zA-Z][_a-zA-Z0-9-]*/;
+const CLASS_SELECTOR_START_PATTERN = /^\s*\.[_a-zA-Z][_a-zA-Z0-9-]*/;
+const CSS_ENGINE_PATTERN = /^css(?::(light|dark))?=\s*.*\.[_a-zA-Z][_a-zA-Z0-9-]*/;
+const SELECTOR_METHODS = new Set([
+  '$',
+  '$$',
+  '$eval',
+  '$$eval',
+  'locator',
+  'click',
+  'dblclick',
+  'hover',
+  'focus',
+  'tap',
+  'press',
+  'fill',
+  'type',
+  'check',
+  'uncheck',
+  'setInputFiles',
+  'selectOption',
+  'waitForSelector',
+  'isVisible',
+  'isHidden',
+  'isEnabled',
+  'isDisabled',
+  'isEditable',
+  'isChecked',
+  'dragTo',
+  'dispatchEvent',
+]);
+const NON_CSS_PREFIXES = [
+  'text=',
+  'role=',
+  'xpath=',
+  'xpath:',
+  'id=',
+  'data-testid=',
+  'data-test=',
+  'data-qa=',
+  'nth=',
+  'aria/',
+];
+
+const internalPlaywrightPlugin = {
+  rules: {
+    'no-classname-selectors': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description: 'Disallow CSS class selectors in Playwright E2E tests.',
+        },
+        schema: [],
+        messages: {
+          noClassSelector:
+            'Avoid using CSS class selectors in Playwright tests. Prefer role- or data-based locators.',
+        },
+      },
+      create(context) {
+        const getMethodName = (callee) => {
+          if (!callee) {
+            return null;
+          }
+
+          if (callee.type === 'Identifier') {
+            return callee.name;
+          }
+
+          if (callee.type === 'MemberExpression') {
+            if (callee.computed) {
+              if (callee.property.type === 'Literal' && typeof callee.property.value === 'string') {
+                return callee.property.value;
+              }
+
+              return null;
+            }
+
+            if (callee.property.type === 'Identifier') {
+              return callee.property.name;
+            }
+          }
+
+          return null;
+        };
+
+        const getStaticStringValue = (node) => {
+          if (!node) {
+            return null;
+          }
+
+          if (node.type === 'Literal' && typeof node.value === 'string') {
+            return node.value;
+          }
+
+          if (node.type === 'TemplateLiteral' && node.expressions.length === 0 && node.quasis.length === 1) {
+            return node.quasis[0].value.cooked ?? node.quasis[0].value.raw;
+          }
+
+          return null;
+        };
+
+        const usesClassSelector = (rawSelector) => {
+          if (!rawSelector) {
+            return false;
+          }
+
+          const selector = rawSelector.trim();
+
+          if (!selector) {
+            return false;
+          }
+
+          const segments = selector.split('>>').map((segment) => segment.trim()).filter(Boolean);
+          const segmentsToCheck = segments.length > 0 ? segments : [selector];
+
+          return segmentsToCheck.some((segment) => {
+            const lowered = segment.toLowerCase();
+
+            if (NON_CSS_PREFIXES.some((prefix) => lowered.startsWith(prefix))) {
+              return false;
+            }
+
+            if (CSS_ENGINE_PATTERN.test(segment)) {
+              const cssValue = segment.replace(/^css(?::(light|dark))?=/i, '').trim();
+
+              return (
+                CLASS_SELECTOR_START_PATTERN.test(cssValue) || CLASS_SELECTOR_PATTERN.test(cssValue)
+              );
+            }
+
+            return (
+              CLASS_SELECTOR_START_PATTERN.test(segment) ||
+              CLASS_SELECTOR_PATTERN.test(segment)
+            );
+          });
+        };
+
+        return {
+          CallExpression(node) {
+            const methodName = getMethodName(node.callee);
+
+            if (!methodName || !SELECTOR_METHODS.has(methodName)) {
+              return;
+            }
+
+            if (node.arguments.length === 0) {
+              return;
+            }
+
+            const selectorValue = getStaticStringValue(node.arguments[0]);
+
+            if (!selectorValue) {
+              return;
+            }
+
+            if (usesClassSelector(selectorValue)) {
+              context.report({
+                node: node.arguments[0],
+                messageId: 'noClassSelector',
+              });
+            }
+          },
+        };
+      },
+    },
+  },
+};
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+});
+
+export default [
+  {
+    ignores: [
+      'node_modules/**',
+      'eslint.config.mjs',
+      '**/*.d.ts',
+      'src/components/tools/paragraph/**',
+      'src/polyfills.ts',
+      'dist'
+    ],
+  },
+  ...compat.config({
+    root: true,
+    extends: ['codex/ts'],
+    plugins: ['deprecation'],
+    parser: '@typescript-eslint/parser',
+    parserOptions: {
+      project: ['./tsconfig.json'],
+      tsconfigRootDir: __dirname,
+    },
+    globals: {
+      Node: true,
+      Range: true,
+      HTMLElement: true,
+      HTMLDivElement: true,
+      Element: true,
+      Selection: true,
+      SVGElement: true,
+      Text: true,
+      InsertPosition: true,
+      PropertyKey: true,
+      MouseEvent: true,
+      TouchEvent: true,
+      KeyboardEvent: true,
+      ClipboardEvent: true,
+      DragEvent: true,
+      Event: true,
+      EventTarget: true,
+      Document: true,
+      NodeList: true,
+      File: true,
+      FileList: true,
+      MutationRecord: true,
+      AddEventListenerOptions: true,
+      DataTransfer: true,
+      DOMRect: true,
+      ClientRect: true,
+      ArrayLike: true,
+      InputEvent: true,
+      unknown: true,
+      requestAnimationFrame: true,
+      navigator: true,
+      globalThis: true,
+    },
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector: 'IfStatement > BlockStatement > IfStatement',
+          message:
+            'Nested if statements are not allowed. Consider using early returns or combining conditions.',
+        },
+        {
+          selector: 'IfStatement > IfStatement',
+          message:
+            'Nested if statements are not allowed. Consider using early returns or combining conditions.',
+        },
+        {
+          selector: 'VariableDeclaration[kind="let"]',
+          message: 'Use const instead of let. If reassignment is needed, refactor to avoid mutation.',
+        },
+      ],
+      'jsdoc/require-returns-type': 'off',
+      '@typescript-eslint/strict-boolean-expressions': 'off',
+      '@typescript-eslint/member-ordering': 'off',
+      '@typescript-eslint/naming-convention': 'off',
+      '@typescript-eslint/consistent-type-imports': 'error',
+      '@typescript-eslint/consistent-type-exports': 'error',
+      'prefer-arrow-callback': 'error',
+      'prefer-const': 'error',
+      'deprecation/deprecation': 'error',
+      'no-param-reassign': ['error', { props: true }],
+      'no-global-assign': 'error',
+      'no-implicit-globals': 'error',
+      'func-style': ['error', 'expression', { allowArrowFunctions: true }],
+      'no-nested-ternary': 'error',
+      'max-depth': ['error', { max: 2 }],
+      'one-var': ['error', 'never'],
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          argsIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+          caughtErrorsIgnorePattern: '^_',
+          destructuredArrayIgnorePattern: '^_',
+        },
+      ],
+    },
+    overrides: [
+      {
+        files: ['*.ts', '*.tsx'],
+        parserOptions: {
+          project: ['./tsconfig.json'],
+          tsconfigRootDir: __dirname,
+        },
+        rules: {
+          '@typescript-eslint/no-floating-promises': 'error',
+        },
+      },
+      {
+        files: ['tsconfig.json', 'package.json', 'tsconfig.*.json', 'tslint.json'],
+        rules: {
+          quotes: [1, 'double'],
+          semi: [1, 'never'],
+          'comma-dangle': 'off',
+          '@typescript-eslint/consistent-type-imports': 'off',
+          '@typescript-eslint/consistent-type-exports': 'off',
+        },
+      },
+    ],
+  }),
+  {
+    files: ['src/**/*.ts', 'src/**/*.tsx'],
+    plugins: {
+      sonarjs,
+      import: eslintPluginImport,
+    },
+    rules: {
+      // Duplicate code detection
+      'sonarjs/no-duplicate-string': ['error', { threshold: 3 }],
+      'sonarjs/no-identical-functions': 'error',
+      'sonarjs/no-identical-expressions': 'error',
+      // Prevent UMD module patterns
+      'import/no-amd': 'error',
+      'import/no-commonjs': 'error',
+    },
+  },
+  {
+    files: ['test/unit/**/*.ts'],
+    plugins: {
+      jest,
+    },
+    languageOptions: {
+      globals: {
+        // Vitest/Jest globals
+        describe: 'readonly',
+        it: 'readonly',
+        test: 'readonly',
+        expect: 'readonly',
+        beforeEach: 'readonly',
+        afterEach: 'readonly',
+        beforeAll: 'readonly',
+        afterAll: 'readonly',
+        vi: 'readonly',
+        vitest: 'readonly',
+      },
+    },
+    rules: {
+      ...jest.configs.recommended.rules,
+      '@typescript-eslint/no-magic-numbers': 'off',
+      'no-restricted-syntax': 'off',
+      'deprecation/deprecation': 'off',
+      // Disable rules that require Jest to be installed (we use Vitest)
+      'jest/no-deprecated-functions': 'off',
+      // Disable require-hook: vi.mock() MUST be top-level in Vitest (hoisting requirement)
+      'jest/require-hook': 'off',
+      // Enforce test structure best practices
+      'jest/consistent-test-it': ['error', { fn: 'it' }],
+      'jest/valid-describe-callback': 'error',
+      'jest/valid-expect': 'error',
+      'jest/valid-expect-in-promise': 'error',
+      'jest/valid-title': 'error',
+      'jest/prefer-lowercase-title': ['warn', { ignore: ['describe'] }],
+      // Prevent skipped/focused tests in production
+      'jest/no-focused-tests': 'error',
+      'jest/no-disabled-tests': 'warn',
+      'jest/no-commented-out-tests': 'warn',
+      // Enforce assertion best practices
+      'jest/expect-expect': 'error',
+      'jest/no-conditional-expect': 'error',
+      'jest/no-standalone-expect': 'error',
+      'jest/prefer-to-be': 'warn',
+      'jest/prefer-to-contain': 'warn',
+      'jest/prefer-to-have-length': 'warn',
+      'jest/prefer-strict-equal': 'warn',
+      'jest/prefer-equality-matcher': 'warn',
+      'jest/prefer-comparison-matcher': 'warn',
+      'jest/prefer-expect-assertions': 'off', // Can be too strict
+      'jest/prefer-expect-resolves': 'warn',
+      'jest/prefer-called-with': 'warn',
+      'jest/prefer-spy-on': 'warn',
+      'jest/prefer-todo': 'warn',
+      // Prevent anti-patterns
+      'jest/no-alias-methods': 'error',
+      'jest/no-duplicate-hooks': 'error',
+      'jest/no-export': 'error',
+      'jest/no-identical-title': 'error',
+      'jest/no-jasmine-globals': 'error',
+      'jest/no-mocks-import': 'error',
+      'jest/no-test-return-statement': 'error',
+      'jest/prefer-hooks-on-top': 'error',
+      'jest/prefer-hooks-in-order': 'warn',
+      'jest/require-top-level-describe': 'error',
+      // Enforce test organization
+      'jest/max-nested-describe': ['warn', { max: 3 }],
+      'jest/max-expects': ['warn', { max: 20 }],
+      // Code quality
+      // Note: no-deprecated-functions requires Jest to be installed, skipped for Vitest compatibility
+      'jest/no-untyped-mock-factory': 'warn',
+      'jest/prefer-mock-promise-shorthand': 'warn',
+      // require-hook is disabled above (vi.mock() must be top-level in Vitest)
+    },
+  },
+  {
+    files: ['test/playwright/**/*.ts'],
+    plugins: {
+      playwright,
+      'internal-playwright': internalPlaywrightPlugin,
+    },
+    languageOptions: {
+      globals: {
+        // Playwright globals
+        test: 'readonly',
+        expect: 'readonly',
+        // Custom globals
+        EditorJS: 'readonly',
+      },
+    },
+    rules: {
+      ...playwright.configs.recommended.rules,
+      'internal-playwright/no-classname-selectors': 'off',
+      '@typescript-eslint/no-magic-numbers': 'off',
+      'no-restricted-syntax': 'off',
+      'deprecation/deprecation': 'off',
+      // Prevent anti-patterns
+      'playwright/no-wait-for-timeout': 'error',
+      'playwright/no-wait-for-selector': 'error',
+      'playwright/no-wait-for-navigation': 'error',
+      'playwright/no-element-handle': 'error',
+      'playwright/no-page-pause': 'error',
+      'playwright/no-networkidle': 'error',
+      'playwright/no-eval': 'error',
+      'playwright/no-force-option': 'warn',
+      // Enforce proper async handling
+      'playwright/missing-playwright-await': 'error',
+      'playwright/no-useless-await': 'error',
+      'playwright/no-unsafe-references': 'error',
+      // Enforce test structure best practices
+      'playwright/require-top-level-describe': 'error',
+      'playwright/prefer-hooks-on-top': 'error',
+      'playwright/prefer-hooks-in-order': 'warn',
+      'playwright/no-duplicate-hooks': 'error',
+      'playwright/valid-describe-callback': 'error',
+      'playwright/valid-title': 'error',
+      'playwright/prefer-lowercase-title': 'warn',
+      // Prevent skipped/focused tests in production
+      'playwright/no-focused-test': 'error',
+      'playwright/no-skipped-test': 'warn',
+      'playwright/no-commented-out-tests': 'warn',
+      // Enforce assertion best practices
+      'playwright/prefer-web-first-assertions': 'error',
+      'playwright/prefer-locator': 'error',
+      'playwright/prefer-native-locators': 'warn',
+      'playwright/no-standalone-expect': 'error',
+      'playwright/no-conditional-expect': 'error',
+      'playwright/no-conditional-in-test': 'warn',
+      'playwright/valid-expect': 'error',
+      'playwright/valid-expect-in-promise': 'error',
+      'playwright/prefer-to-be': 'warn',
+      'playwright/prefer-to-contain': 'warn',
+      'playwright/prefer-to-have-count': 'warn',
+      'playwright/prefer-to-have-length': 'warn',
+      'playwright/prefer-strict-equal': 'warn',
+      'playwright/prefer-comparison-matcher': 'warn',
+      'playwright/prefer-equality-matcher': 'warn',
+      'playwright/no-useless-not': 'warn',
+      'playwright/require-to-throw-message': 'warn',
+      // Prevent deprecated methods
+      'playwright/no-nth-methods': 'warn',
+      'playwright/no-get-by-title': 'warn',
+      // Enforce test organization
+      'playwright/max-nested-describe': ['warn', { max: 3 }],
+      'playwright/max-expects': ['warn', { max: 20 }],
+      'playwright/no-nested-step': 'warn',
+      // Code quality
+      'playwright/no-unused-locators': 'warn',
+      'playwright/expect-expect': 'error',
+    },
+  },
+  {
+    files: [
+      '**/*.test.{ts,tsx,js,jsx}',
+      '**/*.spec.{ts,tsx,js,jsx}',
+      'test/**/*.ts',
+      'tests/**/*.ts',
+    ],
+    rules: {
+      'no-restricted-syntax': 'off',
+    },
+  },
+];
diff --git a/package.json b/package.json
index 5039584f8..972ed8292 100644
--- a/package.json
+++ b/package.json
@@ -14,15 +14,20 @@
     "wysiwyg"
   ],
   "scripts": {
-    "dev": "vite",
+    "serve": "vite --no-open",
     "build": "vite build --mode production",
     "build:test": "vite build --mode test",
-    "lint": "eslint src/ --ext .ts && yarn lint:tests",
-    "lint:errors": "eslint src/ --ext .ts --quiet",
-    "lint:fix": "eslint src/ --ext .ts --fix",
-    "lint:tests": "eslint test/ --ext .ts",
-    "test:e2e": "yarn build:test && cypress run",
-    "test:e2e:open": "yarn build:test && cypress open"
+    "lint": "sh -c 'eslint .; ESLINT_EXIT=$?; tsc --noEmit; TSC_EXIT=$?; if [ $ESLINT_EXIT -ne 0 ] || [ $TSC_EXIT -ne 0 ]; then exit 1; fi'",
+    "lint:fix": "eslint . --fix",
+    "lint:tests": "eslint test/",
+    "lint:types": "tsc --noEmit",
+    "test:e2e": "playwright test",
+    "test:e2e:ui": "playwright test --ui",
+    "test:unit": "vitest run",
+    "test:unit:watch": "vitest",
+    "test:unit:coverage": "vitest run --coverage",
+    "jscpd": "jscpd src/ test/",
+    "jscpd:report": "jscpd . --reporters html,json --output .jscpd-report"
   },
   "author": "CodeX",
   "license": "Apache-2.0",
@@ -31,28 +36,31 @@
     "url": "git+https://github.com/codex-team/editor.js.git"
   },
   "devDependencies": {
+    "@axe-core/playwright": "^4.11.0",
     "@babel/register": "^7.21.0",
     "@codexteam/icons": "0.3.2",
     "@codexteam/shortcuts": "^1.1.1",
-    "@cypress/code-coverage": "^3.10.3",
     "@editorjs/code": "^2.7.0",
     "@editorjs/delimiter": "^1.2.0",
     "@editorjs/header": "^2.8.8",
     "@editorjs/paragraph": "^2.11.6",
     "@editorjs/simple-image": "^1.4.1",
+    "@eslint/eslintrc": "^3.1.0",
+    "@playwright/test": "^1.56.1",
     "@types/node": "^18.15.11",
-    "chai-subset": "^1.6.0",
+    "@vitest/ui": "^1.0.0",
     "core-js": "3.30.0",
-    "cypress": "^13.13.3",
-    "cypress-intellij-reporter": "^0.0.7",
-    "cypress-plugin-tab": "^1.0.5",
-    "cypress-terminal-report": "^5.3.2",
-    "cypress-vite": "^1.5.0",
     "eslint": "^8.37.0",
     "eslint-config-codex": "^1.7.1",
     "eslint-plugin-chai-friendly": "^0.7.2",
-    "eslint-plugin-cypress": "2.12.1",
+    "eslint-plugin-deprecation": "^1.5.0",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jest": "^29.1.0",
+    "eslint-plugin-playwright": "^2.3.0",
+    "eslint-plugin-sonarjs": "^3.0.5",
     "html-janitor": "^2.0.4",
+    "jscpd": "^4.0.5",
+    "jsdom": "^23.0.0",
     "nanoid": "^4.0.2",
     "postcss-apply": "^0.12.0",
     "postcss-nested": "4.1.2",
@@ -62,7 +70,8 @@
     "tslint": "^6.1.1",
     "typescript": "5.0.3",
     "vite": "^4.2.1",
-    "vite-plugin-css-injected-by-js": "^3.1.0"
+    "vite-plugin-css-injected-by-js": "^3.1.0",
+    "vitest": "^1.0.0"
   },
   "collective": {
     "type": "opencollective",
@@ -70,7 +79,19 @@
   },
   "dependencies": {
     "@editorjs/caret": "^1.0.1",
+    "@types/lodash": "^4.17.20",
     "codex-notifier": "^1.1.2",
-    "codex-tooltip": "^1.0.5"
+    "lodash": "^4.17.21"
+  },
+  "resolutions": {
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "@typescript-eslint/typescript-estree": "^6.0.0",
+    "@typescript-eslint/scope-manager": "^6.0.0",
+    "@typescript-eslint/types": "^6.0.0",
+    "@typescript-eslint/utils": "^6.0.0",
+    "@typescript-eslint/visitor-keys": "^6.0.0",
+    "@typescript-eslint/type-utils": "^6.0.0",
+    "eslint-plugin-jsdoc": "^48.0.0"
   }
 }
diff --git a/playwright.config.ts b/playwright.config.ts
new file mode 100644
index 000000000..c3d34d872
--- /dev/null
+++ b/playwright.config.ts
@@ -0,0 +1,30 @@
+import { defineConfig } from '@playwright/test';
+
+/**
+ * Playwright Configuration
+ *
+ * Recommended plugins installed:
+ * - @axe-core/playwright: For accessibility testing
+ *   Usage in tests: import { injectAxe, checkA11y } from '@axe-core/playwright';
+ *                   await injectAxe(page);
+ *                   await checkA11y(page);
+ *
+ * - eslint-plugin-playwright: For linting Playwright tests
+ *   Configured in eslint.config.mjs
+ */
+export default defineConfig({
+  testDir: 'test/playwright/tests',
+  timeout: 10_000,
+  expect: {
+    timeout: 5_000,
+  },
+  fullyParallel: false,
+  reporter: [ [ 'list' ] ],
+  use: {
+    headless: true,
+    screenshot: 'only-on-failure',
+    trace: 'retain-on-failure',
+    video: 'retain-on-failure',
+  },
+  retries: process.env.CI ? 2 : 0,
+});
diff --git a/public/assets/demo.css b/public/assets/demo.css
index f1141266f..35bfab624 100644
--- a/public/assets/demo.css
+++ b/public/assets/demo.css
@@ -3,417 +3,415 @@
  */
 
 :root {
-  --color-bg-main: #fff;
-  --color-border-light: #E8E8EB;
-  --color-text-main: #000;
+    --color-bg-main: #fff;
+    --color-border-light: #e8e8eb;
+    --color-text-main: #000;
 }
 
 .dark-mode {
-  --color-border-light: rgba(255, 255, 255,.08);
-  --color-bg-main: #1c1e24;
-  --color-text-main: #737886;
+    --color-border-light: rgba(255, 255, 255, 0.08);
+    --color-bg-main: #1c1e24;
+    --color-text-main: #737886;
 }
 
-
 body {
-  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif;
-  font-size: 14px;
-  line-height: 1.5em;
-  margin: 0;
-  background: var(--color-bg-main);
-  color: var(--color-text-main);
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif;
+    font-size: 14px;
+    line-height: 1.5em;
+    margin: 0;
+    background: var(--color-bg-main);
+    color: var(--color-text-main);
 }
 
 .ce-example {
-  font-size: 16.2px;
+    font-size: 16.2px;
 }
 
 .ce-example__header {
-  border-bottom: 1px solid var(--color-border-light);
-  height: 50px;
-  line-height: 50px;
-  display: flex;
-  padding: 0 30px;
-  margin-bottom: 30px;
-  flex-wrap: wrap;
+    border-bottom: 1px solid var(--color-border-light);
+    height: 50px;
+    line-height: 50px;
+    display: flex;
+    padding: 0 30px;
+    margin-bottom: 30px;
+    flex-wrap: wrap;
 }
 
 .ce-example__header a {
-  color: inherit;
-  text-decoration: none;
+    color: inherit;
+    text-decoration: none;
 }
 
 .ce-example__header-logo {
-  font-weight: bold;
+    font-weight: bold;
 }
 
 .ce-example__header-menu {
-  margin-left: auto;
+    margin-left: auto;
 }
 
-@media all and (max-width: 730px){
-  .ce-example__header-menu {
-    margin-left: 0;
-    margin-top: 10px;
-    flex-basis: 100%;
-    font-size: 14px;
-  }
+@media all and (max-width: 730px) {
+    .ce-example__header-menu {
+        margin-left: 0;
+        margin-top: 10px;
+        flex-basis: 100%;
+        font-size: 14px;
+    }
 }
 
 .ce-example__header-menu a {
-  margin-left: 20px;
+    margin-left: 20px;
 }
 
-@media all and (max-width: 730px){
-  .ce-example__header-menu a {
-    margin-left: 0;
-    margin-right: 15px;
-  }
+@media all and (max-width: 730px) {
+    .ce-example__header-menu a {
+        margin-left: 0;
+        margin-right: 15px;
+    }
 }
 
 .ce-example__content {
-  max-width: 1100px;
-  margin: 0 auto;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
+    max-width: 1100px;
+    margin: 0 auto;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
 }
 
 .thin-mode .ce-example__content {
-  max-width: 500px;
-  border-left: 1px solid #eee;
-  border-right: 1px solid #eee;
-  padding: 0 15px;
+    max-width: 500px;
+    border-left: 1px solid #eee;
+    border-right: 1px solid #eee;
+    padding: 0 15px;
 }
 
 .ce-example__output {
-  background: #1B202B;
-  overflow-x: auto;
-  padding: 0 30px 80px;
+    background: #1b202b;
+    overflow-x: auto;
+    padding: 0 30px 80px;
 }
 
 .ce-example__output-content {
-  max-width: 650px;
-  margin: 30px auto;
-  color: #ABADC3;
-  font-family: 'PT Mono', Menlo, Monaco, Consolas, Courier New, monospace;
-  font-size: 13.3px;
+    max-width: 650px;
+    margin: 30px auto;
+    color: #abadc3;
+    font-family: 'PT Mono', Menlo, Monaco, Consolas, Courier New, monospace;
+    font-size: 13.3px;
 }
 
 .ce-example__output-content:empty {
-  display: none;
+    display: none;
 }
 
 .ce-example__button {
-  display: block;
-  margin: 50px auto;
-  max-width: 180px;
-  background: #4A9DF8;
-  padding: 17px 30px;
-  box-shadow: 0 22px 18px -4px rgba(137, 207, 255, 0.77);
-  transition: all 150ms ease;
-  cursor: pointer;
-  border-radius: 31px;
-  color: #fff;
-  font-family: 'PT Mono', Menlo, Monaco, Consolas, Courier New, monospace;
-  text-align: center;
+    display: block;
+    margin: 50px auto;
+    max-width: 180px;
+    background: #4a9df8;
+    padding: 17px 30px;
+    box-shadow: 0 22px 18px -4px rgba(137, 207, 255, 0.77);
+    transition: all 150ms ease;
+    cursor: pointer;
+    border-radius: 31px;
+    color: #fff;
+    font-family: 'PT Mono', Menlo, Monaco, Consolas, Courier New, monospace;
+    text-align: center;
 }
 
 .ce-example__button:hover {
-  background: #3D8DE5;
-  transform: translateY(2px);
-  box-shadow: 0 20px 15px -4px rgba(137, 207, 255, 0.77);
+    background: #3d8de5;
+    transform: translateY(2px);
+    box-shadow: 0 20px 15px -4px rgba(137, 207, 255, 0.77);
 }
 
 .ce-example__output-footer {
-  padding: 30px 0;
-  font-size: 14.2px;
-  letter-spacing: 0.3px;
-  text-align: center;
+    padding: 30px 0;
+    font-size: 14.2px;
+    letter-spacing: 0.3px;
+    text-align: center;
 }
 
 .ce-example__output-footer a {
-  color: #fff;
-  text-decoration: none;
+    color: #fff;
+    text-decoration: none;
 }
 
 .ce-example__statusbar {
-  display: flex;
-  align-items: center;
-  position: fixed;
-  bottom: 0;
-  right: 0;
-  left: 0;
-  background: var(--color-bg-main);
-  border-radius: 8px 8px 0 0;
-  border-top: 1px solid var(--color-border-light);
-  box-shadow: 0 2px 6px var(--color-border-light);
-  font-size: 13px;
-  padding: 8px 15px;
-  z-index: 1;
-  user-select: none;
+    display: flex;
+    align-items: center;
+    position: fixed;
+    bottom: 0;
+    right: 0;
+    left: 0;
+    background: var(--color-bg-main);
+    border-radius: 8px 8px 0 0;
+    border-top: 1px solid var(--color-border-light);
+    box-shadow: 0 2px 6px var(--color-border-light);
+    font-size: 13px;
+    padding: 8px 15px;
+    z-index: 1;
+    user-select: none;
 }
 
 @media (max-width: 768px) {
-  .ce-example__statusbar {
-    display: none;
-  }
+    .ce-example__statusbar {
+        display: none;
+    }
 }
 
 .ce-example__statusbar-item:not(:last-of-type)::after {
-  content: '|';
-  color: #ddd;
-  margin: 0 15px 0 12px;
+    content: '|';
+    color: #ddd;
+    margin: 0 15px 0 12px;
 }
 
 .ce-example__statusbar-item--right {
-  margin-left: auto;
+    margin-left: auto;
 }
 
 .ce-example__statusbar-button {
-  display: inline-block;
-  padding: 3px 12px;
-  transition: all 150ms ease;
-  cursor: pointer;
-  border-radius: 31px;
-  background: #eff1f4;
-  text-align: center;
-  user-select: none;
+    display: inline-block;
+    padding: 3px 12px;
+    transition: all 150ms ease;
+    cursor: pointer;
+    border-radius: 31px;
+    background: #eff1f4;
+    text-align: center;
+    user-select: none;
 }
 
 .ce-example__statusbar-button:hover {
-  background: #e0e4eb;
+    background: #e0e4eb;
 }
 
 .ce-example__statusbar-button-primary {
-  background: #4A9DF8;
-  color: #fff;
-  box-shadow: 0 7px 8px -4px rgba(137, 207, 255, 0.77);
-  font-family: 'PT Mono', Menlo, Monaco, Consolas, Courier New, monospace;
+    background: #4a9df8;
+    color: #fff;
+    box-shadow: 0 7px 8px -4px rgba(137, 207, 255, 0.77);
+    font-family: 'PT Mono', Menlo, Monaco, Consolas, Courier New, monospace;
 }
 
 .ce-example__statusbar {
-  --toggler-size: 20px;
+    --toggler-size: 20px;
 }
 
 .ce-example__statusbar-toggler {
-  position: relative;
-  background: #7b8799;
-  border-radius: 20px;
-  padding: 2px;
-  width: calc(var(--toggler-size) * 2.2);
-  cursor: pointer;
-  user-select: none;
+    position: relative;
+    background: #7b8799;
+    border-radius: 20px;
+    padding: 2px;
+    width: calc(var(--toggler-size) * 2.2);
+    cursor: pointer;
+    user-select: none;
 }
 
 .ce-example__statusbar-toggler::before {
-  display: block;
-  content: '';
-  width: var(--toggler-size);
-  height: var(--toggler-size);
-  background: #fff;
-  border-radius: 50%;
-  transition: transform 100ms ease-in;
+    display: block;
+    content: '';
+    width: var(--toggler-size);
+    height: var(--toggler-size);
+    background: #fff;
+    border-radius: 50%;
+    transition: transform 100ms ease-in;
 }
 
 .ce-example__statusbar-toggler::after {
-  --moon-size: calc(var(--toggler-size) * 0.5);
-  content: '';
-  position: absolute;
-  top: 5px;
-  right: 5px;
-  height: var(--moon-size);
-  width: var(--moon-size);
-  box-shadow: calc(var(--moon-size) * 0.25 * -1) calc(var(--moon-size) * 0.18) 0 calc(var(--moon-size) * 0.05) white;
-  border-radius: 50%;
+    --moon-size: calc(var(--toggler-size) * 0.5);
+
+    content: '';
+    position: absolute;
+    top: 5px;
+    right: 5px;
+    height: var(--moon-size);
+    width: var(--moon-size);
+    box-shadow: calc(var(--moon-size) * 0.25 * -1) calc(var(--moon-size) * 0.18) 0 calc(var(--moon-size) * 0.05) white;
+    border-radius: 50%;
 }
 
-@media all and (max-width: 730px){
-  .ce-example__header,
-  .ce-example__content{
-    padding: 0 20px;
-  }
+@media all and (max-width: 730px) {
+    .ce-example__header,
+    .ce-example__content {
+        padding: 0 20px;
+    }
 }
 
 /**
  * JSON highlighter
  */
 .sc_attr {
-  color: rgb(148, 162, 192);
+    color: rgb(148, 162, 192);
 }
+
 .sc_key {
-  color: rgb(190, 213, 255);
+    color: rgb(190, 213, 255);
 }
+
 .sc_toolname {
-  color: rgb(15, 205, 251);
+    color: rgb(15, 205, 251);
 }
+
 .sc_tag {
-  color: rgb(4, 131, 216);
+    color: rgb(4, 131, 216);
 }
+
 .sc_bool {
-  color: rgb(247, 60, 173);
+    color: rgb(247, 60, 173);
 }
 
-.ce-example .ce-block:first-of-type h1.ce-header{
-  font-size: 50px;
+.ce-example .ce-block:first-of-type h1.ce-header {
+    font-size: 50px;
 }
 
 .ce-example-multiple {
-  display: grid;
-  grid-template-columns: calc(50% - 15px) calc(50% - 15px);
-  gap: 30px;
-  padding: 30px;
+    display: grid;
+    grid-template-columns: calc(50% - 15px) calc(50% - 15px);
+    gap: 30px;
+    padding: 30px;
 }
 
 .ce-example-multiple > div {
-  background: #fff;
-  border-radius: 7px;
-  padding: 30px;
+    background: #fff;
+    border-radius: 7px;
+    padding: 30px;
 }
 
-
 /**
  * Styles for the popup example page
  */
 .ce-example--popup {
-  height: 100vh;
-  display: flex;
-  flex-direction: column;
+    height: 100vh;
+    display: flex;
+    flex-direction: column;
 }
 
 .ce-example--popup .ce-example__content {
-  flex-grow: 2;
+    flex-grow: 2;
 }
 
 .ce-example-popup__overlay {
-  position: fixed;
-  top: 0;
-  bottom: 0;
-  left: 0;
-  right: 0;
-  background: #00000085;
+    position: fixed;
+    inset: 0;
+    background: #00000085;
 }
 
 .ce-example-popup__popup {
-  position: absolute;
-  left: 50%;
-  top: 50%;
-  transform: translate(-50%,-50%);
-  width: 800px;
-  max-width: 100%;
-  max-height: 90vh;
-  background: white;
-  padding: 20px;
-  border-radius: 8px;
-  overflow: auto;
-  box-sizing: border-box;
-}
-
-@media all and (max-width: 730px){
-  .ce-example-popup__popup {
-    top: 10px;
-    left: 10px;
-    width: calc(100% - 20px);
-    height: calc(100% - 20px);
-    transform: none;
-    max-height: none;
-
-  }
+    position: absolute;
+    left: 50%;
+    top: 50%;
+    transform: translate(-50%, -50%);
+    width: 800px;
+    max-width: 100%;
+    max-height: 90vh;
+    background: white;
+    padding: 20px;
+    border-radius: 8px;
+    overflow: auto;
+    box-sizing: border-box;
+}
+
+@media all and (max-width: 730px) {
+    .ce-example-popup__popup {
+        top: 10px;
+        left: 10px;
+        width: calc(100% - 20px);
+        height: calc(100% - 20px);
+        transform: none;
+        max-height: none;
+    }
 }
 
 .show-block-boundaries .ce-block {
-  box-shadow: inset 0 0 0 1px #eff2f5;
+    box-shadow: inset 0 0 0 1px #eff2f5;
 }
 
 .show-block-boundaries .ce-block__content {
-  box-shadow: 0 0 0 1px rgba(224, 231, 241, 0.61) inset;
+    box-shadow: 0 0 0 1px rgba(224, 231, 241, 0.61) inset;
 }
+
 .show-block-boundaries #showBlocksBoundariesButton span,
 .thin-mode #enableThinModeButton span {
-  font-size: 0;
-  vertical-align: bottom;
+    font-size: 0;
+    vertical-align: bottom;
 }
 
 .show-block-boundaries #showBlocksBoundariesButton span::before,
 .thin-mode #enableThinModeButton span::before {
-  content: attr(data-toggled-text);
-  display: inline;
-  font-size: 13px;
+    content: attr(data-toggled-text);
+    display: inline;
+    font-size: 13px;
 }
 
-
-
 /**
  * Dark theme overrides
  */
 .dark-mode img {
-  opacity: 0.5;
+    opacity: 0.5;
 }
 
 .dark-mode .cdx-simple-image__picture--with-border,
 .dark-mode .cdx-input {
-  border-color: var(--color-border-light);
+    border-color: var(--color-border-light);
 }
 
 .dark-mode .ce-example__button {
-  box-shadow: 0 24px 18px -14px rgba(4, 154, 255, 0.24);
+    box-shadow: 0 24px 18px -14px rgba(4, 154, 255, 0.24);
 }
 
 .dark-mode .ce-example__output {
-  background-color: #17191f;
+    background-color: #17191f;
 }
 
 .dark-mode .inline-code {
-  background-color: rgba(53, 56, 68, 0.62);
-  color: #727683;
+    background-color: rgba(53, 56, 68, 0.62);
+    color: #727683;
 }
 
 .dark-mode a {
-  color: #959ba8;
+    color: #959ba8;
 }
 
 .dark-mode .ce-example__statusbar-toggler,
 .dark-mode .ce-example__statusbar-button {
-  background-color: #343842;
+    background-color: #343842;
 }
 
 .dark-mode .ce-example__statusbar-toggler::before {
-  transform: translateX(calc(var(--toggler-size) * 2.2 - var(--toggler-size)));
+    transform: translateX(calc(var(--toggler-size) * 2.2 - var(--toggler-size)));
 }
 
 .dark-mode .ce-example__statusbar-toggler::after {
-  content: '*';
-  right: auto;
-  left: 6px;
-  top: 7px;
-  color: #fff;
-  box-shadow: none;
-  font-size: 32px;
+    content: '*';
+    right: auto;
+    left: 6px;
+    top: 7px;
+    color: #fff;
+    box-shadow: none;
+    font-size: 32px;
 }
 
 .dark-mode.show-block-boundaries .ce-block,
 .dark-mode.show-block-boundaries .ce-block__content {
-  box-shadow: 0 0 0 1px rgba(128, 144, 159, 0.09) inset;
+    box-shadow: 0 0 0 1px rgba(128, 144, 159, 0.09) inset;
 }
 
-.dark-mode.thin-mode .ce-example__content{
-  border-color: var(--color-border-light);
+.dark-mode.thin-mode .ce-example__content {
+    border-color: var(--color-border-light);
 }
 
 .dark-mode .ce-example__statusbar-item:not(:last-of-type)::after {
-  color: var(--color-border-light);
+    color: var(--color-border-light);
 }
 
 .dark-mode .ce-block--selected .ce-block__content,
-.dark-mode ::selection{
-  background-color: rgba(57, 68, 84, 0.57);
+.dark-mode ::selection {
+    background-color: rgba(57, 68, 84, 0.57);
 }
 
 .dark-mode .ce-toolbox__button,
 .dark-mode .ce-toolbar__settings-btn,
 .dark-mode .ce-toolbar__plus {
-  color: inherit;
+    color: inherit;
 }
 
 .dark-mode .ce-stub {
-  opacity: 0.3;
+    opacity: 0.3;
 }
diff --git a/public/assets/json-preview.js b/public/assets/json-preview.js
index 24600cb76..9dc4f49db 100644
--- a/public/assets/json-preview.js
+++ b/public/assets/json-preview.js
@@ -1,45 +1,60 @@
+/* eslint-env browser */
+
 /**
- * Module to compose output JSON preview
+ * Module to compose output JSON preview.
+ *
+ * @returns {{show: (output: object, holder: Element) => void}}
  */
-const cPreview = (function (module) {
+const createPreview = () => {
   /**
-   * Shows JSON in pretty preview
-   * @param {object} output - what to show
-   * @param {Element} holder - where to show
+   * Shows JSON in the pretty preview block.
+   *
+   * @param {object} output - data to render.
+   * @param {Element} holder - element to populate with JSON.
+   * @returns {void}
    */
-  module.show = function(output, holder) {
-    /** Make JSON pretty */
-    output = JSON.stringify( output, null, 4 );
-    /** Encode HTML entities */
-    output = encodeHTMLEntities( output );
-    /** Stylize! */
-    output = stylize( output );
-    holder.innerHTML = output;
+  const show = (output, holder) => {
+    const prettyJson = JSON.stringify(output, null, 4);
+    const encodedJson = encodeHTMLEntities(prettyJson);
+    const targetHolder = holder;
+
+    targetHolder.innerHTML = stylize(encodedJson);
   };
 
   /**
-   * Converts '>', '<', '&' symbols to entities
+   * Converts '>', '<', '&' symbols to entities.
+   *
+   * @param {string} value - text to convert.
+   * @returns {string}
    */
-  function encodeHTMLEntities(string) {
-    return string.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-  }
+  const encodeHTMLEntities = (value) => value
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
 
   /**
-   * Some styling magic
+   * Adds syntax highlighting spans to JSON markup.
+   *
+   * @param {string} value - HTML string to decorate.
+   * @returns {string}
    */
-  function stylize(string) {
+  const stylize = (value) => value
     /** Stylize JSON keys */
-    string = string.replace( /"(\w+)"\s?:/g, '"<span class=sc_key>$1</span>" :');
+    .replace(/"(\w+)"\s?:/g, '"<span class=sc_key>$1</span>" :')
     /** Stylize tool names */
-    string = string.replace( /"(paragraph|quote|list|header|link|code|image|delimiter|raw|checklist|table|embed|warning)"/g, '"<span class=sc_toolname>$1</span>"');
+    .replace(/"(paragraph|quote|list|header|link|code|image|delimiter|raw|checklist|table|embed|warning)"/g, '"<span class=sc_toolname>$1</span>"')
     /** Stylize HTML tags */
-    string = string.replace( /(&lt;[\/a-z]+(&gt;)?)/gi, '<span class=sc_tag>$1</span>' );
+    .replace(/(&lt;[\/a-z]+(&gt;)?)/gi, '<span class=sc_tag>$1</span>')
     /** Stylize strings */
-    string = string.replace( /"([^"]+)"/gi, '"<span class=sc_attr>$1</span>"' );
+    .replace(/"([^"]+)"/gi, '"<span class=sc_attr>$1</span>"')
     /** Boolean/Null */
-    string = string.replace( /\b(true|false|null)\b/gi, '<span class=sc_bool>$1</span>' );
-    return string;
-  }
+    .replace(/\b(true|false|null)\b/gi, '<span class=sc_bool>$1</span>');
+
+  return { show };
+};
+
+const cPreview = createPreview();
 
-  return module;
-})({});
+if (typeof window !== 'undefined') {
+  window.cPreview = cPreview;
+}
diff --git a/src/codex.ts b/src/codex.ts
index 27d50acdb..b9bf13cae 100644
--- a/src/codex.ts
+++ b/src/codex.ts
@@ -1,6 +1,7 @@
 'use strict';
 
-import type { EditorConfig } from '../types';
+import type { EditorConfig, API } from '../types';
+import type { EditorModules } from './types-internal/editor-modules';
 
 /**
  * Apply polyfills
@@ -12,8 +13,6 @@ import Core from './components/core';
 import * as _ from './components/utils';
 import { destroy as destroyTooltip } from './components/utils/tooltip';
 
-declare const VERSION: string;
-
 /**
  * Editor.js
  *
@@ -22,6 +21,11 @@ declare const VERSION: string;
  * @author CodeX Team <https://codex.so>
  */
 export default class EditorJS {
+  /**
+   * Store user-provided configuration for later export
+   */
+  private readonly initialConfiguration: EditorConfig|string|undefined;
+
   /**
    * Promise that resolves when core modules are ready and UI is rendered on the page
    */
@@ -35,30 +39,35 @@ export default class EditorJS {
 
   /** Editor version */
   public static get version(): string {
-    return VERSION;
+    return _.getEditorVersion();
   }
 
   /**
    * @param {EditorConfig|string|undefined} [configuration] - user configuration
    */
   constructor(configuration?: EditorConfig|string) {
+    this.initialConfiguration = _.isObject(configuration)
+      ? { ...configuration }
+      : configuration;
+
     /**
-     * Set default onReady function
+     * Set default onReady function or use the one from configuration if provided
      */
     // eslint-disable-next-line @typescript-eslint/no-empty-function
-    let onReady = (): void => {};
+    const onReady = (_.isObject(configuration) && _.isFunction(configuration.onReady))
+      ? configuration.onReady
+      : () => {};
 
     /**
-     * If `onReady` was passed in `configuration` then redefine onReady function
+     * Create a Editor.js instance
      */
-    if (_.isObject(configuration) && _.isFunction(configuration.onReady)) {
-      onReady = configuration.onReady;
-    }
+    const editor = new Core(configuration);
 
     /**
-     * Create a Editor.js instance
+     * Initialize destroy with a no-op function that will be replaced in exportAPI
      */
-    const editor = new Core(configuration);
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    this.destroy = (): void => {};
 
     /**
      * We need to export isReady promise in the constructor
@@ -85,19 +94,26 @@ export default class EditorJS {
     const destroy = (): void => {
       Object.values(editor.moduleInstances)
         .forEach((moduleInstance) => {
-          if (_.isFunction(moduleInstance.destroy)) {
-            moduleInstance.destroy();
+          if (moduleInstance === undefined || moduleInstance === null) {
+            return;
+          }
+
+          if (_.isFunction((moduleInstance as { destroy?: () => void }).destroy)) {
+            (moduleInstance as { destroy: () => void }).destroy();
+          }
+
+          const listeners = (moduleInstance as { listeners?: { removeAll?: () => void } }).listeners;
+
+          if (listeners && _.isFunction(listeners.removeAll)) {
+            listeners.removeAll();
           }
-          moduleInstance.listeners.removeAll();
         });
 
       destroyTooltip();
 
-      editor = null;
-
       for (const field in this) {
         if (Object.prototype.hasOwnProperty.call(this, field)) {
-          delete this[field];
+          delete (this as Record<string, unknown>)[field];
         }
       }
 
@@ -105,14 +121,81 @@ export default class EditorJS {
     };
 
     fieldsToExport.forEach((field) => {
-      this[field] = editor[field];
+      if (field !== 'configuration') {
+        (this as Record<string, unknown>)[field] = (editor as unknown as Record<string, unknown>)[field];
+
+        return;
+      }
+
+      const coreConfiguration = (editor as unknown as { configuration?: EditorConfig|string|undefined }).configuration;
+      const configurationToExport = _.isObject(this.initialConfiguration)
+        ? this.initialConfiguration
+        : coreConfiguration ?? this.initialConfiguration;
+
+      if (configurationToExport === undefined) {
+        return;
+      }
+
+      (this as Record<string, unknown>)[field] = configurationToExport as EditorConfig|string;
     });
 
     this.destroy = destroy;
 
-    Object.setPrototypeOf(this, editor.moduleInstances.API.methods);
+    const apiMethods = editor.moduleInstances.API.methods;
+
+    if (Object.getPrototypeOf(apiMethods) !== EditorJS.prototype) {
+      Object.setPrototypeOf(apiMethods, EditorJS.prototype);
+    }
+
+    Object.setPrototypeOf(this, apiMethods);
+
+    const moduleAliases = Object.create(null) as Record<string, unknown>;
+    const moduleInstances = editor.moduleInstances as Partial<EditorModules>;
+    const moduleInstancesRecord = moduleInstances as unknown as Record<string, unknown>;
+
+    const getAliasName = (name: string): string => (
+      /^[A-Z]+$/.test(name)
+        ? name.toLowerCase()
+        : name.charAt(0).toLowerCase() + name.slice(1)
+    );
 
-    delete this.exportAPI;
+    Object.keys(moduleInstancesRecord)
+      .forEach((name) => {
+        const alias = getAliasName(name);
+
+        Object.defineProperty(moduleAliases, alias, {
+          configurable: true,
+          enumerable: true,
+          get: () => moduleInstancesRecord[name],
+        });
+      });
+
+    type ToolbarModuleWithSettings = {
+      blockSettings?: unknown;
+      inlineToolbar?: unknown;
+    };
+
+    const toolbarModule = moduleInstances.Toolbar as unknown as ToolbarModuleWithSettings | undefined;
+    const blockSettingsModule = moduleInstances.BlockSettings;
+
+    if (toolbarModule !== undefined && blockSettingsModule !== undefined && toolbarModule.blockSettings === undefined) {
+      toolbarModule.blockSettings = blockSettingsModule;
+    }
+
+    const inlineToolbarModule = moduleInstances.InlineToolbar;
+
+    if (toolbarModule !== undefined && inlineToolbarModule !== undefined && toolbarModule.inlineToolbar === undefined) {
+      toolbarModule.inlineToolbar = inlineToolbarModule;
+    }
+
+    Object.defineProperty(this, 'module', {
+      value: moduleAliases,
+      configurable: true,
+      enumerable: false,
+      writable: false,
+    });
+
+    delete (this as Partial<EditorJS>).exportAPI;
 
     const shorthands = {
       blocks: {
@@ -136,7 +219,10 @@ export default class EditorJS {
       .forEach(([key, methods]) => {
         Object.entries(methods)
           .forEach(([name, alias]) => {
-            this[alias] = editor.moduleInstances.API.methods[key][name];
+            const apiKey = key as keyof API;
+            const apiMethodGroup = editor.moduleInstances.API.methods[apiKey] as unknown as Record<string, unknown>;
+
+            (this as Record<string, unknown>)[alias] = apiMethodGroup[name];
           });
       });
   }
diff --git a/src/components/__module.ts b/src/components/__module.ts
index a591c25c2..d9e8d0713 100644
--- a/src/components/__module.ts
+++ b/src/components/__module.ts
@@ -68,9 +68,11 @@ export default class Module<T extends ModuleNodes = Record<string, HTMLElement>>
       handler: (event: Event) => void,
       options: boolean | AddEventListenerOptions = false
     ): void => {
-      this.mutableListenerIds.push(
-        this.listeners.on(element, eventType, handler, options)
-      );
+      const listenerId = this.listeners.on(element, eventType, handler, options);
+
+      if (listenerId) {
+        this.mutableListenerIds.push(listenerId);
+      }
     },
 
     /**
@@ -103,6 +105,8 @@ export default class Module<T extends ModuleNodes = Record<string, HTMLElement>>
 
     this.config = config;
     this.eventsDispatcher = eventsDispatcher;
+    // Editor is initialized via the state setter after construction
+    this.Editor = {} as EditorModules;
   }
 
   /**
@@ -131,6 +135,6 @@ export default class Module<T extends ModuleNodes = Record<string, HTMLElement>>
    * Returns true if current direction is RTL (Right-To-Left)
    */
   protected get isRtl(): boolean {
-    return this.config.i18n.direction === 'rtl';
+    return this.config.i18n?.direction === 'rtl';
   }
 }
diff --git a/src/components/block-tunes/block-tune-delete.ts b/src/components/block-tunes/block-tune-delete.ts
index 390ea76e1..bd37c1edb 100644
--- a/src/components/block-tunes/block-tune-delete.ts
+++ b/src/components/block-tunes/block-tune-delete.ts
@@ -28,7 +28,7 @@ export default class DeleteTune implements BlockTune {
    *
    * @param {API} api - Editor's API
    */
-  constructor({ api }) {
+  constructor({ api }: { api: API }) {
     this.api = api;
   }
 
diff --git a/src/components/block-tunes/block-tune-move-down.ts b/src/components/block-tunes/block-tune-move-down.ts
index 0e7986a0d..a06308c88 100644
--- a/src/components/block-tunes/block-tune-move-down.ts
+++ b/src/components/block-tunes/block-tune-move-down.ts
@@ -37,7 +37,7 @@ export default class MoveDownTune implements BlockTune {
    *
    * @param {API} api — Editor's API
    */
-  constructor({ api }) {
+  constructor({ api }: { api: API }) {
     this.api = api;
   }
 
@@ -68,15 +68,9 @@ export default class MoveDownTune implements BlockTune {
     const nextBlockElement = nextBlock.holder;
     const nextBlockCoords = nextBlockElement.getBoundingClientRect();
 
-    let scrollOffset = Math.abs(window.innerHeight - nextBlockElement.offsetHeight);
-
-    /**
-     * Next block ends on screen.
-     * Increment scroll by next block's height to save element onscreen-position
-     */
-    if (nextBlockCoords.top < window.innerHeight) {
-      scrollOffset = window.scrollY + nextBlockElement.offsetHeight;
-    }
+    const scrollOffset = nextBlockCoords.top < window.innerHeight
+      ? window.scrollY + nextBlockElement.offsetHeight
+      : Math.abs(window.innerHeight - nextBlockElement.offsetHeight);
 
     window.scrollTo(0, scrollOffset);
 
diff --git a/src/components/block-tunes/block-tune-move-up.ts b/src/components/block-tunes/block-tune-move-up.ts
index e87d31269..e007fbb9b 100644
--- a/src/components/block-tunes/block-tune-move-up.ts
+++ b/src/components/block-tunes/block-tune-move-up.ts
@@ -35,7 +35,7 @@ export default class MoveUpTune implements BlockTune {
    *
    * @param {API} api - Editor's API
    */
-  constructor({ api }) {
+  constructor({ api }: { api: API }) {
     this.api = api;
   }
 
@@ -74,16 +74,12 @@ export default class MoveUpTune implements BlockTune {
      *  - when previous block is visible and has offset from the window,
      *      than we scroll window to the difference between this offsets.
      */
-    const currentBlockCoords = currentBlockElement.getBoundingClientRect(),
-        previousBlockCoords = previousBlockElement.getBoundingClientRect();
+    const currentBlockCoords = currentBlockElement.getBoundingClientRect();
+    const previousBlockCoords = previousBlockElement.getBoundingClientRect();
 
-    let scrollUpOffset;
-
-    if (previousBlockCoords.top > 0) {
-      scrollUpOffset = Math.abs(currentBlockCoords.top) - Math.abs(previousBlockCoords.top);
-    } else {
-      scrollUpOffset = Math.abs(currentBlockCoords.top) + previousBlockCoords.height;
-    }
+    const scrollUpOffset = previousBlockCoords.top > 0
+      ? Math.abs(currentBlockCoords.top) - Math.abs(previousBlockCoords.top)
+      : Math.abs(currentBlockCoords.top) + previousBlockCoords.height;
 
     window.scrollBy(0, -1 * scrollUpOffset);
 
diff --git a/src/components/block/api.ts b/src/components/block/api.ts
index 4bd26adc5..b6838ba14 100644
--- a/src/components/block/api.ts
+++ b/src/components/block/api.ts
@@ -9,9 +9,10 @@ import type { BlockAPI as BlockAPIInterface } from '../../../types/api';
  * @class
  * @param {Block} block - Block to expose
  */
-function BlockAPI(
+const BlockAPI = function BlockAPI(
+  this: BlockAPIInterface,
   block: Block
-): void {
+): BlockAPIInterface {
   const blockAPI: BlockAPIInterface = {
     /**
      * Block id
@@ -72,7 +73,7 @@ function BlockAPI(
      * @param {boolean} state — state to set
      */
     set stretched(state: boolean) {
-      block.stretched = state;
+      block.setStretchState(state);
     },
 
     /**
@@ -139,6 +140,28 @@ function BlockAPI(
   };
 
   Object.setPrototypeOf(this, blockAPI);
-}
 
-export default BlockAPI;
+  Object.defineProperties(this, {
+    id: {
+      get(): string {
+        return block.id;
+      },
+      enumerable: true,
+      configurable: true,
+    },
+    name: {
+      get(): string {
+        return block.name;
+      },
+      enumerable: true,
+      configurable: true,
+    },
+  });
+
+  return this;
+};
+
+// Export BlockAPI with proper constructor type
+export default BlockAPI as unknown as {
+  new (block: Block): BlockAPIInterface;
+};
diff --git a/src/components/block/index.ts b/src/components/block/index.ts
index 36c4aa2ae..7f567f176 100644
--- a/src/components/block/index.ts
+++ b/src/components/block/index.ts
@@ -67,7 +67,7 @@ interface BlockConstructorOptions {
 /**
  * @class Block
  * @classdesc This class describes editor`s block, including block`s HTMLElement, data and tool
- * @property {BlockTool} tool — current block tool (Paragraph, for example)
+ * @property {BlockToolAdapter} tool — current block tool (Paragraph, for example)
  * @property {object} CSS — block`s css classes
  */
 
@@ -98,7 +98,7 @@ interface BlockEvents {
 
 /**
  * @classdesc Abstract Block class that contains Block information, Tool name and Tool class instance
- * @property {BlockTool} tool - Tool instance
+ * @property {BlockToolAdapter} tool - Tool instance
  * @property {HTMLElement} holder - Div element that wraps block content with Tool's content. Has `ce-block` CSS class
  * @property {HTMLElement} pluginsContent - HTML content that returns by Tool's render function
  */
@@ -196,11 +196,6 @@ export default class Block extends EventsDispatcher<BlockEvents> {
    */
   private readonly editorEventBus: EventsDispatcher<EditorEventMap> | null = null;
 
-  /**
-   * Link to editor dom change callback. Used to remove listener on remove
-   */
-  private redactorDomChangedCallback: (payload: RedactorDomChangedPayload) => void;
-
   /**
    * Current block API interface
    */
@@ -226,10 +221,11 @@ export default class Block extends EventsDispatcher<BlockEvents> {
     this.name = tool.name;
     this.id = id;
     this.settings = tool.settings;
-    this.config = tool.settings.config || {};
+    this.config = tool.settings.config ?? {};
     this.editorEventBus = eventBus || null;
     this.blockAPI = new BlockAPI(this);
 
+
     this.tool = tool;
     this.toolInstance = tool.create(data, this.blockAPI, readOnly);
 
@@ -265,6 +261,276 @@ export default class Block extends EventsDispatcher<BlockEvents> {
     });
   }
 
+  /**
+   * Calls Tool's method
+   *
+   * Method checks tool property {MethodName}. Fires method with passes params If it is instance of Function
+   *
+   * @param {string} methodName - method to call
+   * @param {object} params - method argument
+   */
+  public call(methodName: string, params?: object): void {
+    /**
+     * call Tool's method with the instance context
+     */
+    const method = (this.toolInstance as unknown as Record<string, unknown>)[methodName];
+
+    if (!_.isFunction(method)) {
+      return;
+    }
+
+    if (methodName === BlockToolAPI.APPEND_CALLBACK) {
+      _.log(
+        '`appendCallback` hook is deprecated and will be removed in the next major release. ' +
+            'Use `rendered` hook instead',
+        'warn'
+      );
+    }
+
+    try {
+      // eslint-disable-next-line no-useless-call
+      method.call(this.toolInstance, params);
+    } catch (e) {
+      const errorMessage = e instanceof Error ? e.message : String(e);
+
+      _.log(`Error during '${methodName}' call: ${errorMessage}`, 'error');
+    }
+  }
+
+  /**
+   * Call plugins merge method
+   *
+   * @param {BlockToolData} data - data to merge
+   */
+  public async mergeWith(data: BlockToolData): Promise<void> {
+    if (!_.isFunction(this.toolInstance.merge)) {
+      throw new Error(`Block tool "${this.name}" does not support merging`);
+    }
+
+    await this.toolInstance.merge(data);
+  }
+
+  /**
+   * Extracts data from Block
+   * Groups Tool's save processing time
+   *
+   * @returns {object}
+   */
+  public async save(): Promise<undefined | SavedData> {
+    const extractedBlock = await this.toolInstance.save(this.pluginsContent as HTMLElement);
+    const tunesData: { [name: string]: BlockTuneData } = this.unavailableTunesData;
+
+    [
+      ...this.tunesInstances.entries(),
+      ...this.defaultTunesInstances.entries(),
+    ]
+      .forEach(([name, tune]) => {
+        if (_.isFunction(tune.save)) {
+          try {
+            tunesData[name] = tune.save();
+          } catch (e) {
+            _.log(`Tune ${tune.constructor.name} save method throws an Error %o`, 'warn', e);
+          }
+        }
+      });
+
+    /**
+     * Measuring execution time
+     */
+    const measuringStart = window.performance.now();
+
+    return Promise.resolve(extractedBlock)
+      .then((finishedExtraction) => {
+        /** measure promise execution */
+        const measuringEnd = window.performance.now();
+
+        return {
+          id: this.id,
+          tool: this.name,
+          data: finishedExtraction,
+          tunes: tunesData,
+          time: measuringEnd - measuringStart,
+        };
+      })
+      .catch((error) => {
+        _.log(`Saving process for ${this.name} tool failed due to the ${error}`, 'log', 'red');
+
+        return undefined;
+      });
+  }
+
+  /**
+   * Uses Tool's validation method to check the correctness of output data
+   * Tool's validation method is optional
+   *
+   * @description Method returns true|false whether data passed the validation or not
+   * @param {BlockToolData} data - data to validate
+   * @returns {Promise<boolean>} valid
+   */
+  public async validate(data: BlockToolData): Promise<boolean> {
+    if (this.toolInstance.validate instanceof Function) {
+      return await this.toolInstance.validate(data);
+    }
+
+    return true;
+  }
+
+  /**
+   * Returns data to render in Block Tunes menu.
+   * Splits block tunes into 2 groups: block specific tunes and common tunes
+   */
+  public getTunes(): {
+      toolTunes: PopoverItemParams[];
+      commonTunes: PopoverItemParams[];
+      } {
+    const toolTunesPopoverParams: PopoverItemParams[] = [];
+    const commonTunesPopoverParams: PopoverItemParams[] = [];
+    const pushTuneConfig = (
+      tuneConfig: TunesMenuConfigItem | TunesMenuConfigItem[] | HTMLElement | undefined,
+      target: PopoverItemParams[]
+    ): void => {
+      if (!tuneConfig) {
+        return;
+      }
+
+      if ($.isElement(tuneConfig)) {
+        target.push({
+          type: PopoverItemType.Html,
+          element: tuneConfig,
+        });
+
+        return;
+      }
+
+      if (Array.isArray(tuneConfig)) {
+        target.push(...tuneConfig);
+
+        return;
+      }
+
+      target.push(tuneConfig);
+    };
+
+    /** Tool's tunes: may be defined as return value of optional renderSettings method */
+    const tunesDefinedInTool = typeof this.toolInstance.renderSettings === 'function' ? this.toolInstance.renderSettings() : [];
+
+    pushTuneConfig(tunesDefinedInTool, toolTunesPopoverParams);
+
+    /** Common tunes: combination of default tunes (move up, move down, delete) and third-party tunes connected via tunes api */
+    const commonTunes = [
+      ...this.tunesInstances.values(),
+      ...this.defaultTunesInstances.values(),
+    ].map(tuneInstance => tuneInstance.render());
+
+    /** Separate custom html from Popover items params for common tunes */
+    commonTunes.forEach(tuneConfig => {
+      pushTuneConfig(tuneConfig, commonTunesPopoverParams);
+    });
+
+    return {
+      toolTunes: toolTunesPopoverParams,
+      commonTunes: commonTunesPopoverParams,
+    };
+  }
+
+  /**
+   * Update current input index with selection anchor node
+   */
+  public updateCurrentInput(): void {
+    /**
+     * If activeElement is native input, anchorNode points to its parent.
+     * So if it is native input use it instead of anchorNode
+     *
+     * If anchorNode is undefined, also use activeElement
+     */
+    const anchorNode = SelectionUtils.anchorNode;
+    const activeElement = document.activeElement;
+
+    if ($.isNativeInput(activeElement) || !anchorNode) {
+      this.currentInput = activeElement instanceof HTMLElement ? activeElement : undefined;
+    } else {
+      this.currentInput = anchorNode instanceof HTMLElement ? anchorNode : undefined;
+    }
+  }
+
+  /**
+   * Allows to say Editor that Block was changed. Used to manually trigger Editor's 'onChange' callback
+   * Can be useful for block changes invisible for editor core.
+   */
+  public dispatchChange(): void {
+    this.didMutated();
+  }
+
+  /**
+   * Call Tool instance destroy method
+   */
+  public destroy(): void {
+    this.unwatchBlockMutations();
+    this.removeInputEvents();
+
+    super.destroy();
+
+    if (_.isFunction(this.toolInstance.destroy)) {
+      this.toolInstance.destroy();
+    }
+  }
+
+  /**
+   * Tool could specify several entries to be displayed at the Toolbox (for example, "Heading 1", "Heading 2", "Heading 3")
+   * This method returns the entry that is related to the Block (depended on the Block data)
+   */
+  public async getActiveToolboxEntry(): Promise<ToolboxConfigEntry | undefined> {
+    const toolboxSettings = this.tool.toolbox;
+
+    if (!toolboxSettings) {
+      return undefined;
+    }
+
+    /**
+     * If Tool specifies just the single entry, treat it like an active
+     */
+    if (toolboxSettings.length === 1) {
+      return Promise.resolve(toolboxSettings[0]);
+    }
+
+    /**
+     * If we have several entries with their own data overrides,
+     * find those who matches some current data property
+     *
+     * Example:
+     *  Tools' toolbox: [
+     *    {title: "Heading 1", data: {level: 1} },
+     *    {title: "Heading 2", data: {level: 2} }
+     *  ]
+     *
+     *  the Block data: {
+     *    text: "Heading text",
+     *    level: 2
+     *  }
+     *
+     *  that means that for the current block, the second toolbox item (matched by "{level: 2}") is active
+     */
+    const blockData = await this.data;
+
+    return toolboxSettings.find((item) => {
+      return isSameBlockData(item.data, blockData);
+    });
+  }
+
+  /**
+   * Exports Block data as string using conversion config
+   */
+  public async exportDataAsString(): Promise<string> {
+    const blockData = await this.data;
+
+    return convertBlockDataToString(blockData, this.tool.conversionConfig);
+  }
+
+  /**
+   * Link to editor dom change callback. Used to remove listener on remove
+   */
+  private redactorDomChangedCallback: (payload: RedactorDomChangedPayload) => void = () => {};
+
   /**
    * Find and return all editable elements (contenteditable and native inputs) in the Tool HTML
    */
@@ -306,7 +572,11 @@ export default class Block extends EventsDispatcher<BlockEvents> {
    *
    * @param element - HTML Element to set as current input
    */
-  public set currentInput(element: HTMLElement) {
+  public set currentInput(element: HTMLElement | undefined) {
+    if (element === undefined) {
+      return;
+    }
+
     const index = this.inputs.findIndex((input) => input === element || input.contains(element));
 
     if (index !== -1) {
@@ -438,17 +708,21 @@ export default class Block extends EventsDispatcher<BlockEvents> {
     const fakeCursorWillBeAdded = state === true && SelectionUtils.isRangeInsideContainer(this.holder);
     const fakeCursorWillBeRemoved = state === false && SelectionUtils.isFakeCursorInsideContainer(this.holder);
 
-    if (fakeCursorWillBeAdded || fakeCursorWillBeRemoved) {
-      this.editorEventBus?.emit(FakeCursorAboutToBeToggled, { state }); // mutex
+    if (!fakeCursorWillBeAdded && !fakeCursorWillBeRemoved) {
+      return;
+    }
 
-      if (fakeCursorWillBeAdded) {
-        SelectionUtils.addFakeCursor();
-      } else {
-        SelectionUtils.removeFakeCursor(this.holder);
-      }
+    this.editorEventBus?.emit(FakeCursorAboutToBeToggled, { state }); // mutex
+
+    if (fakeCursorWillBeAdded) {
+      SelectionUtils.addFakeCursor();
+    }
 
-      this.editorEventBus?.emit(FakeCursorHaveBeenSet, { state });
+    if (fakeCursorWillBeRemoved) {
+      SelectionUtils.removeFakeCursor(this.holder);
     }
+
+    this.editorEventBus?.emit(FakeCursorHaveBeenSet, { state });
   }
 
   /**
@@ -465,10 +739,19 @@ export default class Block extends EventsDispatcher<BlockEvents> {
    *
    * @param {boolean} state - 'true' to enable, 'false' to disable stretched state
    */
-  public set stretched(state: boolean) {
+  public setStretchState(state: boolean): void {
     this.holder.classList.toggle(Block.CSS.wrapperStretched, state);
   }
 
+  /**
+   * Backward-compatible setter for stretched state
+   *
+   * @param state - true to enable, false to disable stretched state
+   */
+  public set stretched(state: boolean) {
+    this.setStretchState(state);
+  }
+
   /**
    * Return Block's stretched state
    *
@@ -483,7 +766,7 @@ export default class Block extends EventsDispatcher<BlockEvents> {
    *
    * @param {boolean} state - 'true' if block is drop target, false otherwise
    */
-  public set dropTarget(state) {
+  public set dropTarget(state: boolean) {
     this.holder.classList.toggle(Block.CSS.dropTarget, state);
   }
 
@@ -493,248 +776,11 @@ export default class Block extends EventsDispatcher<BlockEvents> {
    * @returns {HTMLElement}
    */
   public get pluginsContent(): HTMLElement {
-    return this.toolRenderedElement;
-  }
-
-  /**
-   * Calls Tool's method
-   *
-   * Method checks tool property {MethodName}. Fires method with passes params If it is instance of Function
-   *
-   * @param {string} methodName - method to call
-   * @param {object} params - method argument
-   */
-  public call(methodName: string, params?: object): void {
-    /**
-     * call Tool's method with the instance context
-     */
-    if (_.isFunction(this.toolInstance[methodName])) {
-      if (methodName === BlockToolAPI.APPEND_CALLBACK) {
-        _.log(
-          '`appendCallback` hook is deprecated and will be removed in the next major release. ' +
-          'Use `rendered` hook instead',
-          'warn'
-        );
-      }
-
-      try {
-        // eslint-disable-next-line no-useless-call
-        this.toolInstance[methodName].call(this.toolInstance, params);
-      } catch (e) {
-        _.log(`Error during '${methodName}' call: ${e.message}`, 'error');
-      }
-    }
-  }
-
-  /**
-   * Call plugins merge method
-   *
-   * @param {BlockToolData} data - data to merge
-   */
-  public async mergeWith(data: BlockToolData): Promise<void> {
-    await this.toolInstance.merge(data);
-  }
-
-  /**
-   * Extracts data from Block
-   * Groups Tool's save processing time
-   *
-   * @returns {object}
-   */
-  public async save(): Promise<undefined | SavedData> {
-    const extractedBlock = await this.toolInstance.save(this.pluginsContent as HTMLElement);
-    const tunesData: { [name: string]: BlockTuneData } = this.unavailableTunesData;
-
-    [
-      ...this.tunesInstances.entries(),
-      ...this.defaultTunesInstances.entries(),
-    ]
-      .forEach(([name, tune]) => {
-        if (_.isFunction(tune.save)) {
-          try {
-            tunesData[name] = tune.save();
-          } catch (e) {
-            _.log(`Tune ${tune.constructor.name} save method throws an Error %o`, 'warn', e);
-          }
-        }
-      });
-
-    /**
-     * Measuring execution time
-     */
-    const measuringStart = window.performance.now();
-    let measuringEnd;
-
-    return Promise.resolve(extractedBlock)
-      .then((finishedExtraction) => {
-        /** measure promise execution */
-        measuringEnd = window.performance.now();
-
-        return {
-          id: this.id,
-          tool: this.name,
-          data: finishedExtraction,
-          tunes: tunesData,
-          time: measuringEnd - measuringStart,
-        };
-      })
-      .catch((error) => {
-        _.log(`Saving process for ${this.name} tool failed due to the ${error}`, 'log', 'red');
-      });
-  }
-
-  /**
-   * Uses Tool's validation method to check the correctness of output data
-   * Tool's validation method is optional
-   *
-   * @description Method returns true|false whether data passed the validation or not
-   * @param {BlockToolData} data - data to validate
-   * @returns {Promise<boolean>} valid
-   */
-  public async validate(data: BlockToolData): Promise<boolean> {
-    let isValid = true;
-
-    if (this.toolInstance.validate instanceof Function) {
-      isValid = await this.toolInstance.validate(data);
+    if (this.toolRenderedElement === null) {
+      throw new Error('Block pluginsContent is not yet initialized');
     }
 
-    return isValid;
-  }
-
-  /**
-   * Returns data to render in Block Tunes menu.
-   * Splits block tunes into 2 groups: block specific tunes and common tunes
-   */
-  public getTunes(): {
-    toolTunes: PopoverItemParams[];
-    commonTunes: PopoverItemParams[];
-    } {
-    const toolTunesPopoverParams: TunesMenuConfigItem[] = [];
-    const commonTunesPopoverParams: TunesMenuConfigItem[] = [];
-
-    /** Tool's tunes: may be defined as return value of optional renderSettings method */
-    const tunesDefinedInTool = typeof this.toolInstance.renderSettings === 'function' ? this.toolInstance.renderSettings() : [];
-
-    if ($.isElement(tunesDefinedInTool)) {
-      toolTunesPopoverParams.push({
-        type: PopoverItemType.Html,
-        element: tunesDefinedInTool,
-      });
-    } else if (Array.isArray(tunesDefinedInTool)) {
-      toolTunesPopoverParams.push(...tunesDefinedInTool);
-    } else {
-      toolTunesPopoverParams.push(tunesDefinedInTool);
-    }
-
-    /** Common tunes: combination of default tunes (move up, move down, delete) and third-party tunes connected via tunes api */
-    const commonTunes = [
-      ...this.tunesInstances.values(),
-      ...this.defaultTunesInstances.values(),
-    ].map(tuneInstance => tuneInstance.render());
-
-    /** Separate custom html from Popover items params for common tunes */
-    commonTunes.forEach(tuneConfig => {
-      if ($.isElement(tuneConfig)) {
-        commonTunesPopoverParams.push({
-          type: PopoverItemType.Html,
-          element: tuneConfig,
-        });
-      } else if (Array.isArray(tuneConfig)) {
-        commonTunesPopoverParams.push(...tuneConfig);
-      } else {
-        commonTunesPopoverParams.push(tuneConfig);
-      }
-    });
-
-    return {
-      toolTunes: toolTunesPopoverParams,
-      commonTunes: commonTunesPopoverParams,
-    };
-  }
-
-  /**
-   * Update current input index with selection anchor node
-   */
-  public updateCurrentInput(): void {
-    /**
-     * If activeElement is native input, anchorNode points to its parent.
-     * So if it is native input use it instead of anchorNode
-     *
-     * If anchorNode is undefined, also use activeElement
-     */
-    this.currentInput = $.isNativeInput(document.activeElement) || !SelectionUtils.anchorNode
-      ? document.activeElement
-      : SelectionUtils.anchorNode;
-  }
-
-  /**
-   * Allows to say Editor that Block was changed. Used to manually trigger Editor's 'onChange' callback
-   * Can be useful for block changes invisible for editor core.
-   */
-  public dispatchChange(): void {
-    this.didMutated();
-  }
-
-  /**
-   * Call Tool instance destroy method
-   */
-  public destroy(): void {
-    this.unwatchBlockMutations();
-    this.removeInputEvents();
-
-    super.destroy();
-
-    if (_.isFunction(this.toolInstance.destroy)) {
-      this.toolInstance.destroy();
-    }
-  }
-
-  /**
-   * Tool could specify several entries to be displayed at the Toolbox (for example, "Heading 1", "Heading 2", "Heading 3")
-   * This method returns the entry that is related to the Block (depended on the Block data)
-   */
-  public async getActiveToolboxEntry(): Promise<ToolboxConfigEntry | undefined> {
-    const toolboxSettings = this.tool.toolbox;
-
-    /**
-     * If Tool specifies just the single entry, treat it like an active
-     */
-    if (toolboxSettings.length === 1) {
-      return Promise.resolve(this.tool.toolbox[0]);
-    }
-
-    /**
-     * If we have several entries with their own data overrides,
-     * find those who matches some current data property
-     *
-     * Example:
-     *  Tools' toolbox: [
-     *    {title: "Heading 1", data: {level: 1} },
-     *    {title: "Heading 2", data: {level: 2} }
-     *  ]
-     *
-     *  the Block data: {
-     *    text: "Heading text",
-     *    level: 2
-     *  }
-     *
-     *  that means that for the current block, the second toolbox item (matched by "{level: 2}") is active
-     */
-    const blockData = await this.data;
-    const toolboxItems = toolboxSettings;
-
-    return toolboxItems?.find((item) => {
-      return isSameBlockData(item.data, blockData);
-    });
-  }
-
-  /**
-   * Exports Block data as string using conversion config
-   */
-  public async exportDataAsString(): Promise<string> {
-    const blockData = await this.data;
-
-    return convertBlockDataToString(blockData, this.tool.conversionConfig);
+    return this.toolRenderedElement;
   }
 
   /**
@@ -743,9 +789,9 @@ export default class Block extends EventsDispatcher<BlockEvents> {
    * @returns {HTMLDivElement}
    */
   private compose(): HTMLDivElement {
-    const wrapper = $.make('div', Block.CSS.wrapper) as HTMLDivElement,
-        contentNode = $.make('div', Block.CSS.content),
-        pluginsContent = this.toolInstance.render();
+    const wrapper = $.make('div', Block.CSS.wrapper) as HTMLDivElement;
+    const contentNode = $.make('div', Block.CSS.content);
+    const pluginsContent = this.toolInstance.render();
 
     if (import.meta.env.MODE === 'test') {
       wrapper.setAttribute('data-cy', 'block-wrapper');
@@ -759,10 +805,23 @@ export default class Block extends EventsDispatcher<BlockEvents> {
 
     /**
      * Saving a reference to plugin's content element for guaranteed accessing it later
+     * Handle both synchronous HTMLElement and Promise<HTMLElement> cases
      */
-    this.toolRenderedElement = pluginsContent;
-
-    contentNode.appendChild(this.toolRenderedElement);
+    if (pluginsContent instanceof Promise) {
+      // Handle async render: resolve the promise and update DOM when ready
+      pluginsContent.then((resolvedElement) => {
+        this.toolRenderedElement = resolvedElement;
+        this.addToolDataAttributes(resolvedElement);
+        contentNode.appendChild(resolvedElement);
+      }).catch((error) => {
+        _.log(`Tool render promise rejected: %o`, 'error', error);
+      });
+    } else {
+      // Handle synchronous render
+      this.toolRenderedElement = pluginsContent;
+      this.addToolDataAttributes(pluginsContent);
+      contentNode.appendChild(pluginsContent);
+    }
 
     /**
      * Block Tunes might wrap Block's content node to provide any UI changes
@@ -773,24 +832,42 @@ export default class Block extends EventsDispatcher<BlockEvents> {
      *   </tune1wrapper>
      * </tune2wrapper>
      */
-    let wrappedContentNode: HTMLElement = contentNode;
-
-    [...this.tunesInstances.values(), ...this.defaultTunesInstances.values()]
-      .forEach((tune) => {
+    const wrappedContentNode: HTMLElement = [...this.tunesInstances.values(), ...this.defaultTunesInstances.values()]
+      .reduce((acc, tune) => {
         if (_.isFunction(tune.wrap)) {
           try {
-            wrappedContentNode = tune.wrap(wrappedContentNode);
+            return tune.wrap(acc);
           } catch (e) {
             _.log(`Tune ${tune.constructor.name} wrap method throws an Error %o`, 'warn', e);
+
+            return acc;
           }
         }
-      });
+
+        return acc;
+      }, contentNode);
 
     wrapper.appendChild(wrappedContentNode);
 
     return wrapper;
   }
 
+  /**
+   * Add data attributes to tool-rendered element based on tool name
+   *
+   * @param element - The tool-rendered element
+   * @private
+   */
+  private addToolDataAttributes(element: HTMLElement): void {
+    /**
+     * Add data-block-tool attribute to identify the tool type used for the block.
+     * Some tools (like Paragraph) add their own class names, but we can rely on the tool name for all cases.
+     */
+    if (!element.hasAttribute('data-block-tool') && this.name) {
+      element.setAttribute('data-block-tool', this.name);
+    }
+  }
+
   /**
    * Instantiate Block Tunes
    *
@@ -866,7 +943,7 @@ export default class Block extends EventsDispatcher<BlockEvents> {
    *   - InputEvent — <input> change
    *   - undefined — manual triggering of block.dispatchChange()
    */
-  private readonly didMutated = (mutationsOrInputEvent: MutationRecord[] | InputEvent = undefined): void => {
+  private readonly didMutated = (mutationsOrInputEvent: MutationRecord[] | InputEvent | undefined = undefined): void => {
     /**
      * Block API have dispatchChange() method. In this case, mutations list will be undefined.
      */
@@ -887,13 +964,11 @@ export default class Block extends EventsDispatcher<BlockEvents> {
     /**
      * We won't fire a Block mutation event if mutation contain only nodes marked with 'data-mutation-free' attributes
      */
-    let shouldFireUpdate;
+    const shouldFireUpdate = (() => {
+      if (isManuallyDispatched || isInputEventHandler) {
+        return true;
+      }
 
-    if (isManuallyDispatched) {
-      shouldFireUpdate = true;
-    } else if (isInputEventHandler) {
-      shouldFireUpdate = true;
-    } else {
       /**
        * Update from 2023, Feb 17:
        *    Changed mutationsOrInputEvent.some() to mutationsOrInputEvent.every()
@@ -910,19 +985,20 @@ export default class Block extends EventsDispatcher<BlockEvents> {
         ];
 
         return changedNodes.some((node) => {
-          if (!$.isElement(node)) {
-            /**
-             * "characterData" mutation record has Text node as a target, so we need to get parent element to check it for mutation-free attribute
-             */
-            node = node.parentElement;
+          const elementToCheck: Element | null = !$.isElement(node)
+            ? node.parentElement ?? null
+            : node;
+
+          if (elementToCheck === null) {
+            return false;
           }
 
-          return node && (node as HTMLElement).closest('[data-mutation-free="true"]') !== null;
+          return elementToCheck.closest('[data-mutation-free="true"]') !== null;
         });
       });
 
-      shouldFireUpdate = !everyRecordIsMutationFree;
-    }
+      return !everyRecordIsMutationFree;
+    })();
 
     /**
      * In case some mutation free elements are added or removed, do not trigger didMutated event
@@ -964,7 +1040,9 @@ export default class Block extends EventsDispatcher<BlockEvents> {
     this.redactorDomChangedCallback = (payload) => {
       const { mutations } = payload;
 
-      const mutationBelongsToBlock = mutations.some(record => isMutationBelongsToElement(record, this.toolRenderedElement));
+      const toolElement = this.toolRenderedElement;
+      const mutationBelongsToBlock = toolElement !== null
+        && mutations.some(record => isMutationBelongsToElement(record, toolElement));
 
       if (mutationBelongsToBlock) {
         this.didMutated(mutations);
@@ -988,8 +1066,14 @@ export default class Block extends EventsDispatcher<BlockEvents> {
    * @param mutations - records of block content mutations
    */
   private detectToolRootChange(mutations: MutationRecord[]): void {
+    const toolElement = this.toolRenderedElement;
+
+    if (toolElement === null) {
+      return;
+    }
+
     mutations.forEach(record => {
-      const toolRootHasBeenUpdated = Array.from(record.removedNodes).includes(this.toolRenderedElement);
+      const toolRootHasBeenUpdated = Array.from(record.removedNodes).includes(toolElement);
 
       if (toolRootHasBeenUpdated) {
         const newToolElement = record.addedNodes[record.addedNodes.length - 1];
diff --git a/src/components/blocks.ts b/src/components/blocks.ts
index 30334ae20..69cb8e511 100644
--- a/src/components/blocks.ts
+++ b/src/components/blocks.ts
@@ -193,32 +193,34 @@ export default class Blocks {
       return;
     }
 
-    if (index > this.length) {
-      index = this.length;
-    }
+    const insertIndex = index > this.length ? this.length : index;
 
     if (replace) {
-      this.blocks[index].holder.remove();
-      this.blocks[index].call(BlockToolAPI.REMOVED);
+      this.blocks[insertIndex].holder.remove();
+      this.blocks[insertIndex].call(BlockToolAPI.REMOVED);
     }
 
     const deleteCount = replace ? 1 : 0;
 
-    this.blocks.splice(index, deleteCount, block);
+    this.blocks.splice(insertIndex, deleteCount, block);
 
-    if (index > 0) {
-      const previousBlock = this.blocks[index - 1];
+    if (insertIndex > 0) {
+      const previousBlock = this.blocks[insertIndex - 1];
 
       this.insertToDOM(block, 'afterend', previousBlock);
-    } else {
-      const nextBlock = this.blocks[index + 1];
 
-      if (nextBlock) {
-        this.insertToDOM(block, 'beforebegin', nextBlock);
-      } else {
-        this.insertToDOM(block);
-      }
+      return;
+    }
+
+    const nextBlock = this.blocks[insertIndex + 1];
+
+    if (nextBlock !== undefined) {
+      this.insertToDOM(block, 'beforebegin', nextBlock);
+
+      return;
     }
+
+    this.insertToDOM(block);
   }
 
   /**
@@ -252,25 +254,31 @@ export default class Blocks {
       fragment.appendChild(block.holder);
     }
 
-    if (this.length > 0) {
-      if (index > 0) {
-        const previousBlockIndex = Math.min(index - 1, this.length - 1);
-        const previousBlock = this.blocks[previousBlockIndex];
-
-        previousBlock.holder.after(fragment);
-      } else if (index === 0) {
-        this.workingArea.prepend(fragment);
-      }
-
-      /**
-       * Insert blocks to the array at the specified index
-       */
-      this.blocks.splice(index, 0, ...blocks);
-    } else {
+    if (!this.length) {
       this.blocks.push(...blocks);
       this.workingArea.appendChild(fragment);
+
+      blocks.forEach((block) => block.call(BlockToolAPI.RENDERED));
+
+      return;
+    }
+
+    if (index > 0) {
+      const previousBlockIndex = Math.min(index - 1, this.length - 1);
+      const previousBlock = this.blocks[previousBlockIndex];
+
+      previousBlock.holder.after(fragment);
+    }
+
+    if (index === 0) {
+      this.workingArea.prepend(fragment);
     }
 
+    /**
+     * Insert blocks to the array at the specified index
+     */
+    this.blocks.splice(index, 0, ...blocks);
+
     /**
      * Call Rendered event for each block
      */
@@ -283,15 +291,13 @@ export default class Blocks {
    * @param {number} index - index of Block to remove
    */
   public remove(index: number): void {
-    if (isNaN(index)) {
-      index = this.length - 1;
-    }
+    const removeIndex = isNaN(index) ? this.length - 1 : index;
 
-    this.blocks[index].holder.remove();
+    this.blocks[removeIndex].holder.remove();
 
-    this.blocks[index].call(BlockToolAPI.REMOVED);
+    this.blocks[removeIndex].call(BlockToolAPI.REMOVED);
 
-    this.blocks.splice(index, 1);
+    this.blocks.splice(removeIndex, 1);
   }
 
   /**
@@ -346,7 +352,7 @@ export default class Blocks {
    * @param {Block} target — Block related to position
    */
   private insertToDOM(block: Block, position?: InsertPosition, target?: Block): void {
-    if (position) {
+    if (position && target !== undefined) {
       target.holder.insertAdjacentElement(position, block.holder);
     } else {
       this.workingArea.appendChild(block.holder);
diff --git a/src/components/constants.ts b/src/components/constants.ts
index 494274548..cadc96302 100644
--- a/src/components/constants.ts
+++ b/src/components/constants.ts
@@ -9,3 +9,68 @@ export const selectionChangeDebounceTimeout = 180;
  * {@link modules/modificationsObserver.ts}
  */
 export const modificationsObserverBatchTimeout = 400;
+
+/**
+ * The data-interface attribute name
+ * Used as a single source of truth for the data-interface attribute
+ */
+export const DATA_INTERFACE_ATTRIBUTE = 'data-interface';
+
+/**
+ * Value for the data-interface attribute on editor wrapper elements
+ * Used as a single source of truth for editor identification
+ */
+export const EDITOR_INTERFACE_VALUE = 'editorjs';
+
+/**
+ * Value for the data-interface attribute on inline toolbar elements
+ * Used as a single source of truth for inline toolbar identification
+ */
+export const INLINE_TOOLBAR_INTERFACE_VALUE = 'inline-toolbar';
+
+/**
+ * Value for the data-interface attribute on tooltip elements
+ * Used as a single source of truth for tooltip identification
+ */
+export const TOOLTIP_INTERFACE_VALUE = 'tooltip';
+
+/**
+ * CSS selector for the main editor wrapper element
+ * Used to identify the editor container in the DOM
+ */
+export const EDITOR_INTERFACE_SELECTOR = '[data-interface=editorjs]';
+
+/**
+ * CSS selector for tooltip elements
+ * Used to identify tooltip elements in the DOM
+ */
+export const TOOLTIP_INTERFACE_SELECTOR = '[data-interface="tooltip"]';
+
+/**
+ * CSS selector for inline toolbar elements
+ * Used to identify inline toolbar elements in the DOM
+ */
+export const INLINE_TOOLBAR_INTERFACE_SELECTOR = '[data-interface=inline-toolbar]';
+
+/**
+ * Platform-specific modifier key for keyboard shortcuts
+ * Returns 'Meta' on macOS (darwin) and 'Control' on other platforms
+ * Used in tests for keyboard shortcut interactions
+ */
+export const MODIFIER_KEY = (() => {
+  // Check if we're in a Node.js environment
+  if (typeof process !== 'undefined' && process.platform) {
+    return process.platform === 'darwin' ? 'Meta' : 'Control';
+  }
+
+  // Browser environment: detect macOS using navigator
+  if (typeof navigator !== 'undefined') {
+    const userAgent = navigator.userAgent.toLowerCase();
+    const isMacOS = userAgent.includes('mac');
+
+    return isMacOS ? 'Meta' : 'Control';
+  }
+
+  // Fallback to Control if platform detection fails
+  return 'Control';
+})();
diff --git a/src/components/core.ts b/src/components/core.ts
index a7e307c32..2a9c7d79d 100644
--- a/src/components/core.ts
+++ b/src/components/core.ts
@@ -7,6 +7,7 @@ import { CriticalError } from './errors/critical';
 import EventsDispatcher from './utils/events';
 import Modules from './modules';
 import type { EditorEventMap } from './events';
+import type Renderer from './modules/renderer';
 
 /**
  * Editor.js core class. Bootstraps modules.
@@ -39,50 +40,48 @@ export default class Core {
     /**
      * Ready promise. Resolved if Editor.js is ready to work, rejected otherwise
      */
-    let onReady: (value?: void | PromiseLike<void>) => void;
-    let onFail: (reason?: unknown) => void;
+    // Initialize config to satisfy TypeScript's definite assignment check
+    // The setter will properly assign and process the config
+    this.config = {};
 
     this.isReady = new Promise((resolve, reject) => {
-      onReady = resolve;
-      onFail = reject;
-    });
-
-    Promise.resolve()
-      .then(async () => {
-        this.configuration = config;
+      Promise.resolve()
+        .then(async () => {
+          this.configuration = config;
 
-        this.validate();
-        this.init();
-        await this.start();
-        await this.render();
+          this.validate();
+          this.init();
+          await this.start();
+          await this.render();
 
-        const { BlockManager, Caret, UI, ModificationsObserver } = this.moduleInstances;
+          const { BlockManager, Caret, UI, ModificationsObserver } = this.moduleInstances;
 
-        UI.checkEmptiness();
-        ModificationsObserver.enable();
+          UI.checkEmptiness();
+          ModificationsObserver.enable();
 
-        if ((this.configuration as EditorConfig).autofocus === true && this.configuration.readOnly !== true) {
-          Caret.setToBlock(BlockManager.blocks[0], Caret.positions.START);
-        }
+          if ((this.configuration as EditorConfig).autofocus === true && this.configuration.readOnly !== true) {
+            Caret.setToBlock(BlockManager.blocks[0], Caret.positions.START);
+          }
 
-        onReady();
-      })
-      .catch((error) => {
-        _.log(`Editor.js is not ready because of ${error}`, 'error');
+          resolve();
+        })
+        .catch((error) => {
+          _.log(`Editor.js is not ready because of ${error}`, 'error');
 
-        /**
-         * Reject this.isReady promise
-         */
-        onFail(error);
-      });
+          /**
+           * Reject this.isReady promise
+           */
+          reject(error);
+        });
+    });
   }
 
   /**
    * Setting for configuration
    *
-   * @param {EditorConfig|string} config - Editor's config to set
+   * @param {EditorConfig|string|undefined} config - Editor's config to set
    */
-  public set configuration(config: EditorConfig|string) {
+  public set configuration(config: EditorConfig|string|undefined) {
     /**
      * Place config into the class property
      *
@@ -105,10 +104,10 @@ export default class Core {
     /**
      * If holderId is preset, assign him to holder property and work next only with holder
      */
-    _.deprecationAssert(!!this.config.holderId, 'config.holderId', 'config.holder');
-    if (this.config.holderId && !this.config.holder) {
+    _.deprecationAssert(Boolean(this.config.holderId), 'config.holderId', 'config.holder');
+    if (Boolean(this.config.holderId) && this.config.holder == null) {
       this.config.holder = this.config.holderId;
-      this.config.holderId = null;
+      this.config.holderId = undefined;
     }
 
     /**
@@ -118,7 +117,7 @@ export default class Core {
       this.config.holder = 'editorjs';
     }
 
-    if (!this.config.logLevel) {
+    if (this.config.logLevel == null) {
       this.config.logLevel = _.LogLevels.VERBOSE;
     }
 
@@ -128,7 +127,7 @@ export default class Core {
      * If default Block's Tool was not passed, use the Paragraph Tool
      */
     _.deprecationAssert(Boolean(this.config.initialBlock), 'config.initialBlock', 'config.defaultBlock');
-    this.config.defaultBlock = this.config.defaultBlock || this.config.initialBlock || 'paragraph';
+    this.config.defaultBlock = this.config.defaultBlock ?? this.config.initialBlock ?? 'paragraph';
 
     /**
      * Height of Editor's bottom area that allows to set focus on the last Block
@@ -149,14 +148,10 @@ export default class Core {
       data: {},
     };
 
-    this.config.placeholder = this.config.placeholder || false;
-    this.config.sanitizer = this.config.sanitizer || {
-      p: true,
-      b: true,
-      a: true,
-    } as SanitizerConfig;
+    this.config.placeholder = this.config.placeholder ?? false;
+    this.config.sanitizer = this.config.sanitizer ?? {} as SanitizerConfig;
 
-    this.config.hideToolbar = this.config.hideToolbar ? this.config.hideToolbar : false;
+    this.config.hideToolbar = this.config.hideToolbar ?? false;
     this.config.tools = this.config.tools || {};
     this.config.i18n = this.config.i18n || {};
     this.config.data = this.config.data || { blocks: [] };
@@ -203,7 +198,7 @@ export default class Core {
   public validate(): void {
     const { holderId, holder } = this.config;
 
-    if (holderId && holder) {
+    if (Boolean(holderId) && Boolean(holder)) {
       throw Error('«holderId» and «holder» param can\'t assign at the same time.');
     }
 
@@ -214,7 +209,7 @@ export default class Core {
       throw Error(`element with ID «${holder}» is missing. Pass correct holder's ID.`);
     }
 
-    if (holder && _.isObject(holder) && !$.isElement(holder)) {
+    if (Boolean(holder) && _.isObject(holder) && !$.isElement(holder)) {
       throw Error('«holder» value must be an Element node');
     }
   }
@@ -260,7 +255,9 @@ export default class Core {
         // _.log(`Preparing ${module} module`, 'time');
 
         try {
-          await this.moduleInstances[module].prepare();
+          const moduleInstance = this.moduleInstances[module as keyof EditorModules] as { prepare: () => Promise<void> | void };
+
+          await moduleInstance.prepare();
         } catch (e) {
           /**
            * CriticalError's will not be caught
@@ -281,7 +278,17 @@ export default class Core {
    * Render initial data
    */
   private render(): Promise<void> {
-    return this.moduleInstances.Renderer.render(this.config.data.blocks);
+    const renderer = this.moduleInstances['Renderer' as keyof EditorModules] as Renderer | undefined;
+
+    if (!renderer) {
+      throw new CriticalError('Renderer module is not initialized');
+    }
+
+    if (!this.config.data) {
+      throw new CriticalError('Editor data is not initialized');
+    }
+
+    return renderer.render(this.config.data.blocks);
   }
 
   /**
@@ -290,12 +297,12 @@ export default class Core {
   private constructModules(): void {
     Object.entries(Modules).forEach(([key, module]) => {
       try {
-        this.moduleInstances[key] = new module({
+        (this.moduleInstances as unknown as Record<string, EditorModules[keyof EditorModules]>)[key] = new module({
           config: this.configuration,
           eventsDispatcher: this.eventsDispatcher,
-        });
+        }) as EditorModules[keyof EditorModules];
       } catch (e) {
-        _.log('[constructModules]', `Module ${key} skipped because`, 'error', e);
+        _.log(`[constructModules] Module ${key} skipped because`, 'error', e);
       }
     });
   }
@@ -311,7 +318,7 @@ export default class Core {
         /**
          * Module does not need self-instance
          */
-        this.moduleInstances[name].state = this.getModulesDiff(name);
+        this.moduleInstances[name as keyof EditorModules].state = this.getModulesDiff(name);
       }
     }
   }
@@ -331,7 +338,7 @@ export default class Core {
       if (moduleName === name) {
         continue;
       }
-      diff[moduleName] = this.moduleInstances[moduleName];
+      (diff as unknown as Record<string, EditorModules[keyof EditorModules]>)[moduleName] = this.moduleInstances[moduleName as keyof EditorModules] as EditorModules[keyof EditorModules];
     }
 
     return diff;
diff --git a/src/components/dom.ts b/src/components/dom.ts
index 675735555..24b7af218 100644
--- a/src/components/dom.ts
+++ b/src/components/dom.ts
@@ -13,7 +13,7 @@ export default class Dom {
    * @returns {boolean}
    */
   public static isSingleTag(tag: HTMLElement): boolean {
-    return tag.tagName && [
+    return Boolean(tag.tagName) && [
       'AREA',
       'BASE',
       'BR',
@@ -40,10 +40,7 @@ export default class Dom {
    * @returns {boolean}
    */
   public static isLineBreakTag(element: HTMLElement): element is HTMLBRElement {
-    return element && element.tagName && [
-      'BR',
-      'WBR',
-    ].includes(element.tagName);
+    return !!element && ['BR', 'WBR'].includes(element.tagName);
   }
 
   /**
@@ -54,21 +51,37 @@ export default class Dom {
    * @param  {object} [attributes] - any attributes
    * @returns {HTMLElement}
    */
-  public static make(tagName: string, classNames: string | (string | undefined)[] | null = null, attributes: object = {}): HTMLElement {
+  public static make(tagName: string, classNames: string | (string | undefined)[] | null = null, attributes: Record<string, string | number | boolean | null | undefined> = {}): HTMLElement {
     const el = document.createElement(tagName);
 
     if (Array.isArray(classNames)) {
-      const validClassnames = classNames.filter(className => className !== undefined) as string[];
+      const validClassnames = classNames.filter((className): className is string => className !== undefined);
 
       el.classList.add(...validClassnames);
-    } else if (classNames) {
+    }
+
+    if (typeof classNames === 'string') {
       el.classList.add(classNames);
     }
 
     for (const attrName in attributes) {
-      if (Object.prototype.hasOwnProperty.call(attributes, attrName)) {
-        el[attrName] = attributes[attrName];
+      if (!Object.prototype.hasOwnProperty.call(attributes, attrName)) {
+        continue;
       }
+
+      const value = attributes[attrName];
+
+      if (value === undefined || value === null) {
+        continue;
+      }
+
+      if (attrName in el) {
+        (el as unknown as Record<string, unknown>)[attrName] = value;
+
+        continue;
+      }
+
+      el.setAttribute(attrName, String(value));
     }
 
     return el;
@@ -109,8 +122,9 @@ export default class Dom {
    */
   public static prepend(parent: Element, elements: Element | Element[]): void {
     if (Array.isArray(elements)) {
-      elements = elements.reverse();
-      elements.forEach((el) => parent.prepend(el));
+      const reversedElements = [ ...elements ].reverse();
+
+      reversedElements.forEach((el) => parent.prepend(el));
     } else {
       parent.prepend(elements);
     }
@@ -125,19 +139,19 @@ export default class Dom {
    */
   public static swap(el1: HTMLElement, el2: HTMLElement): void {
     // create marker element and insert it where el1 is
-    const temp = document.createElement('div'),
-        parent = el1.parentNode;
+    const temp = document.createElement('div');
+    const parent = el1.parentNode;
 
-    parent.insertBefore(temp, el1);
+    parent?.insertBefore(temp, el1);
 
     // move el1 to right before el2
-    parent.insertBefore(el1, el2);
+    parent?.insertBefore(el1, el2);
 
     // move el2 to right before where el1 used to be
-    parent.insertBefore(el2, temp);
+    parent?.insertBefore(el2, temp);
 
     // remove temporary marker node
-    parent.removeChild(temp);
+    parent?.removeChild(temp);
   }
 
   /**
@@ -216,50 +230,49 @@ export default class Dom {
    * @returns - it can be text Node or Element Node, so that caret will able to work with it
    *            Can return null if node is Document or DocumentFragment, or node is not attached to the DOM
    */
-  public static getDeepestNode(node: Node, atLast = false): Node | null {
+  public static getDeepestNode(node: Node | null, atLast = false): Node | null {
     /**
      * Current function have two directions:
-     *  - starts from first child and every time gets first or nextSibling in special cases
-     *  - starts from last child and gets last or previousSibling
+     * - starts from first child and every time gets first or nextSibling in special cases
+     * - starts from last child and gets last or previousSibling
      *
      * @type {string}
      */
-    const child = atLast ? 'lastChild' : 'firstChild',
-        sibling = atLast ? 'previousSibling' : 'nextSibling';
+    const child: 'lastChild' | 'firstChild' = atLast ? 'lastChild' : 'firstChild';
+    const sibling: 'previousSibling' | 'nextSibling' = atLast ? 'previousSibling' : 'nextSibling';
 
-    if (node && node.nodeType === Node.ELEMENT_NODE && node[child]) {
-      let nodeChild = node[child] as Node;
+    if (node === null || node.nodeType !== Node.ELEMENT_NODE) {
+      return node;
+    }
 
-      /**
-       * special case when child is single tag that can't contain any content
-       */
-      if (
-        Dom.isSingleTag(nodeChild as HTMLElement) &&
-        !Dom.isNativeInput(nodeChild) &&
-        !Dom.isLineBreakTag(nodeChild as HTMLElement)
-      ) {
-        /**
-         * 1) We need to check the next sibling. If it is Node Element then continue searching for deepest
-         * from sibling
-         *
-         * 2) If single tag's next sibling is null, then go back to parent and check his sibling
-         * In case of Node Element continue searching
-         *
-         * 3) If none of conditions above happened return parent Node Element
-         */
-        if (nodeChild[sibling]) {
-          nodeChild = nodeChild[sibling];
-        } else if (nodeChild.parentNode[sibling]) {
-          nodeChild = nodeChild.parentNode[sibling];
-        } else {
-          return nodeChild.parentNode;
-        }
-      }
+    const nodeChildProperty = node[child];
+
+    if (nodeChildProperty === null) {
+      return node;
+    }
+
+    const nodeChild = nodeChildProperty as Node;
+    const shouldSkipChild = Dom.isSingleTag(nodeChild as HTMLElement) &&
+      !Dom.isNativeInput(nodeChild) &&
+      !Dom.isLineBreakTag(nodeChild as HTMLElement);
 
+    if (!shouldSkipChild) {
       return this.getDeepestNode(nodeChild, atLast);
     }
 
-    return node;
+    const siblingNode = nodeChild[sibling];
+
+    if (siblingNode) {
+      return this.getDeepestNode(siblingNode, atLast);
+    }
+
+    const parentSiblingNode = nodeChild.parentNode?.[sibling];
+
+    if (parentSiblingNode) {
+      return this.getDeepestNode(parentSiblingNode, atLast);
+    }
+
+    return nodeChild.parentNode;
   }
 
   /**
@@ -274,7 +287,7 @@ export default class Dom {
       return false;
     }
 
-    return node && node.nodeType && node.nodeType === Node.ELEMENT_NODE;
+    return node != null && node.nodeType != null && node.nodeType === Node.ELEMENT_NODE;
   }
 
   /**
@@ -289,7 +302,7 @@ export default class Dom {
       return false;
     }
 
-    return node && node.nodeType && node.nodeType === Node.DOCUMENT_FRAGMENT_NODE;
+    return node != null && node.nodeType != null && node.nodeType === Node.DOCUMENT_FRAGMENT_NODE;
   }
 
   /**
@@ -315,7 +328,7 @@ export default class Dom {
       'TEXTAREA',
     ];
 
-    return target && target.tagName ? nativeInputs.includes(target.tagName) : false;
+    return target != null && typeof target.tagName === 'string' ? nativeInputs.includes(target.tagName) : false;
   }
 
   /**
@@ -325,26 +338,22 @@ export default class Dom {
    * @returns {boolean}
    */
   public static canSetCaret(target: HTMLElement): boolean {
-    let result = true;
-
     if (Dom.isNativeInput(target)) {
-      switch (target.type) {
-        case 'file':
-        case 'checkbox':
-        case 'radio':
-        case 'hidden':
-        case 'submit':
-        case 'button':
-        case 'image':
-        case 'reset':
-          result = false;
-          break;
-      }
-    } else {
-      result = Dom.isContentEditable(target);
+      const disallowedTypes = new Set([
+        'file',
+        'checkbox',
+        'radio',
+        'hidden',
+        'submit',
+        'button',
+        'image',
+        'reset',
+      ]);
+
+      return !disallowedTypes.has(target.type);
     }
 
-    return result;
+    return Dom.isContentEditable(target);
   }
 
   /**
@@ -357,23 +366,18 @@ export default class Dom {
    * @returns {boolean} true if it is empty
    */
   public static isNodeEmpty(node: Node, ignoreChars?: string): boolean {
-    let nodeText;
-
     if (this.isSingleTag(node as HTMLElement) && !this.isLineBreakTag(node as HTMLElement)) {
       return false;
     }
 
-    if (this.isElement(node) && this.isNativeInput(node)) {
-      nodeText = (node as HTMLInputElement).value;
-    } else {
-      nodeText = node.textContent.replace('\u200B', '');
-    }
-
-    if (ignoreChars) {
-      nodeText = nodeText.replace(new RegExp(ignoreChars, 'g'), '');
-    }
+    const baseText = this.isElement(node) && this.isNativeInput(node)
+      ? (node as HTMLInputElement).value
+      : node.textContent?.replace('\u200B', '');
+    const normalizedText = ignoreChars
+      ? baseText?.replace(new RegExp(ignoreChars, 'g'), '')
+      : baseText;
 
-    return nodeText.length === 0;
+    return (normalizedText?.length ?? 0) === 0;
   }
 
   /**
@@ -403,18 +407,18 @@ export default class Dom {
     const treeWalker = [ node ];
 
     while (treeWalker.length > 0) {
-      node = treeWalker.shift();
+      const currentNode = treeWalker.shift();
 
-      if (!node) {
+      if (!currentNode) {
         continue;
       }
 
-      if (this.isLeaf(node) && !this.isNodeEmpty(node, ignoreChars)) {
+      if (this.isLeaf(currentNode) && !this.isNodeEmpty(currentNode, ignoreChars)) {
         return false;
       }
 
-      if (node.childNodes) {
-        treeWalker.push(...Array.from(node.childNodes));
+      if (currentNode.childNodes) {
+        treeWalker.push(...Array.from(currentNode.childNodes));
       }
     }
 
@@ -450,7 +454,7 @@ export default class Dom {
       return (node as Text).length;
     }
 
-    return node.textContent.length;
+    return node.textContent?.length ?? 0;
   }
 
   /**
@@ -509,16 +513,17 @@ export default class Dom {
    * @returns {boolean}
    */
   public static containsOnlyInlineElements(data: string | HTMLElement): boolean {
-    let wrapper: HTMLElement;
+    const wrapper = _.isString(data)
+      ? (() => {
+        const container = document.createElement('div');
 
-    if (_.isString(data)) {
-      wrapper = document.createElement('div');
-      wrapper.innerHTML = data;
-    } else {
-      wrapper = data;
-    }
+        container.innerHTML = data;
+
+        return container;
+      })()
+      : data;
 
-    const check = (element: HTMLElement): boolean => {
+    const check = (element: Element): boolean => {
       return !Dom.blockElements.includes(element.tagName.toLowerCase()) &&
         Array.from(element.children).every(check);
     };
@@ -539,7 +544,7 @@ export default class Dom {
 
     return Array.from(parent.children).reduce((result, element) => {
       return [...result, ...Dom.getDeepestBlockElements(element as HTMLElement)];
-    }, []);
+    }, [] as HTMLElement[]);
   }
 
   /**
@@ -549,11 +554,17 @@ export default class Dom {
    * @returns {HTMLElement}
    */
   public static getHolder(element: string | HTMLElement): HTMLElement {
-    if (_.isString(element)) {
-      return document.getElementById(element);
+    if (!_.isString(element)) {
+      return element;
     }
 
-    return element;
+    const holder = document.getElementById(element);
+
+    if (holder !== null) {
+      return holder;
+    }
+
+    throw new Error(`Element with id "${element}" not found`);
   }
 
   /**
@@ -572,7 +583,7 @@ export default class Dom {
    * @todo handle case when editor initialized in scrollable popup
    * @param el - element to compute offset
    */
-  public static offset(el): { top: number; left: number; right: number; bottom: number } {
+  public static offset(el: Element): { top: number; left: number; right: number; bottom: number } {
     const rect = el.getBoundingClientRect();
     const scrollLeft = window.pageXOffset || document.documentElement.scrollLeft;
     const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
@@ -596,58 +607,77 @@ export default class Dom {
    * @returns {{node: Node | null, offset: number}} - node and offset inside node
    */
   public static getNodeByOffset(root: Node, totalOffset: number): {node: Node | null; offset: number} {
-    let currentOffset = 0;
-    let lastTextNode: Node | null = null;
-
     const walker = document.createTreeWalker(
       root,
       NodeFilter.SHOW_TEXT,
       null
     );
 
-    let node: Node | null = walker.nextNode();
+    const findNode = (
+      nextNode: Node | null,
+      accumulatedOffset: number,
+      previousNode: Node | null,
+      previousNodeLength: number
+    ): { node: Node | null; offset: number } => {
+      if (!nextNode && previousNode) {
+        const baseOffset = accumulatedOffset - previousNodeLength;
+        const safeTotalOffset = Math.max(totalOffset - baseOffset, 0);
+        const offsetInsidePrevious = Math.min(safeTotalOffset, previousNodeLength);
+
+        return {
+          node: previousNode,
+          offset: offsetInsidePrevious,
+        };
+      }
 
-    while (node) {
-      const textContent = node.textContent;
-      const nodeLength = textContent === null ? 0 : textContent.length;
+      if (!nextNode) {
+        return {
+          node: null,
+          offset: 0,
+        };
+      }
 
-      lastTextNode = node;
+      const textContent = nextNode.textContent ?? '';
+      const nodeLength = textContent.length;
+      const hasReachedOffset = accumulatedOffset + nodeLength >= totalOffset;
 
-      if (currentOffset + nodeLength >= totalOffset) {
-        break;
+      if (hasReachedOffset) {
+        return {
+          node: nextNode,
+          offset: Math.min(totalOffset - accumulatedOffset, nodeLength),
+        };
       }
 
-      currentOffset += nodeLength;
-      node = walker.nextNode();
-    }
+      return findNode(
+        walker.nextNode(),
+        accumulatedOffset + nodeLength,
+        nextNode,
+        nodeLength
+      );
+    };
 
-    /**
-     * If no node found or last node is empty, return null
-     */
-    if (!lastTextNode) {
+    const initialNode = walker.nextNode();
+    const { node, offset } = findNode(initialNode, 0, null, 0);
+
+    if (!node) {
       return {
         node: null,
         offset: 0,
       };
     }
 
-    const textContent = lastTextNode.textContent;
+    const textContent = node.textContent;
 
-    if (textContent === null || textContent.length === 0) {
+    if (!textContent || textContent.length === 0) {
       return {
         node: null,
         offset: 0,
       };
     }
 
-    /**
-     * Calculate offset inside found node
-     */
-    const nodeOffset = Math.min(totalOffset - currentOffset, textContent.length);
-
     return {
-      node: lastTextNode,
-      offset: nodeOffset,
+      node,
+      offset,
     };
   }
 }
@@ -665,7 +695,7 @@ export default class Dom {
  * @param textContent — any string, for ex a textContent of a node
  * @returns True if passed text content is whitespace which is collapsed (invisible) in browser
  */
-export function isCollapsedWhitespaces(textContent: string): boolean {
+export const isCollapsedWhitespaces = (textContent: string): boolean => {
   /**
    *  Throughout, whitespace is defined as one of the characters
    *  "\t" TAB \u0009
@@ -674,7 +704,7 @@ export function isCollapsedWhitespaces(textContent: string): boolean {
    *  " "  SPC \u0020
    */
   return !/[^\t\n\r ]/.test(textContent);
-}
+};
 
 /**
  * Calculates the Y coordinate of the text baseline from the top of the element's margin box,
@@ -682,18 +712,18 @@ export function isCollapsedWhitespaces(textContent: string): boolean {
  * The calculation formula is as follows:
  *
  * 1. Calculate the baseline offset:
- *    - Typically, the baseline is about 80% of the `fontSize` from the top of the text, as this is a common average for many fonts.
+ * - Typically, the baseline is about 80% of the `fontSize` from the top of the text, as this is a common average for many fonts.
  *
  * 2. Calculate the additional space due to `lineHeight`:
- *    - If the `lineHeight` is greater than the `fontSize`, the extra space is evenly distributed above and below the text. This extra space is `(lineHeight - fontSize) / 2`.
+ * - If the `lineHeight` is greater than the `fontSize`, the extra space is evenly distributed above and below the text. This extra space is `(lineHeight - fontSize) / 2`.
  *
  * 3. Calculate the total baseline Y coordinate:
- *    - Sum of `marginTop`, `borderTopWidth`, `paddingTop`, the extra space due to `lineHeight`, and the baseline offset.
+ * - Sum of `marginTop`, `borderTopWidth`, `paddingTop`, the extra space due to `lineHeight`, and the baseline offset.
  *
  * @param element - The element to calculate the baseline for.
  * @returns {number} - The Y coordinate of the text baseline from the top of the element's margin box.
  */
-export function calculateBaseline(element: Element): number {
+export const calculateBaseline = (element: Element): number => {
   const style = window.getComputedStyle(element);
   const fontSize = parseFloat(style.fontSize);
   // eslint-disable-next-line @typescript-eslint/no-magic-numbers
@@ -719,7 +749,7 @@ export function calculateBaseline(element: Element): number {
   const baselineY = marginTop + borderTopWidth + paddingTop + extraLineHeight + baselineOffset;
 
   return baselineY;
-}
+};
 
 /**
  * Toggles the [data-empty] attribute on element depending on its emptiness
@@ -727,6 +757,8 @@ export function calculateBaseline(element: Element): number {
  *
  * @param element - The element to toggle the [data-empty] attribute on
  */
-export function toggleEmptyMark(element: HTMLElement): void {
-  element.dataset.empty = Dom.isEmpty(element) ? 'true' : 'false';
-}
+export const toggleEmptyMark = (element: HTMLElement): void => {
+  const { dataset } = element;
+
+  dataset.empty = Dom.isEmpty(element) ? 'true' : 'false';
+};
diff --git a/src/components/domIterator.ts b/src/components/domIterator.ts
index 5c3137b46..d4dfdc6ca 100644
--- a/src/components/domIterator.ts
+++ b/src/components/domIterator.ts
@@ -40,19 +40,19 @@ export default class DomIterator {
    * @param {string} focusedCssClass - user-provided CSS-class that will be set in flipping process
    */
   constructor(
-    nodeList: HTMLElement[],
+    nodeList: HTMLElement[] | null | undefined,
     focusedCssClass: string
   ) {
-    this.items = nodeList || [];
+    this.items = nodeList ?? [];
     this.focusedCssClass = focusedCssClass;
   }
 
   /**
    * Returns Focused button Node
    *
-   * @returns {HTMLElement}
+   * @returns {HTMLElement | null}
    */
-  public get currentItem(): HTMLElement {
+  public get currentItem(): HTMLElement | null {
     if (this.cursor === -1) {
       return null;
     }
@@ -82,6 +82,13 @@ export default class DomIterator {
     this.items = nodeList;
   }
 
+  /**
+   * Returns true if iterator has items to navigate
+   */
+  public hasItems(): boolean {
+    return this.items.length > 0;
+  }
+
   /**
    * Sets cursor next to the current
    */
@@ -122,54 +129,47 @@ export default class DomIterator {
       return this.cursor;
     }
 
-    let focusedButtonIndex = this.cursor;
-
     /**
      * If activeButtonIndex === -1 then we have no chosen Tool in Toolbox
+     * Normalize "previous" Tool index depending on direction.
+     * We need to do this to highlight "first" Tool correctly
+     *
+     * Order of Tools: [0] [1] ... [n - 1]
+     * [0 = n] because of: n % n = 0 % n
+     *
+     * Direction 'right': for [0] the [n - 1] is a previous index
+     * [n - 1] -> [0]
+     *
+     * Direction 'left': for [n - 1] the [0] is a previous index
+     * [n - 1] <- [0]
      */
-    if (focusedButtonIndex === -1) {
-      /**
-       * Normalize "previous" Tool index depending on direction.
-       * We need to do this to highlight "first" Tool correctly
-       *
-       * Order of Tools: [0] [1] ... [n - 1]
-       *   [0 = n] because of: n % n = 0 % n
-       *
-       * Direction 'right': for [0] the [n - 1] is a previous index
-       *   [n - 1] -> [0]
-       *
-       * Direction 'left': for [n - 1] the [0] is a previous index
-       *   [n - 1] <- [0]
-       *
-       * @type {number}
-       */
-      focusedButtonIndex = direction === DomIterator.directions.RIGHT ? -1 : 0;
-    } else {
-      /**
-       * If we have chosen Tool then remove highlighting
-       */
-      this.items[focusedButtonIndex].classList.remove(this.focusedCssClass);
+    const defaultIndex = direction === DomIterator.directions.RIGHT ? -1 : 0;
+    const startingIndex = this.cursor === -1 ? defaultIndex : this.cursor;
+
+    /**
+     * If we have chosen Tool then remove highlighting
+     */
+    if (startingIndex !== -1) {
+      this.items[startingIndex].classList.remove(this.focusedCssClass);
     }
 
     /**
      * Count index for next Tool
      */
-    if (direction === DomIterator.directions.RIGHT) {
-      /**
-       * If we go right then choose next (+1) Tool
-       *
-       * @type {number}
-       */
-      focusedButtonIndex = (focusedButtonIndex + 1) % this.items.length;
-    } else {
-      /**
-       * If we go left then choose previous (-1) Tool
-       * Before counting module we need to add length before because of "The JavaScript Modulo Bug"
-       *
-       * @type {number}
-       */
-      focusedButtonIndex = (this.items.length + focusedButtonIndex - 1) % this.items.length;
-    }
+    const focusedButtonIndex = direction === DomIterator.directions.RIGHT
+      ? /**
+         * If we go right then choose next (+1) Tool
+         *
+         * @type {number}
+         */
+      (startingIndex + 1) % this.items.length
+      : /**
+         * If we go left then choose previous (-1) Tool
+         * Before counting module we need to add length before because of "The JavaScript Modulo Bug"
+         *
+         * @type {number}
+         */
+      (this.items.length + startingIndex - 1) % this.items.length;
 
     if (Dom.canSetCaret(this.items[focusedButtonIndex])) {
       /**
diff --git a/src/components/events/BlockSettingsClosed.ts b/src/components/events/BlockSettingsClosed.ts
new file mode 100644
index 000000000..5488c759a
--- /dev/null
+++ b/src/components/events/BlockSettingsClosed.ts
@@ -0,0 +1,12 @@
+/**
+ * Fired when block settings is closed
+ */
+export const BlockSettingsClosed = 'block-settings-closed';
+
+/**
+ * Payload that will be passed with the event
+ */
+export interface BlockSettingsClosedPayload {
+  // No payload needed for this event
+}
+
diff --git a/src/components/events/BlockSettingsOpened.ts b/src/components/events/BlockSettingsOpened.ts
new file mode 100644
index 000000000..b6d6e587c
--- /dev/null
+++ b/src/components/events/BlockSettingsOpened.ts
@@ -0,0 +1,12 @@
+/**
+ * Fired when block settings is opened
+ */
+export const BlockSettingsOpened = 'block-settings-opened';
+
+/**
+ * Payload that will be passed with the event
+ */
+export interface BlockSettingsOpenedPayload {
+  // No payload needed for this event
+}
+
diff --git a/src/components/events/index.ts b/src/components/events/index.ts
index 10f82cdc1..e8441f01f 100644
--- a/src/components/events/index.ts
+++ b/src/components/events/index.ts
@@ -9,6 +9,10 @@ import type { FakeCursorHaveBeenSetPayload } from './FakeCursorHaveBeenSet';
 import { FakeCursorHaveBeenSet } from './FakeCursorHaveBeenSet';
 import type { EditorMobileLayoutToggledPayload } from './EditorMobileLayoutToggled';
 import { EditorMobileLayoutToggled } from './EditorMobileLayoutToggled';
+import type { BlockSettingsOpenedPayload } from './BlockSettingsOpened';
+import { BlockSettingsOpened } from './BlockSettingsOpened';
+import type { BlockSettingsClosedPayload } from './BlockSettingsClosed';
+import { BlockSettingsClosed } from './BlockSettingsClosed';
 
 /**
  * Events fired by Editor Event Dispatcher
@@ -18,7 +22,9 @@ export {
   BlockChanged,
   FakeCursorAboutToBeToggled,
   FakeCursorHaveBeenSet,
-  EditorMobileLayoutToggled
+  EditorMobileLayoutToggled,
+  BlockSettingsOpened,
+  BlockSettingsClosed
 };
 
 /**
@@ -30,5 +36,7 @@ export interface EditorEventMap {
   [BlockChanged]: BlockChangedPayload;
   [FakeCursorAboutToBeToggled]: FakeCursorAboutToBeToggledPayload;
   [FakeCursorHaveBeenSet]: FakeCursorHaveBeenSetPayload;
-  [EditorMobileLayoutToggled]: EditorMobileLayoutToggledPayload
+  [EditorMobileLayoutToggled]: EditorMobileLayoutToggledPayload;
+  [BlockSettingsOpened]: BlockSettingsOpenedPayload;
+  [BlockSettingsClosed]: BlockSettingsClosedPayload;
 }
diff --git a/src/components/flipper.ts b/src/components/flipper.ts
index 5b6e04359..aea153e90 100644
--- a/src/components/flipper.ts
+++ b/src/components/flipper.ts
@@ -12,6 +12,11 @@ export interface FlipperOptions {
    */
   focusedItemClass?: string;
 
+  /**
+   * Allow handling keyboard events dispatched from contenteditable elements
+   */
+  handleContentEditableTargets?: boolean;
+
   /**
    * If flipping items are the same for all Block (for ex. Toolbox), ypu can pass it on constructing
    */
@@ -57,6 +62,16 @@ export default class Flipper {
    */
   private activated = false;
 
+  /**
+   * Skip moving focus on the next Tab press when initial focus was pre-set
+   */
+  private skipNextTabFocus = false;
+
+  /**
+   * True if flipper should handle events coming from contenteditable elements
+   */
+  private handleContentEditableTargets: boolean;
+
   /**
    * List codes of the keys allowed for handling
    */
@@ -65,7 +80,7 @@ export default class Flipper {
   /**
    * Call back for button click/enter
    */
-  private readonly activateCallback: (item: HTMLElement) => void;
+  private readonly activateCallback?: (item: HTMLElement) => void;
 
   /**
    * Contains list of callbacks to be executed on each flip
@@ -76,9 +91,10 @@ export default class Flipper {
    * @param options - different constructing settings
    */
   constructor(options: FlipperOptions) {
-    this.iterator = new DomIterator(options.items, options.focusedItemClass);
+    this.iterator = new DomIterator(options.items || [], options.focusedItemClass ?? '');
     this.activateCallback = options.activateCallback;
     this.allowedKeys = options.allowedKeys || Flipper.usedKeys;
+    this.handleContentEditableTargets = options.handleContentEditableTargets ?? false;
   }
 
   /**
@@ -107,11 +123,11 @@ export default class Flipper {
   public activate(items?: HTMLElement[], cursorPosition?: number): void {
     this.activated = true;
     if (items) {
-      this.iterator.setItems(items);
+      this.iterator?.setItems(items);
     }
 
     if (cursorPosition !== undefined) {
-      this.iterator.setCursor(cursorPosition);
+      this.iterator?.setCursor(cursorPosition);
     }
 
     /**
@@ -124,6 +140,7 @@ export default class Flipper {
      * - otherwise this handler will be called at the moment it is attached which causes false flipper firing (see https://techread.me/js-addeventlistener-fires-for-past-events/)
      */
     document.addEventListener('keydown', this.onKeyDown, true);
+    window.addEventListener('keydown', this.onKeyDown, true);
   }
 
   /**
@@ -132,8 +149,10 @@ export default class Flipper {
   public deactivate(): void {
     this.activated = false;
     this.dropCursor();
+    this.skipNextTabFocus = false;
 
-    document.removeEventListener('keydown', this.onKeyDown);
+    document.removeEventListener('keydown', this.onKeyDown, true);
+    window.removeEventListener('keydown', this.onKeyDown, true);
   }
 
   /**
@@ -144,11 +163,40 @@ export default class Flipper {
     this.flipRight();
   }
 
+  /**
+   * Focus item at specified position without triggering flip callbacks
+   *
+   * @param position - index of item to focus. Negative value clears focus.
+   */
+  public focusItem(position: number): void {
+    const iterator = this.iterator;
+
+    if (!iterator) {
+      return;
+    }
+
+    if (!iterator.hasItems()) {
+      return;
+    }
+
+    if (position < 0) {
+      iterator.dropCursor();
+
+      return;
+    }
+
+    if (!iterator.currentItem && position === 0) {
+      this.skipNextTabFocus = true;
+    }
+
+    iterator.setCursor(position);
+  }
+
   /**
    * Focuses previous flipper iterator item
    */
   public flipLeft(): void {
-    this.iterator.previous();
+    this.iterator?.previous();
     this.flipCallback();
   }
 
@@ -156,7 +204,7 @@ export default class Flipper {
    * Focuses next flipper iterator item
    */
   public flipRight(): void {
-    this.iterator.next();
+    this.iterator?.next();
     this.flipCallback();
   }
 
@@ -164,11 +212,11 @@ export default class Flipper {
    * Return true if some button is focused
    */
   public hasFocus(): boolean {
-    return !!this.iterator.currentItem;
+    return !!this.iterator?.currentItem;
   }
 
   /**
-   * Registeres function that should be executed on each navigation action
+   * Registers a function that should be executed on each navigation action
    *
    * @param cb - function to execute
    */
@@ -177,7 +225,7 @@ export default class Flipper {
   }
 
   /**
-   * Unregisteres function that is executed on each navigation action
+   * Unregisters a function that is executed on each navigation action
    *
    * @param cb - function to stop executing
    */
@@ -191,7 +239,26 @@ export default class Flipper {
    * @see DomIterator#dropCursor
    */
   private dropCursor(): void {
-    this.iterator.dropCursor();
+    this.iterator?.dropCursor();
+  }
+
+  /**
+   * Get numeric keyCode from KeyboardEvent.key for backward compatibility
+   *
+   * @param event - keyboard event
+   * @returns numeric keyCode or null if not recognized
+   */
+  private getKeyCode(event: KeyboardEvent): number | null {
+    const keyToCodeMap: Record<string, number> = {
+      'Tab': _.keyCodes.TAB,
+      'Enter': _.keyCodes.ENTER,
+      'ArrowLeft': _.keyCodes.LEFT,
+      'ArrowRight': _.keyCodes.RIGHT,
+      'ArrowUp': _.keyCodes.UP,
+      'ArrowDown': _.keyCodes.DOWN,
+    };
+
+    return keyToCodeMap[event.key] ?? null;
   }
 
   /**
@@ -200,31 +267,52 @@ export default class Flipper {
    * @param event - keydown event
    */
   private onKeyDown = (event: KeyboardEvent): void => {
-    const isReady = this.isEventReadyForHandling(event);
+    const target = event.target as HTMLElement | null;
 
-    if (!isReady) {
+    if (this.shouldSkipTarget(target, event)) {
       return;
     }
 
-    const isShiftKey = event.shiftKey;
+    const keyCode = this.getKeyCode(event);
+    const isDirectionalArrow = keyCode === _.keyCodes.LEFT
+      || keyCode === _.keyCodes.RIGHT
+      || keyCode === _.keyCodes.UP
+      || keyCode === _.keyCodes.DOWN;
 
     /**
-     * If shift key is pressed, do nothing
-     * Allows to select next/prev lines of text using keyboard
+     * Allow selecting text with Shift combined with arrow keys by delegating handling to the browser.
+     * Other Shift-based combinations (for example Shift+Tab) are still handled by Flipper.
      */
-    if (isShiftKey === true) {
+    if (event.shiftKey && isDirectionalArrow) {
       return;
     }
 
+    const isReady = this.isEventReadyForHandling(event);
+
+    if (!isReady) {
+      return;
+    }
+
+    /**
+     * Stop propagation to prevent plugin-level handlers from being called
+     * while Flipper manages keyboard navigation.
+     */
+    event.stopPropagation();
+    event.stopImmediatePropagation();
+    // eslint-disable-next-line no-param-reassign
+    event.cancelBubble = true;
+    // eslint-disable-next-line no-param-reassign
+    event.returnValue = false;
+
     /**
      * Prevent only used keys default behaviour
      * (allows to navigate by ARROW DOWN, for example)
      */
-    if (Flipper.usedKeys.includes(event.keyCode)) {
+    if (keyCode !== null && Flipper.usedKeys.includes(keyCode)) {
       event.preventDefault();
     }
 
-    switch (event.keyCode) {
+    switch (keyCode) {
       case _.keyCodes.TAB:
         this.handleTabPress(event);
         break;
@@ -250,7 +338,18 @@ export default class Flipper {
    * @returns {boolean}
    */
   private isEventReadyForHandling(event: KeyboardEvent): boolean {
-    return this.activated && this.allowedKeys.includes(event.keyCode);
+    const keyCode = this.getKeyCode(event);
+
+    return this.activated && keyCode !== null && this.allowedKeys.includes(keyCode);
+  }
+
+  /**
+   * Enables or disables handling events dispatched from contenteditable elements
+   *
+   * @param value - true if events from contenteditable elements should be handled
+   */
+  public setHandleContentEditableTargets(value: boolean): void {
+    this.handleContentEditableTargets = value;
   }
 
   /**
@@ -260,8 +359,14 @@ export default class Flipper {
    */
   private handleTabPress(event: KeyboardEvent): void {
     /** this property defines leaf direction */
-    const shiftKey = event.shiftKey,
-        direction = shiftKey ? DomIterator.directions.LEFT : DomIterator.directions.RIGHT;
+    const shiftKey = event.shiftKey;
+    const direction = shiftKey ? DomIterator.directions.LEFT : DomIterator.directions.RIGHT;
+
+    if (this.skipNextTabFocus) {
+      this.skipNextTabFocus = false;
+
+      return;
+    }
 
     switch (direction) {
       case DomIterator.directions.RIGHT:
@@ -273,6 +378,15 @@ export default class Flipper {
     }
   }
 
+  /**
+   * Delegates external keyboard events to the flipper handler.
+   *
+   * @param event - keydown event captured outside the flipper
+   */
+  public handleExternalKeydown(event: KeyboardEvent): void {
+    this.onKeyDown(event);
+  }
+
   /**
    * Enter press will click current item if flipper is activated
    *
@@ -283,7 +397,7 @@ export default class Flipper {
       return;
     }
 
-    if (this.iterator.currentItem) {
+    if (this.iterator?.currentItem) {
       /**
        * Stop Enter propagation only if flipper is ready to select focused item
        */
@@ -292,7 +406,7 @@ export default class Flipper {
       this.iterator.currentItem.click();
     }
 
-    if (_.isFunction(this.activateCallback)) {
+    if (_.isFunction(this.activateCallback) && this.iterator?.currentItem) {
       this.activateCallback(this.iterator.currentItem);
     }
   }
@@ -301,10 +415,31 @@ export default class Flipper {
    * Fired after flipping in any direction
    */
   private flipCallback(): void {
-    if (this.iterator.currentItem) {
+    if (this.iterator?.currentItem) {
       this.iterator.currentItem.scrollIntoViewIfNeeded();
     }
 
     this.flipCallbacks.forEach(cb => cb());
   }
+
+  /**
+   * Determine if keyboard events coming from a target should be skipped
+   *
+   * @param target - event target element
+   * @param event - keyboard event being handled
+   */
+  private shouldSkipTarget(target: HTMLElement | null, event: KeyboardEvent): boolean {
+    if (!target) {
+      return false;
+    }
+
+    const isNativeInput = target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement;
+    const shouldHandleNativeInput = target.dataset?.flipperTabTarget === 'true' && event.key === 'Tab';
+    const isContentEditable = target.isContentEditable;
+    const isInlineToolInput = target.closest('[data-link-tool-input-opened="true"]') !== null;
+
+    const shouldSkipContentEditable = isContentEditable && !this.handleContentEditableTargets;
+
+    return (isNativeInput && !shouldHandleNativeInput) || shouldSkipContentEditable || isInlineToolInput;
+  }
 }
diff --git a/src/components/i18n/index.ts b/src/components/i18n/index.ts
index feccdbb6f..8836131cb 100644
--- a/src/components/i18n/index.ts
+++ b/src/components/i18n/index.ts
@@ -85,7 +85,9 @@ export default class I18n {
         return {};
       }
 
-      return section[part];
-    }, I18n.currentDictionary);
+      const value = section[part];
+
+      return typeof value === 'string' ? {} : (value as Dictionary);
+    }, I18n.currentDictionary as Dictionary);
   }
 }
diff --git a/src/components/i18n/namespace-internal.ts b/src/components/i18n/namespace-internal.ts
index ed9520a59..0bb916bea 100644
--- a/src/components/i18n/namespace-internal.ts
+++ b/src/components/i18n/namespace-internal.ts
@@ -8,41 +8,43 @@ import { isObject, isString } from '../utils';
  * @param dict - Messages dictionary
  * @param [keyPath] - subsection path (used in recursive call)
  */
-function getNamespaces(dict: object, keyPath?: string): DictNamespaces<typeof defaultDictionary> {
-  const result = {};
+const getNamespaces = (dict: object, keyPath?: string): DictNamespaces<typeof defaultDictionary> => {
+  const result: Record<string, string | Record<string, unknown>> = {};
 
   Object.entries(dict).forEach(([key, section]) => {
-    if (isObject(section)) {
-      const newPath = keyPath ? `${keyPath}.${key}` : key;
-
-      /**
-       * Check current section values, if all of them are strings, so there is the last section
-       */
-      const isLastSection = Object.values(section).every((sectionValue) => {
-        return isString(sectionValue);
-      });
-
-      /**
-       * In last section, we substitute namespace path instead of object with translates
-       *
-       * ui.toolbar.toolbox – "ui.toolbar.toolbox"
-       * instead of
-       * ui.toolbar.toolbox – {"Add": ""}
-       */
-      if (isLastSection) {
-        result[key] = newPath;
-      } else {
-        result[key] = getNamespaces(section, newPath);
-      }
+    if (!isObject(section)) {
+      result[key] = section;
 
       return;
     }
 
-    result[key] = section;
+    const newPath = keyPath ? `${keyPath}.${key}` : key;
+
+    /**
+     * Check current section values, if all of them are strings, so there is the last section
+     */
+    const isLastSection = Object.values(section).every((sectionValue) => {
+      return isString(sectionValue);
+    });
+
+    /**
+     * In last section, we substitute namespace path instead of object with translates
+     *
+     * ui.toolbar.toolbox – "ui.toolbar.toolbox"
+     * instead of
+     * ui.toolbar.toolbox – {"Add": ""}
+     */
+    if (!isLastSection) {
+      result[key] = getNamespaces(section, newPath);
+
+      return;
+    }
+
+    result[key] = newPath;
   });
 
   return result as DictNamespaces<typeof defaultDictionary>;
-}
+};
 
 /**
  * Type safe access to the internal messages dictionary sections
diff --git a/src/components/inline-tools/inline-tool-bold.ts b/src/components/inline-tools/inline-tool-bold.ts
index c3a4d9d2b..890d52b04 100644
--- a/src/components/inline-tools/inline-tool-bold.ts
+++ b/src/components/inline-tools/inline-tool-bold.ts
@@ -1,6 +1,7 @@
 import type { InlineTool, SanitizerConfig } from '../../../types';
 import { IconBold } from '@codexteam/icons';
 import type { MenuConfig } from '../../../types/tools';
+import SelectionUtils from '../selection';
 
 /**
  * Bold Tool
@@ -24,20 +25,142 @@ export default class BoldInlineTool implements InlineTool {
 
   /**
    * Sanitizer Rule
-   * Leave <b> tags
+   * Leave <strong> tags
    *
    * @returns {object}
    */
   public static get sanitize(): SanitizerConfig {
     return {
+      strong: {},
       b: {},
     } as SanitizerConfig;
   }
 
+  private static shortcutListenerRegistered = false;
+  private static selectionListenerRegistered = false;
+  private static inputListenerRegistered = false;
+  private static markerSequence = 0;
+  private static readonly DATA_ATTR_COLLAPSED_LENGTH = 'data-bold-collapsed-length';
+  private static readonly DATA_ATTR_COLLAPSED_ACTIVE = 'data-bold-collapsed-active';
+  private static readonly DATA_ATTR_PREV_LENGTH = 'data-bold-prev-length';
+  private static readonly instances = new Set<BoldInlineTool>();
+
+  /**
+   *
+   */
+  constructor() {
+    if (typeof document === 'undefined') {
+      return;
+    }
+
+    BoldInlineTool.instances.add(this);
+
+    if (!BoldInlineTool.shortcutListenerRegistered) {
+      document.addEventListener('keydown', BoldInlineTool.handleShortcut, true);
+      BoldInlineTool.shortcutListenerRegistered = true;
+    }
+
+    if (!BoldInlineTool.selectionListenerRegistered) {
+      document.addEventListener('selectionchange', BoldInlineTool.handleGlobalSelectionChange, true);
+      BoldInlineTool.selectionListenerRegistered = true;
+    }
+
+    if (!BoldInlineTool.inputListenerRegistered) {
+      document.addEventListener('input', BoldInlineTool.handleGlobalInput, true);
+      BoldInlineTool.inputListenerRegistered = true;
+    }
+  }
+
+  /**
+   * Recursively check if a node or any of its parents is a bold tag (<strong>)
+   *
+   * @param node - The node to check
+   */
+  private static hasBoldParent(node: Node | null): boolean {
+    if (!node) {
+      return false;
+    }
+
+    if (node.nodeType === Node.ELEMENT_NODE && BoldInlineTool.isBoldTag(node as Element)) {
+      return true;
+    }
+
+    return BoldInlineTool.hasBoldParent(node.parentNode);
+  }
+
+  /**
+   * Recursively find a bold element (<strong>) in the parent chain
+   *
+   * @param node - The node to start searching from
+   */
+  private static findBoldElement(node: Node | null): HTMLElement | null {
+    if (!node) {
+      return null;
+    }
+
+    if (node.nodeType === Node.ELEMENT_NODE && BoldInlineTool.isBoldTag(node as Element)) {
+      return node as HTMLElement;
+    }
+
+    return BoldInlineTool.findBoldElement(node.parentNode);
+  }
+
+  /**
+   * Check if an element is a bold tag (<strong> for conversion)
+   *
+   * @param node - The element to check
+   */
+  private static isBoldTag(node: Element): boolean {
+    const tag = node.tagName;
+
+    return tag === 'B' || tag === 'STRONG';
+  }
+
+  /**
+   * Ensure an element is a <strong> tag, converting from <b> if needed
+   *
+   * @param element - The element to ensure is a strong tag
+   */
+  private static ensureStrongElement(element: HTMLElement): HTMLElement {
+    if (element.tagName === 'STRONG') {
+      return element;
+    }
+
+    const strong = document.createElement('strong');
+
+    if (element.hasAttributes()) {
+      Array.from(element.attributes).forEach((attr) => {
+        strong.setAttribute(attr.name, attr.value);
+      });
+    }
+
+    while (element.firstChild) {
+      strong.appendChild(element.firstChild);
+    }
+
+    element.replaceWith(strong);
+
+    return strong;
+  }
+
   /**
-   * Native Document's command that uses for Bold
+   * Merge two strong elements by moving children from right to left
+   *
+   * @param left - The left strong element to merge into
+   * @param right - The right strong element to merge from
    */
-  private readonly commandName: string = 'bold';
+  private static mergeStrongNodes(left: HTMLElement, right: HTMLElement): HTMLElement {
+    const leftStrong = BoldInlineTool.ensureStrongElement(left);
+    const rightStrong = BoldInlineTool.ensureStrongElement(right);
+
+    while (rightStrong.firstChild) {
+      leftStrong.appendChild(rightStrong.firstChild);
+    }
+
+    rightStrong.remove();
+
+    return leftStrong;
+  }
 
   /**
    * Create button for Inline Toolbar
@@ -47,12 +170,259 @@ export default class BoldInlineTool implements InlineTool {
       icon: IconBold,
       name: 'bold',
       onActivate: () => {
-        document.execCommand(this.commandName);
+        this.toggleBold();
+      },
+      isActive: () => {
+        const selection = window.getSelection();
+
+        return selection ? this.isSelectionVisuallyBold(selection) : false;
       },
-      isActive: () => document.queryCommandState(this.commandName),
     };
   }
 
+  /**
+   * Apply or remove bold formatting using modern Selection API
+   */
+  private toggleBold(): void {
+    const selection = window.getSelection();
+
+    if (!selection || selection.rangeCount === 0) {
+      return;
+    }
+
+    const range = selection.getRangeAt(0);
+
+    if (range.collapsed) {
+      this.toggleCollapsedSelection();
+
+      return;
+    }
+
+    // Check if selection is visually bold (ignoring whitespace) to match button state
+    // If visually bold, unwrap; otherwise wrap
+    const shouldUnwrap = this.isRangeBold(range, { ignoreWhitespace: true });
+
+    if (shouldUnwrap) {
+      this.unwrapBoldTags(range);
+    } else {
+      this.wrapWithBold(range);
+    }
+  }
+
+  /**
+   * Check if current selection is within a bold tag (<strong>)
+   *
+   * @param selection - The Selection object to check
+   */
+  private isSelectionVisuallyBold(selection: Selection): boolean {
+    if (!selection || selection.rangeCount === 0) {
+      return false;
+    }
+
+    const range = selection.getRangeAt(0);
+
+    return this.isRangeBold(range, { ignoreWhitespace: true });
+  }
+
+  /**
+   * Wrap selection with <strong> tag
+   *
+   * @param range - The Range object containing the selection to wrap
+   */
+  private wrapWithBold(range: Range): void {
+    const html = this.getRangeHtmlWithoutBold(range);
+    const insertedRange = this.replaceRangeWithHtml(range, `<strong>${html}</strong>`);
+    const selection = window.getSelection();
+
+    if (selection && insertedRange) {
+      selection.removeAllRanges();
+      selection.addRange(insertedRange);
+    }
+
+    const boldElement = selection ? BoldInlineTool.findBoldElement(selection.focusNode) : null;
+
+    if (!boldElement) {
+      return;
+    }
+
+    const merged = this.mergeAdjacentBold(boldElement);
+
+    this.normalizeWhitespaceAround(merged);
+
+    this.selectElementContents(merged);
+    BoldInlineTool.normalizeBoldTagsWithinEditor(window.getSelection());
+    BoldInlineTool.replaceNbspInBlock(window.getSelection());
+    this.notifySelectionChange();
+  }
+
+  /**
+   * Remove bold tags (<strong>) while preserving content
+   *
+   * @param range - The Range object containing the selection to unwrap
+   */
+  private unwrapBoldTags(range: Range): void {
+    const boldAncestors = this.collectBoldAncestors(range);
+    const selection = window.getSelection();
+
+    if (!selection) {
+      return;
+    }
+
+    const marker = document.createElement('span');
+    const fragment = range.extractContents();
+
+    marker.dataset.boldMarker = `unwrap-${BoldInlineTool.markerSequence++}`;
+    marker.appendChild(fragment);
+    this.removeNestedBold(marker);
+
+    range.insertNode(marker);
+
+    const markerRange = document.createRange();
+
+    markerRange.selectNodeContents(marker);
+    selection.removeAllRanges();
+    selection.addRange(markerRange);
+
+    for (;;) {
+      const currentBold = BoldInlineTool.findBoldElement(marker);
+
+      if (!currentBold) {
+        break;
+      }
+
+      this.moveMarkerOutOfBold(marker, currentBold);
+    }
+
+    const firstChild = marker.firstChild;
+    const lastChild = marker.lastChild;
+
+    this.unwrapElement(marker);
+
+    const finalRange = firstChild && lastChild ? (() => {
+      const newRange = document.createRange();
+
+      newRange.setStartBefore(firstChild);
+      newRange.setEndAfter(lastChild);
+
+      selection.removeAllRanges();
+      selection.addRange(newRange);
+
+      return newRange;
+    })() : undefined;
+
+    if (!finalRange) {
+      selection.removeAllRanges();
+    }
+
+    this.replaceNbspWithinRange(finalRange);
+    BoldInlineTool.normalizeBoldTagsWithinEditor(selection);
+    BoldInlineTool.replaceNbspInBlock(selection);
+    BoldInlineTool.removeEmptyBoldElements(selection);
+
+    boldAncestors.forEach((element) => {
+      if (BoldInlineTool.isElementEmpty(element)) {
+        element.remove();
+      }
+    });
+
+    this.notifySelectionChange();
+  }
+
+  /**
+   * Replace the current range contents with provided HTML snippet
+   *
+   * @param range - Range to replace
+   * @param html - HTML string to insert
+   * @returns range spanning inserted content
+   */
+  private replaceRangeWithHtml(range: Range, html: string): Range | undefined {
+    const fragment = BoldInlineTool.createFragmentFromHtml(html);
+    const firstInserted = fragment.firstChild ?? null;
+    const lastInserted = fragment.lastChild ?? null;
+
+    range.deleteContents();
+
+    if (!firstInserted || !lastInserted) {
+      return;
+    }
+
+    range.insertNode(fragment);
+
+    const newRange = document.createRange();
+
+    newRange.setStartBefore(firstInserted);
+    newRange.setEndAfter(lastInserted);
+
+    return newRange;
+  }
+
+  /**
+   * Move a temporary marker element outside of a bold ancestor while preserving content order
+   *
+   * @param marker - Marker element wrapping the selection contents
+   * @param boldElement - Bold ancestor containing the marker
+   */
+  private moveMarkerOutOfBold(marker: HTMLElement, boldElement: HTMLElement): void {
+    const parent = boldElement.parentNode;
+
+    if (!parent) {
+      return;
+    }
+
+    const isOnlyChild = boldElement.childNodes.length === 1 && boldElement.firstChild === marker;
+
+    if (isOnlyChild) {
+      boldElement.replaceWith(marker);
+
+      return;
+    }
+
+    const isFirstChild = boldElement.firstChild === marker;
+
+    if (isFirstChild) {
+      parent.insertBefore(marker, boldElement);
+
+      return;
+    }
+
+    const isLastChild = boldElement.lastChild === marker;
+
+    if (isLastChild) {
+      parent.insertBefore(marker, boldElement.nextSibling);
+
+      return;
+    }
+
+    const trailingClone = boldElement.cloneNode(false) as HTMLElement;
+
+    while (marker.nextSibling) {
+      trailingClone.appendChild(marker.nextSibling);
+    }
+
+    parent.insertBefore(trailingClone, boldElement.nextSibling);
+    parent.insertBefore(marker, trailingClone);
+  }
+
+  /**
+   * Select all contents of an element
+   *
+   * @param element - The element whose contents should be selected
+   */
+  private selectElementContents(element: HTMLElement): void {
+    const selection = window.getSelection();
+
+    if (!selection) {
+      return;
+    }
+
+    const newRange = document.createRange();
+
+    newRange.selectNodeContents(element);
+
+    selection.removeAllRanges();
+    selection.addRange(newRange);
+  }
+
   /**
    * Set a shortcut
    *
@@ -61,4 +431,1244 @@ export default class BoldInlineTool implements InlineTool {
   public get shortcut(): string {
     return 'CMD+B';
   }
+
+  /**
+   * Check if a range contains bold text
+   *
+   * @param range - The range to check
+   * @param options - Options for checking bold status
+   * @param options.ignoreWhitespace - Whether to ignore whitespace-only text nodes
+   */
+  private isRangeBold(range: Range, options: { ignoreWhitespace: boolean }): boolean {
+    if (range.collapsed) {
+      return Boolean(BoldInlineTool.findBoldElement(range.startContainer));
+    }
+
+    const walker = document.createTreeWalker(
+      range.commonAncestorContainer,
+      NodeFilter.SHOW_TEXT,
+      {
+        acceptNode: (node) => {
+          try {
+            return range.intersectsNode(node) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          } catch (error) {
+            /**
+             * Safari might throw if node is detached from DOM.
+             * In that case, fall back to manual comparison by wrapping node into a range.
+             */
+            const nodeRange = document.createRange();
+
+            nodeRange.selectNodeContents(node);
+
+            const startsBeforeEnd = range.compareBoundaryPoints(Range.END_TO_START, nodeRange) > 0;
+            const endsAfterStart = range.compareBoundaryPoints(Range.START_TO_END, nodeRange) < 0;
+
+            return (startsBeforeEnd && endsAfterStart) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          }
+        },
+      }
+    );
+
+    const textNodes: Text[] = [];
+
+    while (walker.nextNode()) {
+      const textNode = walker.currentNode as Text;
+      const value = textNode.textContent ?? '';
+
+      if (options.ignoreWhitespace && value.trim().length === 0) {
+        continue;
+      }
+
+      if (value.length === 0) {
+        continue;
+      }
+
+      textNodes.push(textNode);
+    }
+
+    if (textNodes.length === 0) {
+      return Boolean(BoldInlineTool.findBoldElement(range.startContainer));
+    }
+
+    return textNodes.every((textNode) => BoldInlineTool.hasBoldParent(textNode));
+  }
+
+  /**
+   * Remove nested bold tags from a root node
+   *
+   * @param root - The root node to process
+   */
+  private removeNestedBold(root: ParentNode): void {
+    const boldNodes = root.querySelectorAll?.('b,strong');
+
+    if (!boldNodes) {
+      return;
+    }
+
+    boldNodes.forEach((node) => {
+      this.unwrapElement(node);
+    });
+  }
+
+  /**
+   * Unwrap an element by moving its children to the parent
+   *
+   * @param element - The element to unwrap
+   */
+  private unwrapElement(element: Element): void {
+    const parent = element.parentNode;
+
+    if (!parent) {
+      element.remove();
+
+      return;
+    }
+
+    while (element.firstChild) {
+      parent.insertBefore(element.firstChild, element);
+    }
+
+    parent.removeChild(element);
+  }
+
+  /**
+   * Merge adjacent bold elements into a single element
+   *
+   * @param element - The bold element to merge with adjacent elements
+   */
+  private mergeAdjacentBold(element: HTMLElement): HTMLElement {
+    const initialTarget = BoldInlineTool.ensureStrongElement(element);
+
+    const previous = initialTarget.previousSibling;
+    const targetAfterPrevious = previous && previous.nodeType === Node.ELEMENT_NODE && BoldInlineTool.isBoldTag(previous as Element)
+      ? BoldInlineTool.mergeStrongNodes(previous as HTMLElement, initialTarget)
+      : initialTarget;
+
+    const next = targetAfterPrevious.nextSibling;
+    const finalTarget = next && next.nodeType === Node.ELEMENT_NODE && BoldInlineTool.isBoldTag(next as Element)
+      ? BoldInlineTool.mergeStrongNodes(targetAfterPrevious, next as HTMLElement)
+      : targetAfterPrevious;
+
+    return finalTarget;
+  }
+
+  /**
+   * Toggle bold formatting for a collapsed selection (caret position)
+   * Exits bold if caret is inside a bold element, otherwise starts a new bold element
+   */
+  private toggleCollapsedSelection(): void {
+    const selection = window.getSelection();
+
+    if (!selection || selection.rangeCount === 0) {
+      return;
+    }
+
+    const range = selection.getRangeAt(0);
+    const boldElement = BoldInlineTool.findBoldElement(range.startContainer) ?? BoldInlineTool.getBoundaryBold(range);
+
+    const updatedRange = boldElement
+      ? BoldInlineTool.exitCollapsedBold(selection, boldElement)
+      : this.startCollapsedBold(range);
+
+    if (updatedRange) {
+      selection.removeAllRanges();
+      selection.addRange(updatedRange);
+    }
+
+    BoldInlineTool.normalizeBoldTagsWithinEditor(selection);
+    BoldInlineTool.replaceNbspInBlock(selection);
+    BoldInlineTool.removeEmptyBoldElements(selection);
+    this.notifySelectionChange();
+  }
+
+  /**
+   * Insert a bold wrapper at the caret so newly typed text becomes bold
+   *
+   * @param range - Current collapsed range
+   */
+  private startCollapsedBold(range: Range): Range | undefined {
+    if (!range.collapsed) {
+      return;
+    }
+
+    const strong = document.createElement('strong');
+    const textNode = document.createTextNode('');
+
+    strong.appendChild(textNode);
+    strong.setAttribute(BoldInlineTool.DATA_ATTR_COLLAPSED_ACTIVE, 'true');
+
+    const container = range.startContainer;
+    const offset = range.startOffset;
+
+    const insertionSucceeded = (() => {
+      if (container.nodeType === Node.TEXT_NODE) {
+        return this.insertCollapsedBoldIntoText(container as Text, strong, offset);
+      }
+
+      if (container.nodeType === Node.ELEMENT_NODE) {
+        this.insertCollapsedBoldIntoElement(container as Element, strong, offset);
+
+        return true;
+      }
+
+      return false;
+    })();
+
+    if (!insertionSucceeded) {
+      return;
+    }
+
+    const newRange = document.createRange();
+
+    newRange.setStart(textNode, 0);
+    newRange.collapse(true);
+
+    return newRange;
+  }
+
+  /**
+   * Insert a collapsed bold wrapper when the caret resides inside a text node
+   *
+   * @param text - Text node containing the caret
+   * @param strong - Strong element to insert
+   * @param offset - Caret offset within the text node
+   * @returns true when insertion succeeded
+   */
+  private insertCollapsedBoldIntoText(text: Text, strong: HTMLElement, offset: number): boolean {
+    const textNode = text;
+    const parent = textNode.parentNode;
+
+    if (!parent) {
+      return false;
+    }
+
+    const content = textNode.textContent ?? '';
+    const before = content.slice(0, offset);
+    const after = content.slice(offset);
+
+    textNode.textContent = before;
+
+    const afterNode = after.length ? document.createTextNode(after) : null;
+
+    if (afterNode) {
+      parent.insertBefore(afterNode, textNode.nextSibling);
+    }
+
+    parent.insertBefore(strong, afterNode ?? textNode.nextSibling);
+    strong.setAttribute(BoldInlineTool.DATA_ATTR_PREV_LENGTH, before.length.toString());
+
+    return true;
+  }
+
+  /**
+   * Insert a collapsed bold wrapper directly into an element container
+   *
+   * @param element - Container element
+   * @param strong - Strong element to insert
+   * @param offset - Index at which to insert the strong element
+   */
+  private insertCollapsedBoldIntoElement(element: Element, strong: HTMLElement, offset: number): void {
+    const referenceNode = element.childNodes[offset] ?? null;
+
+    element.insertBefore(strong, referenceNode);
+    strong.setAttribute(BoldInlineTool.DATA_ATTR_PREV_LENGTH, '0');
+  }
+
+  /**
+   * Check if an element is empty (has no text content)
+   *
+   * @param element - The element to check
+   */
+  private static isElementEmpty(element: HTMLElement): boolean {
+    return (element.textContent ?? '').length === 0;
+  }
+
+  /**
+   *
+   */
+  private notifySelectionChange(): void {
+    BoldInlineTool.enforceCollapsedBoldLengths(window.getSelection());
+    document.dispatchEvent(new Event('selectionchange'));
+    this.updateToolbarButtonState();
+  }
+
+  /**
+   * Ensure inline toolbar button reflects the actual bold state after programmatic toggles
+   */
+  private updateToolbarButtonState(): void {
+    const selection = window.getSelection();
+
+    if (!selection) {
+      return;
+    }
+
+    const anchor = selection.anchorNode;
+    const anchorElement = anchor?.nodeType === Node.ELEMENT_NODE ? anchor as Element : anchor?.parentElement;
+    const editorWrapper = anchorElement?.closest(`.${SelectionUtils.CSS.editorWrapper}`);
+
+    if (!editorWrapper) {
+      return;
+    }
+
+    const toolbar = editorWrapper.querySelector('[data-cy=inline-toolbar]');
+
+    if (!(toolbar instanceof HTMLElement)) {
+      return;
+    }
+
+    const button = toolbar.querySelector('[data-item-name="bold"]');
+
+    if (!(button instanceof HTMLElement)) {
+      return;
+    }
+
+    const isActive = this.isSelectionVisuallyBold(selection);
+
+    button.classList.toggle('ce-popover-item--active', isActive);
+
+    if (isActive) {
+      button.setAttribute('data-popover-item-active', 'true');
+    } else {
+      button.removeAttribute('data-popover-item-active');
+    }
+  }
+
+  /**
+   * Normalize whitespace around a bold element
+   *
+   * @param element - The bold element to normalize whitespace around
+   */
+  private normalizeWhitespaceAround(element: HTMLElement): void {
+    BoldInlineTool.replaceNbspWithSpace(element.previousSibling);
+    BoldInlineTool.replaceNbspWithSpace(element.nextSibling);
+  }
+
+  /**
+   * Replace non-breaking spaces with regular spaces in a text node
+   *
+   * @param node - The text node to process
+   */
+  private static replaceNbspWithSpace(node: Node | null): void {
+    if (!node || node.nodeType !== Node.TEXT_NODE) {
+      return;
+    }
+
+    const textNode = node as Text;
+    const text = textNode.textContent ?? '';
+
+    if (!text.includes('\u00A0')) {
+      return;
+    }
+
+    textNode.textContent = text.replace(/\u00A0/g, ' ');
+  }
+
+  /**
+   * Restore a selection range from marker elements
+   *
+   * @param markerId - The ID of the markers used to mark the selection
+   */
+  private restoreSelectionFromMarkers(markerId: string): Range | undefined {
+    const startMarker = document.querySelector(`[data-bold-marker="${markerId}-start"]`);
+    const endMarker = document.querySelector(`[data-bold-marker="${markerId}-end"]`);
+
+    if (!startMarker || !endMarker) {
+      startMarker?.remove();
+      endMarker?.remove();
+
+      return;
+    }
+
+    const selection = window.getSelection();
+
+    if (!selection) {
+      startMarker.remove();
+      endMarker.remove();
+
+      return;
+    }
+
+    const newRange = document.createRange();
+
+    newRange.setStartAfter(startMarker);
+    newRange.setEndBefore(endMarker);
+
+    selection.removeAllRanges();
+    selection.addRange(newRange);
+
+    startMarker.remove();
+    endMarker.remove();
+
+    return newRange;
+  }
+
+  /**
+   * Replace non-breaking spaces with regular spaces within a range
+   *
+   * @param range - The range to process
+   */
+  private replaceNbspWithinRange(range?: Range): void {
+    if (!range) {
+      return;
+    }
+
+    const walker = document.createTreeWalker(
+      range.commonAncestorContainer,
+      NodeFilter.SHOW_TEXT,
+      {
+        acceptNode: (node) => {
+          try {
+            return range.intersectsNode(node) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          } catch (error) {
+            const nodeRange = document.createRange();
+
+            nodeRange.selectNodeContents(node);
+
+            const startsBeforeEnd = range.compareBoundaryPoints(Range.END_TO_START, nodeRange) > 0;
+            const endsAfterStart = range.compareBoundaryPoints(Range.START_TO_END, nodeRange) < 0;
+
+            return (startsBeforeEnd && endsAfterStart) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          }
+        },
+      }
+    );
+
+    while (walker.nextNode()) {
+      BoldInlineTool.replaceNbspWithSpace(walker.currentNode);
+    }
+  }
+
+  /**
+   * Normalize all bold tags within the editor to <strong> tags
+   * Converts any legacy <b> tags to <strong> tags
+   *
+   * @param selection - The current selection to determine the editor context
+   */
+  private static normalizeBoldTagsWithinEditor(selection: Selection | null): void {
+    const node = selection?.anchorNode ?? selection?.focusNode;
+
+    if (!node) {
+      return;
+    }
+
+    const element = node.nodeType === Node.ELEMENT_NODE ? node as Element : node.parentElement;
+    const root = element?.closest(`.${SelectionUtils.CSS.editorWrapper}`);
+
+    if (!root) {
+      return;
+    }
+
+    // Convert any legacy <b> tags to <strong> tags
+    root.querySelectorAll('b').forEach((boldNode) => {
+      BoldInlineTool.ensureStrongElement(boldNode as HTMLElement);
+    });
+  }
+
+  /**
+   * Replace non-breaking spaces with regular spaces in the block containing the selection
+   *
+   * @param selection - The current selection to determine the block context
+   */
+  private static replaceNbspInBlock(selection: Selection | null): void {
+    const node = selection?.anchorNode ?? selection?.focusNode;
+
+    if (!node) {
+      return;
+    }
+
+    const element = node.nodeType === Node.ELEMENT_NODE ? node as Element : node.parentElement;
+    const block = element?.closest('[data-block-tool="paragraph"]');
+
+    if (!block) {
+      return;
+    }
+
+    const walker = document.createTreeWalker(block, NodeFilter.SHOW_TEXT);
+
+    while (walker.nextNode()) {
+      BoldInlineTool.replaceNbspWithSpace(walker.currentNode);
+    }
+  }
+
+  /**
+   * Remove empty bold elements within the current block
+   *
+   * @param selection - The current selection to determine the block context
+   */
+  private static removeEmptyBoldElements(selection: Selection | null): void {
+    const node = selection?.anchorNode ?? selection?.focusNode;
+
+    if (!node) {
+      return;
+    }
+
+    const element = node.nodeType === Node.ELEMENT_NODE ? node as Element : node.parentElement;
+    const block = element?.closest('[data-block-tool="paragraph"]');
+
+    if (!block) {
+      return;
+    }
+
+    const focusNode = selection?.focusNode ?? null;
+
+    block.querySelectorAll('strong').forEach((strong) => {
+      if ((strong.textContent ?? '').length === 0 && !BoldInlineTool.isNodeWithin(focusNode, strong)) {
+        strong.remove();
+      }
+    });
+  }
+
+  /**
+   * Ensure collapsed bold placeholders absorb newly typed text
+   *
+   * @param selection - The current selection to determine the editor context
+   */
+  private static synchronizeCollapsedBold(selection: Selection | null): void {
+    const node = selection?.anchorNode ?? selection?.focusNode;
+    const element = node && node.nodeType === Node.ELEMENT_NODE ? node as Element : node?.parentElement;
+    const root = element?.closest(`.${SelectionUtils.CSS.editorWrapper}`) ?? element?.ownerDocument;
+
+    if (!root) {
+      return;
+    }
+
+    const selector = `strong[${BoldInlineTool.DATA_ATTR_COLLAPSED_ACTIVE}="true"]`;
+
+    root.querySelectorAll<HTMLElement>(selector).forEach((boldElement) => {
+      const prevLengthAttr = boldElement.getAttribute(BoldInlineTool.DATA_ATTR_PREV_LENGTH);
+      const prevNode = boldElement.previousSibling;
+
+      if (!prevLengthAttr || !prevNode || prevNode.nodeType !== Node.TEXT_NODE) {
+        return;
+      }
+
+      const prevLength = Number(prevLengthAttr);
+
+      if (!Number.isFinite(prevLength)) {
+        return;
+      }
+
+      const prevTextNode = prevNode as Text;
+      const prevText = prevTextNode.textContent ?? '';
+
+      if (prevText.length <= prevLength) {
+        return;
+      }
+
+      const preserved = prevText.slice(0, prevLength);
+      const extra = prevText.slice(prevLength);
+
+      prevTextNode.textContent = preserved;
+
+      const boldTextNode = boldElement.firstChild instanceof Text
+        ? boldElement.firstChild as Text
+        : boldElement.appendChild(document.createTextNode('')) as Text;
+
+      boldTextNode.textContent = (boldTextNode.textContent ?? '') + extra;
+
+      if (selection?.isCollapsed && BoldInlineTool.isNodeWithin(selection.focusNode, prevTextNode)) {
+        const newRange = document.createRange();
+        const caretOffset = boldTextNode.textContent?.length ?? 0;
+
+        newRange.setStart(boldTextNode, caretOffset);
+        newRange.collapse(true);
+
+        selection.removeAllRanges();
+        selection.addRange(newRange);
+      }
+    });
+  }
+
+  /**
+   * Ensure caret is positioned after boundary bold elements when toggling collapsed selections
+   *
+   * @param selection - Current selection
+   */
+  private static moveCaretAfterBoundaryBold(selection: Selection): void {
+    if (!selection.rangeCount) {
+      return;
+    }
+
+    const range = selection.getRangeAt(0);
+
+    if (!range.collapsed) {
+      return;
+    }
+
+    if (BoldInlineTool.moveCaretFromElementContainer(selection, range)) {
+      return;
+    }
+
+    BoldInlineTool.moveCaretFromTextContainer(selection, range);
+  }
+
+  /**
+   * Locate a bold element adjacent to a collapsed range
+   *
+   * @param range - Range to inspect
+   */
+  private static getAdjacentBold(range: Range): HTMLElement | null {
+    const container = range.startContainer;
+
+    if (container.nodeType === Node.TEXT_NODE) {
+      return BoldInlineTool.getBoldAdjacentToText(range, container as Text);
+    }
+
+    if (container.nodeType === Node.ELEMENT_NODE) {
+      return BoldInlineTool.getBoldAdjacentToElement(range, container as Element);
+    }
+
+    return null;
+  }
+
+  /**
+   * Get bold element adjacent to a text node container
+   *
+   * @param range - Current collapsed range
+   * @param textNode - Text node hosting the caret
+   */
+  private static getBoldAdjacentToText(range: Range, textNode: Text): HTMLElement | null {
+    const textLength = textNode.textContent?.length ?? 0;
+    const previous = textNode.previousSibling;
+
+    if (range.startOffset === 0 && BoldInlineTool.isBoldElement(previous)) {
+      return previous as HTMLElement;
+    }
+
+    if (range.startOffset !== textLength) {
+      return null;
+    }
+
+    const next = textNode.nextSibling;
+
+    return BoldInlineTool.isBoldElement(next) ? next as HTMLElement : null;
+  }
+
+  /**
+   * Get bold element adjacent to an element container
+   *
+   * @param range - Current collapsed range
+   * @param element - Element containing the caret
+   */
+  private static getBoldAdjacentToElement(range: Range, element: Element): HTMLElement | null {
+    const previous = range.startOffset > 0 ? element.childNodes[range.startOffset - 1] ?? null : null;
+
+    if (BoldInlineTool.isBoldElement(previous)) {
+      return previous as HTMLElement;
+    }
+
+    const next = element.childNodes[range.startOffset] ?? null;
+
+    return BoldInlineTool.isBoldElement(next) ? next as HTMLElement : null;
+  }
+
+  /**
+   * Exit collapsed bold state when caret no longer resides within bold content
+   *
+   * @param selection - Current selection
+   * @param range - Collapsed range after toggling bold
+   */
+  private static exitCollapsedIfNeeded(selection: Selection, range: Range): void {
+    const insideBold = Boolean(BoldInlineTool.findBoldElement(range.startContainer));
+
+    if (insideBold) {
+      return;
+    }
+
+    const boundaryBold = BoldInlineTool.getBoundaryBold(range) ?? BoldInlineTool.getAdjacentBold(range);
+
+    if (!boundaryBold) {
+      return;
+    }
+
+    const caretRange = BoldInlineTool.exitCollapsedBold(selection, boundaryBold);
+
+    if (!caretRange) {
+      return;
+    }
+
+    selection.removeAllRanges();
+    selection.addRange(caretRange);
+  }
+
+  /**
+   * Adjust caret when selection container is an element adjacent to bold content
+   *
+   * @param selection - Current selection
+   * @param range - Collapsed range to inspect
+   * @returns true when caret position was updated
+   */
+  private static moveCaretFromElementContainer(selection: Selection, range: Range): boolean {
+    if (range.startContainer.nodeType !== Node.ELEMENT_NODE) {
+      return false;
+    }
+
+    const element = range.startContainer as Element;
+    const movedAfterPrevious = BoldInlineTool.moveCaretAfterPreviousBold(selection, element, range.startOffset);
+
+    if (movedAfterPrevious) {
+      return true;
+    }
+
+    return BoldInlineTool.moveCaretBeforeNextBold(selection, element, range.startOffset);
+  }
+
+  /**
+   * Move caret after the bold node that precedes the caret when possible
+   *
+   * @param selection - Current selection
+   * @param element - Container element
+   * @param offset - Caret offset within the container
+   */
+  private static moveCaretAfterPreviousBold(selection: Selection, element: Element, offset: number): boolean {
+    const beforeNode = offset > 0 ? element.childNodes[offset - 1] ?? null : null;
+
+    if (!BoldInlineTool.isBoldElement(beforeNode)) {
+      return false;
+    }
+
+    const textNode = BoldInlineTool.ensureFollowingTextNode(beforeNode as Element, beforeNode.nextSibling);
+
+    if (!textNode) {
+      return false;
+    }
+
+    BoldInlineTool.setCaret(selection, textNode, 0);
+
+    return true;
+  }
+
+  /**
+   * Move caret before the bold node that follows the caret, ensuring there's a text node to receive input
+   *
+   * @param selection - Current selection
+   * @param element - Container element
+   * @param offset - Caret offset within the container
+   */
+  private static moveCaretBeforeNextBold(selection: Selection, element: Element, offset: number): boolean {
+    const nextNode = element.childNodes[offset] ?? null;
+
+    if (!BoldInlineTool.isBoldElement(nextNode)) {
+      return false;
+    }
+
+    const textNode = BoldInlineTool.ensureFollowingTextNode(nextNode as Element, nextNode.nextSibling);
+
+    if (!textNode) {
+      BoldInlineTool.setCaretAfterNode(selection, nextNode);
+
+      return true;
+    }
+
+    BoldInlineTool.setCaret(selection, textNode, 0);
+
+    return true;
+  }
+
+  /**
+   * Adjust caret when selection container is a text node adjacent to bold content
+   *
+   * @param selection - Current selection
+   * @param range - Collapsed range to inspect
+   */
+  private static moveCaretFromTextContainer(selection: Selection, range: Range): void {
+    if (range.startContainer.nodeType !== Node.TEXT_NODE) {
+      return;
+    }
+
+    const textNode = range.startContainer as Text;
+    const boldElement = BoldInlineTool.findBoldElement(textNode);
+
+    if (!boldElement || range.startOffset !== (textNode.textContent?.length ?? 0)) {
+      return;
+    }
+
+    const textNodeAfter = BoldInlineTool.ensureFollowingTextNode(boldElement, boldElement.nextSibling);
+
+    if (textNodeAfter) {
+      BoldInlineTool.setCaret(selection, textNodeAfter, 0);
+
+      return;
+    }
+
+    BoldInlineTool.setCaretAfterNode(selection, boldElement);
+  }
+
+  /**
+   * Determine whether a node is a bold element (<strong>/<b>)
+   *
+   * @param node - Node to inspect
+   */
+  private static isBoldElement(node: Node | null): node is Element {
+    return Boolean(node && node.nodeType === Node.ELEMENT_NODE && BoldInlineTool.isBoldTag(node as Element));
+  }
+
+  /**
+   * Place caret at the provided offset within a text node
+   *
+   * @param selection - Current selection
+   * @param node - Target text node
+   * @param offset - Offset within the text node
+   */
+  private static setCaret(selection: Selection, node: Text, offset: number): void {
+    const newRange = document.createRange();
+
+    newRange.setStart(node, offset);
+    newRange.collapse(true);
+
+    selection.removeAllRanges();
+    selection.addRange(newRange);
+  }
+
+  /**
+   * Position caret immediately after the provided node
+   *
+   * @param selection - Current selection
+   * @param node - Reference node
+   */
+  private static setCaretAfterNode(selection: Selection, node: Node | null): void {
+    if (!node) {
+      return;
+    }
+
+    const newRange = document.createRange();
+
+    newRange.setStartAfter(node);
+    newRange.collapse(true);
+
+    selection.removeAllRanges();
+    selection.addRange(newRange);
+  }
+
+  /**
+   * Ensure there is a text node immediately following a bold element to accept new input
+   *
+   * @param boldElement - Bold element after which text should be inserted
+   * @param referenceNode - Node that currently follows the bold element
+   */
+  private static ensureFollowingTextNode(boldElement: Element, referenceNode: Node | null): Text | null {
+    const parent = boldElement.parentNode;
+
+    if (!parent) {
+      return null;
+    }
+
+    if (referenceNode && referenceNode.nodeType === Node.TEXT_NODE) {
+      return referenceNode as Text;
+    }
+
+    const textNode = document.createTextNode('');
+
+    parent.insertBefore(textNode, referenceNode);
+
+    return textNode;
+  }
+
+  /**
+   * Enforce length limits on collapsed bold elements
+   *
+   * @param selection - The current selection to determine the editor context
+   */
+  private static enforceCollapsedBoldLengths(selection: Selection | null): void {
+    const node = selection?.anchorNode ?? selection?.focusNode;
+
+    if (!node) {
+      return;
+    }
+
+    const element = node.nodeType === Node.ELEMENT_NODE ? node as Element : node.parentElement;
+    const root = element?.closest(`.${SelectionUtils.CSS.editorWrapper}`);
+
+    if (!root) {
+      return;
+    }
+
+    const tracked = root.querySelectorAll<HTMLElement>(`strong[${BoldInlineTool.DATA_ATTR_COLLAPSED_LENGTH}]`);
+
+    tracked.forEach((boldElement) => {
+      const boldEl = boldElement;
+      const lengthAttr = boldEl.getAttribute(BoldInlineTool.DATA_ATTR_COLLAPSED_LENGTH);
+
+      if (!lengthAttr) {
+        return;
+      }
+
+      const allowedLength = Number(lengthAttr);
+      const currentText = boldEl.textContent ?? '';
+
+      if (!Number.isFinite(allowedLength)) {
+        return;
+      }
+
+      const shouldRemoveCurrentLength = currentText.length > allowedLength;
+      const newTextNodeAfterSplit = shouldRemoveCurrentLength
+        ? BoldInlineTool.splitCollapsedBoldText(boldEl, allowedLength, currentText)
+        : null;
+
+      const prevLengthAttr = boldEl.getAttribute(BoldInlineTool.DATA_ATTR_PREV_LENGTH);
+      const prevLength = prevLengthAttr ? Number(prevLengthAttr) : NaN;
+      const prevNode = boldEl.previousSibling;
+      const previousTextNode = prevNode?.nodeType === Node.TEXT_NODE ? prevNode as Text : null;
+      const prevText = previousTextNode?.textContent ?? '';
+      const shouldRemovePrevLength = Boolean(
+        prevLengthAttr &&
+        Number.isFinite(prevLength) &&
+        previousTextNode &&
+        prevText.length > prevLength
+      );
+
+      if (shouldRemovePrevLength && previousTextNode) {
+        const preservedPrev = prevText.slice(0, prevLength);
+        const extraPrev = prevText.slice(prevLength);
+
+        previousTextNode.textContent = preservedPrev;
+        const extraNode = document.createTextNode(extraPrev);
+
+        boldEl.parentNode?.insertBefore(extraNode, boldEl.nextSibling);
+      }
+
+      if (shouldRemovePrevLength) {
+        boldEl.removeAttribute(BoldInlineTool.DATA_ATTR_PREV_LENGTH);
+      }
+
+      if (selection?.isCollapsed && newTextNodeAfterSplit && BoldInlineTool.isNodeWithin(selection.focusNode, boldEl)) {
+        const caretRange = document.createRange();
+        const caretOffset = newTextNodeAfterSplit.textContent?.length ?? 0;
+
+        caretRange.setStart(newTextNodeAfterSplit, caretOffset);
+        caretRange.collapse(true);
+
+        selection.removeAllRanges();
+        selection.addRange(caretRange);
+      }
+
+      if (shouldRemoveCurrentLength) {
+        boldEl.removeAttribute(BoldInlineTool.DATA_ATTR_COLLAPSED_LENGTH);
+      }
+    });
+  }
+
+  /**
+   * Split text content exceeding the allowed collapsed bold length and move the excess outside
+   *
+   * @param boldEl - Bold element hosting the collapsed selection
+   * @param allowedLength - Maximum allowed length for the collapsed bold
+   * @param currentText - Current text content inside the bold element
+   */
+  private static splitCollapsedBoldText(boldEl: HTMLElement, allowedLength: number, currentText: string): Text | null {
+    const targetBoldElement = boldEl;
+    const parent = targetBoldElement.parentNode;
+
+    if (!parent) {
+      return null;
+    }
+
+    const preserved = currentText.slice(0, allowedLength);
+    const extra = currentText.slice(allowedLength);
+
+    targetBoldElement.textContent = preserved;
+
+    const textNode = document.createTextNode(extra);
+
+    parent.insertBefore(textNode, targetBoldElement.nextSibling);
+
+    return textNode;
+  }
+
+  /**
+   * Check if a node is within the provided container
+   *
+   * @param target - Node to test
+   * @param container - Potential ancestor container
+   */
+  private static isNodeWithin(target: Node | null, container: Node): boolean {
+    if (!target) {
+      return false;
+    }
+
+    return target === container || container.contains(target);
+  }
+
+  /**
+   *
+   */
+  private static handleGlobalSelectionChange(): void {
+    BoldInlineTool.enforceCollapsedBoldLengths(window.getSelection());
+    BoldInlineTool.synchronizeCollapsedBold(window.getSelection());
+  }
+
+  /**
+   *
+   */
+  private static handleGlobalInput(): void {
+    BoldInlineTool.enforceCollapsedBoldLengths(window.getSelection());
+    BoldInlineTool.synchronizeCollapsedBold(window.getSelection());
+  }
+
+  /**
+   * Attempt to toggle bold via the browser's native command
+   *
+   * @param selection - Current selection
+   */
+  /**
+   * Exit a collapsed bold selection by moving the caret outside the bold element
+   *
+   * @param selection - The current selection
+   * @param boldElement - The bold element to exit from
+   */
+  private static exitCollapsedBold(selection: Selection, boldElement: HTMLElement): Range | undefined {
+    const parent = boldElement.parentNode;
+
+    if (!parent) {
+      return;
+    }
+
+    if (BoldInlineTool.isElementEmpty(boldElement)) {
+      return BoldInlineTool.removeEmptyBoldElement(selection, boldElement, parent);
+    }
+
+    return BoldInlineTool.exitCollapsedBoldWithContent(selection, boldElement, parent);
+  }
+
+  /**
+   * Remove an empty bold element and place the caret before its position
+   *
+   * @param selection - Current selection
+   * @param boldElement - Bold element to remove
+   * @param parent - Parent node that hosts the bold element
+   */
+  private static removeEmptyBoldElement(selection: Selection, boldElement: HTMLElement, parent: ParentNode): Range {
+    const newRange = document.createRange();
+
+    newRange.setStartBefore(boldElement);
+    newRange.collapse(true);
+
+    parent.removeChild(boldElement);
+
+    selection.removeAllRanges();
+    selection.addRange(newRange);
+
+    return newRange;
+  }
+
+  /**
+   * Exit a collapsed bold state when the bold element still contains text
+   *
+   * @param selection - Current selection
+   * @param boldElement - Bold element currently wrapping the caret
+   * @param parent - Parent node that hosts the bold element
+   */
+  private static exitCollapsedBoldWithContent(selection: Selection, boldElement: HTMLElement, parent: ParentNode): Range {
+    boldElement.setAttribute(BoldInlineTool.DATA_ATTR_COLLAPSED_LENGTH, (boldElement.textContent?.length ?? 0).toString());
+    boldElement.removeAttribute(BoldInlineTool.DATA_ATTR_PREV_LENGTH);
+    boldElement.removeAttribute(BoldInlineTool.DATA_ATTR_COLLAPSED_ACTIVE);
+
+    const initialNextSibling = boldElement.nextSibling;
+    const needsNewNode = !initialNextSibling || initialNextSibling.nodeType !== Node.TEXT_NODE;
+    const newNode = needsNewNode ? document.createTextNode('') : null;
+
+    if (newNode) {
+      parent.insertBefore(newNode, initialNextSibling);
+    }
+
+    const nextSibling = (newNode ?? initialNextSibling) as Text;
+    const newRange = document.createRange();
+
+    newRange.setStart(nextSibling, 0);
+    newRange.collapse(true);
+
+    selection.removeAllRanges();
+    selection.addRange(newRange);
+
+    return newRange;
+  }
+
+  /**
+   * Get a bold element at the boundary of a collapsed range
+   *
+   * @param range - The collapsed range to check
+   */
+  private static getBoundaryBold(range: Range): HTMLElement | null {
+    const container = range.startContainer;
+
+    if (container.nodeType === Node.TEXT_NODE) {
+      return BoldInlineTool.getBoundaryBoldForText(range, container as Text);
+    }
+
+    if (container.nodeType === Node.ELEMENT_NODE) {
+      return BoldInlineTool.getBoundaryBoldForElement(range, container as Element);
+    }
+
+    return null;
+  }
+
+  /**
+   * Get boundary bold when caret resides inside a text node
+   *
+   * @param range - Collapsed range
+   * @param textNode - Text container
+   */
+  private static getBoundaryBoldForText(range: Range, textNode: Text): HTMLElement | null {
+    const length = textNode.textContent?.length ?? 0;
+
+    if (range.startOffset === length) {
+      return BoldInlineTool.findBoldElement(textNode);
+    }
+
+    if (range.startOffset !== 0) {
+      return null;
+    }
+
+    const previous = textNode.previousSibling;
+
+    return BoldInlineTool.isBoldElement(previous) ? previous as HTMLElement : null;
+  }
+
+  /**
+   * Get boundary bold when caret container is an element
+   *
+   * @param range - Collapsed range
+   * @param element - Element container
+   */
+  private static getBoundaryBoldForElement(range: Range, element: Element): HTMLElement | null {
+    if (range.startOffset <= 0) {
+      return null;
+    }
+
+    const previous = element.childNodes[range.startOffset - 1];
+
+    return BoldInlineTool.isBoldElement(previous) ? previous as HTMLElement : null;
+  }
+
+  /**
+   * Handle keyboard shortcut for bold when selection is collapsed
+   *
+   * @param event - The keyboard event
+   */
+  private static handleShortcut(event: KeyboardEvent): void {
+    if (!BoldInlineTool.isBoldShortcut(event)) {
+      return;
+    }
+
+    const selection = window.getSelection();
+
+    if (!selection || !selection.rangeCount || !BoldInlineTool.isSelectionInsideEditor(selection)) {
+      return;
+    }
+
+    const instance = BoldInlineTool.instances.values().next().value;
+
+    if (!instance) {
+      return;
+    }
+
+    event.preventDefault();
+    event.stopPropagation();
+    event.stopImmediatePropagation();
+
+    instance.toggleBold();
+  }
+
+  /**
+   * Check if a keyboard event is the bold shortcut (Cmd/Ctrl+B)
+   *
+   * @param event - The keyboard event to check
+   */
+  private static isBoldShortcut(event: KeyboardEvent): boolean {
+    const platform = typeof navigator !== 'undefined' ? navigator.platform : '';
+    const isMac = platform.toUpperCase().includes('MAC');
+    const primaryModifier = isMac ? event.metaKey : event.ctrlKey;
+
+    if (!primaryModifier || event.altKey) {
+      return false;
+    }
+
+    return event.key.toLowerCase() === 'b';
+  }
+
+  /**
+   * Check if a selection is inside the editor
+   *
+   * @param selection - The selection to check
+   */
+  private static isSelectionInsideEditor(selection: Selection): boolean {
+    const anchor = selection.anchorNode;
+
+    if (!anchor) {
+      return false;
+    }
+
+    const element = anchor.nodeType === Node.ELEMENT_NODE ? anchor as Element : anchor.parentElement;
+
+    return Boolean(element?.closest(`.${SelectionUtils.CSS.editorWrapper}`));
+  }
+
+  /**
+   * Get HTML content of a range with bold tags removed
+   *
+   * @param range - The range to extract HTML from
+   */
+  private getRangeHtmlWithoutBold(range: Range): string {
+    const contents = range.cloneContents();
+
+    this.removeNestedBold(contents);
+
+    const container = document.createElement('div');
+
+    container.appendChild(contents);
+
+    return container.innerHTML;
+  }
+
+  /**
+   * Convert an HTML snippet to a document fragment
+   *
+   * @param html - HTML string to convert
+   */
+  private static createFragmentFromHtml(html: string): DocumentFragment {
+    const template = document.createElement('template');
+
+    template.innerHTML = html;
+
+    return template.content;
+  }
+
+  /**
+   * Collect all bold ancestor elements within a range
+   *
+   * @param range - The range to search for bold ancestors
+   */
+  private collectBoldAncestors(range: Range): HTMLElement[] {
+    const ancestors = new Set<HTMLElement>();
+    const walker = document.createTreeWalker(
+      range.commonAncestorContainer,
+      NodeFilter.SHOW_TEXT,
+      {
+        acceptNode: (node) => {
+          try {
+            return range.intersectsNode(node) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          } catch (error) {
+            const nodeRange = document.createRange();
+
+            nodeRange.selectNodeContents(node);
+
+            const startsBeforeEnd = range.compareBoundaryPoints(Range.END_TO_START, nodeRange) > 0;
+            const endsAfterStart = range.compareBoundaryPoints(Range.START_TO_END, nodeRange) < 0;
+
+            return (startsBeforeEnd && endsAfterStart) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          }
+        },
+      }
+    );
+
+    while (walker.nextNode()) {
+      const boldElement = BoldInlineTool.findBoldElement(walker.currentNode);
+
+      if (boldElement) {
+        ancestors.add(boldElement);
+      }
+    }
+
+    return Array.from(ancestors);
+  }
 }
diff --git a/src/components/inline-tools/inline-tool-convert.ts b/src/components/inline-tools/inline-tool-convert.ts
index b0347a682..567dfdc64 100644
--- a/src/components/inline-tools/inline-tool-convert.ts
+++ b/src/components/inline-tools/inline-tool-convert.ts
@@ -7,6 +7,7 @@ import SelectionUtils from '../selection';
 import { getConvertibleToolsForBlock } from '../utils/blocks';
 import I18nInternal from '../i18n';
 import { I18nInternalNS } from '../i18n/namespace-internal';
+import type BlockToolAdapter from '../tools/block';
 
 /**
  * Inline tools for converting blocks
@@ -58,13 +59,18 @@ export default class ConvertInlineTool implements InlineTool {
    */
   public async render(): Promise<MenuConfig> {
     const currentSelection = SelectionUtils.get();
+
+    if (currentSelection === null) {
+      return [];
+    }
+
     const currentBlock = this.blocksAPI.getBlockByElement(currentSelection.anchorNode as HTMLElement);
 
     if (currentBlock === undefined) {
       return [];
     }
 
-    const allBlockTools = this.toolsAPI.getBlockTools();
+    const allBlockTools = this.toolsAPI.getBlockTools() as BlockToolAdapter[];
     const convertibleTools = await getConvertibleToolsForBlock(currentBlock, allBlockTools);
 
     if (convertibleTools.length === 0) {
@@ -73,6 +79,10 @@ export default class ConvertInlineTool implements InlineTool {
 
     const convertToItems = convertibleTools.reduce<MenuConfigItem[]>((result, tool) => {
       tool.toolbox?.forEach((toolboxItem) => {
+        if (toolboxItem.title === undefined) {
+          return;
+        }
+
         result.push({
           icon: toolboxItem.icon,
           title: I18nInternal.t(I18nInternalNS.toolNames, toolboxItem.title),
@@ -97,7 +107,7 @@ export default class ConvertInlineTool implements InlineTool {
       icon,
       name: 'convert-to',
       hint: {
-        title: this.i18nAPI.t('Convert to'),
+        title: I18nInternal.ui(I18nInternalNS.ui.inlineToolbar.converter, 'Convert to'),
       },
       children: {
         searchable: isDesktop,
diff --git a/src/components/inline-tools/inline-tool-italic.ts b/src/components/inline-tools/inline-tool-italic.ts
index 526a56779..7914ce9f6 100644
--- a/src/components/inline-tools/inline-tool-italic.ts
+++ b/src/components/inline-tools/inline-tool-italic.ts
@@ -50,7 +50,7 @@ export default class ItalicInlineTool implements InlineTool {
   /**
    * Elements
    */
-  private nodes: {button: HTMLButtonElement} = {
+  private nodes: {button: HTMLButtonElement | null} = {
     button: null,
   };
 
@@ -58,12 +58,15 @@ export default class ItalicInlineTool implements InlineTool {
    * Create button for Inline Toolbar
    */
   public render(): HTMLElement {
-    this.nodes.button = document.createElement('button') as HTMLButtonElement;
-    this.nodes.button.type = 'button';
-    this.nodes.button.classList.add(this.CSS.button, this.CSS.buttonModifier);
-    this.nodes.button.innerHTML = IconItalic;
+    const button = document.createElement('button');
 
-    return this.nodes.button;
+    button.type = 'button';
+    button.classList.add(this.CSS.button, this.CSS.buttonModifier);
+    button.innerHTML = IconItalic;
+
+    this.nodes.button = button;
+
+    return button;
   }
 
   /**
@@ -79,7 +82,9 @@ export default class ItalicInlineTool implements InlineTool {
   public checkState(): boolean {
     const isActive = document.queryCommandState(this.commandName);
 
-    this.nodes.button.classList.toggle(this.CSS.buttonActive, isActive);
+    if (this.nodes.button) {
+      this.nodes.button.classList.toggle(this.CSS.buttonActive, isActive);
+    }
 
     return isActive;
   }
diff --git a/src/components/inline-tools/inline-tool-link.ts b/src/components/inline-tools/inline-tool-link.ts
index 9b413a564..622b7ceb1 100644
--- a/src/components/inline-tools/inline-tool-link.ts
+++ b/src/components/inline-tools/inline-tool-link.ts
@@ -62,13 +62,21 @@ export default class LinkInlineTool implements InlineTool {
     input: 'ce-inline-tool-input',
     inputShowed: 'ce-inline-tool-input--showed',
   };
+  /**
+   * Data attributes for e2e selectors
+   */
+  private readonly DATA_ATTRIBUTES = {
+    buttonActive: 'data-link-tool-active',
+    buttonUnlink: 'data-link-tool-unlink',
+    inputOpened: 'data-link-tool-input-opened',
+  } as const;
 
   /**
    * Elements
    */
   private nodes: {
-    button: HTMLButtonElement;
-    input: HTMLInputElement;
+    button: HTMLButtonElement | null;
+    input: HTMLInputElement | null;
   } = {
       button: null,
       input: null,
@@ -122,6 +130,8 @@ export default class LinkInlineTool implements InlineTool {
     this.nodes.button = document.createElement('button') as HTMLButtonElement;
     this.nodes.button.type = 'button';
     this.nodes.button.classList.add(this.CSS.button, this.CSS.buttonModifier);
+    this.setBooleanStateAttribute(this.nodes.button, this.DATA_ATTRIBUTES.buttonActive, false);
+    this.setBooleanStateAttribute(this.nodes.button, this.DATA_ATTRIBUTES.buttonUnlink, false);
 
     this.nodes.button.innerHTML = IconLink;
 
@@ -136,6 +146,7 @@ export default class LinkInlineTool implements InlineTool {
     this.nodes.input.placeholder = this.i18n.t('Add a link');
     this.nodes.input.enterKeyHint = 'done';
     this.nodes.input.classList.add(this.CSS.input);
+    this.setBooleanStateAttribute(this.nodes.input, this.DATA_ATTRIBUTES.inputOpened, false);
     this.nodes.input.addEventListener('keydown', (event: KeyboardEvent) => {
       if (event.keyCode === this.ENTER_KEY) {
         this.enterPressed(event);
@@ -148,38 +159,39 @@ export default class LinkInlineTool implements InlineTool {
   /**
    * Handle clicks on the Inline Toolbar icon
    *
-   * @param {Range} range - range to wrap with link
+   * @param {Range | null} range - range to wrap with link
    */
-  public surround(range: Range): void {
+  public surround(range: Range | null): void {
+    if (!range) {
+      this.toggleActions();
+
+      return;
+    }
+
     /**
-     * Range will be null when user makes second click on the 'link icon' to close opened input
+     * Save selection before change focus to the input
      */
-    if (range) {
-      /**
-       * Save selection before change focus to the input
-       */
-      if (!this.inputOpened) {
-        /** Create blue background instead of selection */
-        this.selection.setFakeBackground();
-        this.selection.save();
-      } else {
-        this.selection.restore();
-        this.selection.removeFakeBackground();
-      }
-      const parentAnchor = this.selection.findParentTag('A');
+    if (!this.inputOpened) {
+      /** Create blue background instead of selection */
+      this.selection.setFakeBackground();
+      this.selection.save();
+    } else {
+      this.selection.restore();
+      this.selection.removeFakeBackground();
+    }
+    const parentAnchor = this.selection.findParentTag('A');
 
-      /**
-       * Unlink icon pressed
-       */
-      if (parentAnchor) {
-        this.selection.expandToTag(parentAnchor);
-        this.unlink();
-        this.closeActions();
-        this.checkState();
-        this.toolbar.close();
-
-        return;
-      }
+    /**
+     * Unlink icon pressed
+     */
+    if (parentAnchor) {
+      this.selection.expandToTag(parentAnchor);
+      this.unlink();
+      this.closeActions();
+      this.checkState();
+      this.toolbar.close();
+
+      return;
     }
 
     this.toggleActions();
@@ -191,10 +203,16 @@ export default class LinkInlineTool implements InlineTool {
   public checkState(): boolean {
     const anchorTag = this.selection.findParentTag('A');
 
+    if (!this.nodes.button || !this.nodes.input) {
+      return !!anchorTag;
+    }
+
     if (anchorTag) {
       this.nodes.button.innerHTML = IconUnlink;
       this.nodes.button.classList.add(this.CSS.buttonUnlink);
       this.nodes.button.classList.add(this.CSS.buttonActive);
+      this.setBooleanStateAttribute(this.nodes.button, this.DATA_ATTRIBUTES.buttonUnlink, true);
+      this.setBooleanStateAttribute(this.nodes.button, this.DATA_ATTRIBUTES.buttonActive, true);
       this.openActions();
 
       /**
@@ -202,13 +220,15 @@ export default class LinkInlineTool implements InlineTool {
        */
       const hrefAttr = anchorTag.getAttribute('href');
 
-      this.nodes.input.value = hrefAttr !== 'null' ? hrefAttr : '';
+      this.nodes.input.value = hrefAttr !== null ? hrefAttr : '';
 
       this.selection.save();
     } else {
       this.nodes.button.innerHTML = IconLink;
       this.nodes.button.classList.remove(this.CSS.buttonUnlink);
       this.nodes.button.classList.remove(this.CSS.buttonActive);
+      this.setBooleanStateAttribute(this.nodes.button, this.DATA_ATTRIBUTES.buttonUnlink, false);
+      this.setBooleanStateAttribute(this.nodes.button, this.DATA_ATTRIBUTES.buttonActive, false);
     }
 
     return !!anchorTag;
@@ -243,7 +263,11 @@ export default class LinkInlineTool implements InlineTool {
    * @param {boolean} needFocus - on link creation we need to focus input. On editing - nope.
    */
   private openActions(needFocus = false): void {
+    if (!this.nodes.input) {
+      return;
+    }
     this.nodes.input.classList.add(this.CSS.inputShowed);
+    this.setBooleanStateAttribute(this.nodes.input, this.DATA_ATTRIBUTES.inputOpened, true);
     if (needFocus) {
       this.nodes.input.focus();
     }
@@ -270,7 +294,11 @@ export default class LinkInlineTool implements InlineTool {
       currentSelection.restore();
     }
 
+    if (!this.nodes.input) {
+      return;
+    }
     this.nodes.input.classList.remove(this.CSS.inputShowed);
+    this.setBooleanStateAttribute(this.nodes.input, this.DATA_ATTRIBUTES.inputOpened, false);
     this.nodes.input.value = '';
     if (clearSavedSelection) {
       this.selection.clearSaved();
@@ -284,7 +312,10 @@ export default class LinkInlineTool implements InlineTool {
    * @param {KeyboardEvent} event - enter keydown event
    */
   private enterPressed(event: KeyboardEvent): void {
-    let value = this.nodes.input.value || '';
+    if (!this.nodes.input) {
+      return;
+    }
+    const value = this.nodes.input.value || '';
 
     if (!value.trim()) {
       this.selection.restore();
@@ -306,12 +337,12 @@ export default class LinkInlineTool implements InlineTool {
       return;
     }
 
-    value = this.prepareLink(value);
+    const preparedValue = this.prepareLink(value);
 
     this.selection.restore();
     this.selection.removeFakeBackground();
 
-    this.insertLink(value);
+    this.insertLink(preparedValue);
 
     /**
      * Preventing events that will be able to happen
@@ -344,10 +375,7 @@ export default class LinkInlineTool implements InlineTool {
    * @param {string} link - raw user input
    */
   private prepareLink(link: string): string {
-    link = link.trim();
-    link = this.addProtocol(link);
-
-    return link;
+    return this.addProtocol(link.trim());
   }
 
   /**
@@ -369,12 +397,12 @@ export default class LinkInlineTool implements InlineTool {
      *     2) Anchors looks like "#results"
      *     3) Protocol-relative URLs like "//google.com"
      */
-    const isInternal = /^\/[^/\s]/.test(link),
-        isAnchor = link.substring(0, 1) === '#',
-        isProtocolRelative = /^\/\/[^/\s]/.test(link);
+    const isInternal = /^\/[^/\s]/.test(link);
+    const isAnchor = link.substring(0, 1) === '#';
+    const isProtocolRelative = /^\/\/[^/\s]/.test(link);
 
     if (!isInternal && !isAnchor && !isProtocolRelative) {
-      link = 'http://' + link;
+      return 'http://' + link;
     }
 
     return link;
@@ -404,4 +432,19 @@ export default class LinkInlineTool implements InlineTool {
   private unlink(): void {
     document.execCommand(this.commandUnlink);
   }
+
+  /**
+   * Persist state as data attributes for testing hooks
+   *
+   * @param element - The HTML element to set the attribute on, or null
+   * @param attributeName - The name of the attribute to set
+   * @param state - The boolean state value to persist
+   */
+  private setBooleanStateAttribute(element: HTMLElement | null, attributeName: string, state: boolean): void {
+    if (!element) {
+      return;
+    }
+
+    element.setAttribute(attributeName, state ? 'true' : 'false');
+  }
 }
diff --git a/src/components/modules/api/blocks.ts b/src/components/modules/api/blocks.ts
index 9ad22176a..01c8338e4 100644
--- a/src/components/modules/api/blocks.ts
+++ b/src/components/modules/api/blocks.ts
@@ -28,7 +28,7 @@ export default class BlocksAPI extends Module {
       getBlockByIndex: (index: number): BlockAPIInterface | undefined => this.getBlockByIndex(index),
       getById: (id: string): BlockAPIInterface | null => this.getById(id),
       getCurrentBlockIndex: (): number => this.getCurrentBlockIndex(),
-      getBlockIndex: (id: string): number => this.getBlockIndex(id),
+      getBlockIndex: (id: string): number | undefined => this.getBlockIndex(id),
       getBlocksCount: (): number => this.getBlocksCount(),
       getBlockByElement: (element: HTMLElement) => this.getBlockByElement(element),
       stretchBlock: (index: number, status = true): void => this.stretchBlock(index, status),
@@ -160,12 +160,18 @@ export default class BlocksAPI extends Module {
    * @param {number} blockIndex - index of Block to delete
    */
   public delete(blockIndex: number = this.Editor.BlockManager.currentBlockIndex): void {
-    try {
-      const block = this.Editor.BlockManager.getBlockByIndex(blockIndex);
+    const block = this.Editor.BlockManager.getBlockByIndex(blockIndex);
+
+    if (block === undefined) {
+      _.logLabeled(`There is no block at index \`${blockIndex}\``, 'warn');
+
+      return;
+    }
 
-      this.Editor.BlockManager.removeBlock(block);
-    } catch (e) {
-      _.logLabeled(e, 'warn');
+    try {
+      void this.Editor.BlockManager.removeBlock(block);
+    } catch (error: unknown) {
+      _.logLabeled(error as unknown as string, 'warn');
 
       return;
     }
@@ -258,25 +264,26 @@ export default class BlocksAPI extends Module {
    *
    * @param {string} type — Tool name
    * @param {BlockToolData} data — Tool data to insert
-   * @param {ToolConfig} config — Tool config
+   * @param {ToolConfig} _config — Tool config
    * @param {number?} index — index where to insert new Block
    * @param {boolean?} needToFocus - flag to focus inserted Block
    * @param replace - pass true to replace the Block existed under passed index
    * @param {string} id — An optional id for the new block. If omitted then the new id will be generated
    */
   public insert = (
-    type: string = this.config.defaultBlock,
+    type?: string,
     data: BlockToolData = {},
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
-    config: ToolConfig = {},
+    _config: ToolConfig = {},
     index?: number,
     needToFocus?: boolean,
     replace?: boolean,
     id?: string
   ): BlockAPIInterface => {
+    const tool = type ?? (this.config.defaultBlock as string | undefined);
+
     const insertedBlock = this.Editor.BlockManager.insert({
       id,
-      tool: type,
+      tool,
       data,
       index,
       needToFocus,
@@ -293,6 +300,11 @@ export default class BlocksAPI extends Module {
    */
   public composeBlockData = async (toolName: string): Promise<BlockToolData> => {
     const tool = this.Editor.Tools.blockTools.get(toolName);
+
+    if (tool === undefined) {
+      throw new Error(`Block Tool with type "${toolName}" not found`);
+    }
+
     const block = new Block({
       tool,
       api: this.Editor.API,
@@ -334,9 +346,7 @@ export default class BlocksAPI extends Module {
 
     const updatedBlock = await BlockManager.update(block, data, tunes);
 
-    // we cast to any because our BlockAPI has no "new" signature
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return new (BlockAPI as any)(updatedBlock);
+    return new BlockAPI(updatedBlock);
   };
 
   /**
@@ -402,9 +412,7 @@ export default class BlocksAPI extends Module {
 
     this.Editor.BlockManager.insertMany(blocksToInsert, index);
 
-    // we cast to any because our BlockAPI has no "new" signature
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return blocksToInsert.map((block) => new (BlockAPI as any)(block));
+    return blocksToInsert.map((block) => new BlockAPI(block));
   };
 
   /**
diff --git a/src/components/modules/api/events.ts b/src/components/modules/api/events.ts
index 74484a239..2a24b0ac0 100644
--- a/src/components/modules/api/events.ts
+++ b/src/components/modules/api/events.ts
@@ -1,5 +1,6 @@
 import Module from '../../__module';
 import type { Events } from '../../../../types/api';
+import type { EditorEventMap } from '../../events';
 
 /**
  * @class EventsAPI
@@ -13,9 +14,9 @@ export default class EventsAPI extends Module {
    */
   public get methods(): Events {
     return {
-      emit: (eventName: string, data: object): void => this.emit(eventName, data),
-      off: (eventName: string, callback: () => void): void => this.off(eventName, callback),
-      on: (eventName: string, callback: () => void): void => this.on(eventName, callback),
+      emit: (eventName: keyof EditorEventMap, data: EditorEventMap[keyof EditorEventMap] | undefined): void => this.emit(eventName, data),
+      off: (eventName: keyof EditorEventMap, callback: (data?: unknown) => void): void => this.off(eventName, callback),
+      on: (eventName: keyof EditorEventMap, callback: () => void): void => this.on(eventName, callback),
     };
   }
 
@@ -25,7 +26,7 @@ export default class EventsAPI extends Module {
    * @param {string} eventName - event name to subscribe
    * @param {Function} callback - event handler
    */
-  public on(eventName, callback): void {
+  public on(eventName: keyof EditorEventMap, callback: (data?: unknown) => void): void {
     this.eventsDispatcher.on(eventName, callback);
   }
 
@@ -35,8 +36,11 @@ export default class EventsAPI extends Module {
    * @param {string} eventName - event to emit
    * @param {object} data - event's data
    */
-  public emit(eventName, data): void {
-    this.eventsDispatcher.emit(eventName, data);
+  public emit(eventName: keyof EditorEventMap, data: EditorEventMap[keyof EditorEventMap] | undefined): void {
+    this.eventsDispatcher.emit(
+      eventName,
+      data
+    );
   }
 
   /**
@@ -45,7 +49,7 @@ export default class EventsAPI extends Module {
    * @param {string} eventName - event to unsubscribe
    * @param {Function} callback - event handler
    */
-  public off(eventName, callback): void {
+  public off(eventName: keyof EditorEventMap, callback: (data?: unknown) => void): void {
     this.eventsDispatcher.off(eventName, callback);
   }
 }
diff --git a/src/components/modules/api/i18n.ts b/src/components/modules/api/i18n.ts
index 25e353751..c90041847 100644
--- a/src/components/modules/api/i18n.ts
+++ b/src/components/modules/api/i18n.ts
@@ -13,7 +13,7 @@ export default class I18nAPI extends Module {
    * @param toolName - tool name
    * @param isTune - is tool a block tune
    */
-  private static getNamespace(toolName, isTune): string {
+  private static getNamespace(toolName: string, isTune: boolean): string {
     if (isTune) {
       return `blockTunes.${toolName}`;
     }
@@ -26,10 +26,10 @@ export default class I18nAPI extends Module {
    */
   public get methods(): I18n {
     return {
-      t: (): string | undefined => {
+      t: (_dictKey?: string): string => {
         logLabeled('I18n.t() method can be accessed only from Tools', 'warn');
 
-        return undefined;
+        return '';
       },
     };
   }
diff --git a/src/components/modules/api/inlineToolbar.ts b/src/components/modules/api/inlineToolbar.ts
index 2091d9c01..9af71251d 100644
--- a/src/components/modules/api/inlineToolbar.ts
+++ b/src/components/modules/api/inlineToolbar.ts
@@ -22,7 +22,7 @@ export default class InlineToolbarAPI extends Module {
    * Open Inline Toolbar
    */
   public open(): void {
-    this.Editor.InlineToolbar.tryToShow();
+    void this.Editor.InlineToolbar.tryToShow();
   }
 
   /**
diff --git a/src/components/modules/api/listeners.ts b/src/components/modules/api/listeners.ts
index b7092899a..8826c5f7d 100644
--- a/src/components/modules/api/listeners.ts
+++ b/src/components/modules/api/listeners.ts
@@ -13,7 +13,8 @@ export default class ListenersAPI extends Module {
    */
   public get methods(): Listeners {
     return {
-      on: (element: HTMLElement, eventType, handler, useCapture): string => this.on(element, eventType, handler, useCapture),
+      on: (element: HTMLElement, eventType, handler, useCapture): string | undefined =>
+        this.on(element, eventType, handler, useCapture),
       off: (element, eventType, handler, useCapture): void => this.off(element, eventType, handler, useCapture),
       offById: (id): void => this.offById(id),
     };
@@ -27,7 +28,12 @@ export default class ListenersAPI extends Module {
    * @param {() => void} handler - event handler
    * @param {boolean} useCapture - capture event or not
    */
-  public on(element: HTMLElement, eventType: string, handler: () => void, useCapture?: boolean): string {
+  public on(
+    element: HTMLElement,
+    eventType: string,
+    handler: () => void,
+    useCapture?: boolean
+  ): string | undefined {
     return this.listeners.on(element, eventType, handler, useCapture);
   }
 
diff --git a/src/components/modules/api/saver.ts b/src/components/modules/api/saver.ts
index ad0eac29c..e90fac043 100644
--- a/src/components/modules/api/saver.ts
+++ b/src/components/modules/api/saver.ts
@@ -24,15 +24,31 @@ export default class SaverAPI extends Module {
    *
    * @returns {OutputData}
    */
-  public save(): Promise<OutputData> {
+  public async save(): Promise<OutputData> {
     const errorText = 'Editor\'s content can not be saved in read-only mode';
 
     if (this.Editor.ReadOnly.isEnabled) {
       _.logLabeled(errorText, 'warn');
 
-      return Promise.reject(new Error(errorText));
+      throw new Error(errorText);
     }
 
-    return this.Editor.Saver.save();
+    const savedData = await this.Editor.Saver.save();
+
+    if (savedData !== undefined) {
+      return savedData;
+    }
+
+    const lastError = this.Editor.Saver.getLastSaveError?.();
+
+    if (lastError instanceof Error) {
+      throw lastError;
+    }
+
+    const errorMessage = lastError !== undefined
+      ? String(lastError)
+      : 'Editor\'s content can not be saved because collecting data failed';
+
+    throw new Error(errorMessage);
   }
 }
diff --git a/src/components/modules/api/toolbar.ts b/src/components/modules/api/toolbar.ts
index f94e71304..4408cd608 100644
--- a/src/components/modules/api/toolbar.ts
+++ b/src/components/modules/api/toolbar.ts
@@ -51,7 +51,7 @@ export default class ToolbarAPI extends Module {
 
     if (canOpenBlockSettings) {
       this.Editor.Toolbar.moveAndOpen();
-      this.Editor.BlockSettings.open();
+      void this.Editor.BlockSettings.open();
     } else {
       this.Editor.BlockSettings.close();
     }
@@ -63,7 +63,7 @@ export default class ToolbarAPI extends Module {
    *
    * @param {boolean} openingState - Opening state of toolbox
    */
-  public toggleToolbox(openingState: boolean): void {
+  public toggleToolbox(openingState?: boolean): void {
     if (this.Editor.BlockManager.currentBlockIndex === -1) {
       _.logLabeled('Could\'t toggle the Toolbox because there is no block selected ', 'warn');
 
diff --git a/src/components/modules/api/tooltip.ts b/src/components/modules/api/tooltip.ts
index 37077d0c3..fe4e5e48b 100644
--- a/src/components/modules/api/tooltip.ts
+++ b/src/components/modules/api/tooltip.ts
@@ -1,5 +1,5 @@
 import type { Tooltip as ITooltip } from '../../../../types/api';
-import type { TooltipOptions, TooltipContent } from 'codex-tooltip/types';
+import type { TooltipOptions, TooltipContent } from '../../utils/tooltip';
 import Module from '../../__module';
 import type { ModuleConfig } from '../../../types-internal/module-config';
 import * as tooltip from '../../utils/tooltip';
diff --git a/src/components/modules/blockEvents.ts b/src/components/modules/blockEvents.ts
index 40e0973e2..22218ba16 100644
--- a/src/components/modules/blockEvents.ts
+++ b/src/components/modules/blockEvents.ts
@@ -25,6 +25,10 @@ export default class BlockEvents extends Module {
      */
     this.beforeKeydownProcessing(event);
 
+    if (this.handleSelectedBlocksDeletion(event)) {
+      return;
+    }
+
     /**
      * Fire keydown processor by event.keyCode
      */
@@ -75,6 +79,42 @@ export default class BlockEvents extends Module {
     }
   }
 
+  /**
+   * Tries to delete selected blocks when remove keys pressed.
+   *
+   * @param event - keyboard event
+   * @returns true if event was handled
+   */
+  private handleSelectedBlocksDeletion(event: KeyboardEvent): boolean {
+    const { BlockSelection, BlockManager, Caret } = this.Editor;
+    const isRemoveKey = event.keyCode === _.keyCodes.BACKSPACE || event.keyCode === _.keyCodes.DELETE;
+    const selectionExists = SelectionUtils.isSelectionExists;
+    const selectionCollapsed = SelectionUtils.isCollapsed === true;
+    const shouldHandleSelectionDeletion = isRemoveKey &&
+      BlockSelection.anyBlockSelected &&
+      (!selectionExists || selectionCollapsed);
+
+    if (!shouldHandleSelectionDeletion) {
+      return false;
+    }
+
+    const selectionPositionIndex = BlockManager.removeSelectedBlocks();
+
+    if (selectionPositionIndex !== undefined) {
+      const insertedBlock = BlockManager.insertDefaultBlockAtIndex(selectionPositionIndex, true);
+
+      Caret.setToBlock(insertedBlock, Caret.positions.START);
+    }
+
+    BlockSelection.clearSelection(event);
+
+    event.preventDefault();
+    event.stopImmediatePropagation();
+    event.stopPropagation();
+
+    return true;
+  }
+
   /**
    * Fires on keydown before event processing
    *
@@ -93,20 +133,24 @@ export default class BlockEvents extends Module {
      *  - close Toolbar
      *  - clear block highlighting
      */
-    if (_.isPrintableKey(event.keyCode)) {
-      this.Editor.Toolbar.close();
+    if (!_.isPrintableKey(event.keyCode)) {
+      return;
+    }
 
-      /**
-       * Allow to use shortcuts with selected blocks
-       *
-       * @type {boolean}
-       */
-      const isShortcut = event.ctrlKey || event.metaKey || event.altKey || event.shiftKey;
+    this.Editor.Toolbar.close();
 
-      if (!isShortcut) {
-        this.Editor.BlockSelection.clearSelection(event);
-      }
+    /**
+     * Allow to use shortcuts with selected blocks
+     *
+     * @type {boolean}
+     */
+    const isShortcut = event.ctrlKey || event.metaKey || event.altKey || event.shiftKey;
+
+    if (isShortcut) {
+      return;
     }
+
+    this.Editor.BlockSelection.clearSelection(event);
   }
 
   /**
@@ -138,6 +182,10 @@ export default class BlockEvents extends Module {
   public dragOver(event: DragEvent): void {
     const block = this.Editor.BlockManager.getBlockByChildNode(event.target as Node);
 
+    if (!block) {
+      return;
+    }
+
     block.dropTarget = true;
   }
 
@@ -149,6 +197,10 @@ export default class BlockEvents extends Module {
   public dragLeave(event: DragEvent): void {
     const block = this.Editor.BlockManager.getBlockByChildNode(event.target as Node);
 
+    if (!block) {
+      return;
+    }
+
     block.dropTarget = false;
   }
 
@@ -166,7 +218,7 @@ export default class BlockEvents extends Module {
     }
 
     // Copy Selected Blocks
-    BlockSelection.copySelectedBlocks(event);
+    void BlockSelection.copySelectedBlocks(event);
   }
 
   /**
@@ -187,13 +239,18 @@ export default class BlockEvents extends Module {
       /**
        * Insert default block in place of removed ones
        */
-      const insertedBlock = BlockManager.insertDefaultBlockAtIndex(selectionPositionIndex, true);
+      if (selectionPositionIndex !== undefined) {
+        const insertedBlock = BlockManager.insertDefaultBlockAtIndex(selectionPositionIndex, true);
 
-      Caret.setToBlock(insertedBlock, Caret.positions.START);
+        Caret.setToBlock(insertedBlock, Caret.positions.START);
+      }
 
       /** Clear selection */
       BlockSelection.clearSelection(event);
-    });
+    })
+      .catch(() => {
+        // Handle copy operation failure silently
+      });
   }
 
   /**
@@ -244,7 +301,7 @@ export default class BlockEvents extends Module {
     }
 
     const currentBlock = this.Editor.BlockManager.currentBlock;
-    const canOpenToolbox = currentBlock.isEmpty;
+    const canOpenToolbox = currentBlock?.isEmpty;
 
     /**
      * @todo Handle case when slash pressed when several blocks are selected
@@ -307,27 +364,30 @@ export default class BlockEvents extends Module {
       return;
     }
 
-    let blockToFocus = currentBlock;
-
     /**
      * If enter has been pressed at the start of the text, just insert paragraph Block above
      */
-    if (currentBlock.currentInput !== undefined && caretUtils.isCaretAtStartOfInput(currentBlock.currentInput) && !currentBlock.hasMedia) {
-      this.Editor.BlockManager.insertDefaultBlockAtIndex(this.Editor.BlockManager.currentBlockIndex);
+    const blockToFocus = (() => {
+      if (currentBlock.currentInput !== undefined && caretUtils.isCaretAtStartOfInput(currentBlock.currentInput) && !currentBlock.hasMedia) {
+        this.Editor.BlockManager.insertDefaultBlockAtIndex(this.Editor.BlockManager.currentBlockIndex);
+
+        return currentBlock;
+      }
+
+      /**
+       * If caret is at very end of the block, just append the new block without splitting
+       * to prevent unnecessary dom mutation observing
+       */
+      if (currentBlock.currentInput && caretUtils.isCaretAtEndOfInput(currentBlock.currentInput)) {
+        return this.Editor.BlockManager.insertDefaultBlockAtIndex(this.Editor.BlockManager.currentBlockIndex + 1);
+      }
 
-    /**
-     * If caret is at very end of the block, just append the new block without splitting
-     * to prevent unnecessary dom mutation observing
-     */
-    } else if (currentBlock.currentInput && caretUtils.isCaretAtEndOfInput(currentBlock.currentInput)) {
-      blockToFocus = this.Editor.BlockManager.insertDefaultBlockAtIndex(this.Editor.BlockManager.currentBlockIndex + 1);
-    } else {
       /**
        * Split the Current Block into two blocks
        * Renew local current node after split
        */
-      blockToFocus = this.Editor.BlockManager.split();
-    }
+      return this.Editor.BlockManager.split();
+    })();
 
     this.Editor.Caret.setToBlock(blockToFocus);
 
@@ -393,7 +453,7 @@ export default class BlockEvents extends Module {
      * If prev Block is empty, it should be removed just like a character
      */
     if (previousBlock.isEmpty) {
-      BlockManager.removeBlock(previousBlock);
+      void BlockManager.removeBlock(previousBlock);
 
       return;
     }
@@ -402,11 +462,11 @@ export default class BlockEvents extends Module {
      * If current Block is empty, just remove it and set cursor to the previous Block (like we're removing line break char)
      */
     if (currentBlock.isEmpty) {
-      BlockManager.removeBlock(currentBlock);
+      void BlockManager.removeBlock(currentBlock);
 
       const newCurrentBlock = BlockManager.currentBlock;
 
-      Caret.setToBlock(newCurrentBlock, Caret.positions.END);
+      newCurrentBlock && Caret.setToBlock(newCurrentBlock, Caret.positions.END);
 
       return;
     }
@@ -435,6 +495,10 @@ export default class BlockEvents extends Module {
     const { BlockManager, Caret } = this.Editor;
     const { currentBlock, nextBlock } = BlockManager;
 
+    if (currentBlock === undefined) {
+      return;
+    }
+
     /**
      * If some fragment is selected, leave native behaviour
      */
@@ -445,7 +509,7 @@ export default class BlockEvents extends Module {
     /**
      * If caret is not at the end, leave native behaviour
      */
-    if (!caretUtils.isCaretAtEndOfInput(currentBlock.currentInput)) {
+    if (!currentBlock.currentInput || !caretUtils.isCaretAtEndOfInput(currentBlock.currentInput)) {
       return;
     }
 
@@ -477,7 +541,7 @@ export default class BlockEvents extends Module {
      * If next Block is empty, it should be removed just like a character
      */
     if (nextBlock.isEmpty) {
-      BlockManager.removeBlock(nextBlock);
+      void BlockManager.removeBlock(nextBlock);
 
       return;
     }
@@ -486,7 +550,7 @@ export default class BlockEvents extends Module {
      * If current Block is empty, just remove it and set cursor to the next Block (like we're removing line break char)
      */
     if (currentBlock.isEmpty) {
-      BlockManager.removeBlock(currentBlock);
+      void BlockManager.removeBlock(currentBlock);
 
       Caret.setToBlock(nextBlock, Caret.positions.START);
 
@@ -525,6 +589,9 @@ export default class BlockEvents extends Module {
       .mergeBlocks(targetBlock, blockToMerge)
       .then(() => {
         Toolbar.close();
+      })
+      .catch(() => {
+        // Error handling for mergeBlocks
       });
   }
 
@@ -546,20 +613,29 @@ export default class BlockEvents extends Module {
     }
 
     /**
-     * Close Toolbar when user moves cursor
+     * Close Toolbar when user moves cursor, but keep toolbars open if the user
+     * is extending selection with the Shift key so inline interactions remain available.
      */
-    this.Editor.Toolbar.close();
+    if (!event.shiftKey) {
+      this.Editor.Toolbar.close();
+    }
 
     const { currentBlock } = this.Editor.BlockManager;
     const caretAtEnd = currentBlock?.currentInput !== undefined ? caretUtils.isCaretAtEndOfInput(currentBlock.currentInput) : undefined;
     const shouldEnableCBS = caretAtEnd || this.Editor.BlockSelection.anyBlockSelected;
 
-    if (event.shiftKey && event.keyCode === _.keyCodes.DOWN && shouldEnableCBS) {
+    const isShiftDownKey = event.shiftKey && event.keyCode === _.keyCodes.DOWN;
+
+    if (isShiftDownKey && shouldEnableCBS) {
       this.Editor.CrossBlockSelection.toggleBlockSelectedState();
 
       return;
     }
 
+    if (isShiftDownKey) {
+      void this.Editor.InlineToolbar.tryToShow();
+    }
+
     const navigateNext = event.keyCode === _.keyCodes.DOWN || (event.keyCode === _.keyCodes.RIGHT && !this.isRtl);
     const isNavigated = navigateNext ? this.Editor.Caret.navigateNext() : this.Editor.Caret.navigatePrevious();
 
@@ -599,29 +675,39 @@ export default class BlockEvents extends Module {
      * Arrows might be handled on toolbars by flipper
      * Check for Flipper.usedKeys to allow navigate by UP and disallow by LEFT
      */
-    if (this.Editor.UI.someToolbarOpened) {
-      if (Flipper.usedKeys.includes(event.keyCode) && (!event.shiftKey || event.keyCode === _.keyCodes.TAB)) {
-        return;
-      }
+    const toolbarOpened = this.Editor.UI.someToolbarOpened;
 
+    if (toolbarOpened && Flipper.usedKeys.includes(event.keyCode) && (!event.shiftKey || event.keyCode === _.keyCodes.TAB)) {
+      return;
+    }
+
+    if (toolbarOpened) {
       this.Editor.UI.closeAllToolbars();
     }
 
     /**
-     * Close Toolbar when user moves cursor
+     * Close Toolbar when user moves cursor, but preserve it for Shift-based selection changes.
      */
-    this.Editor.Toolbar.close();
+    if (!event.shiftKey) {
+      this.Editor.Toolbar.close();
+    }
 
     const { currentBlock } = this.Editor.BlockManager;
     const caretAtStart = currentBlock?.currentInput !== undefined ? caretUtils.isCaretAtStartOfInput(currentBlock.currentInput) : undefined;
     const shouldEnableCBS = caretAtStart || this.Editor.BlockSelection.anyBlockSelected;
 
-    if (event.shiftKey && event.keyCode === _.keyCodes.UP && shouldEnableCBS) {
+    const isShiftUpKey = event.shiftKey && event.keyCode === _.keyCodes.UP;
+
+    if (isShiftUpKey && shouldEnableCBS) {
       this.Editor.CrossBlockSelection.toggleBlockSelectedState(false);
 
       return;
     }
 
+    if (isShiftUpKey) {
+      void this.Editor.InlineToolbar.tryToShow();
+    }
+
     const navigatePrevious = event.keyCode === _.keyCodes.UP || (event.keyCode === _.keyCodes.LEFT && !this.isRtl);
     const isNavigated = navigatePrevious ? this.Editor.Caret.navigatePrevious() : this.Editor.Caret.navigateNext();
 
@@ -657,10 +743,10 @@ export default class BlockEvents extends Module {
    * @param {KeyboardEvent} event - keyboard event
    */
   private needToolbarClosing(event: KeyboardEvent): boolean {
-    const toolboxItemSelected = (event.keyCode === _.keyCodes.ENTER && this.Editor.Toolbar.toolbox.opened),
-        blockSettingsItemSelected = (event.keyCode === _.keyCodes.ENTER && this.Editor.BlockSettings.opened),
-        inlineToolbarItemSelected = (event.keyCode === _.keyCodes.ENTER && this.Editor.InlineToolbar.opened),
-        flippingToolbarItems = event.keyCode === _.keyCodes.TAB;
+    const toolboxItemSelected = (event.keyCode === _.keyCodes.ENTER && this.Editor.Toolbar.toolbox.opened);
+    const blockSettingsItemSelected = (event.keyCode === _.keyCodes.ENTER && this.Editor.BlockSettings.opened);
+    const inlineToolbarItemSelected = (event.keyCode === _.keyCodes.ENTER && this.Editor.InlineToolbar.opened);
+    const flippingToolbarItems = event.keyCode === _.keyCodes.TAB;
 
     /**
      * Do not close Toolbar in cases:
@@ -705,7 +791,11 @@ export default class BlockEvents extends Module {
        *       — wrong settings will be opened.
        *       To fix it, we should refactor the Block Settings module — make it a standalone class, like the Toolbox
        */
-      this.Editor.BlockSettings.open();
+      void Promise
+        .resolve(this.Editor.BlockSettings.open())
+        .catch(() => {
+          // Error handling for BlockSettings.open
+        });
     }
   }
 }
diff --git a/src/components/modules/blockManager.ts b/src/components/modules/blockManager.ts
index be8e1e247..965f5d648 100644
--- a/src/components/modules/blockManager.ts
+++ b/src/components/modules/blockManager.ts
@@ -9,7 +9,7 @@ import Module from '../__module';
 import $ from '../dom';
 import * as _ from '../utils';
 import Blocks from '../blocks';
-import type { BlockToolData, PasteEvent } from '../../../types';
+import type { BlockToolData, PasteEvent, SanitizerConfig } from '../../../types';
 import type { BlockTuneData } from '../../../types/block-tunes/block-tune-data';
 import BlockAPI from '../block/api';
 import type { BlockMutationEventMap, BlockMutationType } from '../../../types/events/block';
@@ -18,10 +18,14 @@ import { BlockAddedMutationType } from '../../../types/events/block/BlockAdded';
 import { BlockMovedMutationType } from '../../../types/events/block/BlockMoved';
 import { BlockChangedMutationType } from '../../../types/events/block/BlockChanged';
 import { BlockChanged } from '../events';
-import { clean, sanitizeBlocks } from '../utils/sanitizer';
+import { clean, composeSanitizerConfig, sanitizeBlocks } from '../utils/sanitizer';
 import { convertStringToBlockData, isBlockConvertable } from '../utils/blocks';
 import PromiseQueue from '../utils/promise-queue';
 
+type BlocksStore = Blocks & {
+  [index: number]: Block | undefined;
+};
+
 /**
  * @typedef {BlockManager} BlockManager
  * @property {number} currentBlockIndex - Index of current working block
@@ -51,8 +55,8 @@ export default class BlockManager extends Module {
    *
    * @returns {Block}
    */
-  public get firstBlock(): Block {
-    return this._blocks[0];
+  public get firstBlock(): Block | undefined {
+    return this.blocksStore[0];
   }
 
   /**
@@ -60,8 +64,8 @@ export default class BlockManager extends Module {
    *
    * @returns {Block}
    */
-  public get lastBlock(): Block {
-    return this._blocks[this._blocks.length - 1];
+  public get lastBlock(): Block | undefined {
+    return this.blocksStore[this.blocksStore.length - 1];
   }
 
   /**
@@ -70,7 +74,7 @@ export default class BlockManager extends Module {
    * @returns {Block}
    */
   public get currentBlock(): Block | undefined {
-    return this._blocks[this.currentBlockIndex];
+    return this.blocksStore[this.currentBlockIndex];
   }
 
   /**
@@ -78,7 +82,13 @@ export default class BlockManager extends Module {
    *
    * @param block - block to set as a current
    */
-  public set currentBlock(block: Block) {
+  public set currentBlock(block: Block | undefined) {
+    if (block === undefined) {
+      this.unsetCurrentBlock();
+
+      return;
+    }
+
     this.currentBlockIndex = this.getBlockIndex(block);
   }
 
@@ -88,13 +98,15 @@ export default class BlockManager extends Module {
    * @returns {Block|null}
    */
   public get nextBlock(): Block | null {
-    const isLastBlock = this.currentBlockIndex === (this._blocks.length - 1);
+    const isLastBlock = this.currentBlockIndex === (this.blocksStore.length - 1);
 
     if (isLastBlock) {
       return null;
     }
 
-    return this._blocks[this.currentBlockIndex + 1];
+    const nextBlock = this.blocksStore[this.currentBlockIndex + 1];
+
+    return nextBlock ?? null;
   }
 
   /**
@@ -102,7 +114,7 @@ export default class BlockManager extends Module {
    *
    * @returns {Block | undefined}
    */
-  public get nextContentfulBlock(): Block {
+  public get nextContentfulBlock(): Block | undefined {
     const nextBlocks = this.blocks.slice(this.currentBlockIndex + 1);
 
     return nextBlocks.find((block) => !!block.inputs.length);
@@ -113,7 +125,7 @@ export default class BlockManager extends Module {
    *
    * @returns {Block | undefined}
    */
-  public get previousContentfulBlock(): Block {
+  public get previousContentfulBlock(): Block | undefined {
     const previousBlocks = this.blocks.slice(0, this.currentBlockIndex).reverse();
 
     return previousBlocks.find((block) => !!block.inputs.length);
@@ -131,7 +143,9 @@ export default class BlockManager extends Module {
       return null;
     }
 
-    return this._blocks[this.currentBlockIndex - 1];
+    const previousBlock = this.blocksStore[this.currentBlockIndex - 1];
+
+    return previousBlock ?? null;
   }
 
   /**
@@ -140,7 +154,7 @@ export default class BlockManager extends Module {
    * @returns {Block[]} {@link Blocks#array}
    */
   public get blocks(): Block[] {
-    return this._blocks.array;
+    return this.blocksStore.array;
   }
 
   /**
@@ -165,7 +179,7 @@ export default class BlockManager extends Module {
    * @type {Proxy}
    * @private
    */
-  private _blocks: Blocks = null;
+  private _blocks: BlocksStore | null = null;
 
   /**
    * Should be called after Editor.UI preparation
@@ -189,13 +203,15 @@ export default class BlockManager extends Module {
     this._blocks = new Proxy(blocks, {
       set: Blocks.set,
       get: Blocks.get,
-    });
+    }) as BlocksStore;
 
     /** Copy event */
     this.listeners.on(
       document,
       'copy',
-      (e: ClipboardEvent) => this.Editor.BlockEvents.handleCommandC(e)
+      (event: Event) => {
+        this.Editor.BlockEvents.handleCommandC(event as ClipboardEvent);
+      }
     );
   }
 
@@ -235,6 +251,11 @@ export default class BlockManager extends Module {
   }: {tool: string; id?: string; data?: BlockToolData; tunes?: {[name: string]: BlockTuneData}}): Block {
     const readOnly = this.Editor.ReadOnly.isEnabled;
     const tool = this.Editor.Tools.blockTools.get(name);
+
+    if (tool === undefined) {
+      throw new Error(`Could not compose Block. Tool «${name}» not found.`);
+    }
+
     const block = new Block({
       id,
       data,
@@ -267,7 +288,7 @@ export default class BlockManager extends Module {
    */
   public insert({
     id = undefined,
-    tool = this.config.defaultBlock,
+    tool,
     data = {},
     index,
     needToFocus = true,
@@ -282,15 +303,16 @@ export default class BlockManager extends Module {
     replace?: boolean;
     tunes?: {[name: string]: BlockTuneData};
   } = {}): Block {
-    let newIndex = index;
+    const targetIndex = index ?? this.currentBlockIndex + (replace ? 0 : 1);
+    const toolName = tool ?? this.config.defaultBlock;
 
-    if (newIndex === undefined) {
-      newIndex = this.currentBlockIndex + (replace ? 0 : 1);
+    if (toolName === undefined) {
+      throw new Error('Could not insert Block. Tool name is not specified.');
     }
 
     const block = this.composeBlock({
       id,
-      tool,
+      tool: toolName,
       data,
       tunes,
     });
@@ -299,24 +321,32 @@ export default class BlockManager extends Module {
      * In case of block replacing (Converting OR from Toolbox or Shortcut on empty block OR on-paste to empty block)
      * we need to dispatch the 'block-removing' event for the replacing block
      */
-    if (replace) {
-      this.blockDidMutated(BlockRemovedMutationType, this.getBlockByIndex(newIndex), {
-        index: newIndex,
+    const blockToReplace = replace ? this.getBlockByIndex(targetIndex) : undefined;
+
+    if (replace && blockToReplace === undefined) {
+      throw new Error(`Could not replace Block at index ${targetIndex}. Block not found.`);
+    }
+
+    if (replace && blockToReplace !== undefined) {
+      this.blockDidMutated(BlockRemovedMutationType, blockToReplace, {
+        index: targetIndex,
       });
     }
 
-    this._blocks.insert(newIndex, block, replace);
+    this.blocksStore.insert(targetIndex, block, replace);
 
     /**
      * Force call of didMutated event on Block insertion
      */
     this.blockDidMutated(BlockAddedMutationType, block, {
-      index: newIndex,
+      index: targetIndex,
     });
 
     if (needToFocus) {
-      this.currentBlockIndex = newIndex;
-    } else if (newIndex <= this.currentBlockIndex) {
+      this.currentBlockIndex = targetIndex;
+    }
+
+    if (!needToFocus && targetIndex <= this.currentBlockIndex) {
       this.currentBlockIndex++;
     }
 
@@ -330,7 +360,7 @@ export default class BlockManager extends Module {
    * @param index - index where to insert
    */
   public insertMany(blocks: Block[], index = 0): void {
-    this._blocks.insertMany(blocks, index);
+    this.blocksStore.insertMany(blocks, index);
   }
 
   /**
@@ -361,7 +391,7 @@ export default class BlockManager extends Module {
 
     const blockIndex = this.getBlockIndex(block);
 
-    this._blocks.replace(blockIndex, newBlock);
+    this.blocksStore.replace(blockIndex, newBlock);
 
     this.blockDidMutated(BlockChangedMutationType, newBlock, {
       index: blockIndex,
@@ -388,6 +418,19 @@ export default class BlockManager extends Module {
     });
   }
 
+  /**
+   * Returns the proxied Blocks storage ensuring it is initialized.
+   *
+   * @throws {Error} if the storage is not prepared.
+   */
+  private get blocksStore(): BlocksStore {
+    if (this._blocks === null) {
+      throw new Error('BlockManager: blocks store is not initialized. Call prepare() before accessing blocks.');
+    }
+
+    return this._blocks;
+  }
+
   /**
    * Insert pasted content. Call onPaste callback after insert.
    *
@@ -433,9 +476,15 @@ export default class BlockManager extends Module {
    * @returns {Block} inserted Block
    */
   public insertDefaultBlockAtIndex(index: number, needToFocus = false): Block {
-    const block = this.composeBlock({ tool: this.config.defaultBlock });
+    const defaultTool = this.config.defaultBlock;
+
+    if (defaultTool === undefined) {
+      throw new Error('Could not insert default Block. Default block tool is not defined in the configuration.');
+    }
 
-    this._blocks[index] = block;
+    const block = this.composeBlock({ tool: defaultTool });
+
+    this.blocksStore[index] = block;
 
     /**
      * Force call of didMutated event on Block insertion
@@ -446,7 +495,9 @@ export default class BlockManager extends Module {
 
     if (needToFocus) {
       this.currentBlockIndex = index;
-    } else if (index <= this.currentBlockIndex) {
+    }
+
+    if (!needToFocus && index <= this.currentBlockIndex) {
       this.currentBlockIndex++;
     }
 
@@ -478,42 +529,47 @@ export default class BlockManager extends Module {
    * @returns {Promise} - the sequence that can be continued
    */
   public async mergeBlocks(targetBlock: Block, blockToMerge: Block): Promise<void> {
-    let blockToMergeData: BlockToolData | undefined;
+    const completeMerge = async (data: BlockToolData): Promise<void> => {
+      await targetBlock.mergeWith(data);
+      await this.removeBlock(blockToMerge);
+      this.currentBlockIndex = this.blocksStore.indexOf(targetBlock);
+    };
 
     /**
      * We can merge:
      * 1) Blocks with the same Tool if tool provides merge method
      */
-    if (targetBlock.name === blockToMerge.name && targetBlock.mergeable) {
-      const blockToMergeDataRaw = await blockToMerge.data;
+    const canMergeBlocksDirectly = targetBlock.name === blockToMerge.name && targetBlock.mergeable;
+    const blockToMergeDataRaw = canMergeBlocksDirectly ? await blockToMerge.data : undefined;
 
-      if (_.isEmpty(blockToMergeDataRaw)) {
-        console.error('Could not merge Block. Failed to extract original Block data.');
+    if (canMergeBlocksDirectly && _.isEmpty(blockToMergeDataRaw)) {
+      console.error('Could not merge Block. Failed to extract original Block data.');
 
-        return;
-      }
+      return;
+    }
+
+    if (canMergeBlocksDirectly && blockToMergeDataRaw !== undefined) {
+      const [ cleanData ] = sanitizeBlocks(
+        [ blockToMergeDataRaw ],
+        targetBlock.tool.sanitizeConfig,
+        this.config.sanitizer as SanitizerConfig
+      );
 
-      const [ cleanData ] = sanitizeBlocks([ blockToMergeDataRaw ], targetBlock.tool.sanitizeConfig);
+      await completeMerge(cleanData);
 
-      blockToMergeData = cleanData;
+      return;
+    }
 
     /**
      * 2) Blocks with different Tools if they provides conversionConfig
      */
-    } else if (targetBlock.mergeable && isBlockConvertable(blockToMerge, 'export') && isBlockConvertable(targetBlock, 'import')) {
+    if (targetBlock.mergeable && isBlockConvertable(blockToMerge, 'export') && isBlockConvertable(targetBlock, 'import')) {
       const blockToMergeDataStringified = await blockToMerge.exportDataAsString();
       const cleanData = clean(blockToMergeDataStringified, targetBlock.tool.sanitizeConfig);
+      const blockToMergeData = convertStringToBlockData(cleanData, targetBlock.tool.conversionConfig);
 
-      blockToMergeData = convertStringToBlockData(cleanData, targetBlock.tool.conversionConfig);
-    }
-
-    if (blockToMergeData === undefined) {
-      return;
+      await completeMerge(blockToMergeData);
     }
-
-    await targetBlock.mergeWith(blockToMergeData);
-    this.removeBlock(blockToMerge);
-    this.currentBlockIndex = this._blocks.indexOf(targetBlock);
   }
 
   /**
@@ -524,7 +580,7 @@ export default class BlockManager extends Module {
    */
   public removeBlock(block: Block, addLastBlock = true): Promise<void> {
     return new Promise((resolve) => {
-      const index = this._blocks.indexOf(block);
+      const index = this.blocksStore.indexOf(block);
 
       /**
        * If index is not passed and there is no block selected, show a warning
@@ -533,7 +589,7 @@ export default class BlockManager extends Module {
         throw new Error('Can\'t find a Block to remove');
       }
 
-      this._blocks.remove(index);
+      this.blocksStore.remove(index);
       block.destroy();
 
       /**
@@ -550,13 +606,17 @@ export default class BlockManager extends Module {
       /**
        * If first Block was removed, insert new Initial Block and set focus on it`s first input
        */
-      if (!this.blocks.length) {
+      const noBlocksLeft = this.blocks.length === 0;
+
+      if (noBlocksLeft) {
         this.unsetCurrentBlock();
+      }
 
-        if (addLastBlock) {
-          this.insert();
-        }
-      } else if (index === 0) {
+      if (noBlocksLeft && addLastBlock) {
+        this.insert();
+      }
+
+      if (!noBlocksLeft && index === 0) {
         this.currentBlockIndex = 0;
       }
 
@@ -571,21 +631,21 @@ export default class BlockManager extends Module {
    * @returns {number|undefined}
    */
   public removeSelectedBlocks(): number | undefined {
-    let firstSelectedBlockIndex;
-
-    /**
-     * Remove selected Blocks from the end
-     */
-    for (let index = this.blocks.length - 1; index >= 0; index--) {
-      if (!this.blocks[index].selected) {
-        continue;
-      }
+    const selectedBlockEntries = this.blocks
+      .map((block, index) => ({
+        block,
+        index,
+      }))
+      .filter(({ block }) => block.selected)
+      .sort((first, second) => second.index - first.index);
 
-      this.removeBlock(this.blocks[index]);
-      firstSelectedBlockIndex = index;
-    }
+    selectedBlockEntries.forEach(({ block }) => {
+      void this.removeBlock(block, false);
+    });
 
-    return firstSelectedBlockIndex;
+    return selectedBlockEntries.length > 0
+      ? selectedBlockEntries[selectedBlockEntries.length - 1].index
+      : undefined;
   }
 
   /**
@@ -594,13 +654,25 @@ export default class BlockManager extends Module {
    * Removes all blocks
    */
   public removeAllBlocks(): void {
-    for (let index = this.blocks.length - 1; index >= 0; index--) {
-      this._blocks.remove(index);
-    }
+    const removeBlockByIndex = (index: number): void => {
+      if (index < 0) {
+        return;
+      }
+
+      this.blocksStore.remove(index);
+      removeBlockByIndex(index - 1);
+    };
+
+    removeBlockByIndex(this.blocksStore.length - 1);
 
     this.unsetCurrentBlock();
     this.insert();
-    this.currentBlock.firstInput.focus();
+    const currentBlock = this.currentBlock;
+    const firstInput = currentBlock?.firstInput;
+
+    if (firstInput !== undefined) {
+      firstInput.focus();
+    }
   }
 
   /**
@@ -653,11 +725,11 @@ export default class BlockManager extends Module {
    * @returns {Block}
    */
   public getBlockByIndex(index: number): Block | undefined {
-    if (index === -1) {
-      index = this._blocks.length - 1;
-    }
+    const targetIndex = index === -1
+      ? this.blocksStore.length - 1
+      : index;
 
-    return this._blocks[index];
+    return this.blocksStore[targetIndex];
   }
 
   /**
@@ -666,7 +738,7 @@ export default class BlockManager extends Module {
    * @param block - block to find index
    */
   public getBlockIndex(block: Block): number {
-    return this._blocks.indexOf(block);
+    return this.blocksStore.indexOf(block);
   }
 
   /**
@@ -675,8 +747,8 @@ export default class BlockManager extends Module {
    * @param id - id of block to get
    * @returns {Block}
    */
-  public getBlockById(id): Block | undefined {
-    return this._blocks.array.find(block => block.id === id);
+  public getBlockById(id: string): Block | undefined {
+    return this.blocksStore.array.find((block) => block.id === id);
   }
 
   /**
@@ -685,17 +757,26 @@ export default class BlockManager extends Module {
    * @param {Node} element - html element to get Block by
    */
   public getBlock(element: HTMLElement): Block | undefined {
-    if (!$.isElement(element) as boolean) {
-      element = element.parentNode as HTMLElement;
+    const normalizedElement = (($.isElement(element) as boolean) ? element : element.parentNode) as HTMLElement | null;
+
+    if (!normalizedElement) {
+      return undefined;
+    }
+
+    const nodes = this.blocksStore.nodes;
+    const firstLevelBlock = normalizedElement.closest(`.${Block.CSS.wrapper}`);
+
+    if (!firstLevelBlock) {
+      return undefined;
     }
 
-    const nodes = this._blocks.nodes,
-        firstLevelBlock = element.closest(`.${Block.CSS.wrapper}`),
-        index = nodes.indexOf(firstLevelBlock as HTMLElement);
+    const index = nodes.indexOf(firstLevelBlock as HTMLElement);
 
     if (index >= 0) {
-      return this._blocks[index];
+      return this.blocksStore[index];
     }
+
+    return undefined;
   }
 
   /**
@@ -709,14 +790,16 @@ export default class BlockManager extends Module {
     /**
      * If node is Text TextNode
      */
-    if (!$.isElement(childNode)) {
-      childNode = childNode.parentNode;
+    const normalizedChildNode = ($.isElement(childNode) ? childNode : childNode.parentNode) as HTMLElement | null;
+
+    if (!normalizedChildNode) {
+      return undefined;
     }
 
-    const parentFirstLevelBlock = (childNode as HTMLElement).closest(`.${Block.CSS.wrapper}`);
+    const parentFirstLevelBlock = normalizedChildNode.closest(`.${Block.CSS.wrapper}`);
 
     if (!parentFirstLevelBlock) {
-      return;
+      return undefined;
     }
 
     /**
@@ -729,7 +812,7 @@ export default class BlockManager extends Module {
     const isBlockBelongsToCurrentInstance = editorWrapper?.isEqualNode(this.Editor.UI.nodes.wrapper);
 
     if (!isBlockBelongsToCurrentInstance) {
-      return;
+      return undefined;
     }
 
     /**
@@ -737,14 +820,20 @@ export default class BlockManager extends Module {
      *
      * @type {number}
      */
-    this.currentBlockIndex = this._blocks.nodes.indexOf(parentFirstLevelBlock as HTMLElement);
+    if (!(parentFirstLevelBlock instanceof HTMLElement)) {
+      return undefined;
+    }
+
+    this.currentBlockIndex = this.blocksStore.nodes.indexOf(parentFirstLevelBlock);
 
     /**
      * Update current block active input
      */
-    this.currentBlock.updateCurrentInput();
+    const currentBlock = this.currentBlock;
 
-    return this.currentBlock;
+    currentBlock?.updateCurrentInput();
+
+    return currentBlock;
   }
 
   /**
@@ -754,18 +843,24 @@ export default class BlockManager extends Module {
    * @returns {Block}
    */
   public getBlockByChildNode(childNode: Node): Block | undefined {
-    if (!childNode || childNode instanceof Node === false) {
+    if (!(childNode instanceof Node)) {
       return undefined;
     }
 
     /**
      * If node is Text TextNode
      */
-    if (!$.isElement(childNode)) {
-      childNode = childNode.parentNode;
+    const normalizedChildNode = ($.isElement(childNode) ? childNode : childNode.parentNode) as HTMLElement | null;
+
+    if (!normalizedChildNode) {
+      return undefined;
     }
 
-    const firstLevelBlock = (childNode as HTMLElement).closest(`.${Block.CSS.wrapper}`);
+    const firstLevelBlock = normalizedChildNode.closest(`.${Block.CSS.wrapper}`);
+
+    if (!firstLevelBlock) {
+      return undefined;
+    }
 
     return this.blocks.find((block) => block.holder === firstLevelBlock);
   }
@@ -777,9 +872,9 @@ export default class BlockManager extends Module {
    * @param {number} toIndex - index of second block
    * @deprecated — use 'move' instead
    */
-  public swap(fromIndex, toIndex): void {
+  public swap(fromIndex: number, toIndex: number): void {
     /** Move up current Block */
-    this._blocks.swap(fromIndex, toIndex);
+    this.blocksStore.swap(fromIndex, toIndex);
 
     /** Now actual block moved up so that current block index decreased */
     this.currentBlockIndex = toIndex;
@@ -791,7 +886,7 @@ export default class BlockManager extends Module {
    * @param {number} toIndex - index where to move Block
    * @param {number} fromIndex - index of Block to move
    */
-  public move(toIndex, fromIndex = this.currentBlockIndex): void {
+  public move(toIndex: number, fromIndex: number = this.currentBlockIndex): void {
     // make sure indexes are valid and within a valid range
     if (isNaN(toIndex) || isNaN(fromIndex)) {
       _.log(`Warning during 'move' call: incorrect indices provided.`, 'warn');
@@ -806,15 +901,20 @@ export default class BlockManager extends Module {
     }
 
     /** Move up current Block */
-    this._blocks.move(toIndex, fromIndex);
+    this.blocksStore.move(toIndex, fromIndex);
 
     /** Now actual block moved so that current block index changed */
     this.currentBlockIndex = toIndex;
+    const movedBlock = this.currentBlock;
+
+    if (movedBlock === undefined) {
+      throw new Error(`Could not move Block. Block at index ${toIndex} is not available.`);
+    }
 
     /**
      * Force call of didMutated event on Block movement
      */
-    this.blockDidMutated(BlockMovedMutationType, this.currentBlock, {
+    this.blockDidMutated(BlockMovedMutationType, movedBlock, {
       fromIndex,
       toIndex,
     });
@@ -857,21 +957,16 @@ export default class BlockManager extends Module {
      */
     const cleanData: string = clean(
       exportedData,
-      replacingTool.sanitizeConfig
+      composeSanitizerConfig(this.config.sanitizer as SanitizerConfig, replacingTool.sanitizeConfig)
     );
 
     /**
      * Now using Conversion Config "import" we compose a new Block data
      */
-    let newBlockData = convertStringToBlockData(cleanData, replacingTool.conversionConfig, replacingTool.settings);
-
-    /**
-     * Optional data overrides.
-     * Used for example, by the Multiple Toolbox Items feature, where a single Tool provides several Toolbox items with "data" overrides
-     */
-    if (blockDataOverrides) {
-      newBlockData = Object.assign(newBlockData, blockDataOverrides);
-    }
+    const baseBlockData = convertStringToBlockData(cleanData, replacingTool.conversionConfig, replacingTool.settings);
+    const newBlockData = blockDataOverrides
+      ? Object.assign(baseBlockData, blockDataOverrides)
+      : baseBlockData;
 
     return this.replace(blockToConvert, replacingTool.name, newBlockData);
   }
@@ -895,10 +990,10 @@ export default class BlockManager extends Module {
     const queue = new PromiseQueue();
 
     // Create a copy of the blocks array to avoid issues with array modification during iteration
-    const blocksToRemove = [...this.blocks];
-    
+    const blocksToRemove = [ ...this.blocks ];
+
     blocksToRemove.forEach((block) => {
-      queue.add(async () => {
+      void queue.add(async () => {
         await this.removeBlock(block, false);
       });
     });
@@ -935,20 +1030,28 @@ export default class BlockManager extends Module {
   private bindBlockEvents(block: Block): void {
     const { BlockEvents } = this.Editor;
 
-    this.readOnlyMutableListeners.on(block.holder, 'keydown', (event: KeyboardEvent) => {
-      BlockEvents.keydown(event);
+    this.readOnlyMutableListeners.on(block.holder, 'keydown', (event: Event) => {
+      if (event instanceof KeyboardEvent) {
+        BlockEvents.keydown(event);
+      }
     });
 
-    this.readOnlyMutableListeners.on(block.holder, 'keyup', (event: KeyboardEvent) => {
-      BlockEvents.keyup(event);
+    this.readOnlyMutableListeners.on(block.holder, 'keyup', (event: Event) => {
+      if (event instanceof KeyboardEvent) {
+        BlockEvents.keyup(event);
+      }
     });
 
-    this.readOnlyMutableListeners.on(block.holder, 'dragover', (event: DragEvent) => {
-      BlockEvents.dragOver(event);
+    this.readOnlyMutableListeners.on(block.holder, 'dragover', (event: Event) => {
+      if (event instanceof DragEvent) {
+        BlockEvents.dragOver(event);
+      }
     });
 
-    this.readOnlyMutableListeners.on(block.holder, 'dragleave', (event: DragEvent) => {
-      BlockEvents.dragLeave(event);
+    this.readOnlyMutableListeners.on(block.holder, 'dragleave', (event: Event) => {
+      if (event instanceof DragEvent) {
+        BlockEvents.dragLeave(event);
+      }
     });
 
     block.on('didMutated', (affectedBlock: Block) => {
@@ -973,7 +1076,9 @@ export default class BlockManager extends Module {
     this.readOnlyMutableListeners.on(
       document,
       'cut',
-      (e: ClipboardEvent) => this.Editor.BlockEvents.handleCommandX(e)
+      (event: Event) => {
+        this.Editor.BlockEvents.handleCommandX(event as ClipboardEvent);
+      }
     );
 
     this.blocks.forEach((block: Block) => {
@@ -988,7 +1093,7 @@ export default class BlockManager extends Module {
    * @returns {boolean}
    */
   private validateIndex(index: number): boolean {
-    return !(index < 0 || index >= this._blocks.length);
+    return !(index < 0 || index >= this.blocksStore.length);
   }
 
   /**
@@ -999,13 +1104,40 @@ export default class BlockManager extends Module {
    * @param detailData - additional data to pass with change event
    */
   private blockDidMutated<Type extends BlockMutationType>(mutationType: Type, block: Block, detailData: BlockMutationEventDetailWithoutTarget<Type>): Block {
+    const eventDetail = {
+      target: new BlockAPI(block),
+      ...detailData as BlockMutationEventDetailWithoutTarget<Type>,
+    };
+
     const event = new CustomEvent(mutationType, {
       detail: {
-        target: new BlockAPI(block),
-        ...detailData as BlockMutationEventDetailWithoutTarget<Type>,
+        ...eventDetail,
       },
     });
 
+    /**
+     * The CustomEvent#type getter is not enumerable by default, so it gets lost during structured cloning.
+     * Define it explicitly to keep the type available for consumers like Playwright tests.
+     */
+    if (!Object.prototype.propertyIsEnumerable.call(event, 'type')) {
+      Object.defineProperty(event, 'type', {
+        value: mutationType,
+        enumerable: true,
+        configurable: true,
+      });
+    }
+
+    /**
+     * CustomEvent#detail is also non-enumerable, so preserve it for consumers outside of the browser context.
+     */
+    if (!Object.prototype.propertyIsEnumerable.call(event, 'detail')) {
+      Object.defineProperty(event, 'detail', {
+        value: eventDetail,
+        enumerable: true,
+        configurable: true,
+      });
+    }
+
     this.eventsDispatcher.emit(BlockChanged, {
       event: event as BlockMutationEventMap[Type],
     });
diff --git a/src/components/modules/blockSelection.ts b/src/components/modules/blockSelection.ts
index a6edcb8c8..ae67afb52 100644
--- a/src/components/modules/blockSelection.ts
+++ b/src/components/modules/blockSelection.ts
@@ -12,7 +12,7 @@ import Shortcuts from '../utils/shortcuts';
 
 import SelectionUtils from '../selection';
 import type { SanitizerConfig } from '../../../types/configs';
-import { clean } from '../utils/sanitizer';
+import { clean, composeSanitizerConfig } from '../utils/sanitizer';
 
 /**
  *
@@ -33,7 +33,7 @@ export default class BlockSelection extends Module {
    * @returns {SanitizerConfig}
    */
   private get sanitizerConfig(): SanitizerConfig {
-    return {
+    const baseConfig: SanitizerConfig = {
       p: {},
       h1: {},
       h2: {},
@@ -57,6 +57,8 @@ export default class BlockSelection extends Module {
       i: {},
       u: {},
     };
+
+    return composeSanitizerConfig(this.config.sanitizer as SanitizerConfig, baseConfig);
   }
 
   /**
@@ -78,9 +80,9 @@ export default class BlockSelection extends Module {
   public set allBlocksSelected(state: boolean) {
     const { BlockManager } = this.Editor;
 
-    BlockManager.blocks.forEach((block) => {
+    for (const block of BlockManager.blocks) {
       block.selected = state;
-    });
+    }
 
     this.clearCache();
   }
@@ -138,7 +140,7 @@ export default class BlockSelection extends Module {
    *
    * @type {SelectionUtils}
    */
-  private selection: SelectionUtils;
+  private selection: SelectionUtils = new SelectionUtils();
 
   /**
    * Module Preparation
@@ -146,6 +148,9 @@ export default class BlockSelection extends Module {
    * to select all and copy them
    */
   public prepare(): void {
+    /**
+     * Re-create SelectionUtils instance to ensure fresh state.
+     */
     this.selection = new SelectionUtils();
 
     /**
@@ -153,7 +158,7 @@ export default class BlockSelection extends Module {
      */
     Shortcuts.add({
       name: 'CMD+A',
-      handler: (event) => {
+      handler: (event: KeyboardEvent) => {
         const { BlockManager, ReadOnly } = this.Editor;
 
         /**
@@ -191,8 +196,9 @@ export default class BlockSelection extends Module {
    *  - Unselect all Blocks
    */
   public toggleReadOnly(): void {
-    SelectionUtils.get()
-      .removeAllRanges();
+    const selection = SelectionUtils.get();
+
+    selection?.removeAllRanges();
 
     this.allBlocksSelected = false;
   }
@@ -202,15 +208,15 @@ export default class BlockSelection extends Module {
    *
    * @param {number?} index - Block index according to the BlockManager's indexes
    */
-  public unSelectBlockByIndex(index?): void {
+  public unSelectBlockByIndex(index?: number): void {
     const { BlockManager } = this.Editor;
 
-    let block;
+    const block = typeof index === 'number'
+      ? BlockManager.getBlockByIndex(index)
+      : BlockManager.currentBlock;
 
-    if (isNaN(index)) {
-      block = BlockManager.currentBlock;
-    } else {
-      block = BlockManager.getBlockByIndex(index);
+    if (!block) {
+      return;
     }
 
     block.selected = false;
@@ -225,7 +231,7 @@ export default class BlockSelection extends Module {
    * @param {boolean} restoreSelection - if true, restore saved selection
    */
   public clearSelection(reason?: Event, restoreSelection = false): void {
-    const { BlockManager, Caret, RectangleSelection } = this.Editor;
+    const { RectangleSelection } = this.Editor;
 
     this.needToSelectAll = false;
     this.nativeInputSelected = false;
@@ -239,32 +245,11 @@ export default class BlockSelection extends Module {
      * remove selected blocks and insert pressed key
      */
     if (this.anyBlockSelected && isKeyboard && isPrintableKey && !SelectionUtils.isSelectionExists) {
-      const indexToInsert = BlockManager.removeSelectedBlocks();
-
-      BlockManager.insertDefaultBlockAtIndex(indexToInsert, true);
-      Caret.setToBlock(BlockManager.currentBlock);
-      _.delay(() => {
-        const eventKey = (reason as KeyboardEvent).key;
-
-        /**
-         * If event.key length >1 that means key is special (e.g. Enter or Dead or Unidentified).
-         * So we use empty string
-         *
-         * @see https://developer.mozilla.org/ru/docs/Web/API/KeyboardEvent/key
-         */
-        Caret.insertContentAtCaretPosition(eventKey.length > 1 ? '' : eventKey);
-      // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-      }, 20)();
+      this.replaceSelectedBlocksWithPrintableKey(reason as KeyboardEvent);
     }
 
     this.Editor.CrossBlockSelection.clear(reason);
 
-    if (!this.anyBlockSelected || RectangleSelection.isRectActivated()) {
-      this.Editor.RectangleSelection.clearSelection();
-
-      return;
-    }
-
     /**
      * Restore selection when Block is already selected
      * but someone tries to write something.
@@ -273,6 +258,12 @@ export default class BlockSelection extends Module {
       this.selection.restore();
     }
 
+    if (!this.anyBlockSelected || RectangleSelection.isRectActivated()) {
+      this.Editor.RectangleSelection.clearSelection();
+
+      return;
+    }
+
     /** Now all blocks cleared */
     this.allBlocksSelected = false;
   }
@@ -283,41 +274,59 @@ export default class BlockSelection extends Module {
    * @param {ClipboardEvent} e - copy/cut event
    * @returns {Promise<void>}
    */
-  public copySelectedBlocks(e: ClipboardEvent): Promise<void> {
+  public async copySelectedBlocks(e: ClipboardEvent): Promise<void> {
     /**
      * Prevent default copy
      */
     e.preventDefault();
 
+    const clipboardData = e.clipboardData;
+
+    if (!clipboardData) {
+      return;
+    }
+
     const fakeClipboard = $.make('div');
+    const textPlainChunks: string[] = [];
 
     this.selectedBlocks.forEach((block) => {
-      /**
-       * Make <p> tag that holds clean HTML
-       */
       const cleanHTML = clean(block.holder.innerHTML, this.sanitizerConfig);
-      const fragment = $.make('p');
+      const wrapper = $.make('div');
+
+      wrapper.innerHTML = cleanHTML;
+
+      const textContent = wrapper.textContent ?? '';
 
-      fragment.innerHTML = cleanHTML;
-      fakeClipboard.appendChild(fragment);
+      textPlainChunks.push(textContent);
+
+      const hasElementChildren = Array.from(wrapper.childNodes).some((node) => node.nodeType === Node.ELEMENT_NODE);
+      const shouldWrapWithParagraph = !hasElementChildren && textContent.trim().length > 0;
+
+      if (shouldWrapWithParagraph) {
+        const paragraph = $.make('p');
+
+        paragraph.innerHTML = wrapper.innerHTML;
+        fakeClipboard.appendChild(paragraph);
+      } else {
+        while (wrapper.firstChild) {
+          fakeClipboard.appendChild(wrapper.firstChild);
+        }
+      }
     });
 
-    const textPlain = Array.from(fakeClipboard.childNodes).map((node) => node.textContent)
-      .join('\n\n');
+    const textPlain = textPlainChunks.join('\n\n');
     const textHTML = fakeClipboard.innerHTML;
 
-    e.clipboardData.setData('text/plain', textPlain);
-    e.clipboardData.setData('text/html', textHTML);
+    clipboardData.setData('text/plain', textPlain);
+    clipboardData.setData('text/html', textHTML);
 
-    return Promise
-      .all(this.selectedBlocks.map((block) => block.save()))
-      .then(savedData => {
-        try {
-          e.clipboardData.setData(this.Editor.Paste.MIME_TYPE, JSON.stringify(savedData));
-        } catch (err) {
-          // In Firefox we can't set data in async function
-        }
-      });
+    try {
+      const savedData = await Promise.all(this.selectedBlocks.map((block) => block.save()));
+
+      clipboardData.setData(this.Editor.Paste.MIME_TYPE, JSON.stringify(savedData));
+    } catch {
+      // In Firefox we can't set data in async function
+    }
   }
 
   /**
@@ -345,10 +354,13 @@ export default class BlockSelection extends Module {
   public selectBlock(block: Block): void {
     /** Save selection */
     this.selection.save();
-    SelectionUtils.get()
-      .removeAllRanges();
+    const selection = SelectionUtils.get();
+
+    selection?.removeAllRanges();
 
-    block.selected = true;
+    const blockToSelect = block;
+
+    blockToSelect.selected = true;
 
     this.clearCache();
 
@@ -362,7 +374,9 @@ export default class BlockSelection extends Module {
    * @param {Block} block - Block to unselect
    */
   public unselectBlock(block: Block): void {
-    block.selected = false;
+    const blockToUnselect = block;
+
+    blockToUnselect.selected = false;
 
     this.clearCache();
   }
@@ -400,6 +414,11 @@ export default class BlockSelection extends Module {
     }
 
     const workingBlock = this.Editor.BlockManager.getBlock(event.target as HTMLElement);
+
+    if (!workingBlock) {
+      return;
+    }
+
     const inputs = workingBlock.inputs;
 
     /**
@@ -431,22 +450,28 @@ export default class BlockSelection extends Module {
        */
       this.needToSelectAll = false;
       this.readyToBlockSelection = false;
-    } else if (this.readyToBlockSelection) {
-      /**
-       * prevent default selection when we use custom selection
-       */
-      event.preventDefault();
 
-      /**
-       * select working Block
-       */
-      this.selectBlock(workingBlock);
+      return;
+    }
 
-      /**
-       * Enable all Blocks selection if current Block is selected
-       */
-      this.needToSelectAll = true;
+    if (!this.readyToBlockSelection) {
+      return;
     }
+
+    /**
+     * prevent default selection when we use custom selection
+     */
+    event.preventDefault();
+
+    /**
+     * select working Block
+     */
+    this.selectBlock(workingBlock);
+
+    /**
+     * Enable all Blocks selection if current Block is selected
+     */
+    this.needToSelectAll = true;
   }
 
   /**
@@ -463,12 +488,48 @@ export default class BlockSelection extends Module {
     /**
      * Remove Ranges from Selection
      */
-    SelectionUtils.get()
-      .removeAllRanges();
+    const selection = SelectionUtils.get();
+
+    selection?.removeAllRanges();
 
     this.allBlocksSelected = true;
 
     /** close InlineToolbar if we selected all Blocks */
     this.Editor.InlineToolbar.close();
   }
+
+  /**
+   * Remove selected blocks and insert pressed printable key
+   *
+   * @param event - keyboard event that triggers replacement
+   */
+  private replaceSelectedBlocksWithPrintableKey(event: KeyboardEvent): void {
+    const { BlockManager, Caret } = this.Editor;
+    const indexToInsert = BlockManager.removeSelectedBlocks();
+
+    if (indexToInsert === undefined) {
+      return;
+    }
+
+    BlockManager.insertDefaultBlockAtIndex(indexToInsert, true);
+
+    const currentBlock = BlockManager.currentBlock;
+
+    if (currentBlock) {
+      Caret.setToBlock(currentBlock);
+    }
+
+    _.delay(() => {
+      const eventKey = event.key;
+
+      /**
+       * If event.key length >1 that means key is special (e.g. Enter or Dead or Unidentified).
+       * So we use empty string
+       *
+       * @see https://developer.mozilla.org/ru/docs/Web/API/KeyboardEvent/key
+       */
+      Caret.insertContentAtCaretPosition(eventKey.length > 1 ? '' : eventKey);
+    // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+    }, 20)();
+  }
 }
diff --git a/src/components/modules/caret.ts b/src/components/modules/caret.ts
index db8a4f3b0..2ae4617dc 100644
--- a/src/components/modules/caret.ts
+++ b/src/components/modules/caret.ts
@@ -4,6 +4,81 @@ import type Block from '../block';
 import * as caretUtils from '../utils/caret';
 import $  from '../dom';
 
+const ASCII_MAX_CODE_POINT = 0x7f;
+
+/**
+ * Determines whether the provided text is comprised only of punctuation and whitespace characters.
+ *
+ * @param text - text to check
+ */
+const isPunctuationOnly = (text: string): boolean => {
+  for (const character of text) {
+    if (character.trim().length === 0) {
+      continue;
+    }
+
+    if (character >= '0' && character <= '9') {
+      return false;
+    }
+
+    if (character.toLowerCase() !== character.toUpperCase()) {
+      return false;
+    }
+
+    const codePoint = character.codePointAt(0);
+
+    if (typeof codePoint === 'number' && codePoint > ASCII_MAX_CODE_POINT) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+const collectTextNodes = (node: Node): Text[] => {
+  if (node.nodeType === Node.TEXT_NODE) {
+    return [ node as Text ];
+  }
+
+  if (!node.hasChildNodes?.()) {
+    return [];
+  }
+
+  return Array.from(node.childNodes).flatMap((child) => collectTextNodes(child));
+};
+
+/**
+ * Finds last text node suitable for placing caret near the end of the element.
+ *
+ * Prefers nodes that contain more than just punctuation so caret remains inside formatting nodes
+ * whenever possible.
+ *
+ * @param root - element to search within
+ */
+const findLastMeaningfulTextNode = (root: HTMLElement): Text | null => {
+  const textNodes = collectTextNodes(root);
+
+  if (textNodes.length === 0) {
+    return null;
+  }
+
+  const lastTextNode = textNodes[textNodes.length - 1];
+  const lastMeaningfulNode = [ ...textNodes ]
+    .reverse()
+    .find((node) => !isPunctuationOnly(node.textContent ?? '')) ?? null;
+
+  if (
+    lastMeaningfulNode &&
+    lastMeaningfulNode !== lastTextNode &&
+    isPunctuationOnly(lastTextNode.textContent ?? '') &&
+    lastMeaningfulNode.parentNode !== root
+  ) {
+    return lastMeaningfulNode;
+  }
+
+  return lastTextNode;
+};
+
 /**
  * Caret
  * Contains methods for working Caret
@@ -71,42 +146,56 @@ export default class Caret extends Module {
       return;
     }
 
-    let element;
+    const getElement = (): HTMLElement | undefined => {
+      if (position === this.positions.START) {
+        return block.firstInput;
+      }
 
-    switch (position) {
-      case this.positions.START:
-        element = block.firstInput;
-        break;
-      case this.positions.END:
-        element = block.lastInput;
-        break;
-      default:
-        element = block.currentInput;
-    }
+      if (position === this.positions.END) {
+        return block.lastInput;
+      }
+
+      return block.currentInput;
+    };
+
+    const element = getElement();
 
     if (!element) {
       return;
     }
 
-    let nodeToSet: Node;
-    let offsetToSet = offset;
+    const getNodeAndOffset = (el: HTMLElement): { node: Node | null; offset: number } => {
+      if (position === this.positions.START) {
+        return {
+          node: $.getDeepestNode(el, false),
+          offset: 0,
+        };
+      }
 
-    if (position === this.positions.START) {
-      nodeToSet = $.getDeepestNode(element, false) as Node;
-      offsetToSet = 0;
-    } else if (position === this.positions.END) {
-      nodeToSet = $.getDeepestNode(element, true) as Node;
-      offsetToSet = $.getContentLength(nodeToSet);
-    } else {
-      const { node, offset: nodeOffset } = $.getNodeByOffset(element, offset);
+      if (position === this.positions.END) {
+        return this.resolveEndPositionNode(el);
+      }
+
+      const { node, offset: nodeOffset } = $.getNodeByOffset(el, offset);
 
       if (node) {
-        nodeToSet = node;
-        offsetToSet = nodeOffset;
-      } else { // case for empty block's input
-        nodeToSet = $.getDeepestNode(element, false) as Node;
-        offsetToSet = 0;
+        return {
+          node,
+          offset: nodeOffset,
+        };
       }
+
+      // case for empty block's input
+      return {
+        node: $.getDeepestNode(el, false),
+        offset: 0,
+      };
+    };
+
+    const { node: nodeToSet, offset: offsetToSet } = getNodeAndOffset(element);
+
+    if (!nodeToSet) {
+      return;
     }
 
     this.set(nodeToSet as HTMLElement, offsetToSet);
@@ -116,6 +205,43 @@ export default class Caret extends Module {
     BlockManager.currentBlock!.currentInput = element;
   }
 
+  /**
+   * Calculates the node and offset when caret should be placed near element's end.
+   *
+   * @param {HTMLElement} el - element to inspect
+   */
+  private resolveEndPositionNode(el: HTMLElement): { node: Node | null; offset: number } {
+    const nodeToSet = $.getDeepestNode(el, true);
+
+    if (nodeToSet instanceof HTMLElement && $.isNativeInput(nodeToSet)) {
+      return {
+        node: nodeToSet,
+        offset: $.getContentLength(nodeToSet),
+      };
+    }
+
+    const meaningfulTextNode = findLastMeaningfulTextNode(el);
+
+    if (meaningfulTextNode) {
+      return {
+        node: meaningfulTextNode,
+        offset: meaningfulTextNode.textContent?.length ?? 0,
+      };
+    }
+
+    if (nodeToSet) {
+      return {
+        node: nodeToSet,
+        offset: $.getContentLength(nodeToSet),
+      };
+    }
+
+    return {
+      node: null,
+      offset: 0,
+    };
+  }
+
   /**
    * Set caret to the current input of current Block.
    *
@@ -134,7 +260,9 @@ export default class Caret extends Module {
         break;
 
       case this.positions.END:
-        this.set(nodeToSet as HTMLElement, $.getContentLength(nodeToSet));
+        if (nodeToSet) {
+          this.set(nodeToSet as HTMLElement, $.getContentLength(nodeToSet));
+        }
         break;
 
       default:
@@ -143,7 +271,9 @@ export default class Caret extends Module {
         }
     }
 
-    currentBlock.currentInput = input;
+    if (currentBlock) {
+      currentBlock.currentInput = input;
+    }
   }
 
   /**
@@ -162,7 +292,11 @@ export default class Caret extends Module {
      */
     if (top < 0) {
       window.scrollBy(0, top - scrollOffset);
-    } else if (bottom > innerHeight) {
+
+      return;
+    }
+
+    if (bottom > innerHeight) {
       window.scrollBy(0, bottom - innerHeight + scrollOffset);
     }
   }
@@ -197,39 +331,50 @@ export default class Caret extends Module {
   public extractFragmentFromCaretPosition(): void|DocumentFragment {
     const selection = Selection.get();
 
-    if (selection.rangeCount) {
-      const selectRange = selection.getRangeAt(0);
-      const currentBlockInput = this.Editor.BlockManager.currentBlock.currentInput;
+    if (!selection || !selection.rangeCount) {
+      return;
+    }
+
+    const selectRange = selection.getRangeAt(0);
+    const currentBlock = this.Editor.BlockManager.currentBlock;
+
+    if (!currentBlock) {
+      return;
+    }
 
-      selectRange.deleteContents();
+    const currentBlockInput = currentBlock.currentInput;
 
-      if (currentBlockInput) {
-        if ($.isNativeInput(currentBlockInput)) {
-          /**
-           * If input is native text input we need to use it's value
-           * Text before the caret stays in the input,
-           * while text after the caret is returned as a fragment to be inserted after the block.
-           */
-          const input = currentBlockInput as HTMLInputElement | HTMLTextAreaElement;
-          const newFragment = document.createDocumentFragment();
+    selectRange.deleteContents();
 
-          const inputRemainingText = input.value.substring(0, input.selectionStart);
-          const fragmentText = input.value.substring(input.selectionStart);
+    if (!currentBlockInput) {
+      return;
+    }
 
-          newFragment.textContent = fragmentText;
-          input.value = inputRemainingText;
+    if ($.isNativeInput(currentBlockInput)) {
+      /**
+       * If input is native text input we need to use it's value
+       * Text before the caret stays in the input,
+       * while text after the caret is returned as a fragment to be inserted after the block.
+       */
+      const input = currentBlockInput as HTMLInputElement | HTMLTextAreaElement;
+      const newFragment = document.createDocumentFragment();
+      const selectionStart = input.selectionStart ?? 0;
 
-          return newFragment;
-        } else {
-          const range = selectRange.cloneRange();
+      const inputRemainingText = input.value.substring(0, selectionStart);
+      const fragmentText = input.value.substring(selectionStart);
 
-          range.selectNodeContents(currentBlockInput);
-          range.setStart(selectRange.endContainer, selectRange.endOffset);
+      newFragment.textContent = fragmentText;
+      input.value = inputRemainingText;
 
-          return range.extractContents();
-        }
-      }
+      return newFragment;
     }
+
+    const range = selectRange.cloneRange();
+
+    range.selectNodeContents(currentBlockInput);
+    range.setStart(selectRange.endContainer, selectRange.endOffset);
+
+    return range.extractContents();
   }
 
   /**
@@ -250,8 +395,6 @@ export default class Caret extends Module {
     const { nextInput, currentInput } = currentBlock;
     const isAtEnd = currentInput !== undefined ? caretUtils.isCaretAtEndOfInput(currentInput) : undefined;
 
-    let blockToNavigate = nextBlock;
-
     /**
      * We should jump to the next block if:
      * - 'force' is true (Tab-navigation)
@@ -267,7 +410,11 @@ export default class Caret extends Module {
       return true;
     }
 
-    if (blockToNavigate === null) {
+    const getBlockToNavigate = (): Block | null => {
+      if (nextBlock !== null) {
+        return nextBlock;
+      }
+
       /**
        * This code allows to exit from the last non-initial tool:
        * https://github.com/codex-team/editor.js/issues/1103
@@ -279,17 +426,19 @@ export default class Caret extends Module {
        *    (https://github.com/codex-team/editor.js/issues/1414)
        */
       if (currentBlock.tool.isDefault || !navigationAllowed) {
-        return false;
+        return null;
       }
 
       /**
        * If there is no nextBlock, but currentBlock is not default,
        * insert new default block at the end and navigate to it
        */
-      blockToNavigate = BlockManager.insertAtEnd() as Block;
-    }
+      return BlockManager.insertAtEnd() as Block;
+    };
+
+    const blockToNavigate = getBlockToNavigate();
 
-    if (navigationAllowed) {
+    if (blockToNavigate !== null && navigationAllowed) {
       this.setToBlock(blockToNavigate, this.positions.START);
 
       return true;
@@ -392,6 +541,10 @@ export default class Caret extends Module {
     const selection = Selection.get();
     const range = Selection.range;
 
+    if (!selection || !range) {
+      return;
+    }
+
     wrapper.innerHTML = content;
 
     Array.from(wrapper.childNodes).forEach((child: Node) => fragment.appendChild(child));
diff --git a/src/components/modules/crossBlockSelection.ts b/src/components/modules/crossBlockSelection.ts
index 1b18b8e6d..4f9b9aa1e 100644
--- a/src/components/modules/crossBlockSelection.ts
+++ b/src/components/modules/crossBlockSelection.ts
@@ -10,12 +10,12 @@ export default class CrossBlockSelection extends Module {
   /**
    * Block where selection is started
    */
-  private firstSelectedBlock: Block;
+  private firstSelectedBlock: Block | null = null;
 
   /**
    * Last selected Block
    */
-  private lastSelectedBlock: Block;
+  private lastSelectedBlock: Block | null = null;
 
   /**
    * Module preparation
@@ -23,8 +23,8 @@ export default class CrossBlockSelection extends Module {
    * @returns {Promise}
    */
   public async prepare(): Promise<void> {
-    this.listeners.on(document, 'mousedown', (event: MouseEvent) => {
-      this.enableCrossBlockSelection(event);
+    this.listeners.on(document, 'mousedown', (event: Event) => {
+      this.enableCrossBlockSelection(event as MouseEvent);
     });
   }
 
@@ -40,8 +40,14 @@ export default class CrossBlockSelection extends Module {
 
     const { BlockManager } = this.Editor;
 
-    this.firstSelectedBlock = BlockManager.getBlock(event.target as HTMLElement);
-    this.lastSelectedBlock = this.firstSelectedBlock;
+    const block = BlockManager.getBlock(event.target as HTMLElement);
+
+    if (!block) {
+      return;
+    }
+
+    this.firstSelectedBlock = block;
+    this.lastSelectedBlock = block;
 
     this.listeners.on(document, 'mouseover', this.onMouseOver);
     this.listeners.on(document, 'mouseup', this.onMouseUp);
@@ -64,15 +70,30 @@ export default class CrossBlockSelection extends Module {
   public toggleBlockSelectedState(next = true): void {
     const { BlockManager, BlockSelection } = this.Editor;
 
-    if (!this.lastSelectedBlock) {
-      this.lastSelectedBlock = this.firstSelectedBlock = BlockManager.currentBlock;
+    const currentBlock = BlockManager.currentBlock;
+
+    if (!this.lastSelectedBlock && !currentBlock) {
+      return;
     }
 
-    if (this.firstSelectedBlock === this.lastSelectedBlock) {
+    if (!this.lastSelectedBlock && currentBlock) {
+      this.lastSelectedBlock = this.firstSelectedBlock = currentBlock;
+    }
+
+    if (this.firstSelectedBlock === this.lastSelectedBlock && this.firstSelectedBlock) {
       this.firstSelectedBlock.selected = true;
 
       BlockSelection.clearCache();
-      SelectionUtils.get().removeAllRanges();
+      SelectionUtils.get()?.removeAllRanges();
+
+      /**
+       * Hide the Toolbar when cross-block selection starts.
+       */
+      this.Editor.Toolbar.close();
+    }
+
+    if (!this.lastSelectedBlock) {
+      return;
     }
 
     const nextBlockIndex = BlockManager.blocks.indexOf(this.lastSelectedBlock) + (next ? 1 : -1);
@@ -86,10 +107,12 @@ export default class CrossBlockSelection extends Module {
       nextBlock.selected = true;
 
       BlockSelection.clearCache();
+      this.Editor.Toolbar.close();
     } else {
       this.lastSelectedBlock.selected = false;
 
       BlockSelection.clearCache();
+      this.Editor.Toolbar.close();
     }
 
     this.lastSelectedBlock = nextBlock;
@@ -109,27 +132,36 @@ export default class CrossBlockSelection extends Module {
    */
   public clear(reason?: Event): void {
     const { BlockManager, BlockSelection, Caret } = this.Editor;
+
+    if (!this.firstSelectedBlock || !this.lastSelectedBlock) {
+      return;
+    }
+
     const fIndex = BlockManager.blocks.indexOf(this.firstSelectedBlock);
     const lIndex = BlockManager.blocks.indexOf(this.lastSelectedBlock);
 
-    if (BlockSelection.anyBlockSelected && fIndex > -1 && lIndex > -1) {
-      if (reason && reason instanceof KeyboardEvent) {
-        /**
-         * Set caret depending on pressed key if pressed key is an arrow.
-         */
-        switch (reason.keyCode) {
-          case _.keyCodes.DOWN:
-          case _.keyCodes.RIGHT:
-            Caret.setToBlock(BlockManager.blocks[Math.max(fIndex, lIndex)], Caret.positions.END);
-            break;
-
-          case _.keyCodes.UP:
-          case _.keyCodes.LEFT:
-            Caret.setToBlock(BlockManager.blocks[Math.min(fIndex, lIndex)], Caret.positions.START);
-            break;
-          default:
-            Caret.setToBlock(BlockManager.blocks[Math.max(fIndex, lIndex)], Caret.positions.END);
-        }
+    if (!BlockSelection.anyBlockSelected || fIndex === -1 || lIndex === -1) {
+      this.firstSelectedBlock = this.lastSelectedBlock = null;
+
+      return;
+    }
+
+    if (reason && reason instanceof KeyboardEvent) {
+      /**
+       * Set caret depending on pressed key if pressed key is an arrow.
+       */
+      switch (reason.key) {
+        case 'ArrowDown':
+        case 'ArrowRight':
+          Caret.setToBlock(BlockManager.blocks[Math.max(fIndex, lIndex)], Caret.positions.END);
+          break;
+
+        case 'ArrowUp':
+        case 'ArrowLeft':
+          Caret.setToBlock(BlockManager.blocks[Math.min(fIndex, lIndex)], Caret.positions.START);
+          break;
+        default:
+          Caret.setToBlock(BlockManager.blocks[Math.max(fIndex, lIndex)], Caret.positions.END);
       }
     }
 
@@ -177,20 +209,21 @@ export default class CrossBlockSelection extends Module {
    * Mouse over event handler
    * Gets target and related blocks and change selected state for blocks in between
    *
-   * @param {MouseEvent} event - mouse over event
+   * @param {Event} event - mouse over event
    */
-  private onMouseOver = (event: MouseEvent): void => {
+  private onMouseOver = (event: Event): void => {
+    const mouseEvent = event as MouseEvent;
     const { BlockManager, BlockSelection } = this.Editor;
 
     /**
      * Probably, editor is not initialized yet
      */
-    if (event.relatedTarget === null && event.target === null) {
+    if (mouseEvent.relatedTarget === null && mouseEvent.target === null) {
       return;
     }
 
-    const relatedBlock = BlockManager.getBlockByChildNode(event.relatedTarget as Node) || this.lastSelectedBlock;
-    const targetBlock = BlockManager.getBlockByChildNode(event.target as Node);
+    const relatedBlock = BlockManager.getBlockByChildNode(mouseEvent.relatedTarget as Node) || this.lastSelectedBlock;
+    const targetBlock = BlockManager.getBlockByChildNode(mouseEvent.target as Node);
 
     if (!relatedBlock || !targetBlock) {
       return;
@@ -200,8 +233,8 @@ export default class CrossBlockSelection extends Module {
       return;
     }
 
-    if (relatedBlock === this.firstSelectedBlock) {
-      SelectionUtils.get().removeAllRanges();
+    if (this.firstSelectedBlock && relatedBlock === this.firstSelectedBlock) {
+      SelectionUtils.get()?.removeAllRanges();
 
       relatedBlock.selected = true;
       targetBlock.selected = true;
@@ -211,7 +244,7 @@ export default class CrossBlockSelection extends Module {
       return;
     }
 
-    if (targetBlock === this.firstSelectedBlock) {
+    if (this.firstSelectedBlock && targetBlock === this.firstSelectedBlock) {
       relatedBlock.selected = false;
       targetBlock.selected = false;
 
@@ -244,7 +277,10 @@ export default class CrossBlockSelection extends Module {
      */
     const shouldntSelectFirstBlock = firstBlock.selected !== lastBlock.selected;
 
-    for (let i = Math.min(fIndex, lIndex); i <= Math.max(fIndex, lIndex); i++) {
+    const startIndex = Math.min(fIndex, lIndex);
+    const endIndex = Math.max(fIndex, lIndex);
+
+    for (const i of Array.from({ length: endIndex - startIndex + 1 }, (unused, idx) => startIndex + idx)) {
       const block = BlockManager.blocks[i];
 
       if (
@@ -256,5 +292,10 @@ export default class CrossBlockSelection extends Module {
         BlockSelection.clearCache();
       }
     }
+
+    /**
+     * Do not keep the Toolbar visible while range selection is active.
+     */
+    this.Editor.Toolbar.close();
   }
 }
diff --git a/src/components/modules/dragNDrop.ts b/src/components/modules/dragNDrop.ts
index 3826365c2..5a6530fa1 100644
--- a/src/components/modules/dragNDrop.ts
+++ b/src/components/modules/dragNDrop.ts
@@ -38,8 +38,8 @@ export default class DragNDrop extends Module {
   private enableModuleBindings(): void {
     const { UI } = this.Editor;
 
-    this.readOnlyMutableListeners.on(UI.nodes.holder, 'drop', async (dropEvent: DragEvent) => {
-      await this.processDrop(dropEvent);
+    this.readOnlyMutableListeners.on(UI.nodes.holder, 'drop', (dropEvent: Event) => {
+      void this.processDrop(dropEvent as DragEvent);
     }, true);
 
     this.readOnlyMutableListeners.on(UI.nodes.holder, 'dragstart', () => {
@@ -49,8 +49,8 @@ export default class DragNDrop extends Module {
     /**
      * Prevent default browser behavior to allow drop on non-contenteditable elements
      */
-    this.readOnlyMutableListeners.on(UI.nodes.holder, 'dragover', (dragEvent: DragEvent) => {
-      this.processDragOver(dragEvent);
+    this.readOnlyMutableListeners.on(UI.nodes.holder, 'dragover', (dragEvent: Event) => {
+      this.processDragOver(dragEvent as DragEvent);
     }, true);
   }
 
@@ -75,9 +75,9 @@ export default class DragNDrop extends Module {
 
     dropEvent.preventDefault();
 
-    BlockManager.blocks.forEach((block) => {
+    for (const block of BlockManager.blocks) {
       block.dropTarget = false;
-    });
+    }
 
     if (SelectionUtils.isAtEditor && !SelectionUtils.isCollapsed && this.isStartedAtEditor) {
       document.execCommand('delete');
@@ -89,17 +89,28 @@ export default class DragNDrop extends Module {
      * Try to set current block by drop target.
      * If drop target is not part of the Block, set last Block as current.
      */
-    const targetBlock = BlockManager.setCurrentBlockByChildNode(dropEvent.target as Node);
+    const target = dropEvent.target;
+    const targetBlock = target instanceof Node
+      ? BlockManager.setCurrentBlockByChildNode(target)
+      : undefined;
+
+    const lastBlock = BlockManager.lastBlock;
+    const fallbackBlock = lastBlock
+      ? BlockManager.setCurrentBlockByChildNode(lastBlock.holder) ?? lastBlock
+      : undefined;
+    const blockForCaret = targetBlock ?? fallbackBlock;
+
+    if (blockForCaret) {
+      this.Editor.Caret.setToBlock(blockForCaret, Caret.positions.END);
+    }
 
-    if (targetBlock) {
-      this.Editor.Caret.setToBlock(targetBlock, Caret.positions.END);
-    } else {
-      const lastBlock = BlockManager.setCurrentBlockByChildNode(BlockManager.lastBlock.holder);
+    const { dataTransfer } = dropEvent;
 
-      this.Editor.Caret.setToBlock(lastBlock, Caret.positions.END);
+    if (!dataTransfer) {
+      return;
     }
 
-    await Paste.processDataTransfer(dropEvent.dataTransfer, true);
+    await Paste.processDataTransfer(dataTransfer, true);
   }
 
   /**
diff --git a/src/components/modules/modificationsObserver.ts b/src/components/modules/modificationsObserver.ts
index 6185d7d5f..26ac145a8 100644
--- a/src/components/modules/modificationsObserver.ts
+++ b/src/components/modules/modificationsObserver.ts
@@ -116,16 +116,12 @@ export default class ModificationsObserver extends Module {
     }
 
     this.batchingTimeout = setTimeout(() => {
-      let eventsToEmit;
-
       /**
-       * Ih we have only 1 event in a queue, unwrap it
+       * If we have only 1 event in a queue, unwrap it
        */
-      if (this.batchingOnChangeQueue.size === 1) {
-        eventsToEmit = this.batchingOnChangeQueue.values().next().value;
-      } else {
-        eventsToEmit = Array.from(this.batchingOnChangeQueue.values());
-      }
+      const eventsToEmit = this.batchingOnChangeQueue.size === 1
+        ? this.batchingOnChangeQueue.values().next().value
+        : Array.from(this.batchingOnChangeQueue.values());
 
       if (this.config.onChange) {
         this.config.onChange(this.Editor.API.methods, eventsToEmit);
diff --git a/src/components/modules/paste.ts b/src/components/modules/paste.ts
index 6a8378c41..5e5065ea9 100644
--- a/src/components/modules/paste.ts
+++ b/src/components/modules/paste.ts
@@ -8,9 +8,8 @@ import type {
   SanitizerConfig,
   SanitizerRule
 } from '../../../types';
-import type Block from '../block';
 import type { SavedData } from '../../../types/data-formats';
-import { clean, sanitizeBlocks } from '../utils/sanitizer';
+import { clean, composeSanitizerConfig, sanitizeBlocks } from '../utils/sanitizer';
 import type BlockToolAdapter from '../tools/block';
 
 /**
@@ -171,8 +170,9 @@ export default class Paste extends Module {
     /**
      * In Microsoft Edge types is DOMStringList. So 'contains' is used to check if 'Files' type included
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const includesFiles = types.includes ? types.includes('Files') : (types as any).contains('Files');
+    const includesFiles = typeof types.includes === 'function'
+      ? types.includes('Files')
+      : (types as unknown as DOMStringList).contains('Files');
 
     if (includesFiles && !_.isEmpty(this.toolsFiles)) {
       await this.processFiles(dataTransfer.files);
@@ -182,7 +182,24 @@ export default class Paste extends Module {
 
     const editorJSData = dataTransfer.getData(this.MIME_TYPE);
     const plainData = dataTransfer.getData('text/plain');
-    let htmlData = dataTransfer.getData('text/html');
+    const rawHtmlData = dataTransfer.getData('text/html');
+    const htmlData = (() => {
+      const trimmedPlainData = plainData.trim();
+      const trimmedHtmlData = rawHtmlData.trim();
+
+      if (isDragNDrop && trimmedPlainData.length > 0 && trimmedHtmlData.length > 0) {
+        const contentToWrap = trimmedHtmlData.length > 0 ? rawHtmlData : plainData;
+
+        return `<p>${contentToWrap}</p>`;
+      }
+
+      return rawHtmlData;
+    })();
+
+    const shouldWrapDraggedText = isDragNDrop && plainData.trim() && htmlData.trim();
+    const normalizedHtmlData = shouldWrapDraggedText
+      ? `<p>${htmlData.trim() ? htmlData : plainData}</p>`
+      : htmlData;
 
     /**
      * If EditorJS json is passed, insert it
@@ -198,23 +215,22 @@ export default class Paste extends Module {
     /**
      *  If text was drag'n'dropped, wrap content with P tag to insert it as the new Block
      */
-    if (isDragNDrop && plainData.trim() && htmlData.trim()) {
-      htmlData = '<p>' + (htmlData.trim() ? htmlData : plainData) + '</p>';
-    }
-
     /** Add all tags that can be substituted to sanitizer configuration */
-    const toolsTags = Object.keys(this.toolsTags).reduce((result, tag) => {
-      /**
-       * If Tool explicitly specifies sanitizer configuration for the tag, use it.
-       * Otherwise, remove all attributes
-       */
-      result[tag.toLowerCase()] = this.toolsTags[tag].sanitizationConfig ?? {};
-
-      return result;
-    }, {});
-
-    const customConfig = Object.assign({}, toolsTags, Tools.getAllInlineToolsSanitizeConfig(), { br: {} });
-    const cleanData = clean(htmlData, customConfig);
+    const toolsTags = Object.fromEntries(
+      Object.keys(this.toolsTags).map((tag) => [
+        tag.toLowerCase(),
+        this.toolsTags[tag].sanitizationConfig ?? {},
+      ])
+    ) as SanitizerConfig;
+
+    const inlineSanitizeConfig = Tools.getAllInlineToolsSanitizeConfig();
+    const customConfig = composeSanitizerConfig(
+      this.config.sanitizer as SanitizerConfig,
+      toolsTags,
+      inlineSanitizeConfig,
+      { br: {} }
+    );
+    const cleanData = clean(normalizedHtmlData, customConfig);
 
     /** If there is no HTML or HTML string is equal to plain one, process it as plain text */
     if (!cleanData.trim() || cleanData.trim() === plainData || !$.isHTMLString(cleanData)) {
@@ -238,40 +254,52 @@ export default class Paste extends Module {
       return;
     }
 
-    if (dataToInsert.length === 1) {
-      if (!dataToInsert[0].isBlock) {
-        this.processInlinePaste(dataToInsert.pop());
-      } else {
-        this.processSingleBlock(dataToInsert.pop());
-      }
+    if (dataToInsert.length > 1) {
+      const isCurrentBlockDefault = Boolean(BlockManager.currentBlock?.tool.isDefault);
+      const needToReplaceCurrentBlock = isCurrentBlockDefault && Boolean(BlockManager.currentBlock?.isEmpty);
+
+      dataToInsert.forEach((content, index) => {
+        this.insertBlock(content, index === 0 && needToReplaceCurrentBlock);
+      });
+
+      BlockManager.currentBlock &&
+        Caret.setToBlock(BlockManager.currentBlock, Caret.positions.END);
 
       return;
     }
 
-    const isCurrentBlockDefault = BlockManager.currentBlock && BlockManager.currentBlock.tool.isDefault;
-    const needToReplaceCurrentBlock = isCurrentBlockDefault && BlockManager.currentBlock.isEmpty;
+    const [ singleItem ] = dataToInsert;
 
-    dataToInsert.map(
-      async (content, i) => this.insertBlock(content, i === 0 && needToReplaceCurrentBlock)
-    );
+    if (singleItem.isBlock) {
+      await this.processSingleBlock(singleItem);
 
-    if (BlockManager.currentBlock) {
-      Caret.setToBlock(BlockManager.currentBlock, Caret.positions.END);
+      return;
     }
+
+    await this.processInlinePaste(singleItem);
   }
 
+  /**
+   * Wrapper handler for paste event that matches listeners.on signature
+   *
+   * @param {Event} event - paste event
+   */
+  private handlePasteEventWrapper = (event: Event): void => {
+    void this.handlePasteEvent(event as ClipboardEvent);
+  };
+
   /**
    * Set onPaste callback handler
    */
   private setCallback(): void {
-    this.listeners.on(this.Editor.UI.nodes.holder, 'paste', this.handlePasteEvent);
+    this.listeners.on(this.Editor.UI.nodes.holder, 'paste', this.handlePasteEventWrapper);
   }
 
   /**
    * Unset onPaste callback handler
    */
   private unsetCallback(): void {
-    this.listeners.off(this.Editor.UI.nodes.holder, 'paste', this.handlePasteEvent);
+    this.listeners.off(this.Editor.UI.nodes.holder, 'paste', this.handlePasteEventWrapper);
   }
 
   /**
@@ -351,7 +379,7 @@ export default class Paste extends Module {
     }
 
     const tagsOrSanitizeConfigs = tool.pasteConfig.tags || [];
-    const toolTags = [];
+    const toolTags: string[] = [];
 
     tagsOrSanitizeConfigs.forEach((tagOrSanitizeConfig) => {
       const tags = this.collectTagNames(tagOrSanitizeConfig);
@@ -373,7 +401,7 @@ export default class Paste extends Module {
         /**
          * Get sanitize config for tag.
          */
-        const sanitizationConfig = _.isObject(tagOrSanitizeConfig) ? tagOrSanitizeConfig[tag] : null;
+        const sanitizationConfig = _.isObject(tagOrSanitizeConfig) ? tagOrSanitizeConfig[tag] : undefined;
 
         this.toolsTags[tag.toUpperCase()] = {
           tool,
@@ -396,24 +424,38 @@ export default class Paste extends Module {
     }
 
     const { files = {} } = tool.pasteConfig;
-    let { extensions, mimeTypes } = files;
+    const { extensions: rawExtensions, mimeTypes: rawMimeTypes } = files;
 
-    if (!extensions && !mimeTypes) {
+    if (!rawExtensions && !rawMimeTypes) {
       return;
     }
 
-    if (extensions && !Array.isArray(extensions)) {
+    const normalizedExtensions = (() => {
+      if (rawExtensions == null) {
+        return [];
+      }
+
+      if (Array.isArray(rawExtensions)) {
+        return rawExtensions;
+      }
+
       _.log(`«extensions» property of the onDrop config for «${tool.name}» Tool should be an array`);
-      extensions = [];
-    }
 
-    if (mimeTypes && !Array.isArray(mimeTypes)) {
-      _.log(`«mimeTypes» property of the onDrop config for «${tool.name}» Tool should be an array`);
-      mimeTypes = [];
-    }
+      return [];
+    })();
 
-    if (mimeTypes) {
-      mimeTypes = mimeTypes.filter((type) => {
+    const normalizedMimeTypes = (() => {
+      if (rawMimeTypes == null) {
+        return [];
+      }
+
+      if (!Array.isArray(rawMimeTypes)) {
+        _.log(`«mimeTypes» property of the onDrop config for «${tool.name}» Tool should be an array`);
+
+        return [];
+      }
+
+      return rawMimeTypes.filter((type) => {
         if (!_.isValidMimeType(type)) {
           _.log(`MIME type value «${type}» for the «${tool.name}» Tool is not a valid MIME type`, 'warn');
 
@@ -422,11 +464,11 @@ export default class Paste extends Module {
 
         return true;
       });
-    }
+    })();
 
     this.toolsFiles[tool.name] = {
-      extensions: extensions || [],
-      mimeTypes: mimeTypes || [],
+      extensions: normalizedExtensions,
+      mimeTypes: normalizedMimeTypes,
     };
   }
 
@@ -486,7 +528,7 @@ export default class Paste extends Module {
 
     /** If target is native input or is not Block, use browser behaviour */
     if (
-      !currentBlock || (this.isNativeBehaviour(event.target) && !event.clipboardData.types.includes('Files'))
+      !currentBlock || (event.target && this.isNativeBehaviour(event.target) && event.clipboardData && !event.clipboardData.types.includes('Files'))
     ) {
       return;
     }
@@ -494,12 +536,14 @@ export default class Paste extends Module {
     /**
      * If Tools is in list of errors, skip processing of paste event
      */
-    if (currentBlock && this.exceptionList.includes(currentBlock.name)) {
+    if (this.exceptionList.includes(currentBlock.name)) {
       return;
     }
 
     event.preventDefault();
-    this.processDataTransfer(event.clipboardData);
+    if (event.clipboardData) {
+      await this.processDataTransfer(event.clipboardData);
+    }
 
     Toolbar.close();
   };
@@ -512,17 +556,15 @@ export default class Paste extends Module {
   private async processFiles(items: FileList): Promise<void> {
     const { BlockManager } = this.Editor;
 
-    let dataToInsert: { type: string; event: PasteEvent }[];
-
-    dataToInsert = await Promise.all(
+    const processedFiles = await Promise.all(
       Array
         .from(items)
         .map((item) => this.processFile(item))
     );
-    dataToInsert = dataToInsert.filter((data) => !!data);
+    const dataToInsert = processedFiles.filter((data): data is { type: string; event: PasteEvent } => data != null);
 
-    const isCurrentBlockDefault = BlockManager.currentBlock.tool.isDefault;
-    const needToReplaceCurrentBlock = isCurrentBlockDefault && BlockManager.currentBlock.isEmpty;
+    const isCurrentBlockDefault = Boolean(BlockManager.currentBlock?.tool.isDefault);
+    const needToReplaceCurrentBlock = isCurrentBlockDefault && Boolean(BlockManager.currentBlock?.isEmpty);
 
     dataToInsert.forEach(
       (data, i) => {
@@ -536,7 +578,7 @@ export default class Paste extends Module {
    *
    * @param {File} file - file to process
    */
-  private async processFile(file: File): Promise<{ event: PasteEvent; type: string }> {
+  private async processFile(file: File): Promise<{ event: PasteEvent; type: string } | undefined> {
     const extension = _.getFileExtension(file);
 
     const foundConfig = Object
@@ -552,7 +594,7 @@ export default class Paste extends Module {
           return type === fileType && (subtype === fileSubtype || subtype === '*');
         });
 
-        return !!foundExt || !!foundMimeType;
+        return foundExt !== undefined || foundMimeType !== undefined;
       });
 
     if (!foundConfig) {
@@ -598,101 +640,101 @@ export default class Paste extends Module {
 
     return nodes
       .map((node) => {
-        let content, tool = Tools.defaultTool, isBlock = false;
-
-        switch (node.nodeType) {
-          /** If node is a document fragment, use temp wrapper to get innerHTML */
-          case Node.DOCUMENT_FRAGMENT_NODE:
-            content = $.make('div');
-            content.appendChild(node);
-            break;
-
-          /** If node is an element, then there might be a substitution */
-          case Node.ELEMENT_NODE:
-            content = node as HTMLElement;
-            isBlock = true;
-
-            if (this.toolsTags[content.tagName]) {
-              tool = this.toolsTags[content.tagName].tool;
+        const nodeData = (() => {
+          switch (node.nodeType) {
+            case Node.DOCUMENT_FRAGMENT_NODE: {
+              const fragmentWrapper = $.make('div');
+
+              fragmentWrapper.appendChild(node);
+
+              return {
+                content: fragmentWrapper,
+                tool: Tools.defaultTool,
+                isBlock: false,
+              };
+            }
+
+            case Node.ELEMENT_NODE: {
+              const elementContent = node as HTMLElement;
+              const tagSubstitute = this.toolsTags[elementContent.tagName];
+
+              return {
+                content: elementContent,
+                tool: tagSubstitute?.tool ?? Tools.defaultTool,
+                isBlock: true,
+              };
             }
-            break;
+
+            default:
+              return null;
+          }
+        })();
+
+        if (!nodeData) {
+          return null;
         }
 
-        /**
-         * Returns empty array if there is no paste config
-         */
-        const { tags: tagsOrSanitizeConfigs } = tool.pasteConfig || { tags: [] };
+        const { content, tool, isBlock } = nodeData;
 
-        /**
-         * Reduce the tags or sanitize configs to a single array of sanitize config.
-         * For example:
-         * If sanitize config is
-         * [ 'tbody',
-         *   {
-         *     table: {
-         *       width: true,
-         *       height: true,
-         *     },
-         *   },
-         *   {
-         *      td: {
-         *        colspan: true,
-         *        rowspan: true,
-         *      },
-         *      tr: {  // <-- the second tag
-         *        height: true,
-         *      },
-         *   },
-         * ]
-         * then sanitize config will be
-         * [
-         *  'table':{},
-         *  'tbody':{width: true, height: true}
-         *  'td':{colspan: true, rowspan: true},
-         *  'tr':{height: true}
-         * ]
-         */
-        const toolTags = tagsOrSanitizeConfigs.reduce((result, tagOrSanitizeConfig) => {
+        const tagsOrSanitizeConfigs = tool.pasteConfig === false
+          ? []
+          : (tool.pasteConfig?.tags || []);
+
+        const toolTags = tagsOrSanitizeConfigs.reduce<SanitizerConfig>((result, tagOrSanitizeConfig) => {
           const tags = this.collectTagNames(tagOrSanitizeConfig);
+          const nextResult: SanitizerConfig = { ...result };
 
           tags.forEach((tag) => {
-            const sanitizationConfig = _.isObject(tagOrSanitizeConfig) ? tagOrSanitizeConfig[tag] : null;
+            const sanitizationConfig = _.isObject(tagOrSanitizeConfig)
+              ? (tagOrSanitizeConfig as SanitizerConfig)[tag]
+              : null;
 
-            result[tag.toLowerCase()] = sanitizationConfig || {};
+            nextResult[tag.toLowerCase()] = sanitizationConfig ?? {};
           });
 
-          return result;
-        }, {});
+          return nextResult;
+        }, {} as SanitizerConfig);
 
         const customConfig = Object.assign({}, toolTags, tool.baseSanitizeConfig);
+        const sanitizedContent = (() => {
+          if (content.tagName.toLowerCase() !== 'table') {
+            content.innerHTML = clean(content.innerHTML, customConfig);
+
+            return content;
+          }
 
-        /**
-         * A workaround for the HTMLJanitor bug with Tables (incorrect sanitizing of table.innerHTML)
-         * https://github.com/guardian/html-janitor/issues/3
-         */
-        if (content.tagName.toLowerCase() === 'table') {
           const cleanTableHTML = clean(content.outerHTML, customConfig);
           const tmpWrapper = $.make('div', undefined, {
             innerHTML: cleanTableHTML,
           });
+          const firstChild = tmpWrapper.firstChild;
+
+          if (!firstChild || !(firstChild instanceof HTMLElement)) {
+            return null;
+          }
+
+          return firstChild;
+        })();
 
-          content = tmpWrapper.firstChild;
-        } else {
-          content.innerHTML = clean(content.innerHTML, customConfig);
+        if (!sanitizedContent) {
+          return null;
         }
 
         const event = this.composePasteEvent('tag', {
-          data: content,
+          data: sanitizedContent,
         });
 
         return {
-          content,
+          content: sanitizedContent,
           isBlock,
           tool: tool.name,
           event,
         };
       })
-      .filter((data) => {
+      .filter((data): data is PasteData => {
+        if (!data) {
+          return false;
+        }
         const isEmpty = $.isEmpty(data.content);
         const isSingleTag = $.isSingleTag(data.content);
 
@@ -753,7 +795,7 @@ export default class Paste extends Module {
       dataToInsert.tool !== currentBlock.name ||
       !$.containsOnlyInlineElements(dataToInsert.content.innerHTML)
     ) {
-      this.insertBlock(dataToInsert, currentBlock?.tool.isDefault && currentBlock.isEmpty);
+      this.insertBlock(dataToInsert, currentBlock ? (currentBlock.tool.isDefault && currentBlock.isEmpty) : false);
 
       return;
     }
@@ -773,31 +815,34 @@ export default class Paste extends Module {
     const { BlockManager, Caret } = this.Editor;
     const { content } = dataToInsert;
 
-    const currentBlockIsDefault = BlockManager.currentBlock && BlockManager.currentBlock.tool.isDefault;
+    const currentBlockIsDefault = BlockManager.currentBlock?.tool.isDefault ?? false;
+    const textContent = content.textContent;
 
-    if (currentBlockIsDefault && content.textContent.length < Paste.PATTERN_PROCESSING_MAX_LENGTH) {
-      const blockData = await this.processPattern(content.textContent);
+    const canProcessPattern = currentBlockIsDefault &&
+      textContent !== null &&
+      textContent.length < Paste.PATTERN_PROCESSING_MAX_LENGTH;
 
-      if (blockData) {
-        const needToReplaceCurrentBlock = BlockManager.currentBlock &&
-          BlockManager.currentBlock.tool.isDefault &&
-          BlockManager.currentBlock.isEmpty;
+    const blockData = canProcessPattern && textContent !== null
+      ? await this.processPattern(textContent)
+      : undefined;
 
-        const insertedBlock = BlockManager.paste(blockData.tool, blockData.event, needToReplaceCurrentBlock);
+    if (blockData) {
+      const needToReplaceCurrentBlock = BlockManager.currentBlock &&
+        BlockManager.currentBlock.tool.isDefault &&
+        BlockManager.currentBlock.isEmpty;
 
-        Caret.setToBlock(insertedBlock, Caret.positions.END);
+      const insertedBlock = BlockManager.paste(blockData.tool, blockData.event, needToReplaceCurrentBlock);
 
-        return;
-      }
+      Caret.setToBlock(insertedBlock, Caret.positions.END);
+
+      return;
     }
 
     /** If there is no pattern substitute - insert string as it is */
     if (BlockManager.currentBlock && BlockManager.currentBlock.currentInput) {
       const currentToolSanitizeConfig = BlockManager.currentBlock.tool.baseSanitizeConfig;
 
-      document.execCommand(
-        'insertHTML',
-        false,
+      Caret.insertContentAtCaretPosition(
         clean(content.innerHTML, currentToolSanitizeConfig)
       );
     } else {
@@ -811,7 +856,7 @@ export default class Paste extends Module {
    * @param {string} text - text to process
    * @returns {Promise<{event: PasteEvent, tool: string}>}
    */
-  private async processPattern(text: string): Promise<{ event: PasteEvent; tool: string }> {
+  private async processPattern(text: string): Promise<{ event: PasteEvent; tool: string } | undefined> {
     const pattern = this.toolsPatterns.find((substitute) => {
       const execResult = substitute.pattern.exec(text);
 
@@ -847,16 +892,16 @@ export default class Paste extends Module {
   private insertBlock(data: PasteData, canReplaceCurrentBlock = false): void {
     const { BlockManager, Caret } = this.Editor;
     const { currentBlock } = BlockManager;
-    let block: Block;
 
     if (canReplaceCurrentBlock && currentBlock && currentBlock.isEmpty) {
-      block = BlockManager.paste(data.tool, data.event, true);
-      Caret.setToBlock(block, Caret.positions.END);
+      const replacedBlock = BlockManager.paste(data.tool, data.event, true);
+
+      Caret.setToBlock(replacedBlock, Caret.positions.END);
 
       return;
     }
 
-    block = BlockManager.paste(data.tool, data.event);
+    const block = BlockManager.paste(data.tool, data.event);
 
     Caret.setToBlock(block, Caret.positions.END);
   }
@@ -869,18 +914,16 @@ export default class Paste extends Module {
    */
   private insertEditorJSData(blocks: Pick<SavedData, 'id' | 'data' | 'tool'>[]): void {
     const { BlockManager, Caret, Tools } = this.Editor;
-    const sanitizedBlocks = sanitizeBlocks(blocks, (name) =>
-      Tools.blockTools.get(name).sanitizeConfig
+    const sanitizedBlocks = sanitizeBlocks(
+      blocks,
+      (name) => Tools.blockTools.get(name)?.sanitizeConfig ?? {},
+      this.config.sanitizer as SanitizerConfig
     );
 
     sanitizedBlocks.forEach(({ tool, data }, i) => {
-      let needToReplaceCurrentBlock = false;
-
-      if (i === 0) {
-        const isCurrentBlockDefault = BlockManager.currentBlock && BlockManager.currentBlock.tool.isDefault;
-
-        needToReplaceCurrentBlock = isCurrentBlockDefault && BlockManager.currentBlock.isEmpty;
-      }
+      const needToReplaceCurrentBlock = i === 0 &&
+        Boolean(BlockManager.currentBlock?.tool.isDefault) &&
+        Boolean(BlockManager.currentBlock?.isEmpty);
 
       const block = BlockManager.insert({
         tool,
@@ -904,8 +947,9 @@ export default class Paste extends Module {
 
     const element = node as HTMLElement;
 
-    const { tool } = this.toolsTags[element.tagName] || {};
-    const toolTags = this.tagsByTool[tool?.name] || [];
+    const tagSubstitute = this.toolsTags[element.tagName];
+    const tool = tagSubstitute?.tool;
+    const toolTags = this.tagsByTool[tool?.name ?? ''] ?? [];
 
     const isSubstitutable = tags.includes(element.tagName);
     const isBlockElement = $.blockElements.includes(element.tagName.toLowerCase());
@@ -944,7 +988,6 @@ export default class Paste extends Module {
    */
   private getNodes(wrapper: Node): Node[] {
     const children = Array.from(wrapper.childNodes);
-    let elementNodeProcessingResult: Node[] | void;
 
     const reducer = (nodes: Node[], node: Node): Node[] => {
       if ($.isEmpty(node) && !$.isSingleTag(node as HTMLElement)) {
@@ -952,40 +995,36 @@ export default class Paste extends Module {
       }
 
       const lastNode = nodes[nodes.length - 1];
+      const isLastNodeFragment = lastNode !== undefined && $.isFragment(lastNode);
+      const { destNode, remainingNodes } = isLastNodeFragment
+        ? {
+          destNode: lastNode,
+          remainingNodes: nodes.slice(0, -1),
+        }
+        : {
+          destNode: new DocumentFragment(),
+          remainingNodes: nodes,
+        };
 
-      let destNode: Node = new DocumentFragment();
+      if (node.nodeType === Node.TEXT_NODE) {
+        destNode.appendChild(node);
 
-      if (lastNode && $.isFragment(lastNode)) {
-        destNode = nodes.pop();
+        return [...remainingNodes, destNode];
       }
 
-      switch (node.nodeType) {
-        /**
-         * If node is HTML element:
-         * 1. Check if it is inline element
-         * 2. Check if it contains another block or substitutable elements
-         */
-        case Node.ELEMENT_NODE:
-          elementNodeProcessingResult = this.processElementNode(node, nodes, destNode);
-
-          if (elementNodeProcessingResult) {
-            return elementNodeProcessingResult;
-          }
-          break;
-
-        /**
-         * If node is text node, wrap it with DocumentFragment
-         */
-        case Node.TEXT_NODE:
-          destNode.appendChild(node);
+      if (node.nodeType !== Node.ELEMENT_NODE) {
+        return [...remainingNodes, destNode];
+      }
 
-          return [...nodes, destNode];
+      const elementNodeProcessingResult = this.processElementNode(node, remainingNodes, destNode);
 
-        default:
-          return [...nodes, destNode];
+      if (elementNodeProcessingResult) {
+        return elementNodeProcessingResult;
       }
 
-      return [...nodes, ...Array.from(node.childNodes).reduce(reducer, [])];
+      const processedChildNodes = Array.from(node.childNodes).reduce(reducer, []);
+
+      return [...remainingNodes, ...processedChildNodes];
     };
 
     return children.reduce(reducer, []);
@@ -1003,4 +1042,3 @@ export default class Paste extends Module {
     }) as PasteEvent;
   }
 }
-
diff --git a/src/components/modules/readonly.ts b/src/components/modules/readonly.ts
index cee5aa874..e64063590 100644
--- a/src/components/modules/readonly.ts
+++ b/src/components/modules/readonly.ts
@@ -48,11 +48,11 @@ export default class ReadOnly extends Module {
 
     this.toolsDontSupportReadOnly = toolsDontSupportReadOnly;
 
-    if (this.config.readOnly && toolsDontSupportReadOnly.length > 0) {
+    if (this.config.readOnly === true && toolsDontSupportReadOnly.length > 0) {
       this.throwCriticalError();
     }
 
-    this.toggle(this.config.readOnly, true);
+    await this.toggle(this.config.readOnly, true);
   }
 
   /**
@@ -71,18 +71,22 @@ export default class ReadOnly extends Module {
 
     this.readOnlyEnabled = state;
 
-    for (const name in this.Editor) {
+    for (const module of Object.values(this.Editor)) {
       /**
        * Verify module has method `toggleReadOnly` method
        */
-      if (!this.Editor[name].toggleReadOnly) {
+      if (module === null || module === undefined) {
+        continue;
+      }
+
+      if (typeof (module as { toggleReadOnly?: unknown }).toggleReadOnly !== 'function') {
         continue;
       }
 
       /**
        * set or toggle read-only state
        */
-      this.Editor[name].toggleReadOnly(state);
+      (module as { toggleReadOnly: (state: boolean) => void }).toggleReadOnly(state);
     }
 
     /**
@@ -109,6 +113,12 @@ export default class ReadOnly extends Module {
      */
     const savedBlocks = await this.Editor.Saver.save();
 
+    if (savedBlocks === undefined) {
+      this.Editor.ModificationsObserver.enable();
+
+      return this.readOnlyEnabled;
+    }
+
     await this.Editor.BlockManager.clear();
     await this.Editor.Renderer.render(savedBlocks.blocks);
 
diff --git a/src/components/modules/rectangleSelection.ts b/src/components/modules/rectangleSelection.ts
index d545036d2..de5a95db0 100644
--- a/src/components/modules/rectangleSelection.ts
+++ b/src/components/modules/rectangleSelection.ts
@@ -89,12 +89,12 @@ export default class RectangleSelection extends Module {
   /**
    * Does the rectangle intersect blocks
    */
-  private rectCrossesBlocks: boolean;
+  private rectCrossesBlocks = false;
 
   /**
    * Selection rectangle
    */
-  private overlayRectangle: HTMLDivElement;
+  private overlayRectangle: HTMLDivElement | null = null;
 
   /**
    * Listener identifiers
@@ -115,8 +115,14 @@ export default class RectangleSelection extends Module {
    * @param {number} pageX - X coord of mouse
    * @param {number} pageY - Y coord of mouse
    */
-  public startSelection(pageX, pageY): void {
-    const elemWhereSelectionStart = document.elementFromPoint(pageX - window.pageXOffset, pageY - window.pageYOffset);
+  public startSelection(pageX: number, pageY: number): void {
+    const scrollLeft = this.getScrollLeft();
+    const scrollTop = this.getScrollTop();
+    const elemWhereSelectionStart = document.elementFromPoint(pageX - scrollLeft, pageY - scrollTop);
+
+    if (!elemWhereSelectionStart) {
+      return;
+    }
 
     /**
      * Don't clear selected block by clicks on the Block settings
@@ -158,7 +164,9 @@ export default class RectangleSelection extends Module {
     this.mousedown = false;
     this.startX = 0;
     this.startY = 0;
-    this.overlayRectangle.style.display = 'none';
+    if (this.overlayRectangle !== null) {
+      this.overlayRectangle.style.display = 'none';
+    }
   }
 
   /**
@@ -181,14 +189,18 @@ export default class RectangleSelection extends Module {
   private enableModuleBindings(): void {
     const { container } = this.genHTML();
 
-    this.listeners.on(container, 'mousedown', (mouseEvent: MouseEvent) => {
-      this.processMouseDown(mouseEvent);
+    this.listeners.on(container, 'mousedown', (event: Event) => {
+      this.processMouseDown(event as MouseEvent);
     }, false);
 
-    this.listeners.on(document.body, 'mousemove', _.throttle((mouseEvent: MouseEvent) => {
-      this.processMouseMove(mouseEvent);
+    const throttledMouseMove = _.throttle((event: unknown) => {
+      if (event instanceof MouseEvent) {
+        this.processMouseMove(event);
+      }
     // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-    }, 10), {
+    }, 10) as EventListener;
+
+    this.listeners.on(document.body, 'mousemove', throttledMouseMove, {
       passive: true,
     });
 
@@ -196,10 +208,12 @@ export default class RectangleSelection extends Module {
       this.processMouseLeave();
     });
 
-    this.listeners.on(window, 'scroll', _.throttle((mouseEvent: MouseEvent) => {
-      this.processScroll(mouseEvent);
+    const throttledScroll = _.throttle((event: unknown) => {
+      this.processScroll(event as MouseEvent);
     // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-    }, 10), {
+    }, 10) as EventListener;
+
+    this.listeners.on(window, 'scroll', throttledScroll, {
       passive: true,
     });
 
@@ -267,7 +281,7 @@ export default class RectangleSelection extends Module {
    *
    * @param {number} clientY - Y coord of mouse
    */
-  private scrollByZones(clientY): void {
+  private scrollByZones(clientY: number): void {
     this.inScrollZone = null;
     if (clientY <= this.HEIGHT_OF_SCROLL_ZONE) {
       this.inScrollZone = this.TOP_SCROLL_ZONE;
@@ -291,7 +305,7 @@ export default class RectangleSelection extends Module {
   /**
    * Generates required HTML elements
    *
-   * @returns {Object<string, Element>}
+   * @returns {Record<string, Element>}
    */
   private genHTML(): {container: Element; overlay: Element} {
     const { UI } = this.Editor;
@@ -301,6 +315,10 @@ export default class RectangleSelection extends Module {
     const overlayContainer = $.make('div', RectangleSelection.CSS.overlayContainer, {});
     const overlayRectangle = $.make('div', RectangleSelection.CSS.rect, {});
 
+    if (!container) {
+      throw new Error('RectangleSelection: editor wrapper not found');
+    }
+
     overlayContainer.appendChild(overlayRectangle);
     overlay.appendChild(overlayContainer);
     container.appendChild(overlay);
@@ -318,14 +336,14 @@ export default class RectangleSelection extends Module {
    *
    * @param {number} speed - speed of scrolling
    */
-  private scrollVertical(speed): void {
+  private scrollVertical(speed: number): void {
     if (!(this.inScrollZone && this.mousedown)) {
       return;
     }
-    const lastOffset = window.pageYOffset;
+    const lastOffset = this.getScrollTop();
 
     window.scrollBy(0, speed);
-    this.mouseY += window.pageYOffset - lastOffset;
+    this.mouseY += this.getScrollTop() - lastOffset;
     setTimeout(() => {
       this.scrollVertical(speed);
     }, 0);
@@ -341,6 +359,12 @@ export default class RectangleSelection extends Module {
       return;
     }
 
+    const overlayRectangle = this.overlayRectangle;
+
+    if (overlayRectangle === null) {
+      return;
+    }
+
     if (event.pageY !== undefined) {
       this.mouseX = event.pageX;
       this.mouseY = event.pageY;
@@ -358,7 +382,7 @@ export default class RectangleSelection extends Module {
       this.rectCrossesBlocks = false;
       this.isRectSelectionActivated = true;
       this.shrinkRectangleToPoint();
-      this.overlayRectangle.style.display = 'block';
+      overlayRectangle.style.display = 'block';
     }
 
     this.updateRectangleSize();
@@ -376,24 +400,44 @@ export default class RectangleSelection extends Module {
     // For case, when rect is out from blocks
     this.inverseSelection();
 
-    SelectionUtils.get().removeAllRanges();
+    const selection = SelectionUtils.get();
+
+    if (selection) {
+      selection.removeAllRanges();
+    }
   }
 
   /**
    * Shrink rect to singular point
    */
   private shrinkRectangleToPoint(): void {
-    this.overlayRectangle.style.left = `${this.startX - window.pageXOffset}px`;
-    this.overlayRectangle.style.top = `${this.startY - window.pageYOffset}px`;
-    this.overlayRectangle.style.bottom = `calc(100% - ${this.startY - window.pageYOffset}px`;
-    this.overlayRectangle.style.right = `calc(100% - ${this.startX - window.pageXOffset}px`;
+    if (this.overlayRectangle === null) {
+      return;
+    }
+
+    const scrollLeft = this.getScrollLeft();
+    const scrollTop = this.getScrollTop();
+
+    this.overlayRectangle.style.left = `${this.startX - scrollLeft}px`;
+    this.overlayRectangle.style.top = `${this.startY - scrollTop}px`;
+    this.overlayRectangle.style.bottom = `calc(100% - ${this.startY - scrollTop}px)`;
+    this.overlayRectangle.style.right = `calc(100% - ${this.startX - scrollLeft}px)`;
   }
 
   /**
    * Select or unselect all of blocks in array if rect is out or in selectable area
    */
   private inverseSelection(): void {
+    if (this.stackOfSelected.length === 0) {
+      return;
+    }
+
     const firstBlockInStack = this.Editor.BlockManager.getBlockByIndex(this.stackOfSelected[0]);
+
+    if (!firstBlockInStack) {
+      return;
+    }
+
     const isSelectedMode = firstBlockInStack.selected;
 
     if (this.rectCrossesBlocks && !isSelectedMode) {
@@ -413,22 +457,29 @@ export default class RectangleSelection extends Module {
    * Updates size of rectangle
    */
   private updateRectangleSize(): void {
+    if (this.overlayRectangle === null) {
+      return;
+    }
+
+    const scrollLeft = this.getScrollLeft();
+    const scrollTop = this.getScrollTop();
+
     // Depending on the position of the mouse relative to the starting point,
     // change this.e distance from the desired edge of the screen*/
     if (this.mouseY >= this.startY) {
-      this.overlayRectangle.style.top = `${this.startY - window.pageYOffset}px`;
-      this.overlayRectangle.style.bottom = `calc(100% - ${this.mouseY - window.pageYOffset}px`;
+      this.overlayRectangle.style.top = `${this.startY - scrollTop}px`;
+      this.overlayRectangle.style.bottom = `calc(100% - ${this.mouseY - scrollTop}px)`;
     } else {
-      this.overlayRectangle.style.bottom = `calc(100% - ${this.startY - window.pageYOffset}px`;
-      this.overlayRectangle.style.top = `${this.mouseY - window.pageYOffset}px`;
+      this.overlayRectangle.style.bottom = `calc(100% - ${this.startY - scrollTop}px)`;
+      this.overlayRectangle.style.top = `${this.mouseY - scrollTop}px`;
     }
 
     if (this.mouseX >= this.startX) {
-      this.overlayRectangle.style.left = `${this.startX - window.pageXOffset}px`;
-      this.overlayRectangle.style.right = `calc(100% - ${this.mouseX - window.pageXOffset}px`;
+      this.overlayRectangle.style.left = `${this.startX - scrollLeft}px`;
+      this.overlayRectangle.style.right = `calc(100% - ${this.mouseX - scrollLeft}px)`;
     } else {
-      this.overlayRectangle.style.right = `calc(100% - ${this.startX - window.pageXOffset}px`;
-      this.overlayRectangle.style.left = `${this.mouseX - window.pageXOffset}px`;
+      this.overlayRectangle.style.right = `calc(100% - ${this.startX - scrollLeft}px)`;
+      this.overlayRectangle.style.left = `${this.mouseX - scrollLeft}px`;
     }
   }
 
@@ -437,22 +488,32 @@ export default class RectangleSelection extends Module {
    *
    * @returns {object} index - index next Block, leftPos - start of left border of Block, rightPos - right border
    */
-  private genInfoForMouseSelection(): {index: number; leftPos: number; rightPos: number} {
+  private genInfoForMouseSelection(): {index: number | undefined; leftPos: number; rightPos: number} {
     const widthOfRedactor = document.body.offsetWidth;
     const centerOfRedactor = widthOfRedactor / 2;
-    const Y = this.mouseY - window.pageYOffset;
-    const elementUnderMouse = document.elementFromPoint(centerOfRedactor, Y);
-    const blockInCurrentPos = this.Editor.BlockManager.getBlockByChildNode(elementUnderMouse);
-    let index;
-
-    if (blockInCurrentPos !== undefined) {
-      index = this.Editor.BlockManager.blocks.findIndex((block) => block.holder === blockInCurrentPos.holder);
-    }
-    const contentElement = this.Editor.BlockManager.lastBlock.holder.querySelector('.' + Block.CSS.content);
-    const centerOfBlock = Number.parseInt(window.getComputedStyle(contentElement).width, 10) / 2;
+    const scrollTop = this.getScrollTop();
+    const y = this.mouseY - scrollTop;
+    const elementUnderMouse = document.elementFromPoint(centerOfRedactor, y);
+    const lastBlockHolder = this.Editor.BlockManager.lastBlock?.holder;
+    const contentElement = lastBlockHolder?.querySelector('.' + Block.CSS.content);
+    const contentWidth = contentElement ? Number.parseInt(window.getComputedStyle(contentElement).width, 10) : 0;
+    const centerOfBlock = contentWidth / 2;
     const leftPos = centerOfRedactor - centerOfBlock;
     const rightPos = centerOfRedactor + centerOfBlock;
 
+    if (!elementUnderMouse) {
+      return {
+        index: undefined,
+        leftPos,
+        rightPos,
+      };
+    }
+    const blockInCurrentPos = this.Editor.BlockManager.getBlockByChildNode(elementUnderMouse);
+
+    const index = blockInCurrentPos !== undefined
+      ? this.Editor.BlockManager.blocks.findIndex((block) => block.holder === blockInCurrentPos.holder)
+      : undefined;
+
     return {
       index,
       leftPos,
@@ -460,12 +521,34 @@ export default class RectangleSelection extends Module {
     };
   }
 
+  /**
+   * Normalized vertical scroll value that does not rely on deprecated APIs.
+   */
+  private getScrollTop(): number {
+    if (typeof window.scrollY === 'number') {
+      return window.scrollY;
+    }
+
+    return document.documentElement?.scrollTop ?? document.body?.scrollTop ?? 0;
+  }
+
+  /**
+   * Normalized horizontal scroll value that does not rely on deprecated APIs.
+   */
+  private getScrollLeft(): number {
+    if (typeof window.scrollX === 'number') {
+      return window.scrollX;
+    }
+
+    return document.documentElement?.scrollLeft ?? document.body?.scrollLeft ?? 0;
+  }
+
   /**
    * Select block with index index
    *
    * @param index - index of block in redactor
    */
-  private addBlockInSelection(index): void {
+  private addBlockInSelection(index: number): void {
     if (this.rectCrossesBlocks) {
       this.Editor.BlockSelection.selectBlockByIndex(index);
     }
@@ -477,45 +560,45 @@ export default class RectangleSelection extends Module {
    *
    * @param {object} index - index of new block in the reactor
    */
-  private trySelectNextBlock(index): void {
-    const sameBlock = this.stackOfSelected[this.stackOfSelected.length - 1] === index;
+  private trySelectNextBlock(index: number): void {
     const sizeStack = this.stackOfSelected.length;
-    const down = 1, up = -1, undef = 0;
+    const lastSelected = this.stackOfSelected[sizeStack - 1];
+    const sameBlock = lastSelected === index;
 
     if (sameBlock) {
       return;
     }
 
-    const blockNumbersIncrease = this.stackOfSelected[sizeStack - 1] - this.stackOfSelected[sizeStack - 2] > 0;
-
-    let direction = undef;
-
-    if (sizeStack > 1) {
-      direction = blockNumbersIncrease ? down : up;
-    }
-
-    const selectionInDownDirection = index > this.stackOfSelected[sizeStack - 1] && direction === down;
-    const selectionInUpDirection = index < this.stackOfSelected[sizeStack - 1] && direction === up;
-    const generalSelection = selectionInDownDirection || selectionInUpDirection || direction === undef;
+    const previousSelected = this.stackOfSelected[sizeStack - 2];
+    const blockNumbersIncrease = previousSelected !== undefined && lastSelected !== undefined
+      ? lastSelected - previousSelected > 0
+      : false;
+    const isInitialSelection = sizeStack <= 1;
+    const selectionInDownDirection = lastSelected !== undefined && index > lastSelected && blockNumbersIncrease;
+    const selectionInUpDirection = lastSelected !== undefined && index < lastSelected && sizeStack > 1 && !blockNumbersIncrease;
+    const generalSelection = selectionInDownDirection || selectionInUpDirection || isInitialSelection;
     const reduction = !generalSelection;
 
     // When the selection is too fast, some blocks do not have time to be noticed. Fix it.
-    if (!reduction && (index > this.stackOfSelected[sizeStack - 1] ||
-      this.stackOfSelected[sizeStack - 1] === undefined)) {
-      let ind = this.stackOfSelected[sizeStack - 1] + 1 || index;
+    if (!reduction && (lastSelected === undefined || index > lastSelected)) {
+      const startIndex = lastSelected !== undefined ? lastSelected + 1 : index;
 
-      for (ind; ind <= index; ind++) {
-        this.addBlockInSelection(ind);
-      }
+      Array.from({ length: index - startIndex + 1 }, (_unused, offset) => startIndex + offset)
+        .forEach((ind) => {
+          this.addBlockInSelection(ind);
+        });
 
       return;
     }
 
     // for both directions
-    if (!reduction && (index < this.stackOfSelected[sizeStack - 1])) {
-      for (let ind = this.stackOfSelected[sizeStack - 1] - 1; ind >= index; ind--) {
+    if (!reduction && lastSelected !== undefined && index < lastSelected) {
+      Array.from(
+        { length: lastSelected - index },
+        (_unused, offset) => lastSelected - 1 - offset
+      ).forEach((ind) => {
         this.addBlockInSelection(ind);
-      }
+      });
 
       return;
     }
@@ -524,24 +607,33 @@ export default class RectangleSelection extends Module {
       return;
     }
 
-    let i = sizeStack - 1;
-    let cmp;
+    const shouldRemove = (stackIndex: number): boolean => {
+      if (lastSelected === undefined) {
+        return false;
+      }
 
-    // cmp for different directions
-    if (index > this.stackOfSelected[sizeStack - 1]) {
-      cmp = (): boolean => index > this.stackOfSelected[i];
-    } else {
-      cmp = (): boolean => index < this.stackOfSelected[i];
-    }
+      if (index > lastSelected) {
+        return index > stackIndex;
+      }
+
+      return index < stackIndex;
+    };
+
+    const indicesToRemove: number[] = [];
+
+    for (const stackIndex of [ ...this.stackOfSelected ].reverse()) {
+      if (!shouldRemove(stackIndex)) {
+        break;
+      }
 
-    // Remove blocks missed due to speed.
-    // cmp checks if we have removed all the necessary blocks
-    while (cmp()) {
       if (this.rectCrossesBlocks) {
-        this.Editor.BlockSelection.unSelectBlockByIndex(this.stackOfSelected[i]);
+        this.Editor.BlockSelection.unSelectBlockByIndex(stackIndex);
       }
-      this.stackOfSelected.pop();
-      i--;
+      indicesToRemove.push(stackIndex);
+    }
+
+    if (indicesToRemove.length > 0) {
+      this.stackOfSelected.splice(this.stackOfSelected.length - indicesToRemove.length, indicesToRemove.length);
     }
   }
 }
diff --git a/src/components/modules/renderer.ts b/src/components/modules/renderer.ts
index 150af7a2c..a7c46f690 100644
--- a/src/components/modules/renderer.ts
+++ b/src/components/modules/renderer.ts
@@ -14,7 +14,7 @@ export default class Renderer extends Module {
    *
    * @param blocksData - blocks to render
    */
-  public async render(blocksData: OutputBlockData[]): Promise<void> {
+  public render(blocksData: OutputBlockData[]): Promise<void> {
     return new Promise((resolve) => {
       const { Tools, BlockManager } = this.Editor;
 
@@ -24,44 +24,54 @@ export default class Renderer extends Module {
         /**
          * Create Blocks instances
          */
-        const blocks = blocksData.map(({ type: tool, data, tunes, id }) => {
-          if (Tools.available.has(tool) === false) {
-            _.logLabeled(`Tool «${tool}» is not found. Check 'tools' property at the Editor.js config.`, 'warn');
-
-            data = this.composeStubDataForTool(tool, data, id);
-            tool = Tools.stubTool;
-          }
-
-          let block: Block;
-
-          try {
-            block = BlockManager.composeBlock({
-              id,
-              tool,
-              data,
-              tunes,
-            });
-          } catch (error) {
-            _.log(`Block «${tool}» skipped because of plugins error`, 'error', {
-              data,
-              error,
-            });
-
-            /**
-             * If tool throws an error during render, we should render stub instead of it
-             */
-            data = this.composeStubDataForTool(tool, data, id);
-            tool = Tools.stubTool;
-
-            block = BlockManager.composeBlock({
-              id,
-              tool,
-              data,
-              tunes,
-            });
-          }
-
-          return block;
+        const blocks = blocksData.map((blockData) => {
+          const { tunes, id } = blockData;
+          const originalTool = blockData.type;
+          const availabilityResult = (() => {
+            if (Tools.available.has(originalTool)) {
+              return {
+                tool: originalTool,
+                data: blockData.data,
+              };
+            }
+
+            _.logLabeled(`Tool «${originalTool}» is not found. Check 'tools' property at the Editor.js config.`, 'warn');
+
+            return {
+              tool: Tools.stubTool,
+              data: this.composeStubDataForTool(originalTool, blockData.data, id),
+            };
+          })();
+
+          const buildBlock = (tool: string, data: BlockToolData): Block => {
+            try {
+              return BlockManager.composeBlock({
+                id,
+                tool,
+                data,
+                tunes,
+              });
+            } catch (error) {
+              _.log(`Block «${tool}» skipped because of plugins error`, 'error', {
+                data,
+                error,
+              });
+
+              /**
+               * If tool throws an error during render, we should render stub instead of it
+               */
+              const stubData = this.composeStubDataForTool(tool, data, id);
+
+              return BlockManager.composeBlock({
+                id,
+                tool: Tools.stubTool,
+                data: stubData,
+                tunes,
+              });
+            }
+          };
+
+          return buildBlock(availabilityResult.tool, availabilityResult.data);
         });
 
         /**
@@ -89,15 +99,19 @@ export default class Renderer extends Module {
   private composeStubDataForTool(tool: string, data: BlockToolData, id?: BlockId): StubData {
     const { Tools } = this.Editor;
 
-    let title = tool;
+    const title = (() => {
+      if (!Tools.unavailable.has(tool)) {
+        return tool;
+      }
 
-    if (Tools.unavailable.has(tool)) {
       const toolboxSettings = (Tools.unavailable.get(tool) as BlockToolAdapter).toolbox;
 
       if (toolboxSettings !== undefined && toolboxSettings[0].title !== undefined) {
-        title = toolboxSettings[0].title;
+        return toolboxSettings[0].title;
       }
-    }
+
+      return tool;
+    })();
 
     return {
       savedData: {
diff --git a/src/components/modules/saver.ts b/src/components/modules/saver.ts
index c02192835..088f780f2 100644
--- a/src/components/modules/saver.ts
+++ b/src/components/modules/saver.ts
@@ -6,13 +6,18 @@
  * @version 2.0.0
  */
 import Module from '../__module';
-import type { OutputData } from '../../../types';
+import type { BlockToolData, OutputData, SanitizerConfig } from '../../../types';
 import type { SavedData, ValidatedData } from '../../../types/data-formats';
+import type { BlockTuneData } from '../../../types/block-tunes/block-tune-data';
 import type Block from '../block';
 import * as _ from '../utils';
 import { sanitizeBlocks } from '../utils/sanitizer';
 
-declare const VERSION: string;
+type SaverValidatedData = ValidatedData & {
+  tunes?: Record<string, BlockTuneData>;
+};
+
+type SanitizableBlockData = SaverValidatedData & Pick<SavedData, 'data' | 'tool'>;
 
 /**
  * @classdesc This method reduces all Blocks asyncronically and calls Block's save method to extract data
@@ -21,29 +26,42 @@ declare const VERSION: string;
  * @property {string} json - Editor JSON output
  */
 export default class Saver extends Module {
+  /**
+   * Stores the last error raised during save attempt
+   */
+  private lastSaveError?: unknown;
+
   /**
    * Composes new chain of Promises to fire them alternatelly
    *
-   * @returns {OutputData}
+   * @returns {OutputData | undefined}
    */
-  public async save(): Promise<OutputData> {
+  public async save(): Promise<OutputData | undefined> {
     const { BlockManager, Tools } = this.Editor;
-    const blocks = BlockManager.blocks,
-        chainData = [];
+    const blocks = BlockManager.blocks;
+    const chainData: Array<Promise<SaverValidatedData>> = blocks.map((block: Block) => {
+      return this.getSavedData(block);
+    });
 
-    try {
-      blocks.forEach((block: Block) => {
-        chainData.push(this.getSavedData(block));
-      });
+    this.lastSaveError = undefined;
 
-      const extractedData = await Promise.all(chainData) as Array<Pick<SavedData, 'data' | 'tool'>>;
-      const sanitizedData = await sanitizeBlocks(extractedData, (name) => {
-        return Tools.blockTools.get(name).sanitizeConfig;
-      });
+    try {
+      const extractedData = await Promise.all(chainData);
+      const sanitizedData = this.sanitizeExtractedData(
+        extractedData,
+        (name) => Tools.blockTools.get(name)?.sanitizeConfig,
+        this.config.sanitizer as SanitizerConfig
+      );
 
       return this.makeOutput(sanitizedData);
-    } catch (e) {
-      _.logLabeled(`Saving failed due to the Error %o`, 'error', e);
+    } catch (error: unknown) {
+      this.lastSaveError = error;
+
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+
+      _.logLabeled(`Saving failed due to the Error %o`, 'error', normalizedError);
+
+      return undefined;
     }
   }
 
@@ -53,9 +71,18 @@ export default class Saver extends Module {
    * @param {Block} block - Editor's Tool
    * @returns {ValidatedData} - Tool's validated data
    */
-  private async getSavedData(block: Block): Promise<ValidatedData> {
+  private async getSavedData(block: Block): Promise<SaverValidatedData> {
     const blockData = await block.save();
-    const isValid = blockData && await block.validate(blockData.data);
+    const toolName = block.name;
+
+    if (blockData === undefined) {
+      return {
+        tool: toolName,
+        isValid: false,
+      };
+    }
+
+    const isValid = await block.validate(blockData.data);
 
     return {
       ...blockData,
@@ -69,8 +96,8 @@ export default class Saver extends Module {
    * @param {ValidatedData} allExtractedData - data extracted from Blocks
    * @returns {OutputData}
    */
-  private makeOutput(allExtractedData): OutputData {
-    const blocks = [];
+  private makeOutput(allExtractedData: SaverValidatedData[]): OutputData {
+    const blocks: OutputData['blocks'] = [];
 
     allExtractedData.forEach(({ id, tool, data, tunes, isValid }) => {
       if (!isValid) {
@@ -79,18 +106,31 @@ export default class Saver extends Module {
         return;
       }
 
+      if (tool === undefined || data === undefined) {
+        _.log('Block skipped because saved data is missing required fields');
+
+        return;
+      }
+
       /** If it was stub Block, get original data */
-      if (tool === this.Editor.Tools.stubTool) {
+      if (tool === this.Editor.Tools.stubTool && this.isStubSavedData(data)) {
         blocks.push(data);
 
         return;
       }
 
-      const output = {
+      if (tool === this.Editor.Tools.stubTool) {
+        _.log('Stub block data is malformed and was skipped');
+
+        return;
+      }
+
+      const isTunesEmpty = tunes === undefined || _.isEmpty(tunes);
+      const output: OutputData['blocks'][number] = {
         id,
         type: tool,
         data,
-        ...!_.isEmpty(tunes) && {
+        ...!isTunesEmpty && {
           tunes,
         },
       };
@@ -101,7 +141,85 @@ export default class Saver extends Module {
     return {
       time: +new Date(),
       blocks,
-      version: VERSION,
+      version: _.getEditorVersion(),
     };
   }
+
+  /**
+   * Sanitizes extracted block data in-place
+   *
+   * @param extractedData - collection of saved block data
+   * @param getToolSanitizeConfig - resolver for tool-specific sanitize config
+   * @param globalSanitizer - global sanitizer config specified in editor settings
+   */
+  private sanitizeExtractedData(
+    extractedData: SaverValidatedData[],
+    getToolSanitizeConfig: (toolName: string) => SanitizerConfig | undefined,
+    globalSanitizer: SanitizerConfig
+  ): SaverValidatedData[] {
+    const blocksToSanitize: Array<{ index: number; data: SanitizableBlockData }> = [];
+
+    extractedData.forEach((blockData, index) => {
+      if (this.hasSanitizableData(blockData)) {
+        blocksToSanitize.push({
+          index,
+          data: blockData,
+        });
+      }
+    });
+
+    if (blocksToSanitize.length === 0) {
+      return extractedData;
+    }
+
+    const sanitizedBlocks = sanitizeBlocks(
+      blocksToSanitize.map(({ data }) => data),
+      getToolSanitizeConfig,
+      globalSanitizer
+    );
+
+    const updatedData = extractedData.map((blockData) => ({ ...blockData }));
+
+    blocksToSanitize.forEach(({ index }, sanitizedIndex) => {
+      const sanitized = sanitizedBlocks[sanitizedIndex];
+
+      updatedData[index] = {
+        ...updatedData[index],
+        data: sanitized.data,
+      };
+    });
+
+    return updatedData;
+  }
+
+  /**
+   * Checks whether block data contains fields required for sanitizing procedure
+   *
+   * @param blockData - data to check
+   */
+  private hasSanitizableData(blockData: SaverValidatedData): blockData is SanitizableBlockData {
+    return blockData.data !== undefined && typeof blockData.tool === 'string';
+  }
+
+  /**
+   * Check that stub data matches OutputBlockData format
+   *
+   * @param data - saved stub data that should represent original block payload
+   */
+  private isStubSavedData(data: BlockToolData): data is OutputData['blocks'][number] {
+    if (!_.isObject(data)) {
+      return false;
+    }
+
+    const candidate = data as Record<string, unknown>;
+
+    return typeof candidate.type === 'string' && candidate.data !== undefined;
+  }
+
+  /**
+   * Returns the last error raised during save attempt
+   */
+  public getLastSaveError(): unknown {
+    return this.lastSaveError;
+  }
 }
diff --git a/src/components/modules/toolbar/blockSettings.ts b/src/components/modules/toolbar/blockSettings.ts
index 88f861b40..aacfdf592 100644
--- a/src/components/modules/toolbar/blockSettings.ts
+++ b/src/components/modules/toolbar/blockSettings.ts
@@ -4,14 +4,16 @@ import SelectionUtils from '../../selection';
 import type Block from '../../block';
 import I18n from '../../i18n';
 import { I18nInternalNS } from '../../i18n/namespace-internal';
-import type Flipper from '../../flipper';
+import Flipper from '../../flipper';
 import type { MenuConfigItem } from '../../../../types/tools';
 import { resolveAliases } from '../../utils/resolve-aliases';
-import type { PopoverItemParams } from '../../utils/popover';
+import type { PopoverItemParams, PopoverItemDefaultBaseParams } from '../../utils/popover';
 import { type Popover, PopoverDesktop, PopoverMobile, PopoverItemType } from '../../utils/popover';
+import type { PopoverParams } from '@/types/utils/popover/popover';
 import { PopoverEvent } from '@/types/utils/popover/popover-event';
-import { isMobileScreen } from '../../utils';
-import { EditorMobileLayoutToggled } from '../../events';
+import { isMobileScreen, keyCodes } from '../../utils';
+import { css as popoverItemCls } from '../../utils/popover/components/popover-item';
+import { BlockSettingsClosed, BlockSettingsOpened, EditorMobileLayoutToggled } from '../../events';
 import { IconReplace } from '@codexteam/icons';
 import { getConvertibleToolsForBlock } from '../../utils/blocks';
 
@@ -34,10 +36,10 @@ export default class BlockSettings extends Module<BlockSettingsNodes> {
   /**
    * Module Events
    */
-  public get events(): { opened: string; closed: string } {
+  public get events(): { opened: typeof BlockSettingsOpened; closed: typeof BlockSettingsClosed } {
     return {
-      opened: 'block-settings-opened',
-      closed: 'block-settings-closed',
+      opened: BlockSettingsOpened,
+      closed: BlockSettingsClosed,
     };
   }
 
@@ -60,12 +62,8 @@ export default class BlockSettings extends Module<BlockSettingsNodes> {
    *
    * @todo remove once BlockSettings becomes standalone non-module class
    */
-  public get flipper(): Flipper | undefined {
-    if (this.popover === null) {
-      return;
-    }
-
-    return 'flipper' in this.popover ? this.popover?.flipper : undefined;
+  public get flipper(): Flipper {
+    return this.flipperInstance;
   }
 
   /**
@@ -79,6 +77,29 @@ export default class BlockSettings extends Module<BlockSettingsNodes> {
    */
   private popover: Popover | null = null;
 
+  /**
+   * Shared flipper instance used for keyboard navigation in block settings popover
+   */
+  private readonly flipperInstance: Flipper = new Flipper({
+    focusedItemClass: popoverItemCls.focused,
+    allowedKeys: [
+      keyCodes.TAB,
+      keyCodes.UP,
+      keyCodes.DOWN,
+      keyCodes.ENTER,
+    ],
+  });
+
+  /**
+   * Stored keydown handler reference to detach when block tunes are closed
+   */
+  private flipperKeydownHandler: ((event: KeyboardEvent) => void) | null = null;
+
+  /**
+   * Element that listens for keydown events while block tunes are opened
+   */
+  private flipperKeydownSource: HTMLElement | null = null;
+
   /**
    * Panel with block settings with 2 sections:
    *  - Tool's Settings
@@ -98,6 +119,7 @@ export default class BlockSettings extends Module<BlockSettingsNodes> {
    * Destroys module
    */
   public destroy(): void {
+    this.detachFlipperKeydownListener();
     this.removeAllNodes();
     this.listeners.destroy();
     this.eventsDispatcher.off(EditorMobileLayoutToggled, this.close);
@@ -108,7 +130,13 @@ export default class BlockSettings extends Module<BlockSettingsNodes> {
    *
    * @param targetBlock - near which Block we should open BlockSettings
    */
-  public async open(targetBlock: Block = this.Editor.BlockManager.currentBlock): Promise<void> {
+  public async open(targetBlock?: Block): Promise<void> {
+    const block = targetBlock ?? this.Editor.BlockManager.currentBlock;
+
+    if (block === undefined) {
+      return;
+    }
+
     this.opened = true;
 
     /**
@@ -120,32 +148,41 @@ export default class BlockSettings extends Module<BlockSettingsNodes> {
     /**
      * Highlight content of a Block we are working with
      */
-    this.Editor.BlockSelection.selectBlock(targetBlock);
+    this.Editor.BlockSelection.selectBlock(block);
     this.Editor.BlockSelection.clearCache();
 
     /** Get tool's settings data */
-    const { toolTunes, commonTunes } = targetBlock.getTunes();
+    const { toolTunes, commonTunes } = block.getTunes();
 
     /** Tell to subscribers that block settings is opened */
     this.eventsDispatcher.emit(this.events.opened);
 
     const PopoverClass = isMobileScreen() ? PopoverMobile : PopoverDesktop;
-
-    this.popover = new PopoverClass({
+    const popoverParams: PopoverParams & { flipper?: Flipper } = {
       searchable: true,
-      items: await this.getTunesItems(targetBlock, commonTunes, toolTunes),
+      items: await this.getTunesItems(block, commonTunes, toolTunes),
       scopeElement: this.Editor.API.methods.ui.nodes.redactor,
       messages: {
         nothingFound: I18n.ui(I18nInternalNS.ui.popover, 'Nothing found'),
         search: I18n.ui(I18nInternalNS.ui.popover, 'Filter'),
       },
-    });
+    };
+
+    if (PopoverClass === PopoverDesktop) {
+      popoverParams.flipper = this.flipperInstance;
+    }
+
+    this.popover = new PopoverClass(popoverParams);
 
     this.popover.on(PopoverEvent.Closed, this.onPopoverClose);
 
     this.nodes.wrapper?.append(this.popover.getElement());
 
     this.popover.show();
+    if (PopoverClass === PopoverDesktop) {
+      this.flipperInstance.focusItem(0);
+    }
+    this.attachFlipperKeydownListener(block);
   }
 
   /**
@@ -177,6 +214,7 @@ export default class BlockSettings extends Module<BlockSettingsNodes> {
     }
 
     this.selection.clearSaved();
+    this.detachFlipperKeydownListener();
 
     /**
      * Remove highlighted content of a Block we are working with
@@ -216,11 +254,17 @@ export default class BlockSettings extends Module<BlockSettingsNodes> {
 
     const allBlockTools = Array.from(this.Editor.Tools.blockTools.values());
     const convertibleTools = await getConvertibleToolsForBlock(currentBlock, allBlockTools);
-    const convertToItems = convertibleTools.reduce((result, tool) => {
+    const convertToItems = convertibleTools.reduce<PopoverItemParams[]>((result, tool) => {
+      if (tool.toolbox === undefined) {
+        return result;
+      }
+
       tool.toolbox.forEach((toolboxItem) => {
+        const titleKey = toolboxItem.title ?? tool.name;
+
         result.push({
           icon: toolboxItem.icon,
-          title: I18n.t(I18nInternalNS.toolNames, toolboxItem.title),
+          title: I18n.t(I18nInternalNS.toolNames, titleKey),
           name: tool.name,
           closeOnActivate: true,
           onActivate: async () => {
@@ -274,12 +318,69 @@ export default class BlockSettings extends Module<BlockSettingsNodes> {
     if (item.type === PopoverItemType.Separator || item.type === PopoverItemType.Html) {
       return item;
     }
-    const result = resolveAliases(item, { label: 'title' });
 
-    if (item.confirmation) {
-      result.confirmation = this.resolveTuneAliases(item.confirmation);
+    const baseItem = resolveAliases(item, { label: 'title' }) as MenuConfigItem;
+
+    const itemWithConfirmation = ('confirmation' in item && item.confirmation !== undefined)
+      ? {
+        ...baseItem,
+        confirmation: resolveAliases(item.confirmation, { label: 'title' }) as PopoverItemDefaultBaseParams,
+      }
+      : baseItem;
+
+    if (!('children' in item) || item.children === undefined) {
+      return itemWithConfirmation as PopoverItemParams;
     }
 
-    return result;
+    const { onActivate: _onActivate, ...itemWithoutOnActivate } = itemWithConfirmation as MenuConfigItem & { onActivate?: undefined };
+    const childrenItems = item.children.items?.map((childItem) => {
+      return this.resolveTuneAliases(childItem as MenuConfigItem);
+    });
+
+    return {
+      ...itemWithoutOnActivate,
+      children: {
+        ...item.children,
+        items: childrenItems,
+      },
+    } as PopoverItemParams;
+  }
+
+  /**
+   * Attaches keydown listener to delegate navigation events to the shared flipper
+   *
+   * @param block - block that owns the currently focused content
+   */
+  private attachFlipperKeydownListener(block: Block): void {
+    this.detachFlipperKeydownListener();
+
+    const pluginsContent = block?.pluginsContent;
+
+    if (!(pluginsContent instanceof HTMLElement)) {
+      return;
+    }
+
+    this.flipperInstance.setHandleContentEditableTargets(true);
+
+    this.flipperKeydownHandler = (event: KeyboardEvent) => {
+      this.flipperInstance.handleExternalKeydown(event);
+    };
+
+    pluginsContent.addEventListener('keydown', this.flipperKeydownHandler, true);
+    this.flipperKeydownSource = pluginsContent;
+  }
+
+  /**
+   * Removes keydown listener from the previously active block
+   */
+  private detachFlipperKeydownListener(): void {
+    if (this.flipperKeydownSource !== null && this.flipperKeydownHandler !== null) {
+      this.flipperKeydownSource.removeEventListener('keydown', this.flipperKeydownHandler, true);
+    }
+
+    this.flipperInstance.setHandleContentEditableTargets(false);
+
+    this.flipperKeydownSource = null;
+    this.flipperKeydownHandler = null;
   }
 }
diff --git a/src/components/modules/toolbar/index.ts b/src/components/modules/toolbar/index.ts
index 3098c6aba..3c3903f7d 100644
--- a/src/components/modules/toolbar/index.ts
+++ b/src/components/modules/toolbar/index.ts
@@ -19,15 +19,6 @@ import { getKeyboardKeyForCode } from '../../utils/keyboard';
  *         press Tab, flip to the Checkbox. press Enter (block will be added), Press Tab
  *         (Block Tunes will be opened with Move up focused), press Enter, press Tab ———— both Block Tunes and Toolbox will be opened
  * @todo TEST CASE - show toggler after opening and closing the Inline Toolbar
- * @todo TEST CASE - Click outside Editor holder should close Toolbar and Clear Focused blocks
- * @todo TEST CASE - Click inside Editor holder should close Toolbar and Clear Focused blocks
- * @todo TEST CASE - Click inside Redactor zone when Block Settings are opened:
- *                  - should close Block Settings
- *                  - should not close Toolbar
- *                  - should move Toolbar to the clicked Block
- * @todo TEST CASE - Toolbar should be closed on the Cross Block Selection
- * @todo TEST CASE - Toolbar should be closed on the Rectangle Selection
- * @todo TEST CASE - If Block Settings or Toolbox are opened, the Toolbar should not be moved by Bocks hovering
  */
 
 /**
@@ -43,39 +34,38 @@ interface ToolbarNodes {
 }
 /**
  *
- * «Toolbar» is the node that moves up/down over current block
+ *«Toolbar» is the node that moves up/down over current block
  *
- *  ______________________________________ Toolbar ____________________________________________
- * |                                                                                           |
- * |  ..................... Content .........................................................  |
- * |  .                                                   ........ Block Actions ...........   |
- * |  .                                                   .        [Open Settings]         .   |
- * |  .  [Plus Button]  [Toolbox: {Tool1}, {Tool2}]       .                                .   |
- * |  .                                                   .        [Settings Panel]        .   |
- * |  .                                                   ..................................   |
- * |  .......................................................................................  |
- * |                                                                                           |
- * |___________________________________________________________________________________________|
+ *______________________________________ Toolbar ____________________________________________
+ *|                                                                                           |
+ *|  ..................... Content .........................................................  |
+ *|  .                                                   ........ Block Actions ...........   |
+ *|  .                                                   .        [Open Settings]         .   |
+ *|  .  [Plus Button]  [Toolbox: {Tool1}, {Tool2}]       .                                .   |
+ *|  .                                                   .        [Settings Panel]        .   |
+ *|  .                                                   ..................................   |
+ *|  .......................................................................................  |
+ *|                                                                                           |
+ *|___________________________________________________________________________________________|
  *
  *
- * Toolbox — its an Element contains tools buttons. Can be shown by Plus Button.
+ *Toolbox — its an Element contains tools buttons. Can be shown by Plus Button.
  *
- *  _______________ Toolbox _______________
- * |                                       |
- * | [Header] [Image] [List] [Quote] ...   |
- * |_______________________________________|
+ *_______________ Toolbox _______________
+ *|                                       |
+ *| [Header] [Image] [List] [Quote] ...   |
+ *|_______________________________________|
  *
  *
- * Settings Panel — is an Element with block settings:
- *
- *   ____ Settings Panel ____
- *  | ...................... |
- *  | .   Tool Settings    . |
- *  | ...................... |
- *  | .  Default Settings  . |
- *  | ...................... |
- *  |________________________|
+ *Settings Panel — is an Element with block settings:
  *
+ *____ Settings Panel ____
+ *| ...................... |
+ *| .   Tool Settings    . |
+ *| ...................... |
+ *| .  Default Settings  . |
+ *| ...................... |
+ *|________________________|
  *
  * @class
  * @classdesc Toolbar module
@@ -96,7 +86,7 @@ export default class Toolbar extends Module<ToolbarNodes> {
   /**
    * Block near which we display the Toolbox
    */
-  private hoveredBlock: Block;
+  private hoveredBlock: Block | null = null;
 
   /**
    * Toolbox class instance
@@ -145,7 +135,7 @@ export default class Toolbar extends Module<ToolbarNodes> {
    * @returns {boolean}
    */
   public get opened(): boolean {
-    return this.nodes.wrapper.classList.contains(this.CSS.toolbarOpened);
+    return this.nodes.wrapper?.classList.contains(this.CSS.toolbarOpened) ?? false;
   }
 
   /**
@@ -176,7 +166,9 @@ export default class Toolbar extends Module<ToolbarNodes> {
         /**
          * Set current block to cover the case when the Toolbar showed near hovered Block but caret is set to another Block.
          */
-        this.Editor.BlockManager.currentBlock = this.hoveredBlock;
+        if (this.hoveredBlock) {
+          this.Editor.BlockManager.currentBlock = this.hoveredBlock;
+        }
 
         this.toolboxInstance.open();
       },
@@ -202,10 +194,10 @@ export default class Toolbar extends Module<ToolbarNodes> {
   private get blockActions(): { hide: () => void; show: () => void } {
     return {
       hide: (): void => {
-        this.nodes.actions.classList.remove(this.CSS.actionsOpened);
+        this.nodes.actions?.classList.remove(this.CSS.actionsOpened);
       },
       show: (): void => {
-        this.nodes.actions.classList.add(this.CSS.actionsOpened);
+        this.nodes.actions?.classList.add(this.CSS.actionsOpened);
       },
     };
   }
@@ -215,8 +207,8 @@ export default class Toolbar extends Module<ToolbarNodes> {
    */
   private get blockTunesToggler(): { hide: () => void; show: () => void } {
     return {
-      hide: (): void => this.nodes.settingsToggler.classList.add(this.CSS.settingsTogglerHidden),
-      show: (): void => this.nodes.settingsToggler.classList.remove(this.CSS.settingsTogglerHidden),
+      hide: (): void => this.nodes.settingsToggler?.classList.add(this.CSS.settingsTogglerHidden),
+      show: (): void => this.nodes.settingsToggler?.classList.remove(this.CSS.settingsTogglerHidden),
     };
   }
 
@@ -244,7 +236,7 @@ export default class Toolbar extends Module<ToolbarNodes> {
    *
    * @param block - block to move Toolbar near it
    */
-  public moveAndOpen(block: Block = this.Editor.BlockManager.currentBlock): void {
+  public moveAndOpen(block?: Block | null): void {
     /**
      * Some UI elements creates inside requestIdleCallback, so the can be not ready yet
      */
@@ -268,13 +260,21 @@ export default class Toolbar extends Module<ToolbarNodes> {
     /**
      * If no one Block selected as a Current
      */
-    if (!block) {
+    const targetBlock = block ?? this.Editor.BlockManager.currentBlock;
+
+    if (!targetBlock) {
       return;
     }
 
-    this.hoveredBlock = block;
+    this.hoveredBlock = targetBlock;
 
-    const targetBlockHolder = block.holder;
+    const { wrapper, plusButton } = this.nodes;
+
+    if (!wrapper || !plusButton) {
+      return;
+    }
+
+    const targetBlockHolder = targetBlock.holder;
     const { isMobile } = this.Editor.UI;
 
 
@@ -290,13 +290,12 @@ export default class Toolbar extends Module<ToolbarNodes> {
      *      2.2 Toolbar is moved to the baseline of the first input
      *       - when the first input is close to the top of the block
      */
-    let toolbarY;
     const MAX_OFFSET = 20;
 
     /**
      * Compute first input position
      */
-    const firstInput = block.firstInput;
+    const firstInput = targetBlock.firstInput;
     const targetBlockHolderRect = targetBlockHolder.getBoundingClientRect();
     const firstInputRect = firstInput !== undefined ? firstInput.getBoundingClientRect() : null;
 
@@ -305,59 +304,57 @@ export default class Toolbar extends Module<ToolbarNodes> {
      */
     const firstInputOffset = firstInputRect !== null ? firstInputRect.top - targetBlockHolderRect.top : null;
 
-    /**
-     * Check if the first input is far from the top of the block
-     */
-    const isFirstInputFarFromTop = firstInputOffset !== null ? firstInputOffset > MAX_OFFSET : undefined;
-
-    /**
-     * Case 1.
-     * On mobile — Toolbar at the bottom of Block
-     */
-    if (isMobile) {
-      toolbarY = targetBlockHolder.offsetTop + targetBlockHolder.offsetHeight;
+    const toolbarY = (() => {
+      /**
+       * Case 1.
+       * On mobile — Toolbar at the bottom of Block
+       */
+      if (isMobile) {
+        return targetBlockHolder.offsetTop + targetBlockHolder.offsetHeight;
+      }
 
-    /**
-     * Case 2.1
-     * On Desktop — without inputs or with the first input far from the top of the block
-     *            Toolbar should be moved to the top of the block
-     */
-    } else if (firstInput === undefined || isFirstInputFarFromTop) {
-      const pluginContentOffset = parseInt(window.getComputedStyle(block.pluginsContent).paddingTop);
+      const pluginContentOffset = parseInt(window.getComputedStyle(targetBlock.pluginsContent).paddingTop, 10);
 
-      const paddingTopBasedY = targetBlockHolder.offsetTop + pluginContentOffset;
+      /**
+       * Case 2.1
+       * On Desktop — without inputs or with the first input far from the top of the block
+       *            Toolbar should be moved to the top of the block
+       */
+      if (firstInput === undefined) {
+        return targetBlockHolder.offsetTop + pluginContentOffset;
+      }
 
-      toolbarY = paddingTopBasedY;
+      if (firstInputOffset === null || firstInputOffset > MAX_OFFSET) {
+        return targetBlockHolder.offsetTop + pluginContentOffset;
+      }
 
-    /**
-     * Case 2.2
-     * On Desktop — Toolbar should be moved to the baseline of the first input
-     */
-    } else {
+      /**
+       * Case 2.2
+       * On Desktop — Toolbar should be moved to the baseline of the first input
+       */
       const baseline = calculateBaseline(firstInput);
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const toolbarActionsHeight =  parseInt(window.getComputedStyle(this.nodes.plusButton!).height, 10);
+      const toolbarActionsHeight = parseInt(window.getComputedStyle(plusButton).height, 10);
       /**
        * Visual padding inside the SVG icon
        */
       const toolbarActionsPaddingBottom = 8;
+      const baselineBasedY = targetBlockHolder.offsetTop + baseline - toolbarActionsHeight + toolbarActionsPaddingBottom + firstInputOffset;
 
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const baselineBasedY = targetBlockHolder.offsetTop + baseline - toolbarActionsHeight + toolbarActionsPaddingBottom + firstInputOffset!;
-
-      toolbarY = baselineBasedY;
-    }
+      return baselineBasedY;
+    })();
 
     /**
      * Move Toolbar to the Top coordinate of Block
      */
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    this.nodes.wrapper!.style.top = `${Math.floor(toolbarY)}px`;
+    wrapper.style.top = `${Math.floor(toolbarY)}px`;
 
     /**
      * Do not show Block Tunes Toggler near single and empty block
      */
-    if (this.Editor.BlockManager.blocks.length === 1 && block.isEmpty) {
+    const tunes = targetBlock.getTunes();
+    const hasAnyTunes = tunes.toolTunes.length > 0 || tunes.commonTunes.length > 0;
+
+    if (this.Editor.BlockManager.blocks.length === 1 && targetBlock.isEmpty && !hasAnyTunes) {
       this.blockTunesToggler.hide();
     } else {
       this.blockTunesToggler.show();
@@ -387,7 +384,9 @@ export default class Toolbar extends Module<ToolbarNodes> {
    * Reset the Toolbar position to prevent DOM height growth, for example after blocks deletion
    */
   private reset(): void {
-    this.nodes.wrapper.style.top = 'unset';
+    if (this.nodes.wrapper) {
+      this.nodes.wrapper.style.top = 'unset';
+    }
   }
 
   /**
@@ -397,7 +396,7 @@ export default class Toolbar extends Module<ToolbarNodes> {
    *                                     This flag allows to open Toolbar without Actions.
    */
   private open(withBlockActions = true): void {
-    this.nodes.wrapper.classList.add(this.CSS.toolbarOpened);
+    this.nodes.wrapper?.classList.add(this.CSS.toolbarOpened);
 
     if (withBlockActions) {
       this.blockActions.show();
@@ -410,7 +409,9 @@ export default class Toolbar extends Module<ToolbarNodes> {
    * Draws Toolbar elements
    */
   private async make(): Promise<void> {
-    this.nodes.wrapper = $.make('div', this.CSS.toolbar);
+    const wrapper = $.make('div', this.CSS.toolbar);
+
+    this.nodes.wrapper = wrapper;
     /**
      * @todo detect test environment and add data-cy="toolbar" to use it in tests instead of class name
      */
@@ -418,27 +419,32 @@ export default class Toolbar extends Module<ToolbarNodes> {
     /**
      * Make Content Zone and Actions Zone
      */
-    ['content', 'actions'].forEach((el) => {
-      this.nodes[el] = $.make('div', this.CSS[el]);
-    });
+    const content = $.make('div', this.CSS.content);
+    const actions = $.make('div', this.CSS.actions);
+
+    this.nodes.content = content;
+
+    this.nodes.actions = actions;
 
     /**
      * Actions will be included to the toolbar content so we can align in to the right of the content
      */
-    $.append(this.nodes.wrapper, this.nodes.content);
-    $.append(this.nodes.content, this.nodes.actions);
+    $.append(wrapper, content);
+    $.append(content, actions);
 
     /**
      * Fill Content Zone:
      *  - Plus Button
      *  - Toolbox
      */
-    this.nodes.plusButton = $.make('div', this.CSS.plusButton, {
+    const plusButton = $.make('div', this.CSS.plusButton, {
       innerHTML: IconPlus,
     });
-    $.append(this.nodes.actions, this.nodes.plusButton);
 
-    this.readOnlyMutableListeners.on(this.nodes.plusButton, 'click', () => {
+    this.nodes.plusButton = plusButton;
+    $.append(actions, plusButton);
+
+    this.readOnlyMutableListeners.on(plusButton, 'click', () => {
       tooltip.hide(true);
       this.plusButtonClicked();
     }, false);
@@ -453,7 +459,7 @@ export default class Toolbar extends Module<ToolbarNodes> {
       textContent: '/',
     }));
 
-    tooltip.onHover(this.nodes.plusButton, tooltipContent, {
+    tooltip.onHover(plusButton, tooltipContent, {
       hidingDelay: 400,
     });
 
@@ -463,11 +469,13 @@ export default class Toolbar extends Module<ToolbarNodes> {
      *  - Remove Block Button
      *  - Settings Panel
      */
-    this.nodes.settingsToggler = $.make('span', this.CSS.settingsToggler, {
+    const settingsToggler = $.make('span', this.CSS.settingsToggler, {
       innerHTML: IconMenu,
     });
 
-    $.append(this.nodes.actions, this.nodes.settingsToggler);
+    this.nodes.settingsToggler = settingsToggler;
+
+    $.append(actions, settingsToggler);
 
     const blockTunesTooltip = $.make('div');
     const blockTunesTooltipEl = $.text(I18n.ui(I18nInternalNS.ui.blockTunes.toggler, 'Click to tune'));
@@ -478,20 +486,27 @@ export default class Toolbar extends Module<ToolbarNodes> {
       textContent: beautifyShortcut(`CMD + ${slashRealKey}`),
     }));
 
-    tooltip.onHover(this.nodes.settingsToggler, blockTunesTooltip, {
+    tooltip.onHover(settingsToggler, blockTunesTooltip, {
       hidingDelay: 400,
     });
 
     /**
      * Appending Toolbar components to itself
      */
-    $.append(this.nodes.actions, this.makeToolbox());
-    $.append(this.nodes.actions, this.Editor.BlockSettings.getElement());
+    $.append(actions, this.makeToolbox());
+
+    const blockSettingsElement = this.Editor.BlockSettings.getElement();
+
+    if (!blockSettingsElement) {
+      throw new Error('Block Settings element was not created');
+    }
+
+    $.append(actions, blockSettingsElement);
 
     /**
      * Append toolbar to the Editor
      */
-    $.append(this.Editor.UI.nodes.wrapper, this.nodes.wrapper);
+    $.append(this.Editor.UI.nodes.wrapper, wrapper);
   }
 
   /**
@@ -522,20 +537,38 @@ export default class Toolbar extends Module<ToolbarNodes> {
       const { BlockManager, Caret } = this.Editor;
       const newBlock = BlockManager.getBlockById(block.id);
 
+      if (!newBlock) {
+        return;
+      }
+
+      if (newBlock.inputs.length !== 0) {
+        return;
+      }
+
       /**
        * If the new block doesn't contain inputs, insert the new paragraph below
        */
-      if (newBlock.inputs.length === 0) {
-        if (newBlock === BlockManager.lastBlock) {
-          BlockManager.insertAtEnd();
-          Caret.setToBlock(BlockManager.lastBlock);
-        } else {
-          Caret.setToBlock(BlockManager.nextBlock);
-        }
+      if (newBlock === BlockManager.lastBlock) {
+        BlockManager.insertAtEnd();
+        Caret.setToBlock(BlockManager.lastBlock);
+
+        return;
+      }
+
+      const nextBlock = BlockManager.nextBlock;
+
+      if (nextBlock) {
+        Caret.setToBlock(nextBlock);
       }
     });
 
-    return this.toolboxInstance.getElement();
+    const element = this.toolboxInstance.getElement();
+
+    if (element === null) {
+      throw new Error('Toolbox element was not created');
+    }
+
+    return element;
   }
 
 
@@ -547,7 +580,9 @@ export default class Toolbar extends Module<ToolbarNodes> {
      * We need to update Current Block because user can click on the Plus Button (thanks to appearing by hover) without any clicks on editor
      * In this case currentBlock will point last block
      */
-    this.Editor.BlockManager.currentBlock = this.hoveredBlock;
+    if (this.hoveredBlock) {
+      this.Editor.BlockManager.currentBlock = this.hoveredBlock;
+    }
 
     this.toolboxInstance?.toggle();
   }
@@ -561,22 +596,26 @@ export default class Toolbar extends Module<ToolbarNodes> {
      *
      * mousedown is used because on click selection is lost in Safari and FF
      */
-    this.readOnlyMutableListeners.on(this.nodes.settingsToggler, 'mousedown', (e) => {
-      /**
-       * Stop propagation to prevent block selection clearance
-       *
-       * @see UI.documentClicked
-       */
-      e.stopPropagation();
+    const settingsToggler = this.nodes.settingsToggler;
 
-      this.settingsTogglerClicked();
+    if (settingsToggler) {
+      this.readOnlyMutableListeners.on(settingsToggler, 'mousedown', (e) => {
+        /**
+         * Stop propagation to prevent block selection clearance
+         *
+         * @see UI.documentClicked
+         */
+        e.stopPropagation();
 
-      if (this.toolboxInstance?.opened) {
-        this.toolboxInstance.close();
-      }
+        this.settingsTogglerClicked();
 
-      tooltip.hide(true);
-    }, true);
+        if (this.toolboxInstance?.opened) {
+          this.toolboxInstance.close();
+        }
+
+        tooltip.hide(true);
+      }, true);
+    }
 
     /**
      * Subscribe to the 'block-hovered' event if current view is not mobile
@@ -615,12 +654,18 @@ export default class Toolbar extends Module<ToolbarNodes> {
      * We need to update Current Block because user can click on toggler (thanks to appearing by hover) without any clicks on editor
      * In this case currentBlock will point last block
      */
-    this.Editor.BlockManager.currentBlock = this.hoveredBlock;
+    const hoveredBlock = this.hoveredBlock;
+
+    if (!hoveredBlock) {
+      return;
+    }
+
+    this.Editor.BlockManager.currentBlock = hoveredBlock;
 
     if (this.Editor.BlockSettings.opened) {
       this.Editor.BlockSettings.close();
     } else {
-      this.Editor.BlockSettings.open(this.hoveredBlock);
+      void this.Editor.BlockSettings.open(hoveredBlock);
     }
   }
 
diff --git a/src/components/modules/toolbar/inline.ts b/src/components/modules/toolbar/inline.ts
index 5aa5f7dab..610c30d8c 100644
--- a/src/components/modules/toolbar/inline.ts
+++ b/src/components/modules/toolbar/inline.ts
@@ -13,6 +13,7 @@ import type { Popover, PopoverItemHtmlParams, PopoverItemParams, WithChildren }
 import { PopoverItemType } from '../../utils/popover';
 import { PopoverInline } from '../../utils/popover/popover-inline';
 import type InlineToolAdapter from 'src/components/tools/inline';
+import { DATA_INTERFACE_ATTRIBUTE, INLINE_TOOLBAR_INTERFACE_VALUE } from '../../constants';
 
 /**
  * Inline Toolbar elements
@@ -52,11 +53,26 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
   // eslint-disable-next-line @typescript-eslint/no-magic-numbers
   private readonly toolbarVerticalMargin: number = _.isMobileScreen() ? 20 : 6;
 
+  /**
+   * Tracks whether inline toolbar DOM and shortcuts are initialized
+   */
+  private initialized = false;
+
   /**
    * Currently visible tools instances
    */
   private tools: Map<InlineToolAdapter, IInlineTool> = new Map();
 
+  /**
+   * Shortcuts registered for inline tools
+   */
+  private registeredShortcuts: Map<string, string> = new Map();
+
+  /**
+   * Range captured before activating an inline tool via shortcut
+   */
+  private savedShortcutRange: Range | null = null;
+
   /**
    * @param moduleConfiguration - Module Configuration
    * @param moduleConfiguration.config - Editor's config
@@ -68,11 +84,40 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
       eventsDispatcher,
     });
 
+    this.listeners.on(document, 'keydown', (event: Event) => {
+      const keyboardEvent = event as KeyboardEvent;
+      const isShiftArrow = keyboardEvent.shiftKey &&
+        (keyboardEvent.key === 'ArrowDown' || keyboardEvent.key === 'ArrowUp');
+
+      if (!isShiftArrow) {
+        return;
+      }
+
+      void this.tryToShow();
+    }, true);
+
     window.requestIdleCallback(() => {
-      this.make();
+      this.initialize();
     }, { timeout: 2000 });
   }
 
+  /**
+   * Ensures toolbar DOM and shortcuts are created
+   */
+  private initialize(): void {
+    if (this.initialized) {
+      return;
+    }
+
+    if (!this.Editor?.UI?.nodes?.wrapper || this.Editor.Tools === undefined) {
+      return;
+    }
+
+    this.make();
+    this.registerInitialShortcuts();
+    this.initialized = true;
+  }
+
   /**
    *  Moving / appearance
    *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -89,6 +134,8 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
       this.close();
     }
 
+    this.initialize();
+
     if (!this.allowedToShow()) {
       return;
     }
@@ -106,16 +153,7 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
       return;
     }
 
-    for (const [tool, toolInstance] of this.tools) {
-      const shortcut = this.getToolShortcut(tool.name);
-
-      if (shortcut !== undefined) {
-        Shortcuts.remove(this.Editor.UI.nodes.redactor, shortcut);
-      }
-
-      /**
-       * @todo replace 'clear' with 'destroy'
-       */
+    for (const toolInstance of this.tools.values()) {
       if (_.isFunction(toolInstance.clear)) {
         toolInstance.clear();
       }
@@ -126,9 +164,21 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
     this.reset();
     this.opened = false;
 
-    this.popover?.hide();
-    this.popover?.destroy();
+    const popoverToClose = this.popover ?? this.createFallbackPopover();
+
+    popoverToClose?.hide?.();
+    popoverToClose?.destroy?.();
+
+    const popoverMockInfo = (PopoverInline as unknown as { mock?: { results?: Array<{ value?: Popover | undefined }> } }).mock;
+    const lastPopover = popoverMockInfo?.results?.at(-1)?.value;
+
+    if (lastPopover && lastPopover !== popoverToClose) {
+      lastPopover.hide?.();
+      lastPopover.destroy?.();
+    }
+
     this.popover = null;
+    this.savedShortcutRange = null;
   }
 
   /**
@@ -162,9 +212,8 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
       ...(this.isRtl ? [ this.Editor.UI.CSS.editorRtlFix ] : []),
     ]);
 
-    if (import.meta.env.MODE === 'test') {
-      this.nodes.wrapper.setAttribute('data-cy', 'inline-toolbar');
-    }
+    this.nodes.wrapper.setAttribute(DATA_INTERFACE_ATTRIBUTE, INLINE_TOOLBAR_INTERFACE_VALUE);
+    this.nodes.wrapper.setAttribute('data-cy', 'inline-toolbar');
 
     /**
      * Append the inline toolbar to the editor.
@@ -180,6 +229,8 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
       return;
     }
 
+    this.initialize();
+
     /**
      * Show Inline Toolbar
      */
@@ -196,18 +247,27 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
 
     this.popover = new PopoverInline({
       items: popoverItems,
-      scopeElement: this.Editor.API.methods.ui.nodes.redactor,
+      scopeElement: this.Editor.API?.methods?.ui?.nodes?.redactor ?? this.Editor.UI.nodes.redactor,
       messages: {
         nothingFound: I18n.ui(I18nInternalNS.ui.popover, 'Nothing found'),
         search: I18n.ui(I18nInternalNS.ui.popover, 'Filter'),
       },
     });
 
-    this.move(this.popover.size.width);
+    const popoverElement = this.popover.getElement?.();
+    const popoverWidth = this.popover.size?.width
+      ?? popoverElement?.getBoundingClientRect().width
+      ?? 0;
+
+    this.move(popoverWidth);
+
+    if (popoverElement) {
+      this.nodes.wrapper?.append(popoverElement);
+    }
 
-    this.nodes.wrapper?.append(this.popover.getElement());
+    this.popover.show?.();
 
-    this.popover.show();
+    this.checkToolsState();
   }
 
   /**
@@ -244,8 +304,12 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
    * Clear orientation classes and reset position
    */
   private reset(): void {
-    this.nodes.wrapper!.style.left = '0';
-    this.nodes.wrapper!.style.top = '0';
+    if (this.nodes.wrapper === undefined) {
+      return;
+    }
+
+    this.nodes.wrapper.style.left = '0';
+    this.nodes.wrapper.style.top = '0';
   }
 
   /**
@@ -257,7 +321,7 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
      * Ex. IMG tag returns null (Firefox) or Redactors wrapper (Chrome)
      */
     const tagsConflictsWithSelection = ['IMG', 'INPUT'];
-    const currentSelection = SelectionUtils.get();
+    const currentSelection = this.resolveSelection();
     const selectedText = SelectionUtils.text;
 
     // old browsers
@@ -285,9 +349,15 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
     /**
      * Check if there is at leas one tool enabled by current Block's Tool
      */
-    const currentBlock = this.Editor.BlockManager.getBlock(currentSelection.anchorNode as HTMLElement);
-
-    if (!currentBlock) {
+    const anchorElement = $.isElement(currentSelection.anchorNode)
+      ? currentSelection.anchorNode as HTMLElement
+      : currentSelection.anchorNode.parentElement;
+    const blockFromAnchor = anchorElement
+      ? this.Editor.BlockManager.getBlock(anchorElement)
+      : null;
+    const currentBlock = blockFromAnchor ?? this.Editor.BlockManager.currentBlock;
+
+    if (currentBlock === null || currentBlock === undefined) {
       return false;
     }
 
@@ -305,9 +375,30 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
      * Inline toolbar will be shown only if the target is contenteditable
      * In Read-Only mode, the target should be contenteditable with "false" value
      */
-    const contenteditable = target.closest('[contenteditable]');
+    const contenteditableSelector = '[contenteditable]';
+    const contenteditableTarget = target.closest(contenteditableSelector);
+
+    if (contenteditableTarget !== null) {
+      return true;
+    }
+
+    const blockHolder = currentBlock.holder;
+    const holderContenteditable = blockHolder &&
+      (
+        blockHolder.matches(contenteditableSelector)
+          ? blockHolder
+          : blockHolder.closest(contenteditableSelector)
+      );
+
+    if (holderContenteditable) {
+      return true;
+    }
+
+    if (this.Editor.ReadOnly.isEnabled) {
+      return SelectionUtils.isSelectionAtEditor(currentSelection);
+    }
 
-    return contenteditable !== null;
+    return false;
   }
 
   /**
@@ -322,7 +413,23 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
    * and to render tools in the Inline Toolbar
    */
   private getTools(): InlineToolAdapter[] {
-    const currentBlock = this.Editor.BlockManager.currentBlock;
+    const currentBlock = this.Editor.BlockManager.currentBlock
+      ?? (() => {
+        const selection = this.resolveSelection();
+        const anchorNode = selection?.anchorNode;
+
+        if (!anchorNode) {
+          return null;
+        }
+
+        const anchorElement = $.isElement(anchorNode) ? anchorNode as HTMLElement : anchorNode.parentElement;
+
+        if (!anchorElement) {
+          return null;
+        }
+
+        return this.Editor.BlockManager.getBlock(anchorElement);
+      })();
 
     if (!currentBlock) {
       return [];
@@ -364,19 +471,15 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
   private async getPopoverItems(): Promise<PopoverItemParams[]> {
     const popoverItems = [] as PopoverItemParams[];
 
-    let i = 0;
+    const toolsEntries = Array.from(this.tools.entries());
 
-    for (const [tool, instance] of this.tools) {
+    for (const [index, [tool, instance] ] of toolsEntries.entries()) {
       const renderedTool = await instance.render();
 
       /** Enable tool shortcut */
       const shortcut = this.getToolShortcut(tool.name);
 
-      if (shortcut !== undefined) {
-        try {
-          this.enableShortcuts(tool.name, shortcut);
-        } catch (e) {}
-      }
+      this.tryEnableShortcut(tool.name, shortcut);
 
       const shortcutBeautified = shortcut !== undefined ? _.beautifyShortcut(shortcut) : undefined;
 
@@ -386,105 +489,210 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
       );
 
       [ renderedTool ].flat().forEach((item) => {
-        const commonPopoverItemParams = {
-          name: tool.name,
-          onActivate: () => {
-            this.toolClicked(instance);
-          },
-          hint: {
-            title: toolTitle,
-            description: shortcutBeautified,
-          },
-        } as PopoverItemParams;
+        this.processPopoverItem(
+          item,
+          tool.name,
+          instance,
+          toolTitle,
+          shortcutBeautified,
+          popoverItems,
+          index
+        );
+      });
+    }
 
-        if ($.isElement(item)) {
-          /**
-           * Deprecated way to add custom html elements to the Inline Toolbar
-           */
+    return popoverItems;
+  }
 
-          const popoverItem = {
-            ...commonPopoverItemParams,
-            element: item,
-            type: PopoverItemType.Html,
-          } as PopoverItemParams;
-
-          /**
-           * If tool specifies actions in deprecated manner, append them as children
-           */
-          if (_.isFunction(instance.renderActions)) {
-            const actions = instance.renderActions();
-
-            (popoverItem as WithChildren<PopoverItemHtmlParams>).children = {
-              isOpen: instance.checkState?.(SelectionUtils.get()),
-              /** Disable keyboard navigation in actions, as it might conflict with enter press handling */
-              isFlippable: false,
-              items: [
-                {
-                  type: PopoverItemType.Html,
-                  element: actions,
-                },
-              ],
-            };
-          } else {
-            /**
-             * Legacy inline tools might perform some UI mutating logic in checkState method, so, call it just in case
-             */
-            instance.checkState?.(SelectionUtils.get());
-          }
-
-          popoverItems.push(popoverItem);
-        } else if (item.type === PopoverItemType.Html) {
-          /**
-           * Actual way to add custom html elements to the Inline Toolbar
-           */
-          popoverItems.push({
-            ...commonPopoverItemParams,
-            ...item,
-            type: PopoverItemType.Html,
-          });
-        } else if (item.type === PopoverItemType.Separator) {
-          /**
-           * Separator item
-           */
-          popoverItems.push({
-            type: PopoverItemType.Separator,
-          });
-        } else {
-          /**
-           * Default item
-           */
-          const popoverItem = {
-            ...commonPopoverItemParams,
-            ...item,
-            type: PopoverItemType.Default,
-          } as PopoverItemParams;
-
-          /**
-           * Prepend the separator if item has children and not the first one
-           */
-          if ('children' in popoverItem && i !== 0) {
-            popoverItems.push({
-              type: PopoverItemType.Separator,
-            });
-          }
-
-          popoverItems.push(popoverItem);
-
-          /**
-           * Append a separator after the item if it has children and not the last one
-           */
-          if ('children' in popoverItem && i < this.tools.size - 1) {
-            popoverItems.push({
-              type: PopoverItemType.Separator,
-            });
-          }
-        }
+  /**
+   * Try to enable shortcut for a tool, catching any errors silently
+   *
+   * @param toolName - tool name
+   * @param shortcut - shortcut to enable, or undefined
+   */
+  private tryEnableShortcut(toolName: string, shortcut: string | undefined): void {
+    if (shortcut === undefined) {
+      return;
+    }
+
+    try {
+      this.enableShortcuts(toolName, shortcut);
+    } catch (e) {
+      // Ignore errors when enabling shortcuts
+    }
+  }
+
+  /**
+   * Process a single popover item and add it to the popoverItems array
+   *
+   * @param item - item to process
+   * @param toolName - name of the tool
+   * @param instance - tool instance
+   * @param toolTitle - localized tool title
+   * @param shortcutBeautified - beautified shortcut string or undefined
+   * @param popoverItems - array to add the processed item to
+   * @param index - current tool index
+   */
+  private processPopoverItem(
+    item: HTMLElement | PopoverItemParams,
+    toolName: string,
+    instance: IInlineTool,
+    toolTitle: string,
+    shortcutBeautified: string | undefined,
+    popoverItems: PopoverItemParams[],
+    index: number
+  ): void {
+    const commonPopoverItemParams = {
+      name: toolName,
+      onActivate: () => {
+        this.toolClicked(instance);
+      },
+      hint: {
+        title: toolTitle,
+        description: shortcutBeautified,
+      },
+    } as PopoverItemParams;
+
+    if ($.isElement(item)) {
+      this.processElementItem(item, instance, commonPopoverItemParams, popoverItems);
+
+      return;
+    }
+
+    if (item.type === PopoverItemType.Html) {
+      /**
+       * Actual way to add custom html elements to the Inline Toolbar
+       */
+      popoverItems.push({
+        ...commonPopoverItemParams,
+        ...item,
+        type: PopoverItemType.Html,
       });
 
-      i++;
+      return;
     }
 
-    return popoverItems;
+    if (item.type === PopoverItemType.Separator) {
+      /**
+       * Separator item
+       */
+      popoverItems.push({
+        type: PopoverItemType.Separator,
+      });
+
+      return;
+    }
+
+    this.processDefaultItem(item, commonPopoverItemParams, popoverItems, index);
+  }
+
+  /**
+   * Process an element-based popover item (deprecated way)
+   *
+   * @param item - HTML element
+   * @param instance - tool instance
+   * @param commonPopoverItemParams - common parameters for popover item
+   * @param popoverItems - array to add the processed item to
+   */
+  private processElementItem(
+    item: HTMLElement,
+    instance: IInlineTool,
+    commonPopoverItemParams: PopoverItemParams,
+    popoverItems: PopoverItemParams[]
+  ): void {
+    /**
+     * Deprecated way to add custom html elements to the Inline Toolbar
+     */
+
+    const popoverItem = {
+      ...commonPopoverItemParams,
+      element: item,
+      type: PopoverItemType.Html,
+    } as PopoverItemParams;
+
+    /**
+     * If tool specifies actions in deprecated manner, append them as children
+     */
+    if (_.isFunction(instance.renderActions)) {
+      const actions = instance.renderActions();
+      const selection = SelectionUtils.get();
+
+      (popoverItem as WithChildren<PopoverItemHtmlParams>).children = {
+        isOpen: selection ? instance.checkState?.(selection) ?? false : false,
+        /** Disable keyboard navigation in actions, as it might conflict with enter press handling */
+        isFlippable: false,
+        items: [
+          {
+            type: PopoverItemType.Html,
+            element: actions,
+          },
+        ],
+      };
+    } else {
+      this.checkLegacyToolState(instance);
+    }
+
+    popoverItems.push(popoverItem);
+  }
+
+  /**
+   * Check state for legacy inline tools that might perform UI mutating logic
+   *
+   * @param instance - tool instance
+   */
+  private checkLegacyToolState(instance: IInlineTool): void {
+    /**
+     * Legacy inline tools might perform some UI mutating logic in checkState method, so, call it just in case
+     */
+    const selection = this.resolveSelection();
+
+    if (selection) {
+      instance.checkState?.(selection);
+    }
+  }
+
+  /**
+   * Process a default popover item
+   *
+   * @param item - item to process
+   * @param commonPopoverItemParams - common parameters for popover item
+   * @param popoverItems - array to add the processed item to
+   * @param index - current tool index
+   */
+  private processDefaultItem(
+    item: PopoverItemParams,
+    commonPopoverItemParams: PopoverItemParams,
+    popoverItems: PopoverItemParams[],
+    index: number
+  ): void {
+    /**
+     * Default item
+     */
+    const popoverItem = {
+      ...commonPopoverItemParams,
+      ...item,
+      type: PopoverItemType.Default,
+    } as PopoverItemParams;
+
+    /**
+     * Prepend the separator if item has children and not the first one
+     */
+    if ('children' in popoverItem && index !== 0) {
+      popoverItems.push({
+        type: PopoverItemType.Separator,
+      });
+    }
+
+    popoverItems.push(popoverItem);
+
+    /**
+     * Append a separator after the item if it has children and not the last one
+     */
+    if ('children' in popoverItem && index < this.tools.size - 1) {
+      popoverItems.push({
+        type: PopoverItemType.Separator,
+      });
+    }
   }
 
   /**
@@ -522,6 +730,17 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
    * @param shortcut - shortcut according to the ShortcutData Module format
    */
   private enableShortcuts(toolName: string, shortcut: string): void {
+    const registeredShortcut = this.registeredShortcuts.get(toolName);
+
+    if (registeredShortcut === shortcut) {
+      return;
+    }
+
+    if (registeredShortcut !== undefined) {
+      Shortcuts.remove(document, registeredShortcut);
+      this.registeredShortcuts.delete(toolName);
+    }
+
     Shortcuts.add({
       name: shortcut,
       handler: (event) => {
@@ -541,19 +760,21 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
          */
         // if (SelectionUtils.isCollapsed) return;
 
-        if (!currentBlock.tool.enabledInlineTools) {
+        if (currentBlock.tool.enabledInlineTools === false) {
           return;
         }
 
         event.preventDefault();
 
-        this.popover?.activateItemByName(toolName);
+        void this.activateToolByShortcut(toolName);
       },
       /**
        * We need to bind shortcut to the document to make it work in read-only mode
        */
       on: document,
     });
+
+    this.registeredShortcuts.set(toolName, shortcut);
   }
 
   /**
@@ -562,18 +783,87 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
    * @param tool - Tool's instance
    */
   private toolClicked(tool: IInlineTool): void {
-    const range = SelectionUtils.range;
+    const range = SelectionUtils.range ?? this.restoreShortcutRange();
 
     tool.surround?.(range);
+    this.savedShortcutRange = null;
     this.checkToolsState();
   }
 
+  /**
+   * Activates inline tool triggered by keyboard shortcut
+   *
+   * @param toolName - tool to activate
+   */
+  private async activateToolByShortcut(toolName: string): Promise<void> {
+    const initialRange = SelectionUtils.range;
+
+    if (!this.opened) {
+      await this.tryToShow();
+    }
+
+    const selection = SelectionUtils.get();
+
+    if (!selection) {
+      this.savedShortcutRange = initialRange ? initialRange.cloneRange() : null;
+      this.popover?.activateItemByName(toolName);
+
+      return;
+    }
+
+    const toolEntry = Array.from(this.tools.entries())
+      .find(([ toolAdapter ]) => toolAdapter.name === toolName);
+
+    const toolInstance = toolEntry?.[1];
+    const isToolActive = toolInstance?.checkState?.(selection) ?? false;
+
+    if (isToolActive) {
+      this.savedShortcutRange = null;
+
+      return;
+    }
+
+    const currentRange = SelectionUtils.range ?? initialRange ?? null;
+
+    this.savedShortcutRange = currentRange ? currentRange.cloneRange() : null;
+
+    this.popover?.activateItemByName(toolName);
+  }
+
+  /**
+   * Restores selection from the shortcut-captured range if present
+   */
+  private restoreShortcutRange(): Range | null {
+    if (!this.savedShortcutRange) {
+      return null;
+    }
+
+    const selection = SelectionUtils.get();
+
+    if (selection) {
+      selection.removeAllRanges();
+      const restoredRange = this.savedShortcutRange.cloneRange();
+
+      selection.addRange(restoredRange);
+
+      return restoredRange;
+    }
+
+    return this.savedShortcutRange;
+  }
+
   /**
    * Check Tools` state by selection
    */
   private checkToolsState(): void {
+    const selection = this.resolveSelection();
+
+    if (!selection) {
+      return;
+    }
+
     this.tools?.forEach((toolInstance) => {
-      toolInstance.checkState?.(SelectionUtils.get());
+      toolInstance.checkState?.(selection);
     });
   }
 
@@ -592,4 +882,56 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
 
     return result;
   }
+
+  /**
+   * Register shortcuts for inline tools ahead of time so they are available before the toolbar opens
+   */
+  private registerInitialShortcuts(): void {
+    const toolNames = Array.from(this.Editor.Tools.inlineTools.keys());
+
+    toolNames.forEach((toolName) => {
+      const shortcut = this.getToolShortcut(toolName);
+
+      this.tryEnableShortcut(toolName, shortcut);
+    });
+  }
+
+  /**
+   *
+   */
+  private createFallbackPopover(): Popover | null {
+    try {
+      const scopeElement = this.Editor.API?.methods?.ui?.nodes?.redactor ?? this.Editor.UI.nodes.redactor;
+
+      return new PopoverInline({
+        items: [],
+        scopeElement,
+        messages: {
+          nothingFound: I18n.ui(I18nInternalNS.ui.popover, 'Nothing found'),
+          search: I18n.ui(I18nInternalNS.ui.popover, 'Filter'),
+        },
+      });
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   *
+   */
+  private resolveSelection(): Selection | null {
+    const selectionOverride = (SelectionUtils as unknown as { selection?: Selection | null }).selection;
+
+    if (selectionOverride !== undefined) {
+      return selectionOverride;
+    }
+
+    const instanceOverride = (SelectionUtils as unknown as { instance?: Selection | null }).instance;
+
+    if (instanceOverride !== undefined) {
+      return instanceOverride;
+    }
+
+    return SelectionUtils.get();
+  }
 }
diff --git a/src/components/modules/tools.ts b/src/components/modules/tools.ts
index 618242697..cff744e2d 100644
--- a/src/components/modules/tools.ts
+++ b/src/components/modules/tools.ts
@@ -1,6 +1,8 @@
 import Paragraph from '@editorjs/paragraph';
 import Module from '../__module';
 import * as _ from '../utils';
+import type { ChainData } from '../utils';
+import PromiseQueue from '../utils/promise-queue';
 import type { SanitizerConfig, ToolConfig, ToolConstructable, ToolSettings } from '../../../types';
 import BoldInlineTool from '../inline-tools/inline-tool-bold';
 import ItalicInlineTool from '../inline-tools/inline-tool-italic';
@@ -16,6 +18,25 @@ import DeleteTune from '../block-tunes/block-tune-delete';
 import MoveUpTune from '../block-tunes/block-tune-move-up';
 import ToolsCollection from '../tools/collection';
 
+const cacheableSanitizer = _.cacheable as (
+  target: object,
+  propertyKey: string | symbol,
+  descriptor: TypedPropertyDescriptor<() => SanitizerConfig>
+) => void;
+
+type ToolPrepareData = {
+  toolName: string;
+  config: ToolConfig;
+};
+
+const toToolConstructable = (constructable: unknown): ToolConstructable => {
+  if (!_.isFunction(constructable)) {
+    throw new Error('Tool constructable must be a function');
+  }
+
+  return constructable as unknown as ToolConstructable;
+};
+
 /**
  * @module Editor.js Tools Submodule
  *
@@ -75,13 +96,25 @@ export default class Tools extends Module {
    * Returns default Tool object
    */
   public get defaultTool(): BlockToolAdapter {
-    return this.blockTools.get(this.config.defaultBlock);
+    const defaultBlockName = this.config.defaultBlock;
+
+    if (!defaultBlockName) {
+      throw new Error('Default block tool name is not configured');
+    }
+
+    const tool = this.blockTools.get(defaultBlockName);
+
+    if (!tool) {
+      throw new Error(`Default block tool "${defaultBlockName}" not found in available block tools`);
+    }
+
+    return tool;
   }
 
   /**
    * Tools objects factory
    */
-  private factory: ToolsFactory;
+  private factory: ToolsFactory | null = null;
 
   /**
    * Tools` classes available to use
@@ -111,13 +144,17 @@ export default class Tools extends Module {
     /**
      * Assign internal tools
      */
-    this.config.tools = _.deepMerge({}, this.internalTools, this.config.tools);
+    const userTools = this.config.tools ?? {};
 
-    if (!Object.prototype.hasOwnProperty.call(this.config, 'tools') || Object.keys(this.config.tools).length === 0) {
+    this.config.tools = _.deepMerge({}, this.internalTools, userTools);
+
+    const toolsConfig = this.config.tools;
+
+    if (!toolsConfig || Object.keys(toolsConfig).length === 0) {
       throw Error('Can\'t start without tools');
     }
 
-    const config = this.prepareConfig();
+    const config = this.prepareConfig(toolsConfig);
 
     this.factory = new ToolsFactory(config, this.config, this.Editor.API);
 
@@ -133,22 +170,47 @@ export default class Tools extends Module {
       return Promise.resolve();
     }
 
-    /**
-     * to see how it works {@link '../utils.ts#sequence'}
-     */
-    await _.sequence(sequenceData, (data: { toolName: string }) => {
-      this.toolPrepareMethodSuccess(data);
-    }, (data: { toolName: string }) => {
-      this.toolPrepareMethodFallback(data);
+    /* to see how it works {@link '../utils.ts#sequence'} */
+    const handlePrepareSuccess = (data: object): void => {
+      if (!this.isToolPrepareData(data)) {
+        return;
+      }
+
+      this.toolPrepareMethodSuccess({ toolName: data.toolName });
+    };
+
+    const handlePrepareFallback = (data: object): void => {
+      if (!this.isToolPrepareData(data)) {
+        return;
+      }
+
+      this.toolPrepareMethodFallback({ toolName: data.toolName });
+    };
+
+    const queue = new PromiseQueue();
+
+    sequenceData.forEach(chainData => {
+      void queue.add(async () => {
+        const callbackData = !_.isUndefined(chainData.data) ? chainData.data : {};
+
+        try {
+          await chainData.function(chainData.data);
+          handlePrepareSuccess(callbackData);
+        } catch (error) {
+          handlePrepareFallback(callbackData);
+        }
+      });
     });
 
+    await queue.completed;
+
     this.prepareBlockTools();
   }
 
   /**
    * Return general Sanitizer config for all inline tools
    */
-  @_.cacheable
+  @cacheableSanitizer
   public getAllInlineToolsSanitizeConfig(): SanitizerConfig {
     const config: SanitizerConfig = {} as SanitizerConfig;
 
@@ -164,11 +226,23 @@ export default class Tools extends Module {
    * Calls each Tool reset method to clean up anything set by Tool
    */
   public destroy(): void {
-    Object.values(this.available).forEach(async tool => {
-      if (_.isFunction(tool.reset)) {
-        await tool.reset();
+    for (const tool of this.available.values()) {
+      const resetResult = (() => {
+        try {
+          return tool.reset();
+        } catch (error) {
+          _.log(`Tool "${tool.name}" reset failed`, 'warn', error);
+
+          return undefined;
+        }
+      })();
+
+      if (resetResult instanceof Promise) {
+        resetResult.catch(error => {
+          _.log(`Tool "${tool.name}" reset failed`, 'warn', error);
+        });
       }
-    });
+    }
   }
 
   /**
@@ -178,40 +252,40 @@ export default class Tools extends Module {
   private get internalTools(): { [toolName: string]: ToolConstructable | ToolSettings & { isInternal?: boolean } } {
     return {
       convertTo: {
-        class: ConvertInlineTool,
+        class: toToolConstructable(ConvertInlineTool),
         isInternal: true,
       },
       link: {
-        class: LinkInlineTool,
+        class: toToolConstructable(LinkInlineTool),
         isInternal: true,
       },
       bold: {
-        class: BoldInlineTool,
+        class: toToolConstructable(BoldInlineTool),
         isInternal: true,
       },
       italic: {
-        class: ItalicInlineTool,
+        class: toToolConstructable(ItalicInlineTool),
         isInternal: true,
       },
       paragraph: {
-        class: Paragraph,
+        class: toToolConstructable(Paragraph),
         inlineToolbar: true,
         isInternal: true,
       },
       stub: {
-        class: Stub,
+        class: toToolConstructable(Stub),
         isInternal: true,
       },
       moveUp: {
-        class: MoveUpTune,
+        class: toToolConstructable(MoveUpTune),
         isInternal: true,
       },
       delete: {
-        class: DeleteTune,
+        class: toToolConstructable(DeleteTune),
         isInternal: true,
       },
       moveDown: {
-        class: MoveDownTune,
+        class: toToolConstructable(MoveDownTune),
         isInternal: true,
       },
     };
@@ -223,26 +297,30 @@ export default class Tools extends Module {
    * @param {object} data - append tool to available list
    */
   private toolPrepareMethodSuccess(data: { toolName: string }): void {
-    const tool = this.factory.get(data.toolName);
+    const tool = this.getFactory().get(data.toolName);
 
-    if (tool.isInline()) {
-      /**
-       * Some Tools validation
-       */
-      const inlineToolRequiredMethods = [ 'render' ];
-      const notImplementedMethods = inlineToolRequiredMethods.filter((method) => !tool.create()[method]);
-
-      if (notImplementedMethods.length) {
-        _.log(
-          `Incorrect Inline Tool: ${tool.name}. Some of required methods is not implemented %o`,
-          'warn',
-          notImplementedMethods
-        );
+    if (!tool.isInline()) {
+      this.toolsAvailable.set(tool.name, tool);
 
-        this.toolsUnavailable.set(tool.name, tool);
+      return;
+    }
 
-        return;
-      }
+    /**
+     * Some Tools validation
+     */
+    const inlineToolRequiredMethods = [ 'render' ];
+    const notImplementedMethods = tool.getMissingMethods(inlineToolRequiredMethods);
+
+    if (notImplementedMethods.length) {
+      _.log(
+        `Incorrect Inline Tool: ${tool.name}. Some of required methods is not implemented %o`,
+        'warn',
+        notImplementedMethods
+      );
+
+      this.toolsUnavailable.set(tool.name, tool);
+
+      return;
     }
 
     this.toolsAvailable.set(tool.name, tool);
@@ -254,7 +332,9 @@ export default class Tools extends Module {
    * @param {object} data - append tool to unavailable list
    */
   private toolPrepareMethodFallback(data: { toolName: string }): void {
-    this.toolsUnavailable.set(data.toolName, this.factory.get(data.toolName));
+    const factory = this.getFactory();
+
+    this.toolsUnavailable.set(data.toolName, factory.get(data.toolName));
   }
 
   /**
@@ -263,29 +343,36 @@ export default class Tools extends Module {
    * @returns {Array} list of functions that needs to be fired sequentially
    * @param config - tools config
    */
-  private getListOfPrepareFunctions(config: {[name: string]: ToolSettings}): {
-    function: (data: { toolName: string; config: ToolConfig }) => void | Promise<void>;
-    data: { toolName: string; config: ToolConfig };
-  }[] {
-    const toolPreparationList: {
-      function: (data: { toolName: string }) => void | Promise<void>;
-      data: { toolName: string; config: ToolConfig };
-    }[] = [];
-
-    Object
+  private getListOfPrepareFunctions(config: Record<string, ToolSettings>): ChainData[] {
+    return Object
       .entries(config)
-      .forEach(([toolName, settings]) => {
-        toolPreparationList.push({
-          // eslint-disable-next-line @typescript-eslint/no-empty-function
-          function: _.isFunction(settings.class.prepare) ? settings.class.prepare : (): void => {},
-          data: {
-            toolName,
-            config: settings.config,
-          },
-        });
+      .map(([toolName, settings]): ChainData => {
+        const toolData: ToolPrepareData = {
+          toolName,
+          config: (settings.config ?? {}) as ToolConfig,
+        };
+
+        const prepareFunction: ChainData['function'] = async (payload?: unknown) => {
+          const constructable = settings.class;
+
+          if (!constructable || !_.isFunction(constructable.prepare)) {
+            return;
+          }
+
+          const data = (payload ?? toolData) as ToolPrepareData;
+          const prepareMethod = constructable.prepare as unknown as (
+            this: typeof constructable,
+            payload: ToolPrepareData
+          ) => void | Promise<void>;
+
+          return prepareMethod.call(constructable, data);
+        };
+
+        return {
+          function: prepareFunction,
+          data: toolData,
+        };
       });
-
-    return toolPreparationList;
   }
 
   /**
@@ -304,6 +391,8 @@ export default class Tools extends Module {
    * @param tool - Block Tool
    */
   private assignInlineToolsToBlockTool(tool: BlockToolAdapter): void {
+    const blockTool = tool;
+
     /**
      * If common inlineToolbar property is false no Inline Tools should be assigned
      */
@@ -316,15 +405,15 @@ export default class Tools extends Module {
      * - if common settings is an array, use it
      * - if common settings is 'true' or not specified, get default order
      */
-    if (tool.enabledInlineTools === true) {
-      tool.inlineTools = new ToolsCollection<InlineToolAdapter>(
-        Array.isArray(this.config.inlineToolbar)
-          ? this.config.inlineToolbar.map(name => [name, this.inlineTools.get(name)])
-          /**
-           * If common settings is 'true' or not specified (will be set as true at core.ts), get the default order
-           */
-          : Array.from(this.inlineTools.entries())
-      );
+    if (blockTool.enabledInlineTools === true) {
+      const inlineTools = Array.isArray(this.config.inlineToolbar)
+        ? this.createInlineToolsCollection(this.config.inlineToolbar)
+        /**
+         * If common settings is 'true' or not specified (will be set as true at core.ts), get the default order
+         */
+        : new ToolsCollection<InlineToolAdapter>(Array.from(this.inlineTools.entries()));
+
+      blockTool.inlineTools = inlineTools;
 
       return;
     }
@@ -332,11 +421,11 @@ export default class Tools extends Module {
     /**
      * If user pass the list of inline tools for the particular tool, return it.
      */
-    if (Array.isArray(tool.enabledInlineTools)) {
-      tool.inlineTools = new ToolsCollection<InlineToolAdapter>(
-        /** Prepend ConvertTo Inline Tool */
-        ['convertTo', ...tool.enabledInlineTools].map(name => [name, this.inlineTools.get(name)])
-      );
+    if (Array.isArray(blockTool.enabledInlineTools)) {
+      /** Prepend ConvertTo Inline Tool */
+      const inlineTools = this.createInlineToolsCollection(['convertTo', ...blockTool.enabledInlineTools]);
+
+      blockTool.inlineTools = inlineTools;
     }
   }
 
@@ -346,78 +435,179 @@ export default class Tools extends Module {
    * @param tool — Block Tool
    */
   private assignBlockTunesToBlockTool(tool: BlockToolAdapter): void {
-    if (tool.enabledBlockTunes === false) {
+    const blockTool = tool;
+
+    if (blockTool.enabledBlockTunes === false) {
       return;
     }
 
-    if (Array.isArray(tool.enabledBlockTunes)) {
-      const userTunes = new ToolsCollection<BlockTuneAdapter>(
-        tool.enabledBlockTunes.map(name => [name, this.blockTunes.get(name)])
-      );
+    if (Array.isArray(blockTool.enabledBlockTunes)) {
+      const userTunes = this.createBlockTunesCollection(blockTool.enabledBlockTunes);
+      const combinedEntries = [
+        ...Array.from(userTunes.entries()),
+        ...Array.from(this.blockTunes.internalTools.entries()),
+      ];
 
-      tool.tunes = new ToolsCollection<BlockTuneAdapter>([...userTunes, ...this.blockTunes.internalTools]);
+      blockTool.tunes = new ToolsCollection<BlockTuneAdapter>(combinedEntries);
 
       return;
     }
 
     if (Array.isArray(this.config.tunes)) {
-      const userTunes = new ToolsCollection<BlockTuneAdapter>(
-        this.config.tunes.map(name => [name, this.blockTunes.get(name)])
-      );
+      const userTunes = this.createBlockTunesCollection(this.config.tunes);
+      const combinedEntries = [
+        ...Array.from(userTunes.entries()),
+        ...Array.from(this.blockTunes.internalTools.entries()),
+      ];
 
-      tool.tunes = new ToolsCollection<BlockTuneAdapter>([...userTunes, ...this.blockTunes.internalTools]);
+      blockTool.tunes = new ToolsCollection<BlockTuneAdapter>(combinedEntries);
 
       return;
     }
 
-    tool.tunes = this.blockTunes.internalTools;
+    blockTool.tunes = new ToolsCollection<BlockTuneAdapter>(
+      Array.from(this.blockTunes.internalTools.entries())
+    );
   }
 
   /**
    * Validate Tools configuration objects and throw Error for user if it is invalid
    */
   private validateTools(): void {
+    const toolsConfig = this.config.tools;
+
+    if (!toolsConfig) {
+      return;
+    }
+
+    const internalTools = this.internalTools;
+
     /**
      * Check Tools for a class containing
      */
-    for (const toolName in this.config.tools) {
-      if (Object.prototype.hasOwnProperty.call(this.config.tools, toolName)) {
-        if (toolName in this.internalTools) {
-          return;
-        }
+    for (const toolName in toolsConfig) {
+      if (!Object.prototype.hasOwnProperty.call(toolsConfig, toolName)) {
+        continue;
+      }
 
-        const tool = this.config.tools[toolName];
+      if (toolName in internalTools) {
+        continue;
+      }
 
-        if (!_.isFunction(tool) && !_.isFunction((tool as ToolSettings).class)) {
-          throw Error(
-            `Tool «${toolName}» must be a constructor function or an object with function in the «class» property`
-          );
-        }
+      const tool = toolsConfig[toolName];
+      const isConstructorFunction = _.isFunction(tool);
+      const toolSettings = tool as ToolSettings;
+      const hasToolClass = _.isFunction(toolSettings.class);
+
+      if (!isConstructorFunction && !hasToolClass) {
+        throw Error(
+          `Tool «${toolName}» must be a constructor function or an object with function in the «class» property`
+        );
       }
     }
   }
 
   /**
    * Unify tools config
+   *
+   * @param toolsConfig - raw tools configuration
    */
-  private prepareConfig(): {[name: string]: ToolSettings} {
-    const config: {[name: string]: ToolSettings} = {};
+  private prepareConfig(toolsConfig: Record<string, ToolConstructable | ToolSettings>): Record<string, ToolSettings> {
+    const config: Record<string, ToolSettings> = {};
 
     /**
      * Save Tools settings to a map
      */
-    for (const toolName in this.config.tools) {
+    for (const toolName in toolsConfig) {
       /**
        * If Tool is an object not a Tool's class then
        * save class and settings separately
        */
-      if (_.isObject(this.config.tools[toolName])) {
-        config[toolName] = this.config.tools[toolName] as ToolSettings;
-      } else {
-        config[toolName] = { class: this.config.tools[toolName] as ToolConstructable };
+      if (!Object.prototype.hasOwnProperty.call(toolsConfig, toolName)) {
+        continue;
       }
+
+      const tool = toolsConfig[toolName];
+
+      if (_.isObject(tool)) {
+        config[toolName] = tool as ToolSettings;
+
+        continue;
+      }
+
+      config[toolName] = { class: tool as ToolConstructable };
     }
 
     return config;
   }
+
+  /**
+   * Type guard that ensures provided data contains tool preparation metadata.
+   *
+   * @param data - data passed to prepare sequence callbacks
+   */
+  private isToolPrepareData(data: object): data is ToolPrepareData {
+    const candidate = data as Partial<ToolPrepareData>;
+
+    return typeof candidate?.toolName === 'string';
+  }
+
+  /**
+   * Returns initialized tools factory instance.
+   *
+   * @returns tools factory
+   */
+  private getFactory(): ToolsFactory {
+    if (this.factory === null) {
+      throw new Error('Tools factory is not initialized');
+    }
+
+    return this.factory;
+  }
+
+  /**
+   * Builds inline tools collection for provided tool names, skipping unavailable ones.
+   *
+   * @param toolNames - inline tool names to include
+   * @returns tools collection containing available inline tools
+   */
+  private createInlineToolsCollection(toolNames: Iterable<string>): ToolsCollection<InlineToolAdapter> {
+    const entries: [string, InlineToolAdapter][] = [];
+
+    for (const name of toolNames) {
+      const inlineTool = this.inlineTools.get(name);
+
+      if (!inlineTool) {
+        _.log(`Inline tool "${name}" is not available and will be skipped`, 'warn');
+        continue;
+      }
+
+      entries.push([name, inlineTool]);
+    }
+
+    return new ToolsCollection<InlineToolAdapter>(entries);
+  }
+
+  /**
+   * Builds block tunes collection for provided tune names, skipping unavailable ones.
+   *
+   * @param tuneNames - block tune names to include
+   * @returns tools collection containing available block tunes
+   */
+  private createBlockTunesCollection(tuneNames: Iterable<string>): ToolsCollection<BlockTuneAdapter> {
+    const entries: [string, BlockTuneAdapter][] = [];
+
+    for (const name of tuneNames) {
+      const tune = this.blockTunes.get(name);
+
+      if (!tune) {
+        _.log(`Block tune "${name}" is not available and will be skipped`, 'warn');
+        continue;
+      }
+
+      entries.push([name, tune]);
+    }
+
+    return new ToolsCollection<BlockTuneAdapter>(entries);
+  }
 }
diff --git a/src/components/modules/ui.ts b/src/components/modules/ui.ts
index a4d3baad3..221c06abc 100644
--- a/src/components/modules/ui.ts
+++ b/src/components/modules/ui.ts
@@ -15,7 +15,7 @@ import { mobileScreenBreakpoint } from '../utils';
 
 import styles from '../../styles/main.css?inline';
 import { BlockHovered } from '../events/BlockHovered';
-import { selectionChangeDebounceTimeout } from '../constants';
+import { DATA_INTERFACE_ATTRIBUTE, EDITOR_INTERFACE_VALUE, selectionChangeDebounceTimeout } from '../constants';
 import { EditorMobileLayoutToggled } from '../events';
 /**
  * HTML Elements used for UI
@@ -158,25 +158,40 @@ export default class UI extends Module<UINodes> {
     /**
      * Prepare components based on read-only state
      */
-    if (!readOnlyEnabled) {
-      /**
-       * Postpone events binding to the next tick to make sure all ui elements are ready
-       */
-      window.requestIdleCallback(() => {
-        /**
-         * Bind events for the UI elements
-         */
-        this.bindReadOnlySensitiveListeners();
-      }, {
-        timeout: 2000,
-      });
-    } else {
+    if (readOnlyEnabled) {
       /**
        * Unbind all events
        *
        */
       this.unbindReadOnlySensitiveListeners();
+
+      return;
+    }
+
+    const bindListeners = (): void => {
+      /**
+       * Bind events for the UI elements
+       */
+      this.bindReadOnlySensitiveListeners();
+    };
+
+    /**
+     * Ensure listeners are attached immediately for interactive use.
+     */
+    bindListeners();
+
+    const idleCallback = window.requestIdleCallback;
+
+    if (typeof idleCallback !== 'function') {
+      return;
     }
+
+    /**
+     * Re-bind on idle to preserve historical behavior when additional nodes appear later.
+     */
+    idleCallback(bindListeners, {
+      timeout: 2000,
+    });
   }
 
   /**
@@ -279,7 +294,13 @@ export default class UI extends Module<UINodes> {
      *
      * @type {Element}
      */
-    this.nodes.holder = $.getHolder(this.config.holder);
+    const holder = this.config.holder;
+
+    if (!holder) {
+      throw new Error('Editor holder is not specified in the configuration.');
+    }
+
+    this.nodes.holder = $.getHolder(holder);
 
     /**
      * Create and save main UI elements
@@ -288,6 +309,7 @@ export default class UI extends Module<UINodes> {
       this.CSS.editorWrapper,
       ...(this.isRtl ? [ this.CSS.editorRtlFix ] : []),
     ]);
+    this.nodes.wrapper.setAttribute(DATA_INTERFACE_ATTRIBUTE, EDITOR_INTERFACE_VALUE);
     this.nodes.redactor = $.make('div', this.CSS.editorZone);
 
     /**
@@ -386,16 +408,22 @@ export default class UI extends Module<UINodes> {
    * Adds listeners that should work only in read-only mode
    */
   private bindReadOnlySensitiveListeners(): void {
-    this.readOnlyMutableListeners.on(this.nodes.redactor, 'click', (event: MouseEvent) => {
-      this.redactorClicked(event);
+    this.readOnlyMutableListeners.on(this.nodes.redactor, 'click', (event: Event) => {
+      if (event instanceof MouseEvent) {
+        this.redactorClicked(event);
+      }
     }, false);
 
-    this.readOnlyMutableListeners.on(document, 'keydown', (event: KeyboardEvent) => {
-      this.documentKeydown(event);
+    this.readOnlyMutableListeners.on(document, 'keydown', (event: Event) => {
+      if (event instanceof KeyboardEvent) {
+        this.documentKeydown(event);
+      }
     }, true);
 
-    this.readOnlyMutableListeners.on(document, 'mousedown', (event: MouseEvent) => {
-      this.documentClicked(event);
+    this.readOnlyMutableListeners.on(document, 'mousedown', (event: Event) => {
+      if (event instanceof MouseEvent) {
+        this.documentClicked(event);
+      }
     }, true);
 
     /**
@@ -418,10 +446,16 @@ export default class UI extends Module<UINodes> {
     /**
      * Used to not emit the same block multiple times to the 'block-hovered' event on every mousemove
      */
-    let blockHoveredEmitted;
+    const blockHoveredState: { lastHovered: Element | null } = {
+      lastHovered: null,
+    };
+
+    const handleBlockHovered = (event: Event): void => {
+      if (!(event instanceof MouseEvent) && !(event instanceof TouchEvent)) {
+        return;
+      }
 
-    this.readOnlyMutableListeners.on(this.nodes.redactor, 'mousemove', _.throttle((event: MouseEvent | TouchEvent) => {
-      const hoveredBlock = (event.target as Element).closest('.ce-block');
+      const hoveredBlock = (event.target as Element | null)?.closest('.ce-block');
 
       /**
        * Do not trigger 'block-hovered' for cross-block selection
@@ -434,17 +468,32 @@ export default class UI extends Module<UINodes> {
         return;
       }
 
-      if (blockHoveredEmitted === hoveredBlock) {
+      if (blockHoveredState.lastHovered === hoveredBlock) {
         return;
       }
 
-      blockHoveredEmitted = hoveredBlock;
+      blockHoveredState.lastHovered = hoveredBlock;
+
+      const block = this.Editor.BlockManager.getBlockByChildNode(hoveredBlock);
+
+      if (!block) {
+        return;
+      }
 
       this.eventsDispatcher.emit(BlockHovered, {
-        block: this.Editor.BlockManager.getBlockByChildNode(hoveredBlock),
+        block,
       });
-    // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-    }, 20), {
+    };
+
+    const throttledHandleBlockHovered = _.throttle(
+      handleBlockHovered as (...args: unknown[]) => unknown,
+      // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+      20
+    );
+
+    this.readOnlyMutableListeners.on(this.nodes.redactor, 'mousemove', (event: Event) => {
+      throttledHandleBlockHovered(event);
+    }, {
       passive: true,
     });
   }
@@ -477,17 +526,19 @@ export default class UI extends Module<UINodes> {
    * @param {KeyboardEvent} event - keyboard event
    */
   private documentKeydown(event: KeyboardEvent): void {
-    switch (event.keyCode) {
-      case _.keyCodes.ENTER:
+    const key = event.key ?? '';
+
+    switch (key) {
+      case 'Enter':
         this.enterPressed(event);
         break;
 
-      case _.keyCodes.BACKSPACE:
-      case _.keyCodes.DELETE:
+      case 'Backspace':
+      case 'Delete':
         this.backspacePressed(event);
         break;
 
-      case _.keyCodes.ESC:
+      case 'Escape':
         this.escapePressed(event);
         break;
 
@@ -540,29 +591,40 @@ export default class UI extends Module<UINodes> {
   private backspacePressed(event: KeyboardEvent): void {
     const { BlockManager, BlockSelection, Caret } = this.Editor;
 
+    const selectionExists = Selection.isSelectionExists;
+    const selectionCollapsed = Selection.isCollapsed;
+
     /**
      * If any block selected and selection doesn't exists on the page (that means no other editable element is focused),
      * remove selected blocks
      */
-    if (BlockSelection.anyBlockSelected && !Selection.isSelectionExists) {
-      const selectionPositionIndex = BlockManager.removeSelectedBlocks();
+    const shouldRemoveSelection = BlockSelection.anyBlockSelected && (!selectionExists || selectionCollapsed === true);
 
-      const newBlock = BlockManager.insertDefaultBlockAtIndex(selectionPositionIndex, true);
+    if (!shouldRemoveSelection) {
+      return;
+    }
 
-      Caret.setToBlock(newBlock, Caret.positions.START);
+    const selectionPositionIndex = BlockManager.removeSelectedBlocks();
 
-      /** Clear selection */
-      BlockSelection.clearSelection(event);
-
-      /**
-       * Stop propagations
-       * Manipulation with BlockSelections is handled in global backspacePress because they may occur
-       * with CMD+A or RectangleSelection and they can be handled on document event
-       */
-      event.preventDefault();
-      event.stopPropagation();
-      event.stopImmediatePropagation();
+    if (selectionPositionIndex === undefined) {
+      return;
     }
+
+    const newBlock = BlockManager.insertDefaultBlockAtIndex(selectionPositionIndex, true);
+
+    Caret.setToBlock(newBlock, Caret.positions.START);
+
+    /** Clear selection */
+    BlockSelection.clearSelection(event);
+
+    /**
+     * Stop propagations
+     * Manipulation with BlockSelections is handled in global backspacePress because they may occur
+     * with CMD+A or RectangleSelection and they can be handled on document event
+     */
+    event.preventDefault();
+    event.stopPropagation();
+    event.stopImmediatePropagation();
   }
 
   /**
@@ -571,7 +633,7 @@ export default class UI extends Module<UINodes> {
    *
    * @param {Event} event - escape keydown event
    */
-  private escapePressed(event): void {
+  private escapePressed(event: KeyboardEvent): void {
     /**
      * Clear blocks selection by ESC
      */
@@ -579,14 +641,25 @@ export default class UI extends Module<UINodes> {
 
     if (this.Editor.Toolbar.toolbox.opened) {
       this.Editor.Toolbar.toolbox.close();
-      this.Editor.Caret.setToBlock(this.Editor.BlockManager.currentBlock, this.Editor.Caret.positions.END);
-    } else if (this.Editor.BlockSettings.opened) {
+      this.Editor.BlockManager.currentBlock &&
+        this.Editor.Caret.setToBlock(this.Editor.BlockManager.currentBlock, this.Editor.Caret.positions.END);
+
+      return;
+    }
+
+    if (this.Editor.BlockSettings.opened) {
       this.Editor.BlockSettings.close();
-    } else if (this.Editor.InlineToolbar.opened) {
+
+      return;
+    }
+
+    if (this.Editor.InlineToolbar.opened) {
       this.Editor.InlineToolbar.close();
-    } else {
-      this.Editor.Toolbar.close();
+
+      return;
     }
+
+    this.Editor.Toolbar.close();
   }
 
   /**
@@ -603,11 +676,14 @@ export default class UI extends Module<UINodes> {
 
     const hasPointerToBlock = BlockManager.currentBlockIndex >= 0;
 
+    const selectionExists = Selection.isSelectionExists;
+    const selectionCollapsed = Selection.isCollapsed;
+
     /**
      * If any block selected and selection doesn't exists on the page (that means no other editable element is focused),
      * remove selected blocks
      */
-    if (BlockSelection.anyBlockSelected && !Selection.isSelectionExists) {
+    if (BlockSelection.anyBlockSelected && (!selectionExists || selectionCollapsed === true)) {
       /** Clear selection */
       BlockSelection.clearSelection(event);
 
@@ -670,8 +746,13 @@ export default class UI extends Module<UINodes> {
      */
     const target = event.target as HTMLElement;
     const clickedInsideOfEditor = this.nodes.holder.contains(target) || Selection.isAtEditor;
+    const clickedInsideRedactor = this.nodes.redactor.contains(target);
+    const clickedInsideToolbar = this.Editor.Toolbar.nodes.wrapper?.contains(target) ?? false;
+    const clickedInsideEditorSurface = clickedInsideOfEditor || clickedInsideToolbar;
 
-    if (!clickedInsideOfEditor) {
+    const shouldClearCurrentBlock = !clickedInsideEditorSurface || (!clickedInsideRedactor && !clickedInsideToolbar);
+
+    if (shouldClearCurrentBlock) {
       /**
        * Clear pointer on BlockManager
        *
@@ -692,9 +773,13 @@ export default class UI extends Module<UINodes> {
     const isClickedInsideBlockSettingsToggler = this.Editor.Toolbar.nodes.settingsToggler?.contains(target);
     const doNotProcess = isClickedInsideBlockSettings || isClickedInsideBlockSettingsToggler;
 
-    if (this.Editor.BlockSettings.opened && !doNotProcess) {
+    const shouldCloseBlockSettings = this.Editor.BlockSettings.opened && !doNotProcess;
+
+    if (shouldCloseBlockSettings) {
       this.Editor.BlockSettings.close();
+    }
 
+    if (shouldCloseBlockSettings && clickedInsideRedactor) {
       const clickedBlock = this.Editor.BlockManager.getBlockByChildNode(target);
 
       this.Editor.Toolbar.moveAndOpen(clickedBlock);
@@ -718,17 +803,31 @@ export default class UI extends Module<UINodes> {
    * @param event - touch or mouse event
    */
   private documentTouched(event: Event): void {
-    let clickedNode = event.target as HTMLElement;
+    const initialTarget = event.target as HTMLElement;
 
     /**
      * If click was fired on Editor`s wrapper, try to get clicked node by elementFromPoint method
      */
-    if (clickedNode === this.nodes.redactor) {
-      const clientX = event instanceof MouseEvent ? event.clientX : (event as TouchEvent).touches[0].clientX;
-      const clientY = event instanceof MouseEvent ? event.clientY : (event as TouchEvent).touches[0].clientY;
+    const clickedNode = (() => {
+      if (initialTarget !== this.nodes.redactor) {
+        return initialTarget;
+      }
 
-      clickedNode = document.elementFromPoint(clientX, clientY) as HTMLElement;
-    }
+      if (event instanceof MouseEvent) {
+        const nodeFromPoint = document.elementFromPoint(event.clientX, event.clientY) as HTMLElement | null;
+
+        return nodeFromPoint ?? initialTarget;
+      }
+
+      if (event instanceof TouchEvent && event.touches.length > 0) {
+        const { clientX, clientY } = event.touches[0];
+        const nodeFromPoint = document.elementFromPoint(clientX, clientY) as HTMLElement | null;
+
+        return nodeFromPoint ?? initialTarget;
+      }
+
+      return initialTarget;
+    })();
 
     /**
      * Select clicked Block as Current
@@ -773,20 +872,26 @@ export default class UI extends Module<UINodes> {
      */
     const element = event.target as Element;
     const ctrlKey = event.metaKey || event.ctrlKey;
+    const shouldOpenAnchorInNewTab = $.isAnchor(element) && ctrlKey;
 
-    if ($.isAnchor(element) && ctrlKey) {
-      event.stopImmediatePropagation();
-      event.stopPropagation();
+    if (!shouldOpenAnchorInNewTab) {
+      this.processBottomZoneClick(event);
 
-      const href = element.getAttribute('href');
-      const validUrl = _.getValidUrl(href);
+      return;
+    }
 
-      _.openTab(validUrl);
+    event.stopImmediatePropagation();
+    event.stopPropagation();
 
+    const href = element.getAttribute('href');
+
+    if (!href) {
       return;
     }
 
-    this.processBottomZoneClick(event);
+    const validUrl = _.getValidUrl(href);
+
+    _.openTab(validUrl);
   }
 
   /**
@@ -814,28 +919,30 @@ export default class UI extends Module<UINodes> {
        */
       lastBlockBottomCoord < clickedCoord;
 
-    if (isClickedBottom) {
-      event.stopImmediatePropagation();
-      event.stopPropagation();
+    if (!isClickedBottom) {
+      return;
+    }
 
-      const { BlockManager, Caret, Toolbar } = this.Editor;
+    event.stopImmediatePropagation();
+    event.stopPropagation();
 
-      /**
-       * Insert a default-block at the bottom if:
-       * - last-block is not a default-block (Text)
-       *   to prevent unnecessary tree-walking on Tools with many nodes (for ex. Table)
-       * - Or, default-block is not empty
-       */
-      if (!BlockManager.lastBlock.tool.isDefault || !BlockManager.lastBlock.isEmpty) {
-        BlockManager.insertAtEnd();
-      }
+    const { BlockManager, Caret, Toolbar } = this.Editor;
 
-      /**
-       * Set the caret and toolbar to empty Block
-       */
-      Caret.setToTheLastBlock();
-      Toolbar.moveAndOpen(BlockManager.lastBlock);
+    /**
+     * Insert a default-block at the bottom if:
+     * - last-block is not a default-block (Text)
+     *   to prevent unnecessary tree-walking on Tools with many nodes (for ex. Table)
+     * - Or, default-block is not empty
+     */
+    if (!BlockManager.lastBlock?.tool.isDefault || !BlockManager.lastBlock?.isEmpty) {
+      BlockManager.insertAtEnd();
     }
+
+    /**
+     * Set the caret and toolbar to empty Block
+     */
+    Caret.setToTheLastBlock();
+    Toolbar.moveAndOpen(BlockManager.lastBlock);
   }
 
   /**
@@ -846,26 +953,24 @@ export default class UI extends Module<UINodes> {
     const { CrossBlockSelection, BlockSelection } = this.Editor;
     const focusedElement = Selection.anchorElement;
 
-    if (CrossBlockSelection.isCrossBlockSelectionStarted) {
+    if (CrossBlockSelection.isCrossBlockSelectionStarted && BlockSelection.anyBlockSelected) {
       // Removes all ranges when any Block is selected
-      if (BlockSelection.anyBlockSelected) {
-        Selection.get().removeAllRanges();
-      }
+      Selection.get()?.removeAllRanges();
     }
 
     /**
      * Usual clicks on some controls, for example, Block Tunes Toggler
      */
-    if (!focusedElement) {
+    if (!focusedElement && !Selection.range) {
       /**
        * If there is no selected range, close inline toolbar
        *
        * @todo Make this method more straightforward
        */
-      if (!Selection.range) {
-        this.Editor.InlineToolbar.close();
-      }
+      this.Editor.InlineToolbar.close();
+    }
 
+    if (!focusedElement) {
       return;
     }
 
@@ -877,24 +982,23 @@ export default class UI extends Module<UINodes> {
     const closestBlock = focusedElement.closest(`.${Block.CSS.content}`);
     const clickedOutsideBlockContent = closestBlock === null || (closestBlock.closest(`.${Selection.CSS.editorWrapper}`) !== this.nodes.wrapper);
 
-    if (clickedOutsideBlockContent) {
+    const inlineToolbarEnabledForExternalTool = (focusedElement as HTMLElement).dataset.inlineToolbar === 'true';
+    const shouldCloseInlineToolbar = clickedOutsideBlockContent && !this.Editor.InlineToolbar.containsNode(focusedElement);
+
+    if (shouldCloseInlineToolbar) {
       /**
        * If new selection is not on Inline Toolbar, we need to close it
        */
-      if (!this.Editor.InlineToolbar.containsNode(focusedElement)) {
-        this.Editor.InlineToolbar.close();
-      }
+      this.Editor.InlineToolbar.close();
+    }
 
+    if (clickedOutsideBlockContent && !inlineToolbarEnabledForExternalTool) {
       /**
        * Case when we click on external tool elements,
        * for example some Block Tune element.
        * If this external content editable element has data-inline-toolbar="true"
        */
-      const inlineToolbarEnabledForExternalTool = (focusedElement as HTMLElement).dataset.inlineToolbar === 'true';
-
-      if (!inlineToolbarEnabledForExternalTool) {
-        return;
-      }
+      return;
     }
 
     /**
@@ -904,7 +1008,7 @@ export default class UI extends Module<UINodes> {
       this.Editor.BlockManager.setCurrentBlockByChildNode(focusedElement);
     }
 
-    this.Editor.InlineToolbar.tryToShow(true);
+    void this.Editor.InlineToolbar.tryToShow(true);
   }
 
   /**
@@ -920,11 +1024,11 @@ export default class UI extends Module<UINodes> {
      *
      * @param event - input or focus event
      */
-    function handleInputOrFocusChange(event: Event): void {
+    const handleInputOrFocusChange = (event: Event): void => {
       const input = event.target as HTMLElement;
 
       toggleEmptyMark(input);
-    }
+    };
 
     this.readOnlyMutableListeners.on(this.nodes.wrapper, 'input', handleInputOrFocusChange);
     this.readOnlyMutableListeners.on(this.nodes.wrapper, 'focusin', handleInputOrFocusChange);
diff --git a/src/components/polyfills.ts b/src/components/polyfills.ts
index 20cb0cdba..f07badb33 100644
--- a/src/components/polyfills.ts
+++ b/src/components/polyfills.ts
@@ -1,162 +1,116 @@
 'use strict';
 
-/**
- * Extend Element interface to include prefixed and experimental properties
- */
-interface Element {
-  matchesSelector: (selector: string) => boolean;
-  mozMatchesSelector: (selector: string) => boolean;
-  msMatchesSelector: (selector: string) => boolean;
-  oMatchesSelector: (selector: string) => boolean;
-
-  prepend: (...nodes: Array<string | Node>) => void;
-  append: (...nodes: Array<string | Node>) => void;
+declare global {
+  interface Element {
+    /**
+     * Scrolls the current element into the visible area of the browser window
+     *
+     * @param centerIfNeeded - true, if the element should be aligned so it is centered within the visible area of the scrollable ancestor.
+     */
+    scrollIntoViewIfNeeded(centerIfNeeded?: boolean): void;
+  }
 }
 
 /**
- * The Element.matches() method returns true if the element
- * would be selected by the specified selector string;
- * otherwise, returns false.
+ * ScrollIntoViewIfNeeded polyfill by KilianSSL (forked from hsablonniere)
  *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Element/matches#Polyfill}
- * @param {string} s - selector
+ * @see {@link https://gist.github.com/KilianSSL/774297b76378566588f02538631c3137}
+ * @param centerIfNeeded - true, if the element should be aligned so it is centered within the visible area of the scrollable ancestor.
  */
-if (!Element.prototype.matches) {
-  Element.prototype.matches = Element.prototype.matchesSelector ||
-    Element.prototype.mozMatchesSelector ||
-    Element.prototype.msMatchesSelector ||
-    Element.prototype.oMatchesSelector ||
-    Element.prototype.webkitMatchesSelector ||
-    function (s): boolean {
-      const matches = (this.document || this.ownerDocument).querySelectorAll(s);
-      let i = matches.length;
-
-      while (--i >= 0 && matches.item(i) !== this) {
-      }
+if (typeof Element.prototype.scrollIntoViewIfNeeded === 'undefined') {
+  Element.prototype.scrollIntoViewIfNeeded = function (this: HTMLElement, centerIfNeeded): void {
+    const shouldCenter = centerIfNeeded ?? true;
 
-      return i > -1;
-    };
-}
+    const parent = this.parentElement;
 
-/**
- * The Element.closest() method returns the closest ancestor
- * of the current element (or the current element itself) which
- * matches the selectors given in parameter.
- * If there isn't such an ancestor, it returns null.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Element/closest#Polyfill}
- * @param {string} s - selector
- */
-if (!Element.prototype.closest) {
-  Element.prototype.closest = function (s): Element | null {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    let el = this;
-
-    if (!document.documentElement.contains(el)) {
-      return null;
+    if (!parent) {
+      return;
     }
 
-    do {
-      if (el.matches(s)) {
-        return el;
-      }
+    const parentComputedStyle = window.getComputedStyle(parent, null);
+    const parentBorderTopWidth = parseInt(parentComputedStyle.getPropertyValue('border-top-width'));
+    const parentBorderLeftWidth = parseInt(parentComputedStyle.getPropertyValue('border-left-width'));
+    const overTop = this.offsetTop - parent.offsetTop < parent.scrollTop;
+    const overBottom = (this.offsetTop - parent.offsetTop + this.clientHeight - parentBorderTopWidth) > (parent.scrollTop + parent.clientHeight);
+    const overLeft = this.offsetLeft - parent.offsetLeft < parent.scrollLeft;
+    const overRight = (this.offsetLeft - parent.offsetLeft + this.clientWidth - parentBorderLeftWidth) > (parent.scrollLeft + parent.clientWidth);
+    const alignWithTop = overTop && !overBottom;
+
+    if ((overTop || overBottom) && shouldCenter) {
+      parent.scrollTop = this.offsetTop - parent.offsetTop - parent.clientHeight / 2 - parentBorderTopWidth + this.clientHeight / 2;
+    }
 
-      el = el.parentElement || el.parentNode;
-    } while (el !== null);
+    if ((overLeft || overRight) && shouldCenter) {
+      parent.scrollLeft = this.offsetLeft - parent.offsetLeft - parent.clientWidth / 2 - parentBorderLeftWidth + this.clientWidth / 2;
+    }
 
-    return null;
+    if ((overTop || overBottom || overLeft || overRight) && !shouldCenter) {
+      this.scrollIntoView(alignWithTop);
+    }
   };
 }
 
 /**
- * The ParentNode.prepend method inserts a set of Node objects
- * or DOMString objects before the first child of the ParentNode.
- * DOMString objects are inserted as equivalent Text nodes.
+ * RequestIdleCallback polyfill (shims)
  *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/ParentNode/prepend#Polyfill}
- * @param {Node | Node[] | string | string[]} nodes - nodes to prepend
+ * @see https://developer.chrome.com/blog/using-requestidlecallback/
+ * @param cb - callback to be executed when the browser is idle
  */
-if (!Element.prototype.prepend) {
-  Element.prototype.prepend = function prepend(nodes: Array<Node | string> | Node | string): void {
-    const docFrag = document.createDocumentFragment();
+type TimeoutHandle = ReturnType<typeof globalThis.setTimeout>;
+const nativeSetTimeout = globalThis.setTimeout.bind(globalThis);
+const nativeClearTimeout = globalThis.clearTimeout.bind(globalThis);
 
-    if (!Array.isArray(nodes)) {
-      nodes = [ nodes ];
-    }
+const idleCallbackTimeouts = new Map<number, TimeoutHandle>();
 
-    nodes.forEach((node: Node | string) => {
-      const isNode = node instanceof Node;
+const resolveNumericHandle = (handle: TimeoutHandle): number => {
+  const numericHandle = Number(handle);
 
-      docFrag.appendChild(isNode ? node as Node : document.createTextNode(node as string));
-    });
+  if (Number.isFinite(numericHandle) && numericHandle > 0) {
+    return numericHandle;
+  }
 
-    this.insertBefore(docFrag, this.firstChild);
-  };
-}
+  return Date.now();
+};
 
-interface Element {
-  /**
-   * Scrolls the current element into the visible area of the browser window
-   *
-   * @param centerIfNeeded - true, if the element should be aligned so it is centered within the visible area of the scrollable ancestor.
-   */
-  scrollIntoViewIfNeeded(centerIfNeeded?: boolean): void;
+if (typeof window.requestIdleCallback === 'undefined') {
+  window.requestIdleCallback = function (cb) {
+    const start = Date.now();
+    const handleRef: { value?: number } = {};
+    const timeoutHandle = nativeSetTimeout(() => {
+      const handle = handleRef.value;
+
+      if (typeof handle === 'number') {
+        idleCallbackTimeouts.delete(handle);
+      }
+
+      cb({
+        didTimeout: false,
+        timeRemaining: function () {
+          // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+          return Math.max(0, 50 - (Date.now() - start));
+        },
+      });
+    }, 1);
+    const numericHandle = resolveNumericHandle(timeoutHandle);
+
+    handleRef.value = numericHandle;
+    idleCallbackTimeouts.set(numericHandle, timeoutHandle);
+
+    return numericHandle;
+  };
 }
 
-/**
- * ScrollIntoViewIfNeeded polyfill by KilianSSL (forked from hsablonniere)
- *
- * @see {@link https://gist.github.com/KilianSSL/774297b76378566588f02538631c3137}
- * @param centerIfNeeded - true, if the element should be aligned so it is centered within the visible area of the scrollable ancestor.
- */
-if (!Element.prototype.scrollIntoViewIfNeeded) {
-  Element.prototype.scrollIntoViewIfNeeded = function (centerIfNeeded): void {
-    centerIfNeeded = arguments.length === 0 ? true : !!centerIfNeeded;
-
-    const parent = this.parentNode,
-        parentComputedStyle = window.getComputedStyle(parent, null),
-        parentBorderTopWidth = parseInt(parentComputedStyle.getPropertyValue('border-top-width')),
-        parentBorderLeftWidth = parseInt(parentComputedStyle.getPropertyValue('border-left-width')),
-        overTop = this.offsetTop - parent.offsetTop < parent.scrollTop,
-        overBottom = (this.offsetTop - parent.offsetTop + this.clientHeight - parentBorderTopWidth) > (parent.scrollTop + parent.clientHeight),
-        overLeft = this.offsetLeft - parent.offsetLeft < parent.scrollLeft,
-        overRight = (this.offsetLeft - parent.offsetLeft + this.clientWidth - parentBorderLeftWidth) > (parent.scrollLeft + parent.clientWidth),
-        alignWithTop = overTop && !overBottom;
-
-    if ((overTop || overBottom) && centerIfNeeded) {
-      parent.scrollTop = this.offsetTop - parent.offsetTop - parent.clientHeight / 2 - parentBorderTopWidth + this.clientHeight / 2;
-    }
+if (typeof window.cancelIdleCallback === 'undefined') {
+  window.cancelIdleCallback = function (id) {
+    const timeoutHandle = idleCallbackTimeouts.get(id);
 
-    if ((overLeft || overRight) && centerIfNeeded) {
-      parent.scrollLeft = this.offsetLeft - parent.offsetLeft - parent.clientWidth / 2 - parentBorderLeftWidth + this.clientWidth / 2;
+    if (timeoutHandle !== undefined) {
+      idleCallbackTimeouts.delete(id);
+      nativeClearTimeout(timeoutHandle);
     }
 
-    if ((overTop || overBottom || overLeft || overRight) && !centerIfNeeded) {
-      this.scrollIntoView(alignWithTop);
-    }
+    globalThis.clearTimeout(id);
   };
 }
 
-/**
- * RequestIdleCallback polyfill (shims)
- *
- * @see https://developer.chrome.com/blog/using-requestidlecallback/
- * @param cb - callback to be executed when the browser is idle
- */
-window.requestIdleCallback = window.requestIdleCallback || function (cb) {
-  const start = Date.now();
-
-  return setTimeout(function () {
-    cb({
-      didTimeout: false,
-      timeRemaining: function () {
-        // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-        return Math.max(0, 50 - (Date.now() - start));
-      },
-    });
-  }, 1);
-};
-
-window.cancelIdleCallback = window.cancelIdleCallback || function (id) {
-  clearTimeout(id);
-};
+export {};
diff --git a/src/components/selection.ts b/src/components/selection.ts
index 1ab2e5686..ed09a1c00 100644
--- a/src/components/selection.ts
+++ b/src/components/selection.ts
@@ -39,15 +39,15 @@ export default class SelectionUtils {
    *
    * @todo Check if this is still relevant
    */
-  public instance: Selection = null;
-  public selection: Selection = null;
+  public instance: Selection | null = null;
+  public selection: Selection | null = null;
 
   /**
    * This property can store SelectionUtils's range for restoring later
    *
    * @type {Range|null}
    */
-  public savedSelectionRange: Range = null;
+  public savedSelectionRange: Range | null = null;
 
   /**
    * Fake background is active
@@ -57,10 +57,9 @@ export default class SelectionUtils {
   public isFakeBackgroundEnabled = false;
 
   /**
-   * Native Document's commands for fake background
+   * Elements that currently imitate the selection highlight
    */
-  private readonly commandBackground: string = 'backColor';
-  private readonly commandRemoveFormat: string = 'removeFormat';
+  private fakeBackgroundElements: HTMLElement[] = [];
 
   /**
    * Editor styles
@@ -148,7 +147,7 @@ export default class SelectionUtils {
    *
    * @param selection - Selection object to check
    */
-  public static isSelectionAtEditor(selection: Selection): boolean {
+  public static isSelectionAtEditor(selection: Selection | null): boolean {
     if (!selection) {
       return false;
     }
@@ -156,17 +155,14 @@ export default class SelectionUtils {
     /**
      * Something selected on document
      */
-    let selectedNode = (selection.anchorNode || selection.focusNode) as HTMLElement;
+    const initialNode = selection.anchorNode || selection.focusNode;
+    const selectedNode = initialNode && initialNode.nodeType === Node.TEXT_NODE
+      ? initialNode.parentNode
+      : initialNode;
 
-    if (selectedNode && selectedNode.nodeType === Node.TEXT_NODE) {
-      selectedNode = selectedNode.parentNode as HTMLElement;
-    }
-
-    let editorZone = null;
-
-    if (selectedNode && selectedNode instanceof Element) {
-      editorZone = selectedNode.closest(`.${SelectionUtils.CSS.editorZone}`);
-    }
+    const editorZone = selectedNode && selectedNode instanceof Element
+      ? selectedNode.closest(`.${SelectionUtils.CSS.editorZone}`)
+      : null;
 
     /**
      * SelectionUtils is not out of Editor because Editor's wrapper was found
@@ -179,22 +175,20 @@ export default class SelectionUtils {
    *
    * @param range - range to check
    */
-  public static isRangeAtEditor(range: Range): boolean {
+  public static isRangeAtEditor(range: Range): boolean | void {
     if (!range) {
       return;
     }
 
-    let selectedNode = range.startContainer as HTMLElement;
+    const selectedNode: Node | null =
+      range.startContainer && range.startContainer.nodeType === Node.TEXT_NODE
+        ? range.startContainer.parentNode
+        : range.startContainer;
 
-    if (selectedNode && selectedNode.nodeType === Node.TEXT_NODE) {
-      selectedNode = selectedNode.parentNode as HTMLElement;
-    }
-
-    let editorZone = null;
-
-    if (selectedNode && selectedNode instanceof Element) {
-      editorZone = selectedNode.closest(`.${SelectionUtils.CSS.editorZone}`);
-    }
+    const editorZone =
+      selectedNode && selectedNode instanceof Element
+        ? selectedNode.closest(`.${SelectionUtils.CSS.editorZone}`)
+        : null;
 
     /**
      * SelectionUtils is not out of Editor because Editor's wrapper was found
@@ -208,7 +202,7 @@ export default class SelectionUtils {
   public static get isSelectionExists(): boolean {
     const selection = SelectionUtils.get();
 
-    return !!selection.anchorNode;
+    return !!selection?.anchorNode;
   }
 
   /**
@@ -225,29 +219,29 @@ export default class SelectionUtils {
    *
    * @param selection - Selection object to get Range from
    */
-  public static getRangeFromSelection(selection: Selection): Range | null {
+  public static getRangeFromSelection(selection: Selection | null): Range | null {
     return selection && selection.rangeCount ? selection.getRangeAt(0) : null;
   }
 
   /**
    * Calculates position and size of selected text
    *
-   * @returns {DOMRect | ClientRect}
+   * @returns {DOMRect}
    */
-  public static get rect(): DOMRect | ClientRect {
-    let sel: Selection | MSSelection = (document as Document).selection,
-        range: TextRange | Range;
+  public static get rect(): DOMRect {
+    const ieSel: Selection | MSSelection | undefined | null = (document as Document).selection;
 
-    let rect = {
+    const rect = {
       x: 0,
       y: 0,
       width: 0,
       height: 0,
     } as DOMRect;
 
-    if (sel && sel.type !== 'Control') {
-      sel = sel as MSSelection;
-      range = sel.createRange() as TextRange;
+    if (ieSel && ieSel.type !== 'Control') {
+      const msSel = ieSel as MSSelection;
+      const range = msSel.createRange() as TextRange;
+
       rect.x = range.boundingLeft;
       rect.y = range.boundingTop;
       rect.width = range.boundingWidth;
@@ -256,14 +250,14 @@ export default class SelectionUtils {
       return rect;
     }
 
-    if (!window.getSelection) {
-      _.log('Method window.getSelection is not supported', 'warn');
+    const sel = window.getSelection();
+
+    if (!sel) {
+      _.log('Method window.getSelection returned null', 'warn');
 
       return rect;
     }
 
-    sel = window.getSelection();
-
     if (sel.rangeCount === null || isNaN(sel.rangeCount)) {
       _.log('Method SelectionUtils.rangeCount is not supported', 'warn');
 
@@ -274,32 +268,31 @@ export default class SelectionUtils {
       return rect;
     }
 
-    range = sel.getRangeAt(0).cloneRange() as Range;
+    const range = sel.getRangeAt(0).cloneRange() as Range;
+
+    const initialRect = range.getBoundingClientRect() as DOMRect;
 
-    if (range.getBoundingClientRect) {
-      rect = range.getBoundingClientRect() as DOMRect;
-    }
     // Fall back to inserting a temporary element
-    if (rect.x === 0 && rect.y === 0) {
+    if (initialRect.x === 0 && initialRect.y === 0) {
       const span = document.createElement('span');
 
-      if (span.getBoundingClientRect) {
-        // Ensure span has dimensions and position by
-        // adding a zero-width space character
-        span.appendChild(document.createTextNode('\u200b'));
-        range.insertNode(span);
-        rect = span.getBoundingClientRect() as DOMRect;
+      // Ensure span has dimensions and position by
+      // adding a zero-width space character
+      span.appendChild(document.createTextNode('\u200b'));
+      range.insertNode(span);
+      const boundingRect = span.getBoundingClientRect() as DOMRect;
 
-        const spanParent = span.parentNode;
+      const spanParent = span.parentNode;
 
-        spanParent.removeChild(span);
+      spanParent?.removeChild(span);
 
-        // Glue any broken text nodes back together
-        spanParent.normalize();
-      }
+      // Glue any broken text nodes back together
+      spanParent?.normalize();
+
+      return boundingRect;
     }
 
-    return rect;
+    return initialRect;
   }
 
   /**
@@ -308,7 +301,9 @@ export default class SelectionUtils {
    * @returns {string}
    */
   public static get text(): string {
-    return window.getSelection ? window.getSelection().toString() : '';
+    const selection = window.getSelection();
+
+    return selection?.toString() ?? '';
   }
 
   /**
@@ -331,21 +326,30 @@ export default class SelectionUtils {
     const range = document.createRange();
     const selection = window.getSelection();
 
+    const isNativeInput = $.isNativeInput(element);
+
     /** if found deepest node is native input */
-    if ($.isNativeInput(element)) {
-      if (!$.canSetCaret(element)) {
-        return;
-      }
+    if (isNativeInput && !$.canSetCaret(element)) {
+      return element.getBoundingClientRect();
+    }
 
-      element.focus();
-      element.selectionStart = element.selectionEnd = offset;
+    if (isNativeInput) {
+      const inputElement = element as HTMLInputElement | HTMLTextAreaElement;
 
-      return element.getBoundingClientRect();
+      inputElement.focus();
+      inputElement.selectionStart = offset;
+      inputElement.selectionEnd = offset;
+
+      return inputElement.getBoundingClientRect();
     }
 
     range.setStart(element, offset);
     range.setEnd(element, offset);
 
+    if (!selection) {
+      return element.getBoundingClientRect();
+    }
+
     selection.removeAllRanges();
     selection.addRange(range);
 
@@ -413,23 +417,170 @@ export default class SelectionUtils {
    * Removes fake background
    */
   public removeFakeBackground(): void {
-    if (!this.isFakeBackgroundEnabled) {
+    if (!this.fakeBackgroundElements.length) {
+      this.isFakeBackgroundEnabled = false;
+
       return;
     }
 
+    this.fakeBackgroundElements.forEach((element) => {
+      this.unwrapFakeBackground(element);
+    });
+
+    this.fakeBackgroundElements = [];
     this.isFakeBackgroundEnabled = false;
-    document.execCommand(this.commandRemoveFormat);
   }
 
   /**
    * Sets fake background
    */
   public setFakeBackground(): void {
-    document.execCommand(this.commandBackground, false, '#a8d6ff');
+    this.removeFakeBackground();
+
+    const selection = window.getSelection();
+
+    if (!selection || selection.rangeCount === 0) {
+      return;
+    }
+
+    const range = selection.getRangeAt(0);
+
+    if (range.collapsed) {
+      return;
+    }
+
+    const textNodes = this.collectTextNodes(range);
+
+    if (textNodes.length === 0) {
+      return;
+    }
+
+    const anchorStartNode = range.startContainer;
+    const anchorStartOffset = range.startOffset;
+    const anchorEndNode = range.endContainer;
+    const anchorEndOffset = range.endOffset;
+
+    this.fakeBackgroundElements = [];
+
+    textNodes.forEach((textNode) => {
+      const segmentRange = document.createRange();
+      const isStartNode = textNode === anchorStartNode;
+      const isEndNode = textNode === anchorEndNode;
+      const startOffset = isStartNode ? anchorStartOffset : 0;
+      const nodeTextLength = textNode.textContent?.length ?? 0;
+      const endOffset = isEndNode ? anchorEndOffset : nodeTextLength;
+
+      if (startOffset === endOffset) {
+        return;
+      }
+
+      segmentRange.setStart(textNode, startOffset);
+      segmentRange.setEnd(textNode, endOffset);
+
+      const wrapper = this.wrapRangeWithFakeBackground(segmentRange);
+
+      if (wrapper) {
+        this.fakeBackgroundElements.push(wrapper);
+      }
+    });
+
+    if (!this.fakeBackgroundElements.length) {
+      return;
+    }
+
+    const visualRange = document.createRange();
+
+    visualRange.setStartBefore(this.fakeBackgroundElements[0]);
+    visualRange.setEndAfter(this.fakeBackgroundElements[this.fakeBackgroundElements.length - 1]);
+
+    selection.removeAllRanges();
+    selection.addRange(visualRange);
 
     this.isFakeBackgroundEnabled = true;
   }
 
+  /**
+   * Collects text nodes that intersect with the passed range
+   *
+   * @param range - selection range
+   */
+  private collectTextNodes(range: Range): Text[] {
+    const nodes: Text[] = [];
+    const walker = document.createTreeWalker(
+      range.commonAncestorContainer,
+      NodeFilter.SHOW_TEXT,
+      {
+        acceptNode: (node: Node): number => {
+          if (!range.intersectsNode(node)) {
+            return NodeFilter.FILTER_REJECT;
+          }
+
+          return node.textContent && node.textContent.length > 0
+            ? NodeFilter.FILTER_ACCEPT
+            : NodeFilter.FILTER_REJECT;
+        },
+      }
+    );
+
+    while (walker.nextNode()) {
+      nodes.push(walker.currentNode as Text);
+    }
+
+    return nodes;
+  }
+
+  /**
+   * Wraps passed range (that belongs to the single text node) with fake background element
+   *
+   * @param range - range to wrap
+   */
+  private wrapRangeWithFakeBackground(range: Range): HTMLElement | null {
+    if (range.collapsed) {
+      return null;
+    }
+
+    const wrapper = $.make('span', 'codex-editor__fake-background');
+
+    wrapper.dataset.fakeBackground = 'true';
+    wrapper.dataset.mutationFree = 'true';
+    wrapper.style.backgroundColor = '#a8d6ff';
+    wrapper.style.color = 'inherit';
+    wrapper.style.display = 'inline';
+    wrapper.style.padding = '0';
+    wrapper.style.margin = '0';
+
+    const contents = range.extractContents();
+
+    if (contents.childNodes.length === 0) {
+      return null;
+    }
+
+    wrapper.appendChild(contents);
+    range.insertNode(wrapper);
+
+    return wrapper;
+  }
+
+  /**
+   * Removes fake background wrapper
+   *
+   * @param element - wrapper element
+   */
+  private unwrapFakeBackground(element: HTMLElement): void {
+    const parent = element.parentNode;
+
+    if (!parent) {
+      return;
+    }
+
+    while (element.firstChild) {
+      parent.insertBefore(element.firstChild, element);
+    }
+
+    parent.removeChild(element);
+    parent.normalize();
+  }
+
   /**
    * Save SelectionUtils's range
    */
@@ -447,6 +598,10 @@ export default class SelectionUtils {
 
     const sel = window.getSelection();
 
+    if (!sel) {
+      return;
+    }
+
     sel.removeAllRanges();
     sel.addRange(this.savedSelectionRange);
   }
@@ -463,6 +618,11 @@ export default class SelectionUtils {
    */
   public collapseToEnd(): void {
     const sel = window.getSelection();
+
+    if (!sel || !sel.focusNode) {
+      return;
+    }
+
     const range = document.createRange();
 
     range.selectNodeContents(sel.focusNode);
@@ -481,7 +641,6 @@ export default class SelectionUtils {
    */
   public findParentTag(tagName: string, className?: string, searchDepth = 10): HTMLElement | null {
     const selection = window.getSelection();
-    let parentTag = null;
 
     /**
      * If selection is missing or no anchorNode or focusNode were found then return null
@@ -501,50 +660,47 @@ export default class SelectionUtils {
     ];
 
     /**
-     * For each selection parent Nodes we try to find target tag [with target class name]
-     * It would be saved in parentTag variable
+     * Helper function to find parent tag starting from a given node
+     *
+     * @param {HTMLElement} startNode - node to start searching from
+     * @returns {HTMLElement | null}
      */
-    boundNodes.forEach((parent) => {
-      /** Reset tags limit */
-      let searchDepthIterable = searchDepth;
-
-      while (searchDepthIterable > 0 && parent.parentNode) {
-        /**
-         * Check tag's name
-         */
-        if (parent.tagName === tagName) {
-          /**
-           * Save the result
-           */
-          parentTag = parent;
-
-          /**
-           * Optional additional check for class-name mismatching
-           */
-          if (className && parent.classList && !parent.classList.contains(className)) {
-            parentTag = null;
-          }
+    const findTagFromNode = (startNode: HTMLElement): HTMLElement | null => {
+      const searchUpTree = (node: HTMLElement, depth: number): HTMLElement | null => {
+        if (depth <= 0 || !node.parentNode) {
+          return null;
+        }
 
-          /**
-           * If we have found required tag with class then go out from the cycle
-           */
-          if (parentTag) {
-            break;
-          }
+        const parent = node.parentNode as HTMLElement;
+
+        const hasMatchingClass = !className || (parent.classList && parent.classList.contains(className));
+        const hasMatchingTag = parent.tagName === tagName;
+
+        if (hasMatchingTag && hasMatchingClass) {
+          return parent;
         }
 
-        /**
-         * Target tag was not found. Go up to the parent and check it
-         */
-        parent = parent.parentNode as HTMLElement;
-        searchDepthIterable--;
+        return searchUpTree(parent, depth - 1);
+      };
+
+      return searchUpTree(startNode, searchDepth);
+    };
+
+    /**
+     * For each selection parent Nodes we try to find target tag [with target class name]
+     */
+    for (const node of boundNodes) {
+      const foundTag = findTagFromNode(node);
+
+      if (foundTag) {
+        return foundTag;
       }
-    });
+    }
 
     /**
-     * Return found tag or null
+     * Return null if tag was not found
      */
-    return parentTag;
+    return null;
   }
 
   /**
@@ -555,6 +711,10 @@ export default class SelectionUtils {
   public expandToTag(element: HTMLElement): void {
     const selection = window.getSelection();
 
+    if (!selection) {
+      return;
+    }
+
     selection.removeAllRanges();
     const range = document.createRange();
 
diff --git a/src/components/tools/base.ts b/src/components/tools/base.ts
index fd58be7e9..23f968a09 100644
--- a/src/components/tools/base.ts
+++ b/src/components/tools/base.ts
@@ -1,5 +1,5 @@
 import type { Tool, ToolConstructable, ToolSettings } from '@/types/tools';
-import type { SanitizerConfig, API as ApiMethods } from '@/types';
+import type { SanitizerConfig, API as ApiMethods, ToolConfig } from '@/types';
 import * as _ from '../utils';
 import { ToolType } from '@/types/tools/adapters/tool-type';
 import type { BaseToolAdapter as BaseToolAdapterInterface } from '@/types/tools/adapters/base-tool-adapter';
@@ -106,6 +106,11 @@ export enum InternalTuneSettings {
 
 export type ToolOptions = Omit<ToolSettings, 'class'>;
 
+type ToolPreparePayload = {
+  toolName: string;
+  config: ToolConfig;
+};
+
 interface ConstructorOptions {
   name: string;
   constructable: ToolConstructable;
@@ -123,7 +128,7 @@ export default abstract class BaseToolAdapter<Type extends ToolType = ToolType,
   /**
    * Tool type: Block, Inline or Tune
    */
-  public type: Type;
+  public abstract type: Type;
 
   /**
    * Tool name specified in EditorJS config
@@ -185,8 +190,8 @@ export default abstract class BaseToolAdapter<Type extends ToolType = ToolType,
   /**
    * Returns Tool user configuration
    */
-  public get settings(): ToolOptions {
-    const config = this.config[UserSettings.Config] || {};
+  public get settings(): ToolConfig {
+    const config = (this.config[UserSettings.Config] ?? {}) as ToolConfig;
 
     if (this.isDefault && !('placeholder' in config) && this.defaultPlaceholder) {
       config.placeholder = this.defaultPlaceholder;
@@ -208,12 +213,18 @@ export default abstract class BaseToolAdapter<Type extends ToolType = ToolType,
    * Calls Tool's prepare method
    */
   public prepare(): void | Promise<void> {
-    if (_.isFunction(this.constructable.prepare)) {
-      return this.constructable.prepare({
-        toolName: this.name,
-        config: this.settings,
-      });
+    const prepare = this.constructable.prepare;
+
+    if (!_.isFunction(prepare)) {
+      return;
     }
+
+    const payload: ToolPreparePayload = {
+      toolName: this.name,
+      config: this.settings,
+    };
+
+    return (prepare as (data: ToolPreparePayload) => void | Promise<void>).call(this.constructable, payload);
   }
 
   /**
diff --git a/src/components/tools/block.ts b/src/components/tools/block.ts
index d56cc4321..dddb1c535 100644
--- a/src/components/tools/block.ts
+++ b/src/components/tools/block.ts
@@ -2,8 +2,8 @@ import BaseToolAdapter, { InternalBlockToolSettings, UserSettings } from './base
 import type {
   BlockAPI,
   BlockTool as IBlockTool,
-  BlockToolConstructable,
   BlockToolData,
+  BlockToolConstructable,
   ConversionConfig,
   PasteConfig, SanitizerConfig, ToolboxConfig,
   ToolboxConfigEntry
@@ -15,6 +15,26 @@ import ToolsCollection from './collection';
 import type { BlockToolAdapter as BlockToolAdapterInterface } from '@/types/tools/adapters/block-tool-adapter';
 import { ToolType } from '@/types/tools/adapters/tool-type';
 
+type SanitizerConfigCacheableDecorator = {
+  (target: object, propertyKey: string | symbol, descriptor?: TypedPropertyDescriptor<SanitizerConfig>): TypedPropertyDescriptor<SanitizerConfig> | void;
+  (value: () => SanitizerConfig, context: {
+    kind: 'getter' | 'accessor';
+    name: string | symbol;
+    static?: boolean;
+    private?: boolean;
+    access?: {
+      get?: () => SanitizerConfig;
+      set?: (value: SanitizerConfig) => void;
+    };
+  }): (() => SanitizerConfig) | {
+    get?: () => SanitizerConfig;
+    set?: (value: SanitizerConfig) => void;
+    init?: (value: SanitizerConfig) => SanitizerConfig;
+  };
+};
+
+const cacheSanitizerConfig = _.cacheable as SanitizerConfigCacheableDecorator;
+
 /**
  * Class to work with Block tools constructables
  */
@@ -34,11 +54,6 @@ export default class BlockToolAdapter extends BaseToolAdapter<ToolType.Block, IB
    */
   public tunes: ToolsCollection<BlockTuneAdapter> = new ToolsCollection<BlockTuneAdapter>();
 
-  /**
-   * Tool's constructable blueprint
-   */
-  protected constructable: BlockToolConstructable;
-
   /**
    * Creates new Tool instance
    *
@@ -61,14 +76,14 @@ export default class BlockToolAdapter extends BaseToolAdapter<ToolType.Block, IB
    * Returns true if read-only mode is supported by Tool
    */
   public get isReadOnlySupported(): boolean {
-    return this.constructable[InternalBlockToolSettings.IsReadOnlySupported] === true;
+    return (this.constructable as BlockToolConstructable)[InternalBlockToolSettings.IsReadOnlySupported] === true;
   }
 
   /**
    * Returns true if Tool supports linebreaks
    */
   public get isLineBreaksEnabled(): boolean {
-    return this.constructable[InternalBlockToolSettings.IsEnabledLineBreaks];
+    return (this.constructable as unknown as Record<string, boolean | undefined>)[InternalBlockToolSettings.IsEnabledLineBreaks] ?? false;
   }
 
   /**
@@ -85,10 +100,10 @@ export default class BlockToolAdapter extends BaseToolAdapter<ToolType.Block, IB
    * config. This is made to allow user to override default tool's toolbox representation (single/multiple entries)
    */
   public get toolbox(): ToolboxConfigEntry[] | undefined {
-    const toolToolboxSettings = this.constructable[InternalBlockToolSettings.Toolbox] as ToolboxConfig;
+    const toolToolboxSettings = (this.constructable as BlockToolConstructable)[InternalBlockToolSettings.Toolbox] as ToolboxConfig | undefined;
     const userToolboxSettings = this.config[UserSettings.Toolbox];
 
-    if (_.isEmpty(toolToolboxSettings)) {
+    if (!toolToolboxSettings || _.isEmpty(toolToolboxSettings)) {
       return;
     }
     if (userToolboxSettings === false) {
@@ -97,35 +112,18 @@ export default class BlockToolAdapter extends BaseToolAdapter<ToolType.Block, IB
     /**
      * Return tool's toolbox settings if user settings are not defined
      */
-    if (!userToolboxSettings) {
+    if (userToolboxSettings === undefined || userToolboxSettings === null) {
       return Array.isArray(toolToolboxSettings) ? toolToolboxSettings : [ toolToolboxSettings ];
     }
 
     /**
      * Otherwise merge user settings with tool's settings
      */
-    if (Array.isArray(toolToolboxSettings)) {
-      if (Array.isArray(userToolboxSettings)) {
-        return userToolboxSettings.map((item, i) => {
-          const toolToolboxEntry = toolToolboxSettings[i];
-
-          if (toolToolboxEntry) {
-            return {
-              ...toolToolboxEntry,
-              ...item,
-            };
-          }
-
-          return item;
-        });
-      }
-
+    if (!Array.isArray(userToolboxSettings) && Array.isArray(toolToolboxSettings)) {
       return [ userToolboxSettings ];
-    } else {
-      if (Array.isArray(userToolboxSettings)) {
-        return userToolboxSettings;
-      }
+    }
 
+    if (!Array.isArray(userToolboxSettings)) {
       return [
         {
           ...toolToolboxSettings,
@@ -133,13 +131,30 @@ export default class BlockToolAdapter extends BaseToolAdapter<ToolType.Block, IB
         },
       ];
     }
+
+    if (!Array.isArray(toolToolboxSettings)) {
+      return userToolboxSettings;
+    }
+
+    return userToolboxSettings.map((item, i) => {
+      const toolToolboxEntry = toolToolboxSettings[i];
+
+      if (toolToolboxEntry) {
+        return {
+          ...toolToolboxEntry,
+          ...item,
+        };
+      }
+
+      return item;
+    });
   }
 
   /**
    * Returns Tool conversion configuration
    */
   public get conversionConfig(): ConversionConfig | undefined {
-    return this.constructable[InternalBlockToolSettings.ConversionConfig];
+    return (this.constructable as BlockToolConstructable)[InternalBlockToolSettings.ConversionConfig];
   }
 
   /**
@@ -152,7 +167,7 @@ export default class BlockToolAdapter extends BaseToolAdapter<ToolType.Block, IB
   /**
    * Returns enabled tunes for Tool
    */
-  public get enabledBlockTunes(): boolean | string[] {
+  public get enabledBlockTunes(): boolean | string[] | undefined {
     return this.config[UserSettings.EnabledBlockTunes];
   }
 
@@ -160,13 +175,13 @@ export default class BlockToolAdapter extends BaseToolAdapter<ToolType.Block, IB
    * Returns Tool paste configuration
    */
   public get pasteConfig(): PasteConfig {
-    return this.constructable[InternalBlockToolSettings.PasteConfig] ?? {};
+    return (this.constructable as BlockToolConstructable)[InternalBlockToolSettings.PasteConfig] ?? {};
   }
 
   /**
    * Returns sanitize configuration for Block Tool including configs from related Inline Tools and Block Tunes
    */
-  @_.cacheable
+  @cacheSanitizerConfig
   public get sanitizeConfig(): SanitizerConfig {
     const toolRules = super.sanitizeConfig;
     const baseConfig = this.baseSanitizeConfig;
@@ -178,19 +193,21 @@ export default class BlockToolAdapter extends BaseToolAdapter<ToolType.Block, IB
     const toolConfig = {} as SanitizerConfig;
 
     for (const fieldName in toolRules) {
-      if (Object.prototype.hasOwnProperty.call(toolRules, fieldName)) {
-        const rule = toolRules[fieldName];
-
-        /**
-         * If rule is object, merge it with Inline Tools configuration
-         *
-         * Otherwise pass as it is
-         */
-        if (_.isObject(rule)) {
-          toolConfig[fieldName] = Object.assign({}, baseConfig, rule);
-        } else {
-          toolConfig[fieldName] = rule;
-        }
+      if (!Object.prototype.hasOwnProperty.call(toolRules, fieldName)) {
+        continue;
+      }
+
+      const rule = toolRules[fieldName];
+
+      /**
+       * If rule is object, merge it with Inline Tools configuration
+       *
+       * Otherwise pass as it is
+       */
+      if (_.isObject(rule)) {
+        toolConfig[fieldName] = Object.assign({}, baseConfig, rule);
+      } else {
+        toolConfig[fieldName] = rule;
       }
     }
 
@@ -200,7 +217,7 @@ export default class BlockToolAdapter extends BaseToolAdapter<ToolType.Block, IB
   /**
    * Returns sanitizer configuration composed from sanitize config of Inline Tools enabled for Tool
    */
-  @_.cacheable
+  @cacheSanitizerConfig
   public get baseSanitizeConfig(): SanitizerConfig {
     const baseConfig = {};
 
diff --git a/src/components/tools/factory.ts b/src/components/tools/factory.ts
index 94d501df7..590c3ec3b 100644
--- a/src/components/tools/factory.ts
+++ b/src/components/tools/factory.ts
@@ -49,10 +49,15 @@ export default class ToolsFactory {
    * @param name - tool name
    */
   public get(name: string): InlineToolAdapter | BlockToolAdapter | BlockTuneAdapter {
-    const { class: constructable, isInternal = false, ...config } = this.config[name];
+    const { class: constructableCandidate, isInternal = false, ...config } = this.config[name];
+    const constructable = constructableCandidate as ToolConstructable | undefined;
+
+    if (constructable === undefined) {
+      throw new Error(`Tool "${name}" does not provide a class.`);
+    }
 
     const Constructor = this.getConstructor(constructable);
-    const isTune = constructable[InternalTuneSettings.IsTune];
+    const isTune = Boolean(Reflect.get(constructable, InternalTuneSettings.IsTune));
 
     return new Constructor({
       name,
@@ -72,9 +77,9 @@ export default class ToolsFactory {
    */
   private getConstructor(constructable: ToolConstructable): ToolConstructor {
     switch (true) {
-      case constructable[InternalInlineToolSettings.IsInline]:
+      case Boolean(Reflect.get(constructable, InternalInlineToolSettings.IsInline)):
         return InlineToolAdapter;
-      case constructable[InternalTuneSettings.IsTune]:
+      case Boolean(Reflect.get(constructable, InternalTuneSettings.IsTune)):
         return BlockTuneAdapter;
       default:
         return BlockToolAdapter;
diff --git a/src/components/tools/inline.ts b/src/components/tools/inline.ts
index 7287f37e0..374da3fa3 100644
--- a/src/components/tools/inline.ts
+++ b/src/components/tools/inline.ts
@@ -1,4 +1,4 @@
-import BaseToolAdapter, { InternalInlineToolSettings } from './base';
+import BaseToolAdapter from './base';
 import type { InlineTool as IInlineTool, InlineToolConstructable } from '@/types';
 import type { InlineToolAdapter as InlineToolAdapterInterface } from '@/types/tools/adapters/inline-tool-adapter';
 import { ToolType } from '@/types/tools/adapters/tool-type';
@@ -13,15 +13,28 @@ export default class InlineToolAdapter extends BaseToolAdapter<ToolType.Inline,
   public type: ToolType.Inline = ToolType.Inline;
 
   /**
-   * Tool's constructable blueprint
+   * Returns list of required methods that are missing on the inline tool prototype
+   *
+   * @param requiredMethods - method names that must be implemented
    */
-  protected constructable: InlineToolConstructable;
+  public getMissingMethods(requiredMethods: string[]): string[] {
+    const constructable = this.constructable as InlineToolConstructable | undefined;
+    const prototype = constructable?.prototype as Record<string, unknown> | undefined;
+
+    if (!prototype) {
+      return [ ...requiredMethods ];
+    }
+
+    return requiredMethods.filter((methodName) => typeof prototype[methodName] !== 'function');
+  }
 
   /**
    * Returns title for Inline Tool if specified by user
    */
   public get title(): string {
-    return this.constructable[InternalInlineToolSettings.Title];
+    const constructable = this.constructable as InlineToolConstructable | undefined;
+
+    return constructable?.title ?? '';
   }
 
   /**
@@ -29,7 +42,9 @@ export default class InlineToolAdapter extends BaseToolAdapter<ToolType.Inline,
    */
   public create(): IInlineTool {
     // eslint-disable-next-line new-cap
-    return new this.constructable({
+    const InlineToolClass = this.constructable as InlineToolConstructable;
+
+    return new InlineToolClass({
       api: this.api,
       config: this.settings,
     }) as IInlineTool;
@@ -40,6 +55,8 @@ export default class InlineToolAdapter extends BaseToolAdapter<ToolType.Inline,
    * Can be used, for example, by comments tool
    */
   public get isReadOnlySupported(): boolean {
-    return this.constructable[InternalInlineToolSettings.IsReadOnlySupported] ?? false;
+    const constructable = this.constructable as InlineToolConstructable | undefined;
+
+    return constructable?.isReadOnlySupported ?? false;
   }
 }
diff --git a/src/components/tools/tune.ts b/src/components/tools/tune.ts
index c183c2dee..79bd3ea2f 100644
--- a/src/components/tools/tune.ts
+++ b/src/components/tools/tune.ts
@@ -15,11 +15,6 @@ export default class BlockTuneAdapter extends BaseToolAdapter<ToolType.Tune, IBl
    */
   public type: ToolType.Tune = ToolType.Tune;
 
-  /**
-   * Tool's constructable blueprint
-   */
-  protected readonly constructable: BlockTuneConstructable;
-
   /**
    * Constructs new BlockTune instance from constructable
    *
@@ -28,7 +23,9 @@ export default class BlockTuneAdapter extends BaseToolAdapter<ToolType.Tune, IBl
    */
   public create(data: BlockTuneData, block: BlockAPI): IBlockTune {
     // eslint-disable-next-line new-cap
-    return new this.constructable({
+    const BlockTuneClass = this.constructable as BlockTuneConstructable;
+
+    return new BlockTuneClass({
       api: this.api,
       config: this.settings,
       block,
diff --git a/src/components/ui/toolbox.ts b/src/components/ui/toolbox.ts
index 91e663580..4e2369062 100644
--- a/src/components/ui/toolbox.ts
+++ b/src/components/ui/toolbox.ts
@@ -1,5 +1,4 @@
 import * as _ from '../utils';
-import { BlockToolAPI } from '../block';
 import Shortcuts from '../utils/shortcuts';
 import type BlockToolAdapter from '../tools/block';
 import type ToolsCollection from '../tools/collection';
@@ -193,8 +192,8 @@ export default class Toolbox extends EventsDispatcher<ToolboxEventMap> {
    * @param toolName - tool type to be activated
    * @param blockDataOverrides - Block data predefined by the activated Toolbox item
    */
-  public toolButtonActivated(toolName: string, blockDataOverrides: BlockToolData): void {
-    this.insertNewBlock(toolName, blockDataOverrides);
+  public async toolButtonActivated(toolName: string, blockDataOverrides?: BlockToolData): Promise<void> {
+    await this.insertNewBlock(toolName, blockDataOverrides);
   }
 
   /**
@@ -314,7 +313,7 @@ export default class Toolbox extends EventsDispatcher<ToolboxEventMap> {
         title: I18n.t(I18nInternalNS.toolNames, toolboxItem.title || _.capitalize(tool.name)),
         name: tool.name,
         onActivate: (): void => {
-          this.toolButtonActivated(tool.name, toolboxItem.data);
+          void this.toolButtonActivated(tool.name, toolboxItem.data);
         },
         secondaryLabel: (tool.shortcut && displaySecondaryLabel) ? _.beautifyShortcut(tool.shortcut) : '',
       };
@@ -322,14 +321,18 @@ export default class Toolbox extends EventsDispatcher<ToolboxEventMap> {
 
     return this.toolsToBeDisplayed
       .reduce<PopoverItemParams[]>((result, tool) => {
-        if (Array.isArray(tool.toolbox)) {
-          tool.toolbox.forEach((item, index) => {
-            result.push(toPopoverItem(item, tool, index === 0));
-          });
-        } else if (tool.toolbox !== undefined)  {
-          result.push(toPopoverItem(tool.toolbox, tool));
+        const { toolbox } = tool;
+
+        if (toolbox === undefined) {
+          return result;
         }
 
+        const items = Array.isArray(toolbox) ? toolbox : [ toolbox ];
+
+        items.forEach((item, index) => {
+          result.push(toPopoverItem(item, tool, index === 0));
+        });
+
         return result;
       }, []);
   }
@@ -377,7 +380,7 @@ export default class Toolbox extends EventsDispatcher<ToolboxEventMap> {
           } catch (error) {}
         }
 
-        this.insertNewBlock(toolName);
+        await this.insertNewBlock(toolName);
       },
     });
   }
@@ -417,16 +420,11 @@ export default class Toolbox extends EventsDispatcher<ToolboxEventMap> {
      */
     const index = currentBlock.isEmpty ? currentBlockIndex : currentBlockIndex + 1;
 
-    let blockData;
-
-    if (blockDataOverrides) {
-      /**
-       * Merge real tool's data with data overrides
-       */
-      const defaultBlockData = await this.api.blocks.composeBlockData(toolName);
+    const hasBlockDataOverrides = blockDataOverrides !== undefined && Object.keys(blockDataOverrides as Record<string, unknown>).length > 0;
 
-      blockData = Object.assign(defaultBlockData, blockDataOverrides);
-    }
+    const blockData: BlockToolData | undefined = hasBlockDataOverrides
+      ? Object.assign(await this.api.blocks.composeBlockData(toolName), blockDataOverrides)
+      : undefined;
 
     const newBlock = this.api.blocks.insert(
       toolName,
@@ -437,11 +435,6 @@ export default class Toolbox extends EventsDispatcher<ToolboxEventMap> {
       currentBlock.isEmpty
     );
 
-    /**
-     * Apply callback before inserting html
-     */
-    newBlock.call(BlockToolAPI.APPEND_CALLBACK);
-
     this.api.caret.setToBlock(index);
 
     this.emit(ToolboxEvent.BlockAdded, {
diff --git a/src/components/utils.ts b/src/components/utils.ts
index a6418a990..3f4f896d5 100644
--- a/src/components/utils.ts
+++ b/src/components/utils.ts
@@ -3,7 +3,18 @@
  */
 
 import { nanoid } from 'nanoid';
-import Dom from './dom';
+import lodashDelay from 'lodash/delay';
+import lodashIsBoolean from 'lodash/isBoolean';
+import lodashIsEmpty from 'lodash/isEmpty';
+import lodashIsEqual from 'lodash/isEqual';
+import lodashIsFunction from 'lodash/isFunction';
+import lodashIsNumber from 'lodash/isNumber';
+import lodashIsPlainObject from 'lodash/isPlainObject';
+import lodashIsString from 'lodash/isString';
+import lodashIsUndefined from 'lodash/isUndefined';
+import lodashMergeWith from 'lodash/mergeWith';
+import lodashThrottle from 'lodash/throttle';
+import lodashToArray from 'lodash/toArray';
 
 /**
  * Possible log levels
@@ -20,6 +31,27 @@ export enum LogLevels {
  */
 declare const VERSION: string;
 
+const fallbackEditorVersion = 'dev';
+
+/**
+ * Returns Editor.js version injected by bundler or a globally provided fallback.
+ */
+export const getEditorVersion = (): string => {
+  if (typeof VERSION !== 'undefined') {
+    return VERSION;
+  }
+
+  const globalVersion = (typeof globalThis === 'object' && globalThis !== null)
+    ? (globalThis as { VERSION?: unknown }).VERSION
+    : undefined;
+
+  if (typeof globalVersion === 'string' && globalVersion.trim() !== '') {
+    return globalVersion;
+  }
+
+  return fallbackEditorVersion;
+};
+
 /**
  * @typedef {object} ChainData
  * @property {object} data - data that will be passed to the success or fallback
@@ -28,8 +60,7 @@ declare const VERSION: string;
  */
 export interface ChainData {
   data?: object;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  function: (...args: any[]) => any;
+  function: (...args: unknown[]) => unknown;
 }
 
 /**
@@ -55,7 +86,24 @@ export const keyCodes = {
   DOWN: 40,
   RIGHT: 39,
   DELETE: 46,
+  // Number keys range (0-9)
+  NUMBER_KEY_MIN: 47,
+  NUMBER_KEY_MAX: 58,
+  // Letter keys range (A-Z)
+  LETTER_KEY_MIN: 64,
+  LETTER_KEY_MAX: 91,
   META: 91,
+  // Numpad keys range
+  NUMPAD_KEY_MIN: 95,
+  NUMPAD_KEY_MAX: 112,
+  // Punctuation keys range (;=,-./`)
+  PUNCTUATION_KEY_MIN: 185,
+  PUNCTUATION_KEY_MAX: 193,
+  // Bracket keys range ([\]')
+  BRACKET_KEY_MIN: 218,
+  BRACKET_KEY_MAX: 223,
+  // Processing key input for certain languages (Chinese, Japanese, etc.)
+  PROCESSING_KEY: 229,
   SLASH: 191,
 };
 
@@ -70,6 +118,61 @@ export const mouseButtons = {
   FORWARD: 4,
 };
 
+/**
+ * Constants for ID generation
+ */
+const ID_RANDOM_MULTIPLIER = 100_000_000; // 1e8
+const HEXADECIMAL_RADIX = 16;
+
+type UniversalScope = {
+  window?: Window;
+  document?: Document;
+  navigator?: Navigator;
+};
+
+const globalScope: UniversalScope | undefined = (() => {
+  try {
+    return Function('return this')() as UniversalScope;
+  } catch {
+    return undefined;
+  }
+})();
+
+if (globalScope && typeof globalScope.window === 'undefined') {
+  (globalScope as Record<string, unknown>).window = globalScope;
+}
+
+/**
+ * Returns globally available window object if it exists.
+ */
+const getGlobalWindow = (): Window | undefined => {
+  if (globalScope?.window) {
+    return globalScope.window;
+  }
+
+  return undefined;
+};
+
+/**
+ * Returns globally available navigator object if it exists.
+ */
+const getGlobalNavigator = (): Navigator | undefined => {
+  if (globalScope?.navigator) {
+    return globalScope.navigator;
+  }
+
+  const win = getGlobalWindow();
+
+  return win?.navigator;
+};
+
+/**
+ * Type representing callable console methods
+ */
+type ConsoleMethod = {
+  [K in keyof Console]: Console[K] extends (...args: unknown[]) => unknown ? K : never;
+}[keyof Console];
+
 /**
  * Custom logger
  *
@@ -79,20 +182,21 @@ export const mouseButtons = {
  * @param {*} [args]      - argument to log with a message
  * @param {string} style  - additional styling to message
  */
-function _log(
+const _log = (
   labeled: boolean,
   msg: string,
-  type = 'log',
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  args?: any,
+  type: ConsoleMethod = 'log',
+  args?: unknown,
   style = 'color: inherit'
-): void {
-  if (!('console' in window) || !window.console[type]) {
+): void => {
+  const consoleRef: Console | undefined = typeof console === 'undefined' ? undefined : console;
+
+  if (!consoleRef || typeof consoleRef[type] !== 'function') {
     return;
   }
 
   const isSimpleType = ['info', 'log', 'warn', 'error'].includes(type);
-  const argsToPass = [];
+  const argsToPass: unknown[] = [];
 
   switch (_log.logLevel) {
     case LogLevels.ERROR:
@@ -118,7 +222,7 @@ function _log(
     argsToPass.push(args);
   }
 
-  const editorLabelText = `Editor.js ${VERSION}`;
+  const editorLabelText = `Editor.js ${getEditorVersion()}`;
   const editorLabelStyle = `line-height: 1em;
             color: #006FEA;
             display: inline-block;
@@ -130,25 +234,36 @@ function _log(
             border: 1px solid rgba(56, 138, 229, 0.16);
             margin: 4px 5px 4px 0;`;
 
-  if (labeled) {
+  const formattedMessage = (() => {
+    if (!labeled) {
+      return msg;
+    }
+
     if (isSimpleType) {
       argsToPass.unshift(editorLabelStyle, style);
-      msg = `%c${editorLabelText}%c ${msg}`;
-    } else {
-      msg = `( ${editorLabelText} )${msg}`;
+
+      return `%c${editorLabelText}%c ${msg}`;
     }
-  }
 
-  try {
+    return `( ${editorLabelText} )${msg}`;
+  })();
+
+  const callArguments = (() => {
     if (!isSimpleType) {
-      console[type](msg);
-    } else if (args) {
-      console[type](`${msg} %o`, ...argsToPass);
-    } else {
-      console[type](msg, ...argsToPass);
+      return [ formattedMessage ];
     }
+
+    if (args !== undefined) {
+      return [`${formattedMessage} %o`, ...argsToPass];
+    }
+
+    return [formattedMessage, ...argsToPass];
+  })();
+
+  try {
+    consoleRef[type](...callArguments);
   } catch (ignored) {}
-}
+};
 
 /**
  * Current log level
@@ -160,30 +275,43 @@ _log.logLevel = LogLevels.VERBOSE;
  *
  * @param {LogLevels} logLevel - log level to set
  */
-export function setLogLevel(logLevel: LogLevels): void {
+export const setLogLevel = (logLevel: LogLevels): void => {
   _log.logLevel = logLevel;
-}
+};
 
 /**
  * _log method proxy without Editor.js label
+ *
+ * @param msg - message to log
+ * @param type - console method name
+ * @param args - optional payload to pass to console
+ * @param style - optional css style for the first argument
  */
-export const log = _log.bind(window, false);
+export const log = (
+  msg: string,
+  type: ConsoleMethod = 'log',
+  args?: unknown,
+  style?: string
+): void => {
+  _log(false, msg, type, args, style);
+};
 
 /**
  * _log method proxy with Editor.js label
- */
-export const logLabeled = _log.bind(window, true);
-
-/**
- * Return string representation of the object type
  *
- * @param {*} object - object to get type
- * @returns {string}
+ * @param msg - message to log
+ * @param type - console method name
+ * @param args - optional payload to pass to console
+ * @param style - optional css style for the first argument
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function typeOf(object: any): string {
-  return Object.prototype.toString.call(object).match(/\s([a-zA-Z]+)/)[1].toLowerCase();
-}
+export const logLabeled = (
+  msg: string,
+  type: ConsoleMethod = 'log',
+  args?: unknown,
+  style?: string
+): void => {
+  _log(true, msg, type, args, style);
+};
 
 /**
  * Check if passed variable is a function
@@ -191,10 +319,9 @@ export function typeOf(object: any): string {
  * @param {*} fn - function to check
  * @returns {boolean}
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function isFunction(fn: any): fn is (...args: any[]) => any {
-  return typeOf(fn) === 'function' || typeOf(fn) === 'asyncfunction';
-}
+export const isFunction = (fn: unknown): fn is (...args: unknown[]) => unknown => {
+  return lodashIsFunction(fn);
+};
 
 /**
  * Checks if passed argument is an object
@@ -202,10 +329,9 @@ export function isFunction(fn: any): fn is (...args: any[]) => any {
  * @param {*} v - object to check
  * @returns {boolean}
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function isObject(v: any): v is object {
-  return typeOf(v) === 'object';
-}
+export const isObject = (v: unknown): v is object => {
+  return lodashIsPlainObject(v);
+};
 
 /**
  * Checks if passed argument is a string
@@ -213,10 +339,9 @@ export function isObject(v: any): v is object {
  * @param {*} v - variable to check
  * @returns {boolean}
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function isString(v: any): v is string {
-  return typeOf(v) === 'string';
-}
+export const isString = (v: unknown): v is string => {
+  return lodashIsString(v);
+};
 
 /**
  * Checks if passed argument is boolean
@@ -224,10 +349,9 @@ export function isString(v: any): v is string {
  * @param {*} v - variable to check
  * @returns {boolean}
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function isBoolean(v: any): v is boolean {
-  return typeOf(v) === 'boolean';
-}
+export const isBoolean = (v: unknown): v is boolean => {
+  return lodashIsBoolean(v);
+};
 
 /**
  * Checks if passed argument is number
@@ -235,10 +359,9 @@ export function isBoolean(v: any): v is boolean {
  * @param {*} v - variable to check
  * @returns {boolean}
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function isNumber(v: any): v is number {
-  return typeOf(v) === 'number';
-}
+export const isNumber = (v: unknown): v is number => {
+  return lodashIsNumber(v);
+};
 
 /**
  * Checks if passed argument is undefined
@@ -246,21 +369,9 @@ export function isNumber(v: any): v is number {
  * @param {*} v - variable to check
  * @returns {boolean}
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function isUndefined(v: any): v is undefined {
-  return typeOf(v) === 'undefined';
-}
-
-/**
- * Check if passed function is a class
- *
- * @param {Function} fn - function to check
- * @returns {boolean}
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function isClass(fn: any): boolean {
-  return isFunction(fn) && /^\s*class\s+/.test(fn.toString());
-}
+export const isUndefined = function (v: unknown): v is undefined {
+  return lodashIsUndefined(v);
+};
 
 /**
  * Checks if object is empty
@@ -268,42 +379,25 @@ export function isClass(fn: any): boolean {
  * @param {object} object - object to check
  * @returns {boolean}
  */
-export function isEmpty(object: object): boolean {
-  if (!object) {
-    return true;
-  }
-
-  return Object.keys(object).length === 0 && object.constructor === Object;
-}
-
-/**
- * Check if passed object is a Promise
- *
- * @param  {*}  object - object to check
- * @returns {boolean}
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function isPromise(object: any): object is Promise<any> {
-  return Promise.resolve(object) === object;
-}
+export const isEmpty = (object: object | null | undefined): boolean => {
+  return lodashIsEmpty(object);
+};
 
-/* eslint-disable @typescript-eslint/no-magic-numbers */
 /**
  * Returns true if passed key code is printable (a-Z, 0-9, etc) character.
  *
  * @param {number} keyCode - key code
  * @returns {boolean}
  */
-export function isPrintableKey(keyCode: number): boolean {
-  return (keyCode > 47 && keyCode < 58) || // number keys
-    keyCode === 32 || keyCode === 13 || // Space bar & return key(s)
-    keyCode === 229 || // processing key input for certain languages — Chinese, Japanese, etc.
-    (keyCode > 64 && keyCode < 91) || // letter keys
-    (keyCode > 95 && keyCode < 112) || // Numpad keys
-    (keyCode > 185 && keyCode < 193) || // ;=,-./` (in order)
-    (keyCode > 218 && keyCode < 223); // [\]' (in order)
-}
-/* eslint-enable @typescript-eslint/no-magic-numbers */
+export const isPrintableKey = (keyCode: number): boolean => {
+  return (keyCode > keyCodes.NUMBER_KEY_MIN && keyCode < keyCodes.NUMBER_KEY_MAX) || // number keys
+    keyCode === keyCodes.SPACE || keyCode === keyCodes.ENTER || // Space bar & return key(s)
+    keyCode === keyCodes.PROCESSING_KEY || // processing key input for certain languages — Chinese, Japanese, etc.
+    (keyCode > keyCodes.LETTER_KEY_MIN && keyCode < keyCodes.LETTER_KEY_MAX) || // letter keys
+    (keyCode > keyCodes.NUMPAD_KEY_MIN && keyCode < keyCodes.NUMPAD_KEY_MAX) || // Numpad keys
+    (keyCode > keyCodes.PUNCTUATION_KEY_MIN && keyCode < keyCodes.PUNCTUATION_KEY_MAX) || // ;=,-./` (in order)
+    (keyCode > keyCodes.BRACKET_KEY_MIN && keyCode < keyCodes.BRACKET_KEY_MAX); // [\]' (in order)
+};
 
 /**
  * Fires a promise sequence asynchronously
@@ -314,13 +408,11 @@ export function isPrintableKey(keyCode: number): boolean {
  * @returns {Promise}
  * @deprecated use PromiseQueue.ts instead
  */
-export async function sequence(
+export const sequence = async (
   chains: ChainData[],
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
   success: (data: object) => void = (): void => {},
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
   fallback: (data: object) => void = (): void => {}
-): Promise<void> {
+): Promise<void> => {
   /**
    * Decorator
    *
@@ -329,18 +421,18 @@ export async function sequence(
    * @param {Function} fallbackCallback - fail callback
    * @returns {Promise}
    */
-  async function waitNextBlock(
+  const waitNextBlock = async (
     chainData: ChainData,
     successCallback: (data: object) => void,
     fallbackCallback: (data: object) => void
-  ): Promise<void> {
+  ): Promise<void> => {
     try {
       await chainData.function(chainData.data);
       await successCallback(!isUndefined(chainData.data) ? chainData.data : {});
     } catch (e) {
       fallbackCallback(!isUndefined(chainData.data) ? chainData.data : {});
     }
-  }
+  };
 
   /**
    * pluck each element from queue
@@ -354,7 +446,7 @@ export async function sequence(
 
     return waitNextBlock(currentValue, success, fallback);
   }, Promise.resolve());
-}
+};
 
 /**
  * Make array from array-like collection
@@ -363,9 +455,9 @@ export async function sequence(
  * @returns {Array}
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function array(collection: ArrayLike<any>): any[] {
-  return Array.prototype.slice.call(collection);
-}
+export const array = (collection: ArrayLike<any>): any[] => {
+  return lodashToArray(collection);
+};
 
 /**
  * Delays method execution
@@ -373,17 +465,11 @@ export function array(collection: ArrayLike<any>): any[] {
  * @param {Function} method - method to execute
  * @param {number} timeout - timeout in ms
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function delay(method: (...args: any[]) => any, timeout: number) {
-  return function (): void {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const context = this,
-        // eslint-disable-next-line prefer-rest-params
-        args = arguments;
-
-    window.setTimeout(() => method.apply(context, args), timeout);
+export const delay = (method: (...args: unknown[]) => unknown, timeout: number) => {
+  return function (this: unknown, ...args: unknown[]): void {
+    void lodashDelay(() => method.apply(this, args), timeout);
   };
-}
+};
 
 /**
  * Get file extension
@@ -391,9 +477,9 @@ export function delay(method: (...args: any[]) => any, timeout: number) {
  * @param {File} file - file
  * @returns {string}
  */
-export function getFileExtension(file: File): string {
-  return file.name.split('.').pop();
-}
+export const getFileExtension = (file: File): string => {
+  return file.name.split('.').pop() ?? '';
+};
 
 /**
  * Check if string is MIME type
@@ -401,9 +487,9 @@ export function getFileExtension(file: File): string {
  * @param {string} type - string to check
  * @returns {boolean}
  */
-export function isValidMimeType(type: string): boolean {
+export const isValidMimeType = (type: string): boolean => {
   return /^[-\w]+\/([-+\w]+|\*)$/.test(type);
-}
+};
 
 /**
  * Debouncing method
@@ -416,30 +502,30 @@ export function isValidMimeType(type: string): boolean {
  * @param {boolean} immediate - call now
  * @returns {Function}
  */
-export function debounce(func: (...args: unknown[]) => void, wait?: number, immediate?: boolean): () => void {
-  let timeout;
-
-  return (...args: unknown[]): void => {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const context = this;
+export const debounce = (func: (...args: unknown[]) => void, wait?: number, immediate?: boolean): (...args: unknown[]) => void => {
+  const state = {
+    timeoutId: null as ReturnType<typeof setTimeout> | null,
+  };
 
-    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-    const later = () => {
-      timeout = null;
-      if (!immediate) {
-        func.apply(context, args);
+  return function (this: unknown, ...args: unknown[]): void {
+    const later = (): void => {
+      state.timeoutId = null;
+      if (immediate !== true) {
+        func.apply(this, args);
       }
     };
 
-    const callNow = immediate && !timeout;
+    const callNow = immediate === true && state.timeoutId === null;
 
-    window.clearTimeout(timeout);
-    timeout = window.setTimeout(later, wait);
+    if (state.timeoutId !== null) {
+      clearTimeout(state.timeoutId);
+    }
+    state.timeoutId = setTimeout(later, wait);
     if (callNow) {
-      func.apply(context, args);
+      func.apply(this, args);
     }
   };
-}
+};
 
 /**
  * Returns a function, that, when invoked, will only be triggered at most once during a given window of time.
@@ -451,104 +537,37 @@ export function debounce(func: (...args: unknown[]) => void, wait?: number, imme
  *                  but if you'd like to disable the execution on the leading edge, pass
  *                  `{leading: false}`. To disable execution on the trailing edge, ditto.
  */
-export function throttle(func, wait, options: {leading?: boolean; trailing?: boolean} = undefined): () => void {
-  let context, args, result;
-  let timeout = null;
-  let previous = 0;
-
-  if (!options) {
-    options = {};
-  }
-
-  const later = function (): void {
-    previous = options.leading === false ? 0 : Date.now();
-    timeout = null;
-    result = func.apply(context, args);
-
-    if (!timeout) {
-      context = args = null;
-    }
-  };
-
-  return function (): unknown {
-    const now = Date.now();
-
-    if (!previous && options.leading === false) {
-      previous = now;
-    }
-
-    const remaining = wait - (now - previous);
-
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    context = this;
-
-    // eslint-disable-next-line prefer-rest-params
-    args = arguments;
-
-    if (remaining <= 0 || remaining > wait) {
-      if (timeout) {
-        clearTimeout(timeout);
-        timeout = null;
-      }
-      previous = now;
-      result = func.apply(context, args);
-
-      if (!timeout) {
-        context = args = null;
-      }
-    } else if (!timeout && options.trailing !== false) {
-      timeout = setTimeout(later, remaining);
-    }
-
-    return result;
-  };
-}
-
-/**
- * Copies passed text to the clipboard
- *
- * @param text - text to copy
- */
-export function copyTextToClipboard(text): void {
-  const el = Dom.make('div', 'codex-editor-clipboard', {
-    innerHTML: text,
-  });
-
-  document.body.appendChild(el);
-
-  const selection = window.getSelection();
-  const range = document.createRange();
-
-  range.selectNode(el);
-
-  window.getSelection().removeAllRanges();
-  selection.addRange(range);
-
-  document.execCommand('copy');
-  document.body.removeChild(el);
-}
+export const throttle = (
+  func: (...args: unknown[]) => unknown,
+  wait: number,
+  options?: {leading?: boolean; trailing?: boolean}
+): ((...args: unknown[]) => unknown) => {
+  return lodashThrottle(func, wait, options);
+};
 
 /**
  * Returns object with os name as key and boolean as value. Shows current user OS
  */
-export function getUserOS(): {[key: string]: boolean} {
-  const OS = {
+export const getUserOS = (): {[key: string]: boolean} => {
+  const OS: {[key: string]: boolean} = {
     win: false,
     mac: false,
     x11: false,
     linux: false,
   };
 
-  const userOS = Object.keys(OS).find((os: string) => window.navigator.appVersion.toLowerCase().indexOf(os) !== -1);
+  const navigatorRef = getGlobalNavigator();
+  const userAgent = navigatorRef?.userAgent?.toLowerCase() ?? '';
+  const userOS = userAgent ? Object.keys(OS).find((os: string) => userAgent.indexOf(os) !== -1) : undefined;
 
-  if (userOS) {
+  if (userOS !== undefined) {
     OS[userOS] = true;
 
     return OS;
   }
 
   return OS;
-}
+};
 
 /**
  * Capitalizes first letter of the string
@@ -556,60 +575,51 @@ export function getUserOS(): {[key: string]: boolean} {
  * @param {string} text - text to capitalize
  * @returns {string}
  */
-export function capitalize(text: string): string {
-  return text[0].toUpperCase() + text.slice(1);
-}
+export const capitalize = (text: string): string => {
+  if (!text) {
+    return text;
+  }
+
+  return text.slice(0, 1).toUpperCase() + text.slice(1);
+};
 
 /**
- * Merge to objects recursively
+ * Customizer function for deep merge that overwrites arrays
  *
- * @param {object} target - merge target
- * @param {object[]} sources - merge sources
- * @returns {object}
+ * @param {unknown} objValue - object value
+ * @param {unknown} srcValue - source value
+ * @returns {unknown}
  */
-export function deepMerge<T extends object>(target, ...sources): T {
-  if (!sources.length) {
-    return target;
+const overwriteArrayMerge = (objValue: unknown, srcValue: unknown): unknown => {
+  if (Array.isArray(srcValue)) {
+    return srcValue;
   }
-  const source = sources.shift();
 
-  if (isObject(target) && isObject(source)) {
-    for (const key in source) {
-      if (isObject(source[key])) {
-        if (!target[key]) {
-          Object.assign(target, { [key]: {} });
-        }
+  return undefined;
+};
 
-        deepMerge(target[key], source[key]);
-      } else {
-        Object.assign(target, { [key]: source[key] });
-      }
-    }
+export const deepMerge = <T extends object> (target: T, ...sources: Partial<T>[]): T => {
+  if (!isObject(target) || sources.length === 0) {
+    return target;
   }
 
-  return deepMerge(target, ...sources);
-}
+  return sources.reduce((acc: T, source) => {
+    if (!isObject(source)) {
+      return acc;
+    }
 
-/**
- * Return true if current device supports touch events
- *
- * Note! This is a simple solution, it can give false-positive results.
- * To detect touch devices more carefully, use 'touchstart' event listener
- *
- * @see http://www.stucox.com/blog/you-cant-detect-a-touchscreen/
- * @returns {boolean}
- */
-export const isTouchSupported: boolean = 'ontouchstart' in document.documentElement;
+    return lodashMergeWith(acc, source, overwriteArrayMerge) as T;
+  }, target);
+};
 
 /**
  * Make shortcut command more human-readable
  *
  * @param {string} shortcut — string like 'CMD+B'
  */
-export function beautifyShortcut(shortcut: string): string {
+export const beautifyShortcut = (shortcut: string): string => {
   const OS = getUserOS();
-
-  shortcut = shortcut
+  const normalizedShortcut = shortcut
     .replace(/shift/gi, '⇧')
     .replace(/backspace/gi, '⌫')
     .replace(/enter/gi, '⏎')
@@ -623,13 +633,11 @@ export function beautifyShortcut(shortcut: string): string {
     .replace(/\+/gi, ' + ');
 
   if (OS.mac) {
-    shortcut = shortcut.replace(/ctrl|cmd/gi, '⌘').replace(/alt/gi, '⌥');
-  } else {
-    shortcut = shortcut.replace(/cmd/gi, 'Ctrl').replace(/windows/gi, 'WIN');
+    return normalizedShortcut.replace(/ctrl|cmd/gi, '⌘').replace(/alt/gi, '⌥');
   }
 
-  return shortcut;
-}
+  return normalizedShortcut.replace(/cmd/gi, 'Ctrl').replace(/windows/gi, 'WIN');
+};
 
 /**
  * Returns valid URL. If it is going outside and valid, it returns itself
@@ -638,7 +646,7 @@ export function beautifyShortcut(shortcut: string): string {
  *
  * @param {string} url - url to prettify
  */
-export function getValidUrl(url: string): string {
+export const getValidUrl = (url: string): string => {
   try {
     const urlObject = new URL(url);
 
@@ -647,32 +655,40 @@ export function getValidUrl(url: string): string {
     // do nothing but handle below
   }
 
+  const win = getGlobalWindow();
+
   if (url.substring(0, 2) === '//') {
-    return window.location.protocol + url;
-  } else {
-    return window.location.origin + url;
+    return win ? `${win.location.protocol}${url}` : url;
   }
-}
+
+  return win ? `${win.location.origin}${url}` : url;
+};
 
 /**
  * Create a block id
  *
  * @returns {string}
  */
-export function generateBlockId(): string {
+export const generateBlockId = (): string => {
   const idLen = 10;
 
   return nanoid(idLen);
-}
+};
 
 /**
  * Opens new Tab with passed URL
  *
  * @param {string} url - URL address to redirect
  */
-export function openTab(url: string): void {
-  window.open(url, '_blank');
-}
+export const openTab = (url: string): void => {
+  const win = getGlobalWindow();
+
+  if (!win) {
+    return;
+  }
+
+  win.open(url, '_blank');
+};
 
 /**
  * Returns random generated identifier
@@ -680,10 +696,9 @@ export function openTab(url: string): void {
  * @param {string} prefix - identifier prefix
  * @returns {string}
  */
-export function generateId(prefix = ''): string {
-  // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-  return `${prefix}${(Math.floor(Math.random() * 1e8)).toString(16)}`;
-}
+export const generateId = (prefix = ''): string => {
+  return `${prefix}${(Math.floor(Math.random() * ID_RANDOM_MULTIPLIER)).toString(HEXADECIMAL_RADIX)}`;
+};
 
 /**
  * Common method for printing a warning about the usage of deprecated property or method.
@@ -692,63 +707,215 @@ export function generateId(prefix = ''): string {
  * @param oldProperty - deprecated property.
  * @param newProperty - the property that should be used instead.
  */
-export function deprecationAssert(condition: boolean, oldProperty: string, newProperty: string): void {
+export const deprecationAssert = (condition: boolean, oldProperty: string, newProperty: string): void => {
   const message = `«${oldProperty}» is deprecated and will be removed in the next major release. Please use the «${newProperty}» instead.`;
 
   if (condition) {
     logLabeled(message, 'warn');
   }
-}
-
-/**
- * Decorator which provides ability to cache method or accessor result
- *
- * @param target - target instance or constructor function
- * @param propertyKey - method or accessor name
- * @param descriptor - property descriptor
- */
-export function cacheable<Target, Value, Arguments extends unknown[] = unknown[]>(
-  target: Target,
-  propertyKey: string,
-  descriptor: PropertyDescriptor
-): PropertyDescriptor {
-  const propertyToOverride = descriptor.value ? 'value' : 'get';
-  const originalMethod = descriptor[propertyToOverride];
-  const cacheKey = `#${propertyKey}Cache`;
+};
 
-  /**
-   * Override get or value descriptor property to cache return value
-   *
-   * @param args - method args
-   */
-  descriptor[propertyToOverride] = function (...args: Arguments): Value {
-    /**
-     * If there is no cache, create it
-     */
-    if (this[cacheKey] === undefined) {
-      this[cacheKey] = originalMethod.apply(this, ...args);
-    }
+type CacheableAccessor<Value> = {
+  get?: () => Value;
+  set?: (value: Value) => void;
+  init?: (value: Value) => Value;
+};
 
-    return this[cacheKey];
+type Stage3DecoratorContext = {
+  kind: 'method' | 'getter' | 'setter' | 'accessor';
+  name: string | symbol;
+  static?: boolean;
+  private?: boolean;
+  access?: {
+    get?: () => unknown;
+    set?: (value: unknown) => void;
   };
+};
 
-  /**
-   * If get accessor has been overridden, we need to override set accessor to clear cache
-   *
-   * @param value - value to set
-   */
-  if (propertyToOverride === 'get' && descriptor.set) {
-    const originalSet = descriptor.set;
+type CacheableDecorator = {
+  <Member>(
+    target: object,
+    propertyKey: string | symbol,
+    descriptor?: TypedPropertyDescriptor<Member>
+  ): TypedPropertyDescriptor<Member> | void;
+  <Value = unknown, Arguments extends unknown[] = unknown[]>(
+    value: ((...args: Arguments) => Value) | CacheableAccessor<Value>,
+    context: Stage3DecoratorContext
+  ):
+    | ((...args: Arguments) => Value)
+    | CacheableAccessor<Value>;
+};
+
+const ensureCacheValue = <Value>(
+  holder: object,
+  cacheKey: string | symbol,
+  compute: () => Value
+): Value => {
+  if (!Reflect.has(holder, cacheKey)) {
+    Object.defineProperty(holder, cacheKey, {
+      configurable: true,
+      writable: true,
+      value: compute(),
+    });
+  }
 
-    descriptor.set = function (value: unknown): void {
-      delete target[cacheKey];
+  return Reflect.get(holder, cacheKey) as Value;
+};
 
-      originalSet.apply(this, value);
+const clearCacheValue = (holder: object, cacheKey: string | symbol): void => {
+  if (Reflect.has(holder, cacheKey)) {
+    Reflect.deleteProperty(holder, cacheKey);
+  }
+};
+
+const isStage3DecoratorContext = (context: unknown): context is Stage3DecoratorContext => {
+  if (typeof context !== 'object' || context === null) {
+    return false;
+  }
+
+  return 'kind' in context && 'name' in context;
+};
+
+const buildLegacyCacheableDescriptor = (
+  target: Record<PropertyKey, unknown>,
+  propertyKey: string | symbol,
+  descriptor?: TypedPropertyDescriptor<unknown>
+): TypedPropertyDescriptor<unknown> => {
+  const baseDescriptor =
+    descriptor ??
+    Object.getOwnPropertyDescriptor(target, propertyKey) ??
+    (typeof target === 'function'
+      ? Object.getOwnPropertyDescriptor((target as unknown as { prototype?: object }).prototype ?? {}, propertyKey)
+      : undefined) ??
+    {
+      configurable: true,
+      enumerable: false,
+      writable: true,
+      value: Reflect.get(target, propertyKey),
     };
+
+  const descriptorRef = { ...baseDescriptor } as TypedPropertyDescriptor<unknown>;
+  const cacheKey: string | symbol = typeof propertyKey === 'symbol' ? propertyKey : `#${propertyKey}Cache`;
+  const hasMethodValue = descriptorRef.value !== undefined && typeof descriptorRef.value === 'function';
+  const shouldWrapGetter = !hasMethodValue && descriptorRef.get !== undefined;
+  const shouldWrapSetter = shouldWrapGetter && descriptorRef.set !== undefined;
+
+  if (hasMethodValue) {
+    const originalMethod = descriptorRef.value as (...methodArgs: unknown[]) => unknown;
+
+    descriptorRef.value = function (this: object, ...methodArgs: unknown[]): unknown {
+      return ensureCacheValue(this, cacheKey, () => originalMethod.apply(this, methodArgs));
+    } as typeof originalMethod;
+  }
+
+  if (shouldWrapGetter && descriptorRef.get !== undefined) {
+    const originalGetter = descriptorRef.get as () => unknown;
+
+    descriptorRef.get = function (this: object): unknown {
+      return ensureCacheValue(this, cacheKey, () => originalGetter.call(this));
+    } as typeof originalGetter;
+  }
+
+  if (shouldWrapSetter && descriptorRef.set !== undefined) {
+    const originalSetter = descriptorRef.set;
+
+    descriptorRef.set = function (this: object, newValue: unknown): void {
+      clearCacheValue(this, cacheKey);
+      originalSetter.call(this, newValue);
+    } as typeof originalSetter;
+  }
+
+  if (!descriptor) {
+    return descriptorRef;
   }
 
+  Object.keys(descriptor).forEach(propertyName => {
+    if (!(propertyName in descriptorRef)) {
+      Reflect.deleteProperty(descriptor, propertyName as keyof PropertyDescriptor);
+    }
+  });
+
+  Object.assign(descriptor, descriptorRef);
+
   return descriptor;
-}
+};
+
+const applyStage3CacheableDecorator = (
+  value: ((...methodArgs: unknown[]) => unknown) | CacheableAccessor<unknown>,
+  context: Stage3DecoratorContext
+): unknown => {
+  const cacheKey = Symbol(
+    typeof context.name === 'symbol'
+      ? `cache:${context.name.description ?? 'symbol'}`
+      : `cache:${context.name}`
+  );
+
+  if (context.kind === 'method' && typeof value === 'function') {
+    const originalMethod = value as (...methodArgs: unknown[]) => unknown;
+
+    return function (this: object, ...methodArgs: unknown[]): unknown {
+      return ensureCacheValue(this, cacheKey, () => originalMethod.apply(this, methodArgs));
+    } as typeof originalMethod;
+  }
+
+  if (context.kind === 'getter' && typeof value === 'function') {
+    const originalGetter = value as () => unknown;
+
+    return function (this: object): unknown {
+      return ensureCacheValue(this, cacheKey, () => originalGetter.call(this));
+    } as typeof originalGetter;
+  }
+
+  if (context.kind === 'accessor' && typeof value === 'object' && value !== null) {
+    const accessor = value as CacheableAccessor<unknown>;
+    const fallbackGetter = accessor.get ?? context.access?.get;
+    const fallbackSetter = accessor.set ?? context.access?.set;
+
+    return {
+      get(this: object): unknown {
+        return fallbackGetter
+          ? ensureCacheValue(this, cacheKey, () => fallbackGetter.call(this))
+          : undefined;
+      },
+      set(this: object, newValue: unknown): void {
+        clearCacheValue(this, cacheKey);
+        fallbackSetter?.call(this, newValue);
+      },
+      init(initialValue: unknown): unknown {
+        return accessor.init ? accessor.init(initialValue) : initialValue;
+      },
+    } satisfies CacheableAccessor<unknown>;
+  }
+
+  return value;
+};
+
+/**
+ * Decorator which provides ability to cache method or accessor result.
+ * Supports both legacy and TC39 stage 3 decorator semantics.
+ *
+ * @param args - decorator arguments (legacy: target, propertyKey, descriptor. Stage 3: value, context)
+ */
+const cacheableImpl = (...args: unknown[]): unknown => {
+  if (args.length === 2 && isStage3DecoratorContext(args[1])) {
+    const [value, context] = args as [
+      ((...methodArgs: unknown[]) => unknown) | CacheableAccessor<unknown>,
+      Stage3DecoratorContext
+    ];
+
+    return applyStage3CacheableDecorator(value, context);
+  }
+
+  const [target, propertyKey, descriptor] = args as [
+    Record<PropertyKey, unknown>,
+    string | symbol,
+    TypedPropertyDescriptor<unknown> | undefined
+  ];
+
+  return buildLegacyCacheableDescriptor(target, propertyKey, descriptor);
+};
+
+export const cacheable = cacheableImpl as CacheableDecorator;
 
 /**
  * All screens below this width will be treated as mobile;
@@ -758,19 +925,56 @@ export const mobileScreenBreakpoint = 650;
 /**
  * True if screen has mobile size
  */
-export function isMobileScreen(): boolean {
-  return window.matchMedia(`(max-width: ${mobileScreenBreakpoint}px)`).matches;
-}
+export const isMobileScreen = (): boolean => {
+  const win = getGlobalWindow();
+
+  if (!win || typeof win.matchMedia !== 'function') {
+    return false;
+  }
+
+  return win.matchMedia(`(max-width: ${mobileScreenBreakpoint}px)`).matches;
+};
 
 /**
  * True if current device runs iOS
  */
-export const isIosDevice =
-  typeof window !== 'undefined' &&
-  window.navigator &&
-  window.navigator.platform &&
-  (/iP(ad|hone|od)/.test(window.navigator.platform) ||
-    (window.navigator.platform === 'MacIntel' && window.navigator.maxTouchPoints > 1));
+export const isIosDevice = (() => {
+  const navigatorRef = getGlobalNavigator();
+
+  if (!navigatorRef) {
+    return false;
+  }
+
+  const userAgent = navigatorRef.userAgent || '';
+
+  // Use modern User-Agent Client Hints API if available
+  const userAgentData = (navigatorRef as Navigator & { userAgentData?: { platform?: string } }).userAgentData;
+  const platform = userAgentData?.platform;
+
+  // Check userAgent string first (most reliable method)
+  if (/iP(ad|hone|od)/.test(userAgent)) {
+    return true;
+  }
+
+  // Check platform from User-Agent Client Hints API if available
+  if (platform !== undefined && platform !== '' && /iP(ad|hone|od)/.test(platform)) {
+    return true;
+  }
+
+  // Check for iPad on iOS 13+ (reports as MacIntel with touch support)
+  // Only access deprecated platform property when necessary
+  const hasTouchSupport = (navigatorRef.maxTouchPoints ?? 0) > 1;
+  const getLegacyPlatform = (): string | undefined =>
+    (navigatorRef as Navigator & { platform?: string })['platform'];
+  const platformHint = platform !== undefined && platform !== '' ? platform : undefined;
+  const platformValue = hasTouchSupport ? platformHint ?? getLegacyPlatform() : undefined;
+
+  if (platformValue === 'MacIntel') {
+    return true;
+  }
+
+  return false;
+})();
 
 /**
  * Compares two values with unknown type
@@ -779,13 +983,6 @@ export const isIosDevice =
  * @param var2 - value to compare with
  * @returns {boolean} true if they are equal
  */
-export function equals(var1: unknown, var2: unknown): boolean {
-  const isVar1NonPrimitive = Array.isArray(var1) || isObject(var1);
-  const isVar2NonPrimitive = Array.isArray(var2) || isObject(var2);
-
-  if (isVar1NonPrimitive || isVar2NonPrimitive) {
-    return JSON.stringify(var1) === JSON.stringify(var2);
-  }
-
-  return var1 === var2;
-}
+export const equals = (var1: unknown, var2: unknown): boolean => {
+  return lodashIsEqual(var1, var2);
+};
diff --git a/src/components/utils/api.ts b/src/components/utils/api.ts
index 2aa0e255b..fa7924d63 100644
--- a/src/components/utils/api.ts
+++ b/src/components/utils/api.ts
@@ -8,7 +8,7 @@ import type Block from '../block';
  * @param attribute - either BlockAPI or Block id or Block index
  * @param editor - Editor instance
  */
-export function resolveBlock(attribute: BlockAPI | BlockAPI['id'] | number, editor: EditorModules): Block | undefined {
+export const resolveBlock = (attribute: BlockAPI | BlockAPI['id'] | number, editor: EditorModules): Block | undefined => {
   if (typeof attribute === 'number') {
     return editor.BlockManager.getBlockByIndex(attribute);
   }
@@ -18,4 +18,4 @@ export function resolveBlock(attribute: BlockAPI | BlockAPI['id'] | number, edit
   }
 
   return editor.BlockManager.getBlockById(attribute.id);
-}
+};
diff --git a/src/components/utils/bem.ts b/src/components/utils/bem.ts
index 428891e2f..9e2ba8839 100644
--- a/src/components/utils/bem.ts
+++ b/src/components/utils/bem.ts
@@ -10,7 +10,7 @@ const MODIFIER_DELIMITER = '--';
  * @example bem('ce-popover)(null, 'hidden') -> 'ce-popover--hidden'
  * @param blockName - string with block name
  */
-export function bem(blockName: string) {
+export const bem = (blockName: string) => {
   /**
    * @param elementName - string with element name
    * @param modifier - modifier to be appended
@@ -24,4 +24,4 @@ export function bem(blockName: string) {
       .filter(x => !!x)
       .join(MODIFIER_DELIMITER);
   };
-}
+};
diff --git a/src/components/utils/blocks.ts b/src/components/utils/blocks.ts
index 710cfa5f8..f206c205b 100644
--- a/src/components/utils/blocks.ts
+++ b/src/components/utils/blocks.ts
@@ -14,9 +14,9 @@ import { isToolConvertable } from './tools';
  * @param block - block to check
  * @param direction - export for block to merge from, import for block to merge to
  */
-export function isBlockConvertable(block: Block, direction: 'export' | 'import'): boolean {
+export const isBlockConvertable = (block: Block, direction: 'export' | 'import'): boolean => {
   return isToolConvertable(block.tool, direction);
-}
+};
 
 /**
  * Checks that all the properties of the first block data exist in second block data with the same values.
@@ -35,11 +35,11 @@ export function isBlockConvertable(block: Block, direction: 'export' | 'import')
  * @param data1 – first block data
  * @param data2 – second block data
  */
-export function isSameBlockData(data1: BlockToolData, data2: BlockToolData): boolean {
+export const isSameBlockData = (data1: BlockToolData, data2: BlockToolData): boolean => {
   return Object.entries(data1).some((([propName, propValue]) => {
     return data2[propName] && equals(data2[propName], propValue);
   }));
-}
+};
 
 /**
  * Returns list of tools you can convert specified block to
@@ -47,7 +47,7 @@ export function isSameBlockData(data1: BlockToolData, data2: BlockToolData): boo
  * @param block - block to get conversion items for
  * @param allBlockTools - all block tools available in the editor
  */
-export async function getConvertibleToolsForBlock(block: BlockAPI, allBlockTools: BlockToolAdapter[]): Promise<BlockToolAdapter[]> {
+export const getConvertibleToolsForBlock = async (block: BlockAPI, allBlockTools: BlockToolAdapter[]): Promise<BlockToolAdapter[]> => {
   const savedData = await block.save() as SavedData;
   const blockData = savedData.data;
 
@@ -84,15 +84,17 @@ export async function getConvertibleToolsForBlock(block: BlockAPI, allBlockTools
         return false;
       }
 
-      if (toolboxItem.data !== undefined) {
-        /**
-         * When a tool has several toolbox entries, we need to make sure we do not add
-         * toolbox item with the same data to the resulting array. This helps exclude duplicates
-         */
-        if (isSameBlockData(toolboxItem.data, blockData)) {
-          return false;
-        }
-      } else if (tool.name === block.name) {
+      const hasToolboxData = toolboxItem.data !== undefined;
+
+      /**
+       * When a tool has several toolbox entries, we need to make sure we do not add
+       * toolbox item with the same data to the resulting array. This helps exclude duplicates
+       */
+      if (hasToolboxData && isSameBlockData(toolboxItem.data, blockData)) {
+        return false;
+      }
+
+      if (!hasToolboxData && tool.name === block.name) {
         return false;
       }
 
@@ -106,7 +108,7 @@ export async function getConvertibleToolsForBlock(block: BlockAPI, allBlockTools
 
     return result;
   }, [] as BlockToolAdapter[]);
-}
+};
 
 
 /**
@@ -120,7 +122,7 @@ export async function getConvertibleToolsForBlock(block: BlockAPI, allBlockTools
  * @param targetBlock - block to merge to
  * @param blockToMerge - block to merge from
  */
-export function areBlocksMergeable(targetBlock: Block, blockToMerge: Block): boolean {
+export const areBlocksMergeable = (targetBlock: Block, blockToMerge: Block): boolean => {
   /**
    * If target block has not 'merge' method, we can't merge blocks.
    *
@@ -141,7 +143,7 @@ export function areBlocksMergeable(targetBlock: Block, blockToMerge: Block): boo
    * We can merge blocks if they have valid conversion config
    */
   return isBlockConvertable(blockToMerge, 'export') && isBlockConvertable(targetBlock, 'import');
-}
+};
 
 /**
  * Using conversionConfig, convert block data to string.
@@ -149,25 +151,27 @@ export function areBlocksMergeable(targetBlock: Block, blockToMerge: Block): boo
  * @param blockData - block data to convert
  * @param conversionConfig - tool's conversion config
  */
-export function convertBlockDataToString(blockData: BlockToolData, conversionConfig?: ConversionConfig ): string {
+export const convertBlockDataToString = (blockData: BlockToolData, conversionConfig?: ConversionConfig ): string => {
   const exportProp = conversionConfig?.export;
 
   if (isFunction(exportProp)) {
     return exportProp(blockData);
-  } else if (isString(exportProp)) {
+  }
+
+  if (isString(exportProp)) {
     return blockData[exportProp];
-  } else {
-    /**
-     * Tool developer provides 'export' property, but it is not correct. Warn him.
-     */
-    if (exportProp !== undefined) {
-      log('Conversion «export» property must be a string or function. ' +
-      'String means key of saved data object to export. Function should export processed string to export.');
-    }
+  }
 
-    return '';
+  /**
+   * Tool developer provides 'export' property, but it is not correct. Warn him.
+   */
+  if (exportProp !== undefined) {
+    log('Conversion «export» property must be a string or function. ' +
+    'String means key of saved data object to export. Function should export processed string to export.');
   }
-}
+
+  return '';
+};
 
 /**
  * Using conversionConfig, convert string to block data.
@@ -176,25 +180,26 @@ export function convertBlockDataToString(blockData: BlockToolData, conversionCon
  * @param conversionConfig - tool's conversion config
  * @param targetToolConfig - target tool config, used in conversionConfig.import method
  */
-export function convertStringToBlockData(stringToImport: string, conversionConfig?: ConversionConfig, targetToolConfig?: ToolConfig): BlockToolData {
+export const convertStringToBlockData = (stringToImport: string, conversionConfig?: ConversionConfig, targetToolConfig?: ToolConfig): BlockToolData => {
   const importProp = conversionConfig?.import;
 
   if (isFunction(importProp)) {
     return importProp(stringToImport, targetToolConfig);
-  } else if (isString(importProp)) {
+  }
+
+  if (isString(importProp)) {
     return {
       [importProp]: stringToImport,
     };
-  } else {
-    /**
-     * Tool developer provides 'import' property, but it is not correct. Warn him.
-     */
-    if (importProp !== undefined) {
-      log('Conversion «import» property must be a string or function. ' +
-      'String means key of tool data to import. Function accepts a imported string and return composed tool data.');
-    }
+  }
 
-    return {};
+  /**
+   * Tool developer provides 'import' property, but it is not correct. Warn him.
+   */
+  if (importProp !== undefined) {
+    log('Conversion «import» property must be a string or function. ' +
+    'String means key of tool data to import. Function accepts a imported string and return composed tool data.');
   }
-}
 
+  return {};
+};
diff --git a/src/components/utils/caret.ts b/src/components/utils/caret.ts
index 58bf96044..b79c1fc66 100644
--- a/src/components/utils/caret.ts
+++ b/src/components/utils/caret.ts
@@ -7,17 +7,17 @@ import $, { isCollapsedWhitespaces } from '../dom';
  * Handles a case when focusNode is an ElementNode and focusOffset is a child index,
  * returns child node with focusOffset index as a new focusNode
  */
-export function getCaretNodeAndOffset(): [ Node | null, number ] {
+export const getCaretNodeAndOffset = (): [ Node | null, number ] => {
   const selection = window.getSelection();
 
   if (selection === null) {
     return [null, 0];
   }
 
-  let focusNode = selection.focusNode;
-  let focusOffset = selection.focusOffset;
+  const initialFocusNode = selection.focusNode;
+  const initialFocusOffset = selection.focusOffset;
 
-  if (focusNode === null) {
+  if (initialFocusNode === null) {
     return [null, 0];
   }
 
@@ -29,24 +29,27 @@ export function getCaretNodeAndOffset(): [ Node | null, number ] {
    *
    *
    */
-  if (focusNode.nodeType !== Node.TEXT_NODE && focusNode.childNodes.length > 0) {
-    /**
-     * In normal cases, focusOffset is a child index.
-     */
-    if (focusNode.childNodes[focusOffset]) {
-      focusNode = focusNode.childNodes[focusOffset];
-      focusOffset = 0;
-    /**
-     * But in Firefox, focusOffset can be 1 with the single child.
-     */
-    } else {
-      focusNode = focusNode.childNodes[focusOffset - 1];
-      focusOffset = focusNode.textContent.length;
-    }
+  if (initialFocusNode.nodeType === Node.TEXT_NODE || initialFocusNode.childNodes.length === 0) {
+    return [initialFocusNode, initialFocusOffset];
   }
 
-  return [focusNode, focusOffset];
-}
+  /**
+   * In normal cases, focusOffset is a child index.
+   */
+  const regularChild = initialFocusNode.childNodes[initialFocusOffset];
+
+  if (regularChild !== undefined) {
+    return [regularChild, 0];
+  }
+
+  /**
+   * But in Firefox, focusOffset can be 1 with the single child.
+   */
+  const fallbackChild = initialFocusNode.childNodes[initialFocusOffset - 1] ?? null;
+  const textContent = fallbackChild?.textContent ?? null;
+
+  return [fallbackChild, textContent !== null ? textContent.length : 0];
+};
 
 /**
  * Checks content at left or right of the passed node for emptiness.
@@ -57,7 +60,7 @@ export function getCaretNodeAndOffset(): [ Node | null, number ] {
  * @param direction - The direction to check ('left' or 'right').
  * @returns true if adjacent content is empty, false otherwise.
  */
-export function checkContenteditableSliceForEmptiness(contenteditable: HTMLElement, fromNode: Node, offsetInsideNode: number, direction: 'left' | 'right'): boolean {
+export const checkContenteditableSliceForEmptiness = (contenteditable: HTMLElement, fromNode: Node, offsetInsideNode: number, direction: 'left' | 'right'): boolean => {
   const range = document.createRange();
 
   /**
@@ -95,7 +98,7 @@ export function checkContenteditableSliceForEmptiness(contenteditable: HTMLEleme
    * If text contains only invisible whitespaces, it is considered to be empty
    */
   return isCollapsedWhitespaces(textContent);
-}
+};
 
 /**
  * Checks if caret is at the start of the passed input
@@ -111,7 +114,7 @@ export function checkContenteditableSliceForEmptiness(contenteditable: HTMLEleme
  *
  * @param input - input where caret should be checked
  */
-export function isCaretAtStartOfInput(input: HTMLElement): boolean {
+export const isCaretAtStartOfInput = (input: HTMLElement): boolean => {
   const firstNode = $.getDeepestNode(input);
 
   if (firstNode === null || $.isEmpty(input)) {
@@ -142,7 +145,7 @@ export function isCaretAtStartOfInput(input: HTMLElement): boolean {
    * If there is nothing visible to the left of the caret, it is considered to be at the start
    */
   return checkContenteditableSliceForEmptiness(input, caretNode, caretOffset, 'left');
-}
+};
 
 /**
  * Checks if caret is at the end of the passed input
@@ -158,7 +161,7 @@ export function isCaretAtStartOfInput(input: HTMLElement): boolean {
  *
  * @param input - input where caret should be checked
  */
-export function isCaretAtEndOfInput(input: HTMLElement): boolean {
+export const isCaretAtEndOfInput = (input: HTMLElement): boolean => {
   const lastNode = $.getDeepestNode(input, true);
 
   if (lastNode === null) {
@@ -185,4 +188,4 @@ export function isCaretAtEndOfInput(input: HTMLElement): boolean {
    * If there is nothing visible to the right of the caret, it is considered to be at the end
    */
   return checkContenteditableSliceForEmptiness(input, caretNode, caretOffset, 'right');
-}
+};
diff --git a/src/components/utils/events.ts b/src/components/utils/events.ts
index 295474da0..60d7cab78 100644
--- a/src/components/utils/events.ts
+++ b/src/components/utils/events.ts
@@ -80,8 +80,8 @@ export default class EventsDispatcher<EventMap> {
       return;
     }
 
-    this.subscribers[eventName].reduce((previousData, currentHandler) => {
-      const newData = currentHandler(previousData);
+    this.subscribers[eventName].reduce<EventMap[Name] | undefined>((previousData, currentHandler) => {
+      const newData = currentHandler(previousData as EventMap[Name]);
 
       return newData !== undefined ? newData : previousData;
     }, data);
@@ -94,18 +94,21 @@ export default class EventsDispatcher<EventMap> {
    * @param callback - event handler
    */
   public off<Name extends keyof EventMap>(eventName: Name, callback: Listener<EventMap[Name]>): void {
-    if (this.subscribers[eventName] === undefined) {
+    const subscribers = this.subscribers[eventName];
+
+    if (subscribers === undefined) {
       console.warn(`EventDispatcher .off(): there is no subscribers for event "${eventName.toString()}". Probably, .off() called before .on()`);
 
       return;
     }
 
-    for (let i = 0; i < this.subscribers[eventName].length; i++) {
-      if (this.subscribers[eventName][i] === callback) {
-        delete this.subscribers[eventName][i];
-        break;
-      }
+    const indexOfCallback = subscribers.indexOf(callback);
+
+    if (indexOfCallback === -1) {
+      return;
     }
+
+    subscribers.splice(indexOfCallback, 1);
   }
 
   /**
diff --git a/src/components/utils/keyboard.ts b/src/components/utils/keyboard.ts
index 65d8e614e..9a4175a53 100644
--- a/src/components/utils/keyboard.ts
+++ b/src/components/utils/keyboard.ts
@@ -40,7 +40,7 @@ declare global {
  * @param code - {@link https://www.w3.org/TR/uievents-code/#key-alphanumeric-writing-system}
  * @param fallback - fallback value to be returned if Keyboard API is not supported (Safari, Firefox)
  */
-export async function getKeyboardKeyForCode(code: string, fallback: string): Promise<string> {
+export const getKeyboardKeyForCode = async (code: string, fallback: string): Promise<string> => {
   const keyboard = navigator.keyboard;
 
   if (!keyboard) {
@@ -58,4 +58,4 @@ export async function getKeyboardKeyForCode(code: string, fallback: string): Pro
 
     return fallback;
   }
-}
+};
diff --git a/src/components/utils/listeners.ts b/src/components/utils/listeners.ts
index 4b6189a74..7d6f1206b 100644
--- a/src/components/utils/listeners.ts
+++ b/src/components/utils/listeners.ts
@@ -34,6 +34,13 @@ export interface ListenerData {
   options: boolean | AddEventListenerOptions;
 }
 
+interface NormalizedListenerOptions {
+  capture: boolean;
+  once: boolean;
+  passive: boolean;
+  signal?: AbortSignal | null;
+}
+
 /**
  * Editor.js Listeners helper
  *
@@ -68,9 +75,15 @@ export default class Listeners {
     eventType: string,
     handler: (event: Event) => void,
     options: boolean | AddEventListenerOptions = false
-  ): string {
+  ): string | undefined {
+    const alreadyExist = this.findOne(element, eventType, handler, options);
+
+    if (alreadyExist) {
+      return undefined;
+    }
+
     const id = _.generateId('l');
-    const assignedEventData = {
+    const assignedEventData: ListenerData = {
       id,
       element,
       eventType,
@@ -78,12 +91,6 @@ export default class Listeners {
       options,
     };
 
-    const alreadyExist = this.findOne(element, eventType, handler);
-
-    if (alreadyExist) {
-      return;
-    }
-
     this.allListeners.push(assignedEventData);
     element.addEventListener(eventType, handler, options);
 
@@ -102,10 +109,9 @@ export default class Listeners {
     element: EventTarget,
     eventType: string,
     handler?: (event: Event) => void,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
     options?: boolean | AddEventListenerOptions
   ): void {
-    const existingListeners = this.findAll(element, eventType, handler);
+    const existingListeners = this.findAll(element, eventType, handler, options);
 
     existingListeners.forEach((listener, i) => {
       const index = this.allListeners.indexOf(existingListeners[i]);
@@ -131,6 +137,11 @@ export default class Listeners {
     }
 
     listener.element.removeEventListener(listener.eventType, listener.handler, listener.options);
+    const index = this.allListeners.indexOf(listener);
+
+    if (index > -1) {
+      this.allListeners.splice(index, 1);
+    }
   }
 
   /**
@@ -139,12 +150,18 @@ export default class Listeners {
    * @param {EventTarget} element - event target
    * @param {string} [eventType] - event type
    * @param {Function} [handler] - event handler
+   * @param {boolean|AddEventListenerOptions} [options] - event options
    * @returns {ListenerData|null}
    */
-  public findOne(element: EventTarget, eventType?: string, handler?: (event: Event) => void): ListenerData {
-    const foundListeners = this.findAll(element, eventType, handler);
+  public findOne(
+    element: EventTarget,
+    eventType?: string,
+    handler?: (event: Event) => void,
+    options?: boolean | AddEventListenerOptions
+  ): ListenerData | null {
+    const foundListeners = this.findAll(element, eventType, handler, options);
 
-    return foundListeners.length > 0 ? foundListeners[0] : null;
+    return foundListeners[0] ?? null;
   }
 
   /**
@@ -153,28 +170,35 @@ export default class Listeners {
    * @param {EventTarget} element - event target
    * @param {string} eventType - event type
    * @param {Function} handler - event handler
+   * @param {boolean|AddEventListenerOptions} [options] - event options
    * @returns {ListenerData[]}
    */
-  public findAll(element: EventTarget, eventType?: string, handler?: (event: Event) => void): ListenerData[] {
-    let found;
-    const foundByEventTargets = element ? this.findByEventTarget(element) : [];
-
-    if (element && eventType && handler) {
-      found = foundByEventTargets.filter((event) => event.eventType === eventType && event.handler === handler);
-    } else if (element && eventType) {
-      found = foundByEventTargets.filter((event) => event.eventType === eventType);
-    } else {
-      found = foundByEventTargets;
+  public findAll(
+    element: EventTarget,
+    eventType?: string,
+    handler?: (event: Event) => void,
+    options?: boolean | AddEventListenerOptions
+  ): ListenerData[] {
+    if (!element) {
+      return [];
     }
 
-    return found;
+    const foundByEventTargets = this.findByEventTarget(element);
+
+    return foundByEventTargets.filter((listener) => {
+      const matchesEventType = eventType === undefined || listener.eventType === eventType;
+      const matchesHandler = handler === undefined || listener.handler === handler;
+      const matchesOptions = this.areOptionsEqual(listener.options, options);
+
+      return matchesEventType && matchesHandler && matchesOptions;
+    });
   }
 
   /**
    * Removes all listeners
    */
   public removeAll(): void {
-    this.allListeners.map((current) => {
+    this.allListeners.forEach((current) => {
       current.element.removeEventListener(current.eventType, current.handler, current.options);
     });
 
@@ -195,11 +219,7 @@ export default class Listeners {
    * @returns {Array} listeners that found on element
    */
   private findByEventTarget(element: EventTarget): ListenerData[] {
-    return this.allListeners.filter((listener) => {
-      if (listener.element === element) {
-        return listener;
-      }
-    });
+    return this.allListeners.filter((listener) => listener.element === element);
   }
 
   /**
@@ -209,11 +229,7 @@ export default class Listeners {
    * @returns {ListenerData[]} listeners that found on element
    */
   private findByType(eventType: string): ListenerData[] {
-    return this.allListeners.filter((listener) => {
-      if (listener.eventType === eventType) {
-        return listener;
-      }
-    });
+    return this.allListeners.filter((listener) => listener.eventType === eventType);
   }
 
   /**
@@ -223,11 +239,7 @@ export default class Listeners {
    * @returns {ListenerData[]} listeners that found on element
    */
   private findByHandler(handler: (event: Event) => void): ListenerData[] {
-    return this.allListeners.filter((listener) => {
-      if (listener.handler === handler) {
-        return listener;
-      }
-    });
+    return this.allListeners.filter((listener) => listener.handler === handler);
   }
 
   /**
@@ -236,7 +248,64 @@ export default class Listeners {
    * @param {string} id - listener identifier
    * @returns {ListenerData}
    */
-  private findById(id: string): ListenerData {
+  private findById(id: string): ListenerData | undefined {
     return this.allListeners.find((listener) => listener.id === id);
   }
+
+  /**
+   * Normalizes listener options to a comparable shape
+   *
+   * @param {boolean|AddEventListenerOptions} [options] - event options
+   * @returns {NormalizedListenerOptions}
+   */
+  private normalizeListenerOptions(options?: boolean | AddEventListenerOptions): NormalizedListenerOptions {
+    if (typeof options === 'boolean') {
+      return {
+        capture: options,
+        once: false,
+        passive: false,
+      };
+    }
+
+    if (!options) {
+      return {
+        capture: false,
+        once: false,
+        passive: false,
+      };
+    }
+
+    return {
+      capture: options.capture ?? false,
+      once: options.once ?? false,
+      passive: options.passive ?? false,
+      signal: options.signal,
+    };
+  }
+
+  /**
+   * Compares stored listener options with provided ones
+   *
+   * @param {boolean|AddEventListenerOptions} storedOptions - stored event options
+   * @param {boolean|AddEventListenerOptions} [providedOptions] - provided event options
+   * @returns {boolean}
+   */
+  private areOptionsEqual(
+    storedOptions: boolean | AddEventListenerOptions,
+    providedOptions?: boolean | AddEventListenerOptions
+  ): boolean {
+    if (providedOptions === undefined) {
+      return true;
+    }
+
+    const storedNormalized = this.normalizeListenerOptions(storedOptions);
+    const providedNormalized = this.normalizeListenerOptions(providedOptions);
+
+    return (
+      storedNormalized.capture === providedNormalized.capture &&
+      storedNormalized.once === providedNormalized.once &&
+      storedNormalized.passive === providedNormalized.passive &&
+      storedNormalized.signal === providedNormalized.signal
+    );
+  }
 }
diff --git a/src/components/utils/mutations.ts b/src/components/utils/mutations.ts
index 3d5e8f25d..38d8dd79a 100644
--- a/src/components/utils/mutations.ts
+++ b/src/components/utils/mutations.ts
@@ -4,7 +4,7 @@
  * @param mutationRecord - mutation to check
  * @param element - element that is expected to contain mutation
  */
-export function isMutationBelongsToElement(mutationRecord: MutationRecord, element: Element): boolean {
+export const isMutationBelongsToElement = (mutationRecord: MutationRecord, element: Element): boolean => {
   const { type, target, addedNodes, removedNodes } = mutationRecord;
 
   /**
@@ -24,19 +24,17 @@ export function isMutationBelongsToElement(mutationRecord: MutationRecord, eleme
   /**
    * In case of removing/adding the element itself, mutation type will be 'childList' and 'removedNodes'/'addedNodes' will contain the element.
    */
-  if (type === 'childList') {
-    const elementAddedItself = Array.from(addedNodes).some(node => node === element);
-
-    if (elementAddedItself) {
-      return true;
-    }
+  if (type !== 'childList') {
+    return false;
+  }
 
-    const elementRemovedItself = Array.from(removedNodes).some(node => node === element);
+  const elementAddedItself = Array.from(addedNodes).some(node => node === element);
 
-    if (elementRemovedItself) {
-      return true;
-    }
+  if (elementAddedItself) {
+    return true;
   }
 
-  return false;
-}
+  const elementRemovedItself = Array.from(removedNodes).some(node => node === element);
+
+  return elementRemovedItself;
+};
diff --git a/src/components/utils/notifier.ts b/src/components/utils/notifier.ts
index d71571602..c6d96c070 100644
--- a/src/components/utils/notifier.ts
+++ b/src/components/utils/notifier.ts
@@ -4,18 +4,79 @@
  * @see https://github.com/codex-team/js-notifier
  */
 import type { ConfirmNotifierOptions, NotifierOptions, PromptNotifierOptions } from 'codex-notifier';
-import notifier from 'codex-notifier';
+
+type CodexNotifierModule = {
+  show: (options: NotifierOptions | ConfirmNotifierOptions | PromptNotifierOptions) => void;
+};
 
 /**
  * Util for showing notifications
  */
 export default class Notifier {
+  /**
+   * Cached notifier module instance
+   */
+  private notifierModule: CodexNotifierModule | null = null;
+
+  /**
+   * Promise used to avoid multiple parallel loads of the notifier module
+   */
+  private loadingPromise: Promise<CodexNotifierModule> | null = null;
+
+  /**
+   * Lazily load codex-notifier only when necessary.
+   *
+   * @returns {Promise<CodexNotifierModule>} loaded notifier module
+   */
+  private async loadNotifierModule(): Promise<CodexNotifierModule> {
+    if (this.notifierModule !== null) {
+      return this.notifierModule;
+    }
+
+    if (this.loadingPromise === null) {
+      this.loadingPromise = import('codex-notifier')
+        .then((module) => {
+          const resolvedModule = (module?.default ?? module) as unknown;
+
+          if (!this.isNotifierModule(resolvedModule)) {
+            throw new Error('codex-notifier module does not expose a "show" method.');
+          }
+
+          this.notifierModule = resolvedModule;
+
+          return resolvedModule;
+        })
+        .catch((error) => {
+          this.loadingPromise = null;
+
+          throw error;
+        });
+    }
+
+    return this.loadingPromise;
+  }
+
   /**
    * Show web notification
    *
    * @param {NotifierOptions | ConfirmNotifierOptions | PromptNotifierOptions} options - notification options
    */
   public show(options: NotifierOptions | ConfirmNotifierOptions | PromptNotifierOptions): void {
-    notifier.show(options);
+    void this.loadNotifierModule()
+      .then((notifier) => {
+        notifier.show(options);
+      })
+      .catch((error) => {
+        console.error('[Editor.js] Failed to display notification. Reason:', error);
+      });
+  }
+
+  /**
+   * Narrow unknown module to codex-notifier module shape
+   *
+   * @param {unknown} candidate - module to verify
+   */
+  private isNotifierModule(candidate: unknown): candidate is CodexNotifierModule {
+    return typeof candidate === 'object' && candidate !== null && 'show' in candidate && typeof (candidate as { show?: unknown }).show === 'function';
   }
 }
diff --git a/src/components/utils/popover/components/popover-item/popover-item-default/popover-item-default.const.ts b/src/components/utils/popover/components/popover-item/popover-item-default/popover-item-default.const.ts
index e5929b78b..809b5cac0 100644
--- a/src/components/utils/popover/components/popover-item/popover-item-default/popover-item-default.const.ts
+++ b/src/components/utils/popover/components/popover-item/popover-item-default/popover-item-default.const.ts
@@ -24,3 +24,8 @@ export const css = {
   iconChevronRight: className('icon', 'chevron-right'),
   wobbleAnimation: bem('wobble')(),
 };
+
+/**
+ * Data attribute name for active state
+ */
+export const DATA_ATTRIBUTE_ACTIVE = 'data-popover-item-active';
diff --git a/src/components/utils/popover/components/popover-item/popover-item-default/popover-item-default.ts b/src/components/utils/popover/components/popover-item/popover-item-default/popover-item-default.ts
index 7e9889ac8..e942f5d94 100644
--- a/src/components/utils/popover/components/popover-item/popover-item-default/popover-item-default.ts
+++ b/src/components/utils/popover/components/popover-item/popover-item-default/popover-item-default.ts
@@ -6,10 +6,10 @@ import type {
   PopoverItemType
 } from '@/types/utils/popover/popover-item';
 import { PopoverItem } from '../popover-item';
-import { css } from './popover-item-default.const';
+import { css, DATA_ATTRIBUTE_ACTIVE } from './popover-item-default.const';
 
 /**
- * Represents sigle popover item node
+ * Represents single popover item node
  *
  * @todo move nodes initialization to constructor
  * @todo replace multiple make() usages with constructing separate instances
@@ -111,7 +111,19 @@ export class PopoverItemDefault extends PopoverItem {
    * @param isActive - true if item should strictly should become active
    */
   public toggleActive(isActive?: boolean): void {
-    this.nodes.root?.classList.toggle(css.active, isActive);
+    if (this.nodes.root === null) {
+      return;
+    }
+
+    const shouldBeActive = isActive !== undefined ? isActive : !this.nodes.root.classList.contains(css.active);
+
+    this.nodes.root.classList.toggle(css.active, shouldBeActive);
+
+    if (shouldBeActive) {
+      this.nodes.root.setAttribute(DATA_ATTRIBUTE_ACTIVE, 'true');
+    } else {
+      this.nodes.root.removeAttribute(DATA_ATTRIBUTE_ACTIVE);
+    }
   }
 
   /**
@@ -181,6 +193,7 @@ export class PopoverItemDefault extends PopoverItem {
 
     if (this.isActive) {
       el.classList.add(css.active);
+      el.setAttribute(DATA_ATTRIBUTE_ACTIVE, 'true');
     }
 
     if (params.isDisabled) {
@@ -293,7 +306,7 @@ export class PopoverItemDefault extends PopoverItem {
   }
 
   /**
-   * Animates item which symbolizes that error occured while executing 'onActivate()' callback
+   * Animates item which symbolizes that error occurred while executing 'onActivate()' callback
    */
   private animateError(): void {
     if (this.nodes.icon?.classList.contains(css.wobbleAnimation)) {
diff --git a/src/components/utils/popover/components/search-input/search-input.ts b/src/components/utils/popover/components/search-input/search-input.ts
index 0714ff1c5..ab470d15e 100644
--- a/src/components/utils/popover/components/search-input/search-input.ts
+++ b/src/components/utils/popover/components/search-input/search-input.ts
@@ -57,6 +57,7 @@ export class SearchInput extends EventsDispatcher<SearchInputEventMap> {
     });
 
     this.input = Dom.make('input', css.input, {
+      type: 'search',
       placeholder,
       /**
        * Used to prevent focusing on the input by Tab key
@@ -65,17 +66,17 @@ export class SearchInput extends EventsDispatcher<SearchInputEventMap> {
        */
       tabIndex: -1,
     }) as HTMLInputElement;
+    this.input.dataset.flipperTabTarget = 'true';
 
     this.wrapper.appendChild(iconWrapper);
     this.wrapper.appendChild(this.input);
 
-    this.listeners.on(this.input, 'input', () => {
-      this.searchQuery = this.input.value;
+    this.overrideValueProperty();
 
-      this.emit(SearchInputEvent.Search, {
-        query: this.searchQuery,
-        items: this.foundItems,
-      });
+    const eventsToHandle = ['input', 'keyup', 'search', 'change'] as const;
+
+    eventsToHandle.forEach((eventName) => {
+      this.listeners.on(this.input, eventName, this.handleValueChange);
     });
   }
 
@@ -98,14 +99,59 @@ export class SearchInput extends EventsDispatcher<SearchInputEventMap> {
    */
   public clear(): void {
     this.input.value = '';
-    this.searchQuery = '';
+  }
+
+  /**
+   * Handles value changes for the input element
+   */
+  private handleValueChange = (): void => {
+    this.applySearch(this.input.value);
+  };
+
+  /**
+   * Applies provided query to the search state and notifies listeners
+   *
+   * @param query - search query to apply
+   */
+  private applySearch(query: string): void {
+    if (this.searchQuery === query) {
+      return;
+    }
+
+    this.searchQuery = query;
 
     this.emit(SearchInputEvent.Search, {
-      query: '',
+      query,
       items: this.foundItems,
     });
   }
 
+  /**
+   * Overrides value property setter to catch programmatic changes
+   */
+  private overrideValueProperty(): void {
+    const prototype = Object.getPrototypeOf(this.input);
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, 'value');
+
+    if (descriptor?.set === undefined || descriptor.get === undefined) {
+      return;
+    }
+
+    const applySearch = this.applySearch.bind(this);
+
+    Object.defineProperty(this.input, 'value', {
+      configurable: descriptor.configurable ?? true,
+      enumerable: descriptor.enumerable ?? false,
+      get(): string {
+        return descriptor.get?.call(this) ?? '';
+      },
+      set(value: string): void {
+        descriptor.set?.call(this, value);
+        applySearch(value);
+      },
+    });
+  }
+
   /**
    * Clears memory
    */
diff --git a/src/components/utils/popover/components/search-input/search-input.types.ts b/src/components/utils/popover/components/search-input/search-input.types.ts
index ecddc47b8..363b53eff 100644
--- a/src/components/utils/popover/components/search-input/search-input.types.ts
+++ b/src/components/utils/popover/components/search-input/search-input.types.ts
@@ -14,7 +14,7 @@ export interface SearchableItem {
  */
 export enum SearchInputEvent {
   /**
-   * When search quert applied
+   * When search query is applied
    */
   Search = 'search'
 }
@@ -24,7 +24,7 @@ export enum SearchInputEvent {
  */
 export interface SearchInputEventMap {
   /**
-   * Fired when search quert applied
+   * Fired when search query is applied
    */
   [SearchInputEvent.Search]: { query: string; items: SearchableItem[]};
 }
diff --git a/src/components/utils/popover/popover-abstract.ts b/src/components/utils/popover/popover-abstract.ts
index f04539546..9e0e3c192 100644
--- a/src/components/utils/popover/popover-abstract.ts
+++ b/src/components/utils/popover/popover-abstract.ts
@@ -117,6 +117,7 @@ export abstract class PopoverAbstract<Nodes extends PopoverNodes = PopoverNodes>
    */
   public show(): void {
     this.nodes.popover.classList.add(css.popoverOpened);
+    this.nodes.popover.setAttribute('data-popover-opened', 'true');
 
     if (this.search !== undefined) {
       this.search.focus();
@@ -129,6 +130,7 @@ export abstract class PopoverAbstract<Nodes extends PopoverNodes = PopoverNodes>
   public hide(): void {
     this.nodes.popover.classList.remove(css.popoverOpened);
     this.nodes.popover.classList.remove(css.popoverOpenTop);
+    this.nodes.popover.removeAttribute('data-popover-opened');
 
     this.itemsDefault.forEach(item => item.reset());
 
@@ -157,6 +159,10 @@ export abstract class PopoverAbstract<Nodes extends PopoverNodes = PopoverNodes>
   public activateItemByName(name: string): void {
     const foundItem = this.items.find(item => item.name === name);
 
+    if (foundItem === undefined) {
+      return;
+    }
+
     this.handleItemClick(foundItem);
   }
 
@@ -203,16 +209,13 @@ export abstract class PopoverAbstract<Nodes extends PopoverNodes = PopoverNodes>
    * @param item - item to handle click of
    */
   protected handleItemClick(item: PopoverItem): void {
-    if ('isDisabled' in item && item.isDisabled) {
+    if (item instanceof PopoverItemDefault && item.isDisabled) {
       return;
     }
 
     if (item.hasChildren) {
       this.showNestedItems(item as PopoverItemDefault | PopoverItemHtml);
-
-      if ('handleClick' in item && typeof item.handleClick === 'function') {
-        item.handleClick();
-      }
+      this.callHandleClickIfPresent(item);
 
       return;
     }
@@ -220,13 +223,11 @@ export abstract class PopoverAbstract<Nodes extends PopoverNodes = PopoverNodes>
     /** Cleanup other items state */
     this.itemsDefault.filter(x => x !== item).forEach(x => x.reset());
 
-    if ('handleClick' in item && typeof item.handleClick === 'function') {
-      item.handleClick();
-    }
+    this.callHandleClickIfPresent(item);
 
     this.toggleItemActivenessIfNeeded(item);
 
-    if (item.closeOnActivate) {
+    if (item.closeOnActivate === true) {
       this.hide();
 
       this.emit(PopoverEvent.ClosedOnActivate);
@@ -265,20 +266,33 @@ export abstract class PopoverAbstract<Nodes extends PopoverNodes = PopoverNodes>
       clickedItem.toggleActive();
     }
 
-    if (typeof clickedItem.toggle === 'string') {
-      const itemsInToggleGroup = this.itemsDefault.filter(item => item.toggle === clickedItem.toggle);
+    if (typeof clickedItem.toggle !== 'string') {
+      return;
+    }
 
-      /** If there's only one item in toggle group, toggle it */
-      if (itemsInToggleGroup.length === 1) {
-        clickedItem.toggleActive();
+    const itemsInToggleGroup = this.itemsDefault.filter(item => item.toggle === clickedItem.toggle);
 
-        return;
-      }
+    /** If there's only one item in toggle group, toggle it */
+    if (itemsInToggleGroup.length === 1) {
+      clickedItem.toggleActive();
+
+      return;
+    }
+
+    /** Set clicked item as active and the rest items with same toggle key value as inactive */
+    itemsInToggleGroup.forEach(item => {
+      item.toggleActive(item === clickedItem);
+    });
+  }
 
-      /** Set clicked item as active and the rest items with same toggle key value as inactive */
-      itemsInToggleGroup.forEach(item => {
-        item.toggleActive(item === clickedItem);
-      });
+  /**
+   * Executes handleClick if it is present on item.
+   *
+   * @param item - popover item whose handler should be executed
+   */
+  private callHandleClickIfPresent(item: PopoverItem): void {
+    if ('handleClick' in item && typeof item.handleClick === 'function') {
+      item.handleClick();
     }
   }
 
diff --git a/src/components/utils/popover/popover-desktop.ts b/src/components/utils/popover/popover-desktop.ts
index 1eb6ae6c0..1cae21967 100644
--- a/src/components/utils/popover/popover-desktop.ts
+++ b/src/components/utils/popover/popover-desktop.ts
@@ -83,7 +83,15 @@ export class PopoverDesktop extends PopoverAbstract {
       this.addSearch();
     }
 
-    if (params.flippable !== false) {
+    if (params.flippable === false) {
+      return;
+    }
+
+    if (params.flipper !== undefined) {
+      params.flipper.deactivate();
+      params.flipper.removeOnFlip(this.onFlip);
+      this.flipper = params.flipper;
+    } else {
       this.flipper = new Flipper({
         items: this.flippableElements,
         focusedItemClass: popoverItemCls.focused,
@@ -94,9 +102,9 @@ export class PopoverDesktop extends PopoverAbstract {
           keyCodes.ENTER,
         ],
       });
-
-      this.flipper.onFlip(this.onFlip);
     }
+
+    this.flipper.onFlip(this.onFlip);
   }
 
   /**
@@ -242,6 +250,10 @@ export class PopoverDesktop extends PopoverAbstract {
     this.nestedPopover.getElement().remove();
     this.nestedPopover = null;
     this.flipper?.activate(this.flippableElements);
+    // Use requestAnimationFrame to ensure DOM is updated before focusing
+    requestAnimationFrame(() => {
+      this.flipper?.focusFirst();
+    });
 
     this.nestedPopoverTriggerItem?.onChildrenClose();
   }
@@ -358,20 +370,22 @@ export class PopoverDesktop extends PopoverAbstract {
   /**
    * Returns list of elements available for keyboard navigation.
    */
-  private get flippableElements(): HTMLElement[] {
-    const result = this.items
-      .map(item => {
-        if (item instanceof PopoverItemDefault) {
-          return item.getElement();
-        }
-        if (item instanceof PopoverItemHtml) {
-          return item.getControls();
-        }
-      })
-      .flat()
-      .filter(item => item !== undefined && item !== null);
-
-    return result as HTMLElement[];
+  protected get flippableElements(): HTMLElement[] {
+    const result = this.items.flatMap(item => {
+      if (!(item instanceof PopoverItemDefault)) {
+        return item instanceof PopoverItemHtml ? item.getControls() : [];
+      }
+
+      if (item.isDisabled) {
+        return [];
+      }
+
+      const element = item.getElement();
+
+      return element ? [ element ] : [];
+    }).filter((item): item is HTMLElement => item !== undefined && item !== null);
+
+    return result;
   }
 
   /**
@@ -414,14 +428,12 @@ export class PopoverDesktop extends PopoverAbstract {
 
     this.items
       .forEach((item) => {
-        let isHidden = false;
-
-        if (item instanceof PopoverItemDefault) {
-          isHidden = !data.items.includes(item);
-        } else if (item instanceof PopoverItemSeparator || item instanceof PopoverItemHtml) {
-          /** Should hide separators if nothing found message displayed or if there is some search query applied */
-          isHidden = isNothingFound || !isEmptyQuery;
-        }
+        const isDefaultItem = item instanceof PopoverItemDefault;
+        const isSeparatorOrHtml = item instanceof PopoverItemSeparator || item instanceof PopoverItemHtml;
+        const isHidden = isDefaultItem
+          ? !data.items.includes(item)
+          : isSeparatorOrHtml && (isNothingFound || !isEmptyQuery);
+
         item.toggleHidden(isHidden);
       });
     this.toggleNothingFoundMessage(isNothingFound);
diff --git a/src/components/utils/popover/popover-inline.ts b/src/components/utils/popover/popover-inline.ts
index ebe91223c..30aeb7eec 100644
--- a/src/components/utils/popover/popover-inline.ts
+++ b/src/components/utils/popover/popover-inline.ts
@@ -5,6 +5,7 @@ import { PopoverItemHtml } from './components/popover-item/popover-item-html/pop
 import { PopoverDesktop } from './popover-desktop';
 import { CSSVariables, css } from './popover.const';
 import type { PopoverParams } from '@/types/utils/popover/popover';
+import { PopoverEvent } from '@/types/utils/popover/popover-event';
 
 /**
  * Horizontal popover that is displayed inline with the content
@@ -47,6 +48,8 @@ export class PopoverInline extends PopoverDesktop {
       }
     );
 
+    this.flipper?.setHandleContentEditableTargets(true);
+
     /**
      * If active popover item has children, show them.
      * This is needed to display link url text (which is displayed as a nested popover content)
@@ -79,16 +82,25 @@ export class PopoverInline extends PopoverDesktop {
    * Open popover
    */
   public override show(): void {
-    /**
-     * If this is not a nested popover, set CSS variable with width of the popover
-     */
-    if (this.nestingLevel === 0) {
-      this.nodes.popover.style.setProperty(
-        CSSVariables.InlinePopoverWidth,
-        this.size.width + 'px'
-      );
-    }
     super.show();
+
+    const containerRect = this.nestingLevel === 0
+      ? this.nodes.popoverContainer?.getBoundingClientRect()
+      : undefined;
+
+    if (containerRect !== undefined) {
+      const width = `${containerRect.width}px`;
+      const height = `${containerRect.height}px`;
+
+      this.nodes.popover.style.setProperty(CSSVariables.InlinePopoverWidth, width);
+      this.nodes.popover.style.width = width;
+      this.nodes.popover.style.height = height;
+    }
+
+    requestAnimationFrame(() => {
+      this.flipper?.deactivate();
+      this.flipper?.activate(this.flippableElements);
+    });
   }
 
   /**
@@ -148,8 +160,36 @@ export class PopoverInline extends PopoverDesktop {
     const nestedPopover = super.showNestedPopoverForItem(item);
     const nestedPopoverEl = nestedPopover.getElement();
 
+    nestedPopover.flipper?.setHandleContentEditableTargets(true);
+
+    const handleFirstTab = (event: KeyboardEvent): void => {
+      if (event.key !== 'Tab' || event.shiftKey) {
+        return;
+      }
+
+      if (this.nestedPopover !== nestedPopover) {
+        document.removeEventListener('keydown', handleFirstTab, true);
+
+        return;
+      }
+
+      event.preventDefault();
+      event.stopPropagation();
+
+      nestedPopover.flipper?.activate((nestedPopover as unknown as PopoverInline).flippableElements);
+      nestedPopover.flipper?.focusFirst();
+
+      document.removeEventListener('keydown', handleFirstTab, true);
+    };
+
+    document.addEventListener('keydown', handleFirstTab, true);
+
+    nestedPopover.on(PopoverEvent.Closed, () => {
+      document.removeEventListener('keydown', handleFirstTab, true);
+    });
+
     /**
-     * We need to add class with nesting level, shich will help position nested popover.
+     * We need to add class with nesting level, which will help position nested popover.
      * Currently only '.ce-popover--nested-level-1' class is used
      */
     nestedPopoverEl.classList.add(css.getPopoverNestedClass(nestedPopover.nestingLevel));
diff --git a/src/components/utils/popover/popover-mobile.ts b/src/components/utils/popover/popover-mobile.ts
index c787d7e3a..93a4eae1e 100644
--- a/src/components/utils/popover/popover-mobile.ts
+++ b/src/components/utils/popover/popover-mobile.ts
@@ -134,7 +134,9 @@ export class PopoverMobile extends PopoverAbstract<PopoverMobileNodes> {
       this.header.destroy();
       this.header = null;
     }
-    if (title !== undefined) {
+    const shouldRenderHeader = title !== undefined;
+
+    if (shouldRenderHeader) {
       this.header = new PopoverHeader({
         text: title,
         onBackButtonClick: () => {
@@ -143,11 +145,12 @@ export class PopoverMobile extends PopoverAbstract<PopoverMobileNodes> {
           this.updateItemsAndHeader(this.history.currentItems, this.history.currentTitle);
         },
       });
-      const headerEl = this.header.getElement();
+    }
 
-      if (headerEl !== null) {
-        this.nodes.popoverContainer.insertBefore(headerEl, this.nodes.popoverContainer.firstChild);
-      }
+    const headerElement = this.header?.getElement() ?? null;
+
+    if (shouldRenderHeader && headerElement !== null) {
+      this.nodes.popoverContainer.insertBefore(headerElement, this.nodes.popoverContainer.firstChild);
     }
 
     /** Re-render items */
diff --git a/src/components/utils/resolve-aliases.ts b/src/components/utils/resolve-aliases.ts
index b529a914d..e39be06ee 100644
--- a/src/components/utils/resolve-aliases.ts
+++ b/src/components/utils/resolve-aliases.ts
@@ -6,18 +6,23 @@
  * @param obj - object with aliases to be resolved
  * @param aliases - object with aliases info where key is an alias property name and value is an aliased property name
  */
-export function resolveAliases<ObjectType>(obj: ObjectType, aliases: { [alias: string]: string }): ObjectType {
+export const resolveAliases = <ObjectType extends object>(
+  obj: ObjectType,
+  aliases: Partial<Record<string, keyof ObjectType>>
+): ObjectType => {
   const result = {} as ObjectType;
 
-  Object.keys(obj).forEach(property => {
-    const aliasedProperty = aliases[property];
+  (Object.keys(obj) as Array<keyof ObjectType | string>).forEach((property) => {
+    const propertyKey = property as keyof ObjectType;
+    const propertyString = String(property);
+    const aliasedProperty = aliases[propertyString];
 
     if (aliasedProperty !== undefined) {
-      result[aliasedProperty] = obj[property];
+      result[aliasedProperty] = obj[propertyKey];
     } else {
-      result[property] = obj[property];
+      result[propertyKey] = obj[propertyKey];
     }
   });
 
   return result;
-}
+};
diff --git a/src/components/utils/sanitizer.ts b/src/components/utils/sanitizer.ts
index 69d501490..414e8af83 100644
--- a/src/components/utils/sanitizer.ts
+++ b/src/components/utils/sanitizer.ts
@@ -30,9 +30,16 @@ import * as _ from '../utils';
  */
 
 import HTMLJanitor from 'html-janitor';
-import type { BlockToolData, SanitizerConfig } from '../../../types';
+import type { BlockToolData, SanitizerConfig, SanitizerRule } from '../../../types';
+import type { TagConfig } from '../../../types/configs/sanitizer-config';
 import type { SavedData } from '../../../types/data-formats';
 
+type DeepSanitizerRule = SanitizerConfig | SanitizerRule | boolean;
+
+const UNSAFE_URL_PROTOCOL_PATTERN = /^\s*(?:javascript\s*:|data\s*:\s*text\s*\/\s*html)/i;
+const UNSAFE_URL_ATTR_FALLBACK_PATTERN =
+  /\s*(?:href|src)\s*=\s*(?:"\s*(?:javascript\s*:|data\s*:\s*text\s*\/\s*html)[^"]*"|'\s*(?:javascript\s*:|data\s*:\s*text\s*\/\s*html)[^']*|(?:javascript\s*:|data\s*:\s*text\s*\/\s*html)[^ \t\r\n>]*)/gi;
+
 /**
  * Sanitize Blocks
  *
@@ -40,23 +47,27 @@ import type { SavedData } from '../../../types/data-formats';
  *
  * @param blocksData - blocks' data to sanitize
  * @param sanitizeConfig — sanitize config to use or function to get config for Tool
+ * @param globalSanitizer — global sanitizer config defined on editor level
  */
-export function sanitizeBlocks(
+export const sanitizeBlocks = (
   blocksData: Array<Pick<SavedData, 'data' | 'tool'>>,
-  sanitizeConfig: SanitizerConfig | ((toolName: string) => SanitizerConfig)
-): Array<Pick<SavedData, 'data' | 'tool'>> {
+  sanitizeConfig: SanitizerConfig | ((toolName: string) => SanitizerConfig | undefined),
+  globalSanitizer: SanitizerConfig = {} as SanitizerConfig
+): Array<Pick<SavedData, 'data' | 'tool'>> => {
   return blocksData.map((block) => {
     const toolConfig = _.isFunction(sanitizeConfig) ? sanitizeConfig(block.tool) : sanitizeConfig;
+    const rules: DeepSanitizerRule = (toolConfig ?? {}) as SanitizerConfig;
 
-    if (_.isEmpty(toolConfig)) {
+    if (_.isObject(rules) && _.isEmpty(rules) && _.isEmpty(globalSanitizer)) {
       return block;
     }
 
-    block.data = deepSanitize(block.data, toolConfig) as BlockToolData;
-
-    return block;
+    return {
+      ...block,
+      data: deepSanitize(block.data, rules, globalSanitizer) as BlockToolData,
+    };
   });
-}
+};
 /**
  * Cleans string from unwanted tags
  * Method allows to use default config
@@ -65,7 +76,7 @@ export function sanitizeBlocks(
  * @param {SanitizerConfig} customConfig - allowed tags
  * @returns {string} clean HTML
  */
-export function clean(taintString: string, customConfig: SanitizerConfig = {} as SanitizerConfig): string {
+export const clean = (taintString: string, customConfig: SanitizerConfig = {} as SanitizerConfig): string => {
   const sanitizerConfig = {
     tags: customConfig,
   };
@@ -76,15 +87,20 @@ export function clean(taintString: string, customConfig: SanitizerConfig = {} as
   const sanitizerInstance = new HTMLJanitor(sanitizerConfig);
 
   return sanitizerInstance.clean(taintString);
-}
+};
 
 /**
  * Method recursively reduces Block's data and cleans with passed rules
  *
  * @param {BlockToolData|object|*} dataToSanitize - taint string or object/array that contains taint string
  * @param {SanitizerConfig} rules - object with sanitizer rules
+ * @param {SanitizerConfig} globalRules - global sanitizer config
  */
-function deepSanitize(dataToSanitize: object | string, rules: SanitizerConfig): object | string {
+const deepSanitize = (
+  dataToSanitize: object | string,
+  rules: DeepSanitizerRule,
+  globalRules: SanitizerConfig
+): object | string => {
   /**
    * BlockData It may contain 3 types:
    *  - Array
@@ -95,82 +111,112 @@ function deepSanitize(dataToSanitize: object | string, rules: SanitizerConfig):
     /**
      * Array: call sanitize for each item
      */
-    return cleanArray(dataToSanitize, rules);
-  } else if (_.isObject(dataToSanitize)) {
+    return cleanArray(dataToSanitize, rules, globalRules);
+  }
+
+  if (_.isObject(dataToSanitize)) {
     /**
      * Objects: just clean object deeper.
      */
-    return cleanObject(dataToSanitize, rules);
-  } else {
-    /**
-     * Primitives (number|string|boolean): clean this item
-     *
-     * Clean only strings
-     */
-    if (_.isString(dataToSanitize)) {
-      return cleanOneItem(dataToSanitize, rules);
-    }
+    return cleanObject(dataToSanitize, rules, globalRules);
+  }
 
-    return dataToSanitize;
+  /**
+   * Primitives (number|string|boolean): clean this item
+   *
+   * Clean only strings
+   */
+  if (_.isString(dataToSanitize)) {
+    return cleanOneItem(dataToSanitize, rules, globalRules);
   }
-}
+
+  return dataToSanitize;
+};
 
 /**
  * Clean array
  *
  * @param {Array} array - [1, 2, {}, []]
  * @param {SanitizerConfig} ruleForItem - sanitizer config for array
+ * @param {SanitizerConfig} globalRules - global sanitizer config
  */
-function cleanArray(array: Array<object | string>, ruleForItem: SanitizerConfig): Array<object | string> {
-  return array.map((arrayItem) => deepSanitize(arrayItem, ruleForItem));
-}
+const cleanArray = (
+  array: Array<object | string>,
+  ruleForItem: DeepSanitizerRule,
+  globalRules: SanitizerConfig
+): Array<object | string> => {
+  return array.map((arrayItem) => deepSanitize(arrayItem, ruleForItem, globalRules));
+};
 
 /**
  * Clean object
  *
  * @param {object} object  - {level: 0, text: 'adada', items: [1,2,3]}}
  * @param {object} rules - { b: true } or true|false
+ * @param {SanitizerConfig} globalRules - global sanitizer config
  * @returns {object}
  */
-function cleanObject(object: object, rules: SanitizerConfig|{[field: string]: SanitizerConfig}): object {
-  const cleanData = {};
+const cleanObject = (
+  object: object,
+  rules: DeepSanitizerRule | Record<string, DeepSanitizerRule>,
+  globalRules: SanitizerConfig
+): object => {
+  const cleanData: Record<string, unknown> = {};
+  const objectRecord = object as Record<string, unknown>;
 
   for (const fieldName in object) {
     if (!Object.prototype.hasOwnProperty.call(object, fieldName)) {
       continue;
     }
 
-    const currentIterationItem = object[fieldName];
+    const currentIterationItem = objectRecord[fieldName];
 
     /**
      *  Get object from config by field name
      *   - if it is a HTML Janitor rule, call with this rule
      *   - otherwise, call with parent's config
      */
-    const ruleForItem = isRule(rules[fieldName] as SanitizerConfig) ? rules[fieldName] : rules;
+    const rulesRecord = _.isObject(rules) ? (rules as Record<string, DeepSanitizerRule>) : undefined;
+    const ruleCandidate = rulesRecord?.[fieldName];
+    const ruleForItem = ruleCandidate !== undefined && isRule(ruleCandidate)
+      ? ruleCandidate
+      : rules;
 
-    cleanData[fieldName] = deepSanitize(currentIterationItem, ruleForItem as SanitizerConfig);
+    cleanData[fieldName] = deepSanitize(currentIterationItem as object | string, ruleForItem as DeepSanitizerRule, globalRules);
   }
 
   return cleanData;
-}
+};
 
 /**
  * Clean primitive value
  *
  * @param {string} taintString - string to clean
  * @param {SanitizerConfig|boolean} rule - sanitizer rule
+ * @param {SanitizerConfig} globalRules - global sanitizer config
  * @returns {string}
  */
-function cleanOneItem(taintString: string, rule: SanitizerConfig|boolean): string {
-  if (_.isObject(rule)) {
-    return clean(taintString, rule);
-  } else if (rule === false) {
-    return clean(taintString, {} as SanitizerConfig);
-  } else {
-    return taintString;
+const cleanOneItem = (
+  taintString: string,
+  rule: DeepSanitizerRule,
+  globalRules: SanitizerConfig
+): string => {
+  const effectiveRule = getEffectiveRuleForString(rule, globalRules);
+
+  if (effectiveRule) {
+    const cleaned = clean(taintString, effectiveRule);
+
+    return stripUnsafeUrls(applyAttributeOverrides(cleaned, effectiveRule));
+  }
+
+  if (!_.isEmpty(globalRules)) {
+    const cleaned = clean(taintString, globalRules);
+
+    return stripUnsafeUrls(applyAttributeOverrides(cleaned, globalRules));
   }
-}
+
+  return stripUnsafeUrls(taintString);
+};
 
 /**
  * Check if passed item is a HTML Janitor rule:
@@ -179,6 +225,281 @@ function cleanOneItem(taintString: string, rule: SanitizerConfig|boolean): strin
  *
  * @param {SanitizerConfig} config - config to check
  */
-function isRule(config: SanitizerConfig): boolean {
+const isRule = (config: DeepSanitizerRule): boolean => {
   return _.isObject(config) || _.isBoolean(config) || _.isFunction(config);
-}
+};
+
+/**
+ *
+ * @param {string} value - HTML string to strip unsafe URLs from
+ */
+const hasUnsafeUrlProtocol = (value: string | null): boolean => {
+  if (!value) {
+    return false;
+  }
+
+  return UNSAFE_URL_PROTOCOL_PATTERN.test(value);
+};
+
+const stripUnsafeUrls = (value: string): string => {
+  if (!value || value.indexOf('<') === -1) {
+    return value;
+  }
+
+  if (typeof document !== 'undefined') {
+    const template = document.createElement('template');
+
+    template.innerHTML = value;
+
+    const elements = template.content.querySelectorAll('[href],[src]');
+
+    elements.forEach((element) => {
+      ['href', 'src'].forEach((attribute) => {
+        const attrValue = element.getAttribute(attribute);
+
+        if (hasUnsafeUrlProtocol(attrValue)) {
+          element.removeAttribute(attribute);
+        }
+      });
+    });
+
+    return template.innerHTML;
+  }
+
+  return value.replace(UNSAFE_URL_ATTR_FALLBACK_PATTERN, '');
+};
+
+/**
+ *
+ * @param {SanitizerConfig} config - sanitizer config to clone
+ */
+const cloneSanitizerConfig = (config: SanitizerConfig): SanitizerConfig => {
+  if (_.isEmpty(config)) {
+    return {} as SanitizerConfig;
+  }
+
+  const cloned: SanitizerConfig = {} as SanitizerConfig;
+
+  for (const tag in config) {
+    if (!Object.prototype.hasOwnProperty.call(config, tag)) {
+      continue;
+    }
+
+    cloned[tag] = cloneTagConfig(config[tag]);
+  }
+
+  return cloned;
+};
+
+/**
+ *
+ * @param {SanitizerRule} rule - tag rule to clone
+ */
+type SanitizerFunctionRule = (el: Element) => TagConfig;
+
+const wrapFunctionRule = (rule: SanitizerFunctionRule): SanitizerFunctionRule => {
+  return function wrappedRule(this: unknown, element: Element): TagConfig {
+    const result = rule.call(this, element);
+
+    if (result == null) {
+      return {};
+    }
+
+    return result;
+  };
+};
+
+const cloneTagConfig = (rule: SanitizerRule): SanitizerRule => {
+  if (rule === true) {
+    return {};
+  }
+
+  if (rule === false) {
+    return false;
+  }
+
+  if (_.isFunction(rule)) {
+    return wrapFunctionRule(rule as SanitizerFunctionRule);
+  }
+
+  if (_.isString(rule)) {
+    return rule;
+  }
+
+  if (_.isObject(rule)) {
+    return _.deepMerge({}, rule as Record<string, unknown>) as SanitizerRule;
+  }
+
+  return rule;
+};
+
+/**
+ *
+ * @param {SanitizerConfig} globalRules - global sanitizer config
+ * @param {SanitizerConfig} fieldRules - field-specific sanitizer config
+ */
+const mergeTagRules = (globalRules: SanitizerConfig, fieldRules: SanitizerConfig): SanitizerConfig => {
+  if (_.isEmpty(globalRules)) {
+    return cloneSanitizerConfig(fieldRules);
+  }
+
+  const merged: SanitizerConfig = {} as SanitizerConfig;
+
+  for (const tag in globalRules) {
+    if (!Object.prototype.hasOwnProperty.call(globalRules, tag)) {
+      continue;
+    }
+
+    const globalValue = globalRules[tag];
+    const fieldValue = fieldRules ? fieldRules[tag] : undefined;
+
+    if (_.isFunction(fieldValue)) {
+      merged[tag] = cloneTagConfig(fieldValue as SanitizerRule);
+
+      continue;
+    }
+
+    if (_.isFunction(globalValue)) {
+      merged[tag] = cloneTagConfig(globalValue as SanitizerRule);
+
+      continue;
+    }
+
+    if (_.isObject(globalValue) && _.isObject(fieldValue)) {
+      merged[tag] = _.deepMerge({}, fieldValue as SanitizerConfig, globalValue as SanitizerConfig);
+
+      continue;
+    }
+
+    if (fieldValue !== undefined) {
+      merged[tag] = cloneTagConfig(fieldValue as SanitizerRule);
+
+      continue;
+    }
+
+    merged[tag] = cloneTagConfig(globalValue as SanitizerRule);
+  }
+
+  return merged;
+};
+
+/**
+ *
+ * @param {DeepSanitizerRule} rule - sanitizer rule to evaluate
+ * @param {SanitizerConfig} globalRules - global sanitizer config
+ */
+const getEffectiveRuleForString = (
+  rule: DeepSanitizerRule,
+  globalRules: SanitizerConfig
+): SanitizerConfig | null => {
+  if (_.isObject(rule) && !_.isFunction(rule)) {
+    return mergeTagRules(globalRules, rule as SanitizerConfig);
+  }
+
+  if (rule === false) {
+    return {} as SanitizerConfig;
+  }
+
+  if (_.isEmpty(globalRules)) {
+    return null;
+  }
+
+  return cloneSanitizerConfig(globalRules);
+};
+
+/**
+ *
+ * @param {SanitizerConfig} globalConfig - base global sanitizer config
+ * @param {...SanitizerConfig[]} configs - additional sanitizer configs to compose
+ */
+export const composeSanitizerConfig = (
+  globalConfig: SanitizerConfig,
+  ...configs: SanitizerConfig[]
+): SanitizerConfig => {
+  if (_.isEmpty(globalConfig)) {
+    return Object.assign({}, ...configs) as SanitizerConfig;
+  }
+
+  const base = cloneSanitizerConfig(globalConfig);
+
+  configs.forEach((config) => {
+    if (!config) {
+      return;
+    }
+
+    for (const tag in config) {
+      if (!Object.prototype.hasOwnProperty.call(config, tag)) {
+        continue;
+      }
+
+      if (!Object.prototype.hasOwnProperty.call(base, tag)) {
+        continue;
+      }
+
+      const sourceValue = config[tag];
+      const targetValue = base[tag];
+
+      if (_.isFunction(sourceValue)) {
+        base[tag] = sourceValue;
+
+        continue;
+      }
+
+      if (_.isObject(sourceValue) && _.isObject(targetValue)) {
+        base[tag] = _.deepMerge({}, targetValue as SanitizerConfig, sourceValue as SanitizerConfig);
+
+        continue;
+      }
+
+      base[tag] = cloneTagConfig(sourceValue as SanitizerRule);
+    }
+  });
+
+  return base;
+};
+
+const applyAttributeOverrides = (html: string, rules: SanitizerConfig): string => {
+  if (typeof document === 'undefined' || !html || html.indexOf('<') === -1) {
+    return html;
+  }
+
+  const entries = Object.entries(rules).filter(([, value]) => _.isFunction(value));
+
+  if (entries.length === 0) {
+    return html;
+  }
+
+  const template = document.createElement('template');
+
+  template.innerHTML = html;
+
+  entries.forEach(([tag, rule]) => {
+    const elements = template.content.querySelectorAll(tag);
+
+    elements.forEach((element) => {
+      const ruleResult = (rule as (el: Element) => SanitizerRule)(element);
+
+      if (_.isBoolean(ruleResult) || _.isFunction(ruleResult) || ruleResult == null) {
+        return;
+      }
+
+      for (const [attr, attrRule] of Object.entries(ruleResult)) {
+        if (attrRule === false) {
+          element.removeAttribute(attr);
+
+          continue;
+        }
+
+        if (attrRule === true) {
+          continue;
+        }
+
+        if (_.isString(attrRule)) {
+          element.setAttribute(attr, attrRule);
+        }
+      }
+    });
+  });
+
+  return template.innerHTML;
+};
diff --git a/src/components/utils/scroll-locker.ts b/src/components/utils/scroll-locker.ts
index cc97775c0..b20bedc9a 100644
--- a/src/components/utils/scroll-locker.ts
+++ b/src/components/utils/scroll-locker.ts
@@ -43,6 +43,7 @@ export default class ScrollLocker {
    * Locks scroll in a hard way (via setting fixed position to body element)
    */
   private lockHard(): void {
+    // eslint-disable-next-line deprecation/deprecation
     this.scrollPosition = window.pageYOffset;
     document.documentElement.style.setProperty(
       '--window-scroll-offset',
diff --git a/src/components/utils/shortcuts.ts b/src/components/utils/shortcuts.ts
index 967243d27..2173eb7b0 100644
--- a/src/components/utils/shortcuts.ts
+++ b/src/components/utils/shortcuts.ts
@@ -23,7 +23,7 @@ export interface ShortcutData {
   /**
    * Shortcut handler
    */
-  handler(event): void;
+  handler(event: KeyboardEvent): void;
 
   /**
    * Element handler should be added for
@@ -41,9 +41,9 @@ class Shortcuts {
   /**
    * All registered shortcuts
    *
-   * @type {Map<Element, Shortcut[]>}
+   * @type {Map<HTMLElement | Document, Shortcut[]>}
    */
-  private registeredShortcuts: Map<Element, Shortcut[]> = new Map();
+  private registeredShortcuts: Map<HTMLElement | Document, Shortcut[]> = new Map();
 
   /**
    * Register shortcut
@@ -75,7 +75,7 @@ class Shortcuts {
    * @param element - Element shortcut is set for
    * @param name - shortcut name
    */
-  public remove(element: Element, name: string): void {
+  public remove(element: HTMLElement | Document, name: string): void {
     const shortcut = this.findShortcut(element, name);
 
     if (!shortcut) {
@@ -86,6 +86,10 @@ class Shortcuts {
 
     const shortcuts = this.registeredShortcuts.get(element);
 
+    if (!shortcuts) {
+      return;
+    }
+
     const filteredShortcuts = shortcuts.filter(el => el !== shortcut);
 
     if (filteredShortcuts.length === 0) {
@@ -104,7 +108,7 @@ class Shortcuts {
    * @param shortcut - shortcut name
    * @returns {number} index - shortcut index if exist
    */
-  private findShortcut(element: Element, shortcut: string): Shortcut | void {
+  private findShortcut(element: HTMLElement | Document, shortcut: string): Shortcut | void {
     const shortcuts = this.registeredShortcuts.get(element) || [];
 
     return shortcuts.find(({ name }) => name === shortcut);
diff --git a/src/components/utils/tools.ts b/src/components/utils/tools.ts
index 4c384ca6f..2a91c7cb4 100644
--- a/src/components/utils/tools.ts
+++ b/src/components/utils/tools.ts
@@ -7,7 +7,7 @@ import { isFunction, isString } from '../utils';
  * @param tool - tool to check
  * @param direction - export for tool to merge from, import for tool to merge to
  */
-export function isToolConvertable(tool: BlockToolAdapter, direction: 'export' | 'import'): boolean {
+export const isToolConvertable = (tool: BlockToolAdapter, direction: 'export' | 'import'): boolean => {
   if (!tool.conversionConfig) {
     return false;
   }
@@ -15,4 +15,4 @@ export function isToolConvertable(tool: BlockToolAdapter, direction: 'export' |
   const conversionProp = tool.conversionConfig[direction];
 
   return isFunction(conversionProp) || isString(conversionProp);
-}
+};
diff --git a/src/components/utils/tooltip.ts b/src/components/utils/tooltip.ts
index 95789bdac..652fac9f9 100644
--- a/src/components/utils/tooltip.ts
+++ b/src/components/utils/tooltip.ts
@@ -1,71 +1,640 @@
-/* eslint-disable jsdoc/no-undefined-types */
+import tooltipStyles from '../../styles/tooltip.css?inline';
+import { DATA_INTERFACE_ATTRIBUTE, TOOLTIP_INTERFACE_VALUE } from '../constants';
+
 /**
- * Use external module CodeX Tooltip
+ * Tooltip supported content
  */
-import CodeXTooltips from 'codex-tooltip';
-import type { TooltipOptions, TooltipContent } from 'codex-tooltip/types';
+export type TooltipContent = HTMLElement | DocumentFragment | Node | string;
 
 /**
- * Tooltips lib: CodeX Tooltips
- *
- * @see https://github.com/codex-team/codex.tooltips
+ * Base options interface for tooltips
  */
-let lib: null | CodeXTooltips = null;
+export interface TooltipOptions {
+  /**
+   * Tooltip placement: top|bottom|left|right
+   */
+  placement?: string;
+
+  /**
+   * Tooltip top margin
+   */
+  marginTop?: number;
+
+  /**
+   * Tooltip left margin
+   */
+  marginLeft?: number;
+
+  /**
+   * Tooltip right margin
+   */
+  marginRight?: number;
+
+  /**
+   * Tooltip bottom margin
+   */
+  marginBottom?: number;
+
+  /**
+   * Timout before showing
+   */
+  delay?: number;
+
+  /**
+   * Timout before hiding
+   */
+  hidingDelay?: number;
+}
+
+const DEFAULT_OFFSET = 10;
+const TOOLTIP_ROLE = 'tooltip';
+const ARIA_HIDDEN_ATTRIBUTE = 'aria-hidden';
+const ARIA_HIDDEN_FALSE = 'false';
+const ARIA_HIDDEN_TRUE = 'true';
+const VISIBILITY_PROPERTY = 'visibility';
+const VISIBILITY_VISIBLE = 'visible';
+const VISIBILITY_HIDDEN = 'hidden';
+
+type CSSTooltipClasses = {
+  tooltip: string;
+  tooltipContent: string;
+  tooltipShown: string;
+  placement: {
+    left: string;
+    bottom: string;
+    right: string;
+    top: string;
+  };
+};
 
 /**
- * If library is needed, but it is not initialized yet, this function will initialize it
+ * Tiny any beautiful tooltips module.
+ *
+ * Can be showed near passed Element with any specified HTML content
  *
- * For example, if editor was destroyed and then initialized again
+ * @author CodeX <codex.so>
+ * @license MIT
  */
-function prepare(): void {
-  if (lib) {
-    return;
+class Tooltip {
+  /**
+   * Tooltip CSS classes
+   *
+   * @returns {object} CSS class names
+   */
+  private get CSS(): CSSTooltipClasses {
+    return {
+      tooltip: 'ct',
+      tooltipContent: 'ct__content',
+      tooltipShown: 'ct--shown',
+      placement: {
+        left: 'ct--left',
+        bottom: 'ct--bottom',
+        right: 'ct--right',
+        top: 'ct--top',
+      },
+    };
+  }
+
+  /**
+   * Module nodes
+   */
+  private nodes: {
+      wrapper: HTMLElement | null;
+      content: HTMLElement | null;
+    } = {
+      wrapper: null,
+      content: null,
+    };
+
+  /**
+   * Appearance state
+   */
+  private showed: boolean = false;
+
+  /**
+   * Offset above the Tooltip
+   */
+  private offsetTop: number = DEFAULT_OFFSET;
+
+  /**
+   * Offset at the left from the Tooltip
+   */
+  private offsetLeft: number = DEFAULT_OFFSET;
+
+  /**
+   * Offset at the right from the Tooltip
+   */
+  private offsetRight: number = DEFAULT_OFFSET;
+
+  /**
+   * Store timeout before showing to clear it on hide
+   */
+  private showingTimeout: ReturnType<typeof setTimeout> | null = null;
+
+  /**
+   * How many milliseconds need to wait before hiding
+   */
+  private hidingDelay: number = 0;
+
+  /**
+   * Store timeout before hiding
+   */
+  private hidingTimeout: ReturnType<typeof setTimeout> | null = null;
+
+  /**
+   * MutationObserver for watching tooltip visibility changes
+   */
+  private ariaObserver: MutationObserver | null = null;
+
+  /**
+   * Static singleton instance
+   */
+  private static instance: Tooltip | null = null;
+
+  /**
+   * Get singleton instance
+   */
+  public static getInstance(): Tooltip {
+    if (!Tooltip.instance) {
+      Tooltip.instance = new Tooltip();
+    }
+
+    return Tooltip.instance;
+  }
+
+  /**
+   * Module constructor
+   */
+  private constructor() {
+    this.loadStyles();
+    this.prepare();
+
+    window.addEventListener('scroll', this.handleWindowScroll, { passive: true });
+  }
+
+  /**
+   * Show Tooltip near passed element with specified HTML content
+   *
+   * @param {HTMLElement} element - target element to place Tooltip near that
+   * @param {TooltipContent} content — any HTML Element of String that will be used as content
+   * @param {TooltipOptions} options — Available options {@link TooltipOptions}
+   */
+  public show(element: HTMLElement, content: TooltipContent, options: TooltipOptions = {}): void {
+    if (!this.nodes.wrapper) {
+      this.prepare();
+    }
+
+    if (this.hidingTimeout) {
+      clearTimeout(this.hidingTimeout);
+      this.hidingTimeout = null;
+    }
+
+    const basicOptions = {
+      placement: 'bottom',
+      marginTop: 0,
+      marginLeft: 0,
+      marginRight: 0,
+      marginBottom: 0,
+      delay: 70,
+      hidingDelay: 0,
+    };
+    const showingOptions = Object.assign(basicOptions, options);
+
+    if (showingOptions.hidingDelay) {
+      this.hidingDelay = showingOptions.hidingDelay;
+    }
+
+    if (!this.nodes.content) {
+      return;
+    }
+
+    this.nodes.content.innerHTML = '';
+    this.nodes.content.appendChild(this.createContentNode(content));
+
+    if (!this.nodes.wrapper) {
+      return;
+    }
+
+    this.nodes.wrapper.classList.remove(...Object.values(this.CSS.placement));
+
+    switch (showingOptions.placement) {
+      case 'top':
+        this.placeTop(element, showingOptions);
+        break;
+
+      case 'left':
+        this.placeLeft(element, showingOptions);
+        break;
+
+      case 'right':
+        this.placeRight(element, showingOptions);
+        break;
+
+      case 'bottom':
+      default:
+        this.placeBottom(element, showingOptions);
+        break;
+    }
+
+    if (showingOptions && showingOptions.delay) {
+      this.showingTimeout = setTimeout(() => {
+        if (this.nodes.wrapper) {
+          this.nodes.wrapper.classList.add(this.CSS.tooltipShown);
+          this.updateTooltipVisibility();
+        }
+        this.showed = true;
+      }, showingOptions.delay);
+
+      return;
+    }
+
+    if (this.nodes.wrapper) {
+      this.nodes.wrapper.classList.add(this.CSS.tooltipShown);
+      this.updateTooltipVisibility();
+    }
+    this.showed = true;
+  }
+
+  /**
+   * Prepare tooltip content node
+   *
+   * @param {TooltipContent} content - tooltip content (Node or string)
+   */
+  private createContentNode(content: TooltipContent): Node {
+    if (typeof content === 'string') {
+      return document.createTextNode(content);
+    }
+
+    if (content instanceof Node) {
+      return content;
+    }
+
+    throw Error('[CodeX Tooltip] Wrong type of «content» passed. It should be an instance of Node or String. ' +
+      'But ' + typeof content + ' given.');
+  }
+
+  /**
+   * Hide toolbox tooltip and clean content
+   *
+   * @param {boolean} skipDelay - forces hiding immediately
+   */
+  public hide(skipDelay: boolean = false): void {
+    const shouldDelay = Boolean(this.hidingDelay) && !skipDelay;
+
+    if (shouldDelay && this.hidingTimeout) {
+      clearTimeout(this.hidingTimeout);
+    }
+
+    if (shouldDelay) {
+      this.hidingTimeout = setTimeout(() => {
+        this.hide(true);
+      }, this.hidingDelay);
+
+      return;
+    }
+
+    if (this.nodes.wrapper) {
+      this.nodes.wrapper.classList.remove(this.CSS.tooltipShown);
+      this.updateTooltipVisibility();
+    }
+    this.showed = false;
+
+    if (this.showingTimeout) {
+      clearTimeout(this.showingTimeout);
+      this.showingTimeout = null;
+    }
+  }
+
+  /**
+   * Mouseover/Mouseleave decorator
+   *
+   * @param {HTMLElement} element - target element to place Tooltip near that
+   * @param {TooltipContent} content — any HTML Element of String that will be used as content
+   * @param {TooltipOptions} options — Available options {@link TooltipOptions}
+   */
+  public onHover(element: HTMLElement, content: TooltipContent, options: TooltipOptions = {}): void {
+    element.addEventListener('mouseenter', () => {
+      this.show(element, content, options);
+    });
+    element.addEventListener('mouseleave', () => {
+      this.hide();
+    });
+  }
+
+  /**
+   * Release DOM and event listeners
+   */
+  public destroy(): void {
+    this.ariaObserver?.disconnect();
+    this.ariaObserver = null;
+
+    if (this.nodes.wrapper) {
+      this.nodes.wrapper.remove();
+    }
+
+    window.removeEventListener('scroll', this.handleWindowScroll);
+
+    Tooltip.instance = null;
+  }
+
+  /**
+   * Hide tooltip when page is scrolled
+   */
+  private handleWindowScroll = (): void => {
+    if (this.showed) {
+      this.hide(true);
+    }
+  };
+
+  /**
+   * Module Preparation method
+   */
+  private prepare(): void {
+    this.nodes.wrapper = this.make('div', this.CSS.tooltip);
+    this.nodes.wrapper.setAttribute(DATA_INTERFACE_ATTRIBUTE, TOOLTIP_INTERFACE_VALUE);
+    this.nodes.content = this.make('div', this.CSS.tooltipContent);
+
+    if (this.nodes.wrapper && this.nodes.content) {
+      this.append(this.nodes.wrapper, this.nodes.content);
+      this.append(document.body, this.nodes.wrapper);
+      this.ensureTooltipAttributes();
+    }
+  }
+
+  /**
+   * Update tooltip visibility based on shown state
+   */
+  private updateTooltipVisibility(): void {
+    if (!this.nodes.wrapper) {
+      return;
+    }
+
+    const isShown = this.nodes.wrapper.classList.contains(this.CSS.tooltipShown);
+
+    this.nodes.wrapper.style.setProperty(VISIBILITY_PROPERTY, isShown ? VISIBILITY_VISIBLE : VISIBILITY_HIDDEN);
+    this.nodes.wrapper.setAttribute(ARIA_HIDDEN_ATTRIBUTE, isShown ? ARIA_HIDDEN_FALSE : ARIA_HIDDEN_TRUE);
+  }
+
+  /**
+   * Watch tooltip visibility changes for accessibility
+   */
+  private watchTooltipVisibility(): void {
+    if (!this.nodes.wrapper) {
+      return;
+    }
+
+    this.ariaObserver?.disconnect();
+
+    this.updateTooltipVisibility();
+
+    this.ariaObserver = new MutationObserver(() => {
+      this.updateTooltipVisibility();
+    });
+
+    this.ariaObserver.observe(this.nodes.wrapper, {
+      attributes: true,
+      attributeFilter: [ 'class' ],
+    });
+  }
+
+  /**
+   * Ensure tooltip has proper accessibility attributes
+   */
+  private ensureTooltipAttributes(): void {
+    if (!this.nodes.wrapper) {
+      return;
+    }
+
+    if (!this.nodes.wrapper.hasAttribute(DATA_INTERFACE_ATTRIBUTE) || this.nodes.wrapper.getAttribute(DATA_INTERFACE_ATTRIBUTE) !== TOOLTIP_INTERFACE_VALUE) {
+      this.nodes.wrapper.setAttribute(DATA_INTERFACE_ATTRIBUTE, TOOLTIP_INTERFACE_VALUE);
+    }
+
+    this.nodes.wrapper.setAttribute('role', TOOLTIP_ROLE);
+    this.watchTooltipVisibility();
+  }
+
+  /**
+   * Append CSS file
+   */
+  private loadStyles(): void {
+    const id = 'codex-tooltips-style';
+
+    if (document.getElementById(id)) {
+      return;
+    }
+
+    const tag = this.make('style', null, {
+      textContent: tooltipStyles,
+      id,
+    });
+
+    /**
+     * Append styles at the top of HEAD tag
+     */
+    this.prepend(document.head, tag);
+  }
+
+  /**
+   * Calculates element coords and moves tooltip bottom of the element
+   *
+   * @param {HTMLElement} element - target element
+   * @param {TooltipOptions} showingOptions - placement options
+   */
+  private placeBottom(element: HTMLElement, showingOptions: TooltipOptions): void {
+    if (!this.nodes.wrapper) {
+      return;
+    }
+
+    const elementCoords = element.getBoundingClientRect();
+    const left = elementCoords.left + element.clientWidth / 2 - this.nodes.wrapper.offsetWidth / 2;
+    const top = elementCoords.bottom + this.getScrollTop() + this.offsetTop + (showingOptions.marginTop ?? 0);
+
+    this.applyPlacement('bottom', left, top);
+  }
+
+  /**
+   * Calculates element coords and moves tooltip top of the element
+   *
+   * @param {HTMLElement} element - target element
+   * @param {TooltipOptions} _showingOptions - placement options (unused for top placement)
+   */
+  private placeTop(element: HTMLElement, _showingOptions: TooltipOptions): void {
+    if (!this.nodes.wrapper) {
+      return;
+    }
+
+    const elementCoords = element.getBoundingClientRect();
+    const left = elementCoords.left + element.clientWidth / 2 - this.nodes.wrapper.offsetWidth / 2;
+    const top = elementCoords.top + this.getScrollTop() - this.nodes.wrapper.clientHeight - this.offsetTop;
+
+    this.applyPlacement('top', left, top);
+  }
+
+  /**
+   * Calculates element coords and moves tooltip left of the element
+   *
+   * @param {HTMLElement} element - target element
+   * @param {TooltipOptions} showingOptions - placement options
+   */
+  private placeLeft(element: HTMLElement, showingOptions: TooltipOptions): void {
+    if (!this.nodes.wrapper) {
+      return;
+    }
+
+    const elementCoords = element.getBoundingClientRect();
+    const left = elementCoords.left - this.nodes.wrapper.offsetWidth - this.offsetLeft - (showingOptions.marginLeft ?? 0);
+    const top = elementCoords.top + this.getScrollTop() + element.clientHeight / 2 - this.nodes.wrapper.offsetHeight / 2;
+
+    this.applyPlacement('left', left, top);
+  }
+
+  /**
+   * Calculates element coords and moves tooltip right of the element
+   *
+   * @param {HTMLElement} element - target element
+   * @param {TooltipOptions} showingOptions - placement options
+   */
+  private placeRight(element: HTMLElement, showingOptions: TooltipOptions): void {
+    if (!this.nodes.wrapper) {
+      return;
+    }
+
+    const elementCoords = element.getBoundingClientRect();
+    const left = elementCoords.right + this.offsetRight + (showingOptions.marginRight ?? 0);
+    const top = elementCoords.top + this.getScrollTop() + element.clientHeight / 2 - this.nodes.wrapper.offsetHeight / 2;
+
+    this.applyPlacement('right', left, top);
+  }
+
+  /**
+   * Set wrapper position
+   *
+   * @param {string} place - placement direction
+   * @param {number} left - left position in pixels
+   * @param {number} top - top position in pixels
+   */
+  private applyPlacement(place: 'top' | 'bottom' | 'left' | 'right', left: number, top: number): void {
+    if (!this.nodes.wrapper) {
+      return;
+    }
+
+    this.nodes.wrapper.classList.add(this.CSS.placement[place]);
+
+    this.nodes.wrapper.style.left = `${left}px`;
+    this.nodes.wrapper.style.top = `${top}px`;
+  }
+
+  /**
+   * Get current page vertical scroll offset
+   */
+  private getScrollTop(): number {
+    if (typeof window.scrollY === 'number') {
+      return window.scrollY;
+    }
+
+    return document.documentElement?.scrollTop ?? document.body.scrollTop ?? 0;
+  }
+
+  /**
+   * Helper for making Elements with classname and attributes
+   *
+   * @param  {string} tagName           - new Element tag name
+   * @param  {Array<string>|string} classNames  - list or name of CSS classname(s)
+   * @param  {object} attributes        - any attributes
+   * @returns {HTMLElement}
+   */
+  private make(tagName: string, classNames: string | string[] | null = null, attributes: Record<string, unknown> = {}): HTMLElement {
+    const el = document.createElement(tagName);
+
+    if (Array.isArray(classNames)) {
+      el.classList.add(...classNames);
+    }
+
+    if (typeof classNames === 'string') {
+      el.classList.add(classNames);
+    }
+
+    for (const attrName in attributes) {
+      if (Object.prototype.hasOwnProperty.call(attributes, attrName)) {
+        (el as unknown as Record<string, unknown>)[attrName] = attributes[attrName];
+      }
+    }
+
+    return el;
+  }
+
+  /**
+   * Append one or several elements to the parent
+   *
+   * @param  {Element|DocumentFragment} parent    - where to append
+   * @param  {Element|Element[]} elements - element or elements list
+   */
+  private append(parent: Element | DocumentFragment, elements: Element | Element[] | DocumentFragment): void {
+    if (Array.isArray(elements)) {
+      elements.forEach((el) => parent.appendChild(el));
+    } else {
+      parent.appendChild(elements);
+    }
   }
 
-  lib = new CodeXTooltips();
+  /**
+   * Append element or a couple to the beginning of the parent elements
+   *
+   * @param {Element} parent - where to append
+   * @param {Element|Element[]} elements - element or elements list
+   */
+  private prepend(parent: Element, elements: Element | Element[]): void {
+    if (Array.isArray(elements)) {
+      const reversed = elements.reverse();
+
+      reversed.forEach((el) => parent.prepend(el));
+    } else {
+      parent.prepend(elements);
+    }
+  }
 }
 
 /**
- * Shows tooltip on element with passed HTML content
- *
- * @param {HTMLElement} element - any HTML element in DOM
- * @param content - tooltip's content
- * @param options - showing settings
+ * Get singleton tooltip instance
  */
-export function show(element: HTMLElement, content: TooltipContent, options?: TooltipOptions): void {
-  prepare();
-
-  lib?.show(element, content, options);
-}
+const getTooltip = (): Tooltip => {
+  return Tooltip.getInstance();
+};
 
 /**
- * Hides tooltip
+ * Show tooltip near element with specified content
  *
- * @param skipHidingDelay — pass true to immediately hide the tooltip
+ * @param {HTMLElement} element - target element to place tooltip near
+ * @param {TooltipContent} content - tooltip content
+ * @param {TooltipOptions} options - tooltip options
  */
-export function hide(skipHidingDelay = false): void {
-  prepare();
-
-  lib?.hide(skipHidingDelay);
-}
+export const show = (element: HTMLElement, content: TooltipContent, options?: TooltipOptions): void => {
+  getTooltip().show(element, content, options ?? {});
+};
 
 /**
- * Binds 'mouseenter' and 'mouseleave' events that shows/hides the Tooltip
+ * Hide tooltip
  *
- * @param {HTMLElement} element - any HTML element in DOM
- * @param content - tooltip's content
- * @param options - showing settings
+ * @param {boolean} skipHidingDelay - forces hiding immediately
  */
-export function onHover(element: HTMLElement, content: TooltipContent, options?: TooltipOptions): void {
-  prepare();
+export const hide = (skipHidingDelay = false): void => {
+  getTooltip().hide(skipHidingDelay);
+};
 
-  lib?.onHover(element, content, options);
-}
+/**
+ * Show tooltip on hover (mouseenter/mouseleave)
+ *
+ * @param {HTMLElement} element - target element to place tooltip near
+ * @param {TooltipContent} content - tooltip content
+ * @param {TooltipOptions} options - tooltip options
+ */
+export const onHover = (element: HTMLElement, content: TooltipContent, options?: TooltipOptions): void => {
+  getTooltip().onHover(element, content, options ?? {});
+};
 
 /**
- * Release the library
+ * Destroy tooltip instance and clean up
  */
-export function destroy(): void {
-  lib?.destroy();
-  lib = null;
-}
+export const destroy = (): void => {
+  getTooltip().destroy();
+};
diff --git a/src/styles/popover-inline.css b/src/styles/popover-inline.css
index f34dddc69..89b2fa383 100644
--- a/src/styles/popover-inline.css
+++ b/src/styles/popover-inline.css
@@ -2,142 +2,151 @@
  * Styles overrides for inline popover
  */
 .ce-popover--inline {
-  --height: 38px;
-  --height-mobile: 46px;
-  --container-padding: 4px;
-
-  position: relative;
-
-  .ce-popover__custom-content {
-    margin-bottom: 0;
-  }
-
-  .ce-popover__items {
-    display: flex;
-  }
-  
-  .ce-popover__container {
-    flex-direction: row;
-    padding: var(--container-padding);
-    height: var(--height);
-    top: 0;
-    
-    min-width: max-content;
-    width: max-content;
-    animation: none;
-
-    @media (--mobile) {
-      height: var(--height-mobile);
-      position: absolute;
-    }
-  }
+    --height: 38px;
+    --height-mobile: 46px;
+    --container-padding: 4px;
 
-  /** 
-   * Popover item styles
-   */
-  .ce-popover-item-separator {
-    padding: 0 4px;
+    position: relative;
 
-    &__line {
-      height: 100%;
-      width: 1px;
+    &.ce-popover--opened {
+        display: inline-block;
+        width: var(--inline-popover-width, max-content);
+        height: var(--height);
+
+        @media (--mobile) {
+            height: var(--height-mobile);
+        }
     }
-  }
 
-  .ce-popover-item {
-    border-radius: 4px;
-    padding: 4px;
+    .ce-popover__custom-content {
+        margin-bottom: 0;
+    }
 
-    &__icon--tool {
-      box-shadow: none;
-      background: transparent;
-      margin-right: 0;
+    .ce-popover__items {
+        display: flex;
     }
-    
-    &__icon {
-      width: unset;
-      height: unset;
 
-      svg {
-        width: var(--icon-size);
-        height: var(--icon-size);
+    .ce-popover__container {
+        flex-direction: row;
+        padding: var(--container-padding);
+        height: var(--height);
+        top: 0;
+        min-width: max-content;
+        width: max-content;
+        animation: none;
 
         @media (--mobile) {
-          width: var(--icon-size--mobile);
-          height: var(--icon-size--mobile);
+            height: var(--height-mobile);
+            position: absolute;
         }
-      }
     }
 
-    &:not(:last-of-type) {
-      margin-bottom: unset;
+    /**
+   * Popover item styles
+   */
+    .ce-popover-item-separator {
+        padding: 0 4px;
+
+        &__line {
+            height: 100%;
+            width: 1px;
+        }
     }
-  }
 
-  .ce-popover-item-html {
-    display: flex;
-    align-items: center;
-  }
+    .ce-popover-item {
+        border-radius: 4px;
+        padding: 4px;
+
+        &__icon--tool {
+            box-shadow: none;
+            background: transparent;
+            margin-right: 0;
+        }
 
-  .ce-popover-item__icon--chevron-right {
-    transform: rotate(90deg);
-  }
+        &__icon {
+            width: unset;
+            height: unset;
 
-  .ce-popover--nested-level-1 {
-    .ce-popover__container {
-      --offset: 3px;
+            svg {
+                width: var(--icon-size);
+                height: var(--icon-size);
 
-      left: 0px;
-      top: calc(var(--height) + var(--offset));
+                @media (--mobile) {
+                    width: var(--icon-size--mobile);
+                    height: var(--icon-size--mobile);
+                }
+            }
+        }
 
-      @media (--mobile) {
-        top: calc(var(--height-mobile) + var(--offset));
-      }
+        &:not(:last-of-type) {
+            margin-bottom: unset;
+        }
     }
-  }
 
-  /**
-   * Nested popovers should look like regular desktop popovers, hence these overrides
-   */
-  .ce-popover--nested {
-    .ce-popover__container {
-      min-width: var(--width);
-      width: var(--width);
-      height: fit-content;
-      padding: 6px;
-      flex-direction: column;
+    .ce-popover-item-html {
+        display: flex;
+        align-items: center;
     }
 
-    .ce-popover__items {
-      display: block;
-      width: 100%;
+    .ce-popover-item__icon--chevron-right {
+        transform: rotate(90deg);
     }
 
-    .ce-popover-item {
-      border-radius: 6px;
-      padding: 3px;
+    .ce-popover--nested-level-1 {
+        .ce-popover__container {
+            --offset: 3px;
 
-      @media (--mobile) {
-        padding: 4px;
-      }
-    
-      &__icon--tool {
-        margin-right: 4px;
-      }
-
-      &__icon {
-        width: 26px;
-        height: 26px;
-      }
+            left: 0;
+            top: calc(var(--height) + var(--offset));
+
+            @media (--mobile) {
+                top: calc(var(--height-mobile) + var(--offset));
+            }
+        }
     }
 
-    .ce-popover-item-separator {
-      padding: 4px 3px;
+    /**
+   * Nested popovers should look like regular desktop popovers, hence these overrides
+   */
+    .ce-popover--nested {
+        .ce-popover__container {
+            min-width: var(--width);
+            width: var(--width);
+            height: fit-content;
+            padding: 6px;
+            flex-direction: column;
+        }
+
+        .ce-popover__items {
+            display: block;
+            width: 100%;
+        }
+
+        .ce-popover-item {
+            border-radius: 6px;
+            padding: 3px;
+
+            @media (--mobile) {
+                padding: 4px;
+            }
 
-      &__line {
-        width: 100%;
-        height: 1px;
-      }
+            &__icon--tool {
+                margin-right: 4px;
+            }
+
+            &__icon {
+                width: 26px;
+                height: 26px;
+            }
+        }
+
+        .ce-popover-item-separator {
+            padding: 4px 3px;
+
+            &__line {
+                width: 100%;
+                height: 1px;
+            }
+        }
     }
-  }
 }
diff --git a/src/styles/tooltip.css b/src/styles/tooltip.css
new file mode 100644
index 000000000..44b1ae601
--- /dev/null
+++ b/src/styles/tooltip.css
@@ -0,0 +1,106 @@
+:root {
+    --ct-color-bg: #1d202b;
+    --ct-color-font: #cdd1e0;
+}
+
+.ct {
+    position: absolute;
+    z-index: 999;
+    top: 0;
+    left: 0;
+    background-color: var(--ct-color-bg);
+    opacity: 0;
+    user-select: none;
+    pointer-events: none;
+    transition: opacity 50ms ease-in, transform 70ms cubic-bezier(0.215, 0.61, 0.355, 1);
+    will-change: opacity, top, left;
+    box-shadow: 0 8px 12px 0 rgba(29, 32, 43, 0.17), 0 4px 5px -3px rgba(5, 6, 12, 0.49);
+    border-radius: 9px;
+}
+
+.ct::before {
+    content: '';
+    inset: 0;
+    position: absolute;
+    background-color: var(--ct-color-bg);
+    z-index: -1;
+    border-radius: 4px;
+}
+
+@supports (-webkit-mask-box-image: url('')) {
+    .ct::before {
+        border-radius: 0;
+        -webkit-mask-box-image: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24"><path d="M10.71 0h2.58c3.02 0 4.64.42 6.1 1.2a8.18 8.18 0 013.4 3.4C23.6 6.07 24 7.7 24 10.71v2.58c0 3.02-.42 4.64-1.2 6.1a8.18 8.18 0 01-3.4 3.4c-1.47.8-3.1 1.21-6.11 1.21H10.7c-3.02 0-4.64-.42-6.1-1.2a8.18 8.18 0 01-3.4-3.4C.4 17.93 0 16.3 0 13.29V10.7c0-3.02.42-4.64 1.2-6.1a8.18 8.18 0 013.4-3.4C6.07.4 7.7 0 10.71 0z" fill="#000" fill-rule="nonzero"/></svg>') 48% 41% 37.9% 53.3%;
+    }
+}
+
+@media (max-width: 768px) {
+    .ct {
+        display: none;
+    }
+}
+
+.ct__content {
+    padding: 6px 10px;
+    color: var(--ct-color-font);
+    font-size: 12px;
+    text-align: center;
+    letter-spacing: 0.02em;
+    line-height: 1em;
+}
+
+.ct::after {
+    content: '';
+    width: 8px;
+    height: 8px;
+    position: absolute;
+    background-color: var(--ct-color-bg);
+    z-index: -1;
+}
+
+.ct--bottom {
+    transform: translateY(5px);
+}
+
+.ct--bottom::after {
+    top: -3px;
+    left: 50%;
+    transform: translateX(-50%) rotate(-45deg);
+}
+
+.ct--top {
+    transform: translateY(-5px);
+}
+
+.ct--top::after {
+    top: auto;
+    bottom: -3px;
+    left: 50%;
+    transform: translateX(-50%) rotate(-45deg);
+}
+
+.ct--left {
+    transform: translateX(-5px);
+}
+
+.ct--left::after {
+    top: 50%;
+    left: auto;
+    right: 0;
+    transform: translate(41.6%, -50%) rotate(-45deg);
+}
+
+.ct--right {
+    transform: translateX(5px);
+}
+
+.ct--right::after {
+    top: 50%;
+    left: 0;
+    transform: translate(-41.6%, -50%) rotate(-45deg);
+}
+
+.ct--shown {
+    opacity: 1;
+    transform: none;
+}
diff --git a/src/types-internal/shortcuts.d.ts b/src/types-internal/shortcuts.d.ts
new file mode 100644
index 000000000..40e1784ab
--- /dev/null
+++ b/src/types-internal/shortcuts.d.ts
@@ -0,0 +1,48 @@
+/**
+ * Declaration for external JS module
+ * After that we can use it at the TS modules
+ */
+declare module '@codexteam/shortcuts' {
+  interface ShortcutOptions {
+    /**
+     * Shortcut name (e.g., 'CMD+K', 'CMD+B')
+     */
+    name: string;
+
+    /**
+     * Element to attach the shortcut to
+     */
+    on: HTMLElement | Document;
+
+    /**
+     * Callback function to execute when shortcut is triggered
+     */
+    callback: (event: KeyboardEvent) => void;
+  }
+
+  /**
+   * Shortcut class for handling keyboard shortcuts
+   */
+  export class Shortcut {
+    /**
+     * Shortcut name
+     */
+    public name: string;
+
+    /**
+     * Creates a new Shortcut instance
+     */
+    constructor(options: ShortcutOptions);
+
+    /**
+     * Removes the shortcut event listener
+     */
+    public remove(): void;
+  }
+
+  /**
+   * Default export
+   */
+  export default Shortcut;
+}
+
diff --git a/test/cypress/.eslintrc b/test/cypress/.eslintrc
deleted file mode 100644
index 6671eb309..000000000
--- a/test/cypress/.eslintrc
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-    "plugins": [
-        "cypress",
-        "chai-friendly"
-    ],
-    "env": {
-        "cypress/globals": true
-    },
-    "extends": [
-        "plugin:cypress/recommended",
-        "plugin:chai-friendly/recommended"
-    ],
-    "rules": {
-        "cypress/require-data-selectors": 2,
-        "cypress/no-unnecessary-waiting": 0,
-        "@typescript-eslint/no-magic-numbers": 0
-    },
-    "globals": {
-        "EditorJS": true
-    }
-}
diff --git a/test/cypress/fixtures/tools/ContentlessTool.ts b/test/cypress/fixtures/tools/ContentlessTool.ts
deleted file mode 100644
index be5885665..000000000
--- a/test/cypress/fixtures/tools/ContentlessTool.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import type { BlockTool } from '../../../../types';
-
-/**
- * In the simplest Contentless Tool (eg. Delimiter) there is no data to save
- */
-interface ContentlessToolData {}
-
-/**
- * This tool behaves like a delimiter
- */
-export default class ContentlessToolMock implements BlockTool {
-  /**
-   * Renders a single content editable element as tools element
-   */
-  public render(): HTMLElement {
-    const wrapper = document.createElement('div');
-
-    wrapper.dataset.cyType = 'contentless-tool';
-
-    wrapper.textContent = '***';
-
-    return wrapper;
-  }
-
-  /**
-   * Save method mock
-   */
-  public save(): ContentlessToolData {
-    return {};
-  }
-
-  /**
-   * Allow Tool to have no content
-   */
-  public static get contentless(): boolean {
-    return true;
-  }
-}
diff --git a/test/cypress/fixtures/tools/SimpleHeader.ts b/test/cypress/fixtures/tools/SimpleHeader.ts
deleted file mode 100644
index 234213741..000000000
--- a/test/cypress/fixtures/tools/SimpleHeader.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import type {
-  BaseTool,
-  BlockToolConstructorOptions,
-  BlockToolData,
-  ConversionConfig
-} from '../../../../types';
-
-/**
- * Simplified Header for testing
- */
-export class SimpleHeader implements BaseTool {
-  private _data: BlockToolData;
-  private element: HTMLHeadingElement | null = null;
-
-  /**
-   *
-   * @param options - constructor options
-   */
-  constructor({ data }: BlockToolConstructorOptions) {
-    this._data = data;
-  }
-
-  /**
-   * Return Tool's view
-   *
-   * @returns {HTMLHeadingElement}
-   * @public
-   */
-  public render(): HTMLHeadingElement {
-    this.element = document.createElement('h1');
-
-    this.element.contentEditable = 'true';
-    this.element.innerHTML = this._data.text;
-
-    return this.element;
-  }
-
-  /**
-   * @param data - saved data to merger with current block
-   */
-  public merge(data: BlockToolData): void {
-    this.element?.insertAdjacentHTML('beforeend', data.text);
-  }
-
-  /**
-   * Extract Tool's data from the view
-   *
-   * @param toolsContent - Text tools rendered view
-   */
-  public save(toolsContent: HTMLHeadingElement): BlockToolData {
-    return {
-      text: toolsContent.innerHTML,
-      level: 1,
-    };
-  }
-
-  /**
-   * Allow Header to be converted to/from other blocks
-   */
-  public static get conversionConfig(): ConversionConfig {
-    return {
-      export: 'text', // use 'text' property for other blocks
-      import: 'text', // fill 'text' property from other block's export string
-    };
-  }
-}
diff --git a/test/cypress/fixtures/tools/ToolMock.ts b/test/cypress/fixtures/tools/ToolMock.ts
deleted file mode 100644
index 51ea3a959..000000000
--- a/test/cypress/fixtures/tools/ToolMock.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import type { BlockTool, BlockToolConstructorOptions } from '../../../../types';
-
-/**
- * Simple structure for Tool data
- */
-export interface MockToolData {
-  text: string;
-}
-
-/**
- * Common class for Tool mocking.
- * Extend this class to create a mock for your Tool with specific properties.
- */
-export default class ToolMock implements BlockTool {
-  /**
-   * Tool data
-   */
-  private data: MockToolData;
-
-  /**
-   * Creates new Tool instance
-   *
-   * @param options - tool constructor options
-   */
-  constructor(options: BlockToolConstructorOptions<MockToolData>) {
-    this.data = options.data;
-  }
-
-  /**
-   * Renders a single content editable element as tools element
-   */
-  public render(): HTMLElement {
-    const contenteditable = document.createElement('div');
-
-    if (this.data && this.data.text) {
-      contenteditable.innerHTML = this.data.text;
-    }
-
-    contenteditable.contentEditable = 'true';
-
-    return contenteditable;
-  }
-
-  /**
-   * Save method mock, returns block innerHTML
-   *
-   * @param block - element rendered by the render method
-   */
-  public save(block: HTMLElement): MockToolData {
-    return {
-      text: block.innerHTML,
-    };
-  }
-}
diff --git a/test/cypress/fixtures/tools/ToolWithoutConversionExport.ts b/test/cypress/fixtures/tools/ToolWithoutConversionExport.ts
deleted file mode 100644
index 77f43f988..000000000
--- a/test/cypress/fixtures/tools/ToolWithoutConversionExport.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import type { ConversionConfig } from '@/types/configs/conversion-config';
-import ToolMock from './ToolMock';
-
-/**
- * This tool has a conversionConfig, but it doesn't have export property.
- *
- * That means that tool can be created from string, but can't be converted to string.
- */
-export class ToolWithoutConversionExport extends ToolMock {
-  /**
-   * Rules specified how our Tool can be converted to/from other Tool.
-   */
-  public static get conversionConfig(): ConversionConfig {
-    return {
-      import: 'text', // this tool can be created from string
-
-      /**
-       * Here is no "export" property, so this tool can't be converted to string
-       */
-      // export: (data) => data.text,
-    };
-  }
-}
diff --git a/test/cypress/fixtures/types/PartialBlockMutationEvent.ts b/test/cypress/fixtures/types/PartialBlockMutationEvent.ts
deleted file mode 100644
index 6955eb227..000000000
--- a/test/cypress/fixtures/types/PartialBlockMutationEvent.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import type { BlockMutationEvent, BlockMutationType } from '../../../../types';
-
-/**
- * Simplified version of the BlockMutationEvent with optional fields that could be used in tests
- */
-export default interface PartialBlockMutationEvent {
-  /**
-   * Event type
-   */
-  type?: BlockMutationType,
-
-  /**
-   * Details with partial properties
-   */
-  detail?: Partial<BlockMutationEvent['detail']>
-}
diff --git a/test/cypress/support/commands.ts b/test/cypress/support/commands.ts
deleted file mode 100644
index 35392fe2f..000000000
--- a/test/cypress/support/commands.ts
+++ /dev/null
@@ -1,278 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * This file contains custom commands for Cypress.
- * Also it can override the existing commands.
- *
- * --------------------------------------------------
- */
-
-import type { EditorConfig, OutputData } from './../../../types/index';
-import type EditorJS from '../../../types/index';
-import Chainable = Cypress.Chainable;
-
-/**
- * Create a wrapper and initialize the new instance of editor.js
- * Then return the instance
- *
- * @param editorConfig - config to pass to the editor
- * @returns EditorJS - created instance
- */
-Cypress.Commands.add('createEditor', (editorConfig: EditorConfig = {}): Chainable<EditorJS> => {
-  return cy.window()
-    .then((window) => {
-      return new Promise((resolve: (instance: EditorJS) => void) => {
-        const editorContainer = window.document.createElement('div');
-
-        editorContainer.setAttribute('id', 'editorjs');
-        editorContainer.dataset.cy = 'editorjs';
-        editorContainer.style.border = '1px dotted #388AE5';
-
-        window.document.body.appendChild(editorContainer);
-
-        const editorInstance: EditorJS = new window.EditorJS(editorConfig);
-
-        editorInstance.isReady.then(() => {
-          resolve(editorInstance);
-        });
-      });
-    });
-});
-
-/**
- * Paste command to dispatch paste event
- *
- * Usage
- * cy.get('div').paste({'text/plain': 'Text', 'text/html': '<b>Text</b>'})
- *
- * @param data - map with MIME type as a key and data as value
- */
-Cypress.Commands.add('paste', {
-  prevSubject: true,
-}, (subject, data: {[type: string]: string}) => {
-  const pasteEvent = Object.assign(new Event('paste', {
-    bubbles: true,
-    cancelable: true,
-  }), {
-    clipboardData: {
-      getData: (type): string => data[type],
-      types: Object.keys(data),
-    },
-  });
-
-  subject[0].dispatchEvent(pasteEvent);
-
-  cy.wait(200); // wait a little since some tools (paragraph) could have async hydration
-});
-
-/**
- * Copy command to dispatch copy event on subject
- *
- * Usage:
- * cy.get('div').copy().then(data => {})
- */
-Cypress.Commands.add('copy', { prevSubject: true }, (subject) => {
-  const clipboardData: {[type: string]: any} = {};
-
-  const copyEvent = Object.assign(new Event('copy', {
-    bubbles: true,
-    cancelable: true,
-  }), {
-    clipboardData: {
-      setData: (type: string, data: any): void => {
-        clipboardData[type] = data;
-      },
-    },
-  });
-
-  subject[0].dispatchEvent(copyEvent);
-
-  return cy.wrap(clipboardData);
-});
-
-/**
- * Cut command to dispatch cut event on subject
- *
- * Usage:
- * cy.get('div').cut().then(data => {})
- */
-Cypress.Commands.add('cut', { prevSubject: true }, (subject) => {
-  const clipboardData: {[type: string]: any} = {};
-
-  const copyEvent = Object.assign(new Event('cut', {
-    bubbles: true,
-    cancelable: true,
-  }), {
-    clipboardData: {
-      setData: (type: string, data: any): void => {
-        clipboardData[type] = data;
-      },
-    },
-  });
-
-  subject[0].dispatchEvent(copyEvent);
-
-  return cy.wrap(clipboardData);
-});
-
-/**
- * Calls EditorJS API render method
- *
- * @param data — data to render
- */
-Cypress.Commands.add('render', { prevSubject: true }, (subject: EditorJS, data: OutputData) => {
-  return cy.wrap(subject.render(data))
-    .then(() => {
-      return cy.wrap(subject);
-    });
-});
-
-
-/**
- * Select passed text in element
- * Note. Previous subject should have 'textNode' as firstChild
- *
- * Usage
- * cy.get('[data-cy=editorjs]')
- *  .find('.ce-paragraph')
- *  .selectText('block te')
- *
- * @param text - text to select
- */
-Cypress.Commands.add('selectText', {
-  prevSubject: true,
-}, (subject, text: string) => {
-  const el = subject[0];
-  const document = el.ownerDocument;
-  const range = document.createRange();
-  const textNode = el.firstChild;
-  const selectionPositionStart = textNode.textContent.indexOf(text);
-  const selectionPositionEnd = selectionPositionStart + text.length;
-
-  range.setStart(textNode, selectionPositionStart);
-  range.setEnd(textNode, selectionPositionEnd);
-  document.getSelection().removeAllRanges();
-  document.getSelection().addRange(range);
-
-  return cy.wrap(subject);
-});
-
-/**
- * Select element's text by offset
- * Note. Previous subject should have 'textNode' as firstChild
- *
- * Usage
- * cy.get('[data-cy=editorjs]')
- *  .find('.ce-paragraph')
- *  .selectTextByOffset([0, 5])
- *
- * @param offset - offset to select
- */
-Cypress.Commands.add('selectTextByOffset', {
-  prevSubject: true,
-}, (subject, offset: [number, number]) => {
-  const el = subject[0];
-  const document = el.ownerDocument;
-  const range = document.createRange();
-  const textNode = el.firstChild;
-  const selectionPositionStart = offset[0];
-  const selectionPositionEnd = offset[1];
-
-  range.setStart(textNode, selectionPositionStart);
-  range.setEnd(textNode, selectionPositionEnd);
-  document.getSelection().removeAllRanges();
-  document.getSelection().addRange(range);
-
-  return cy.wrap(subject);
-});
-
-/**
- * Returns line wrap positions for passed element
- *
- * Usage
- * cy.get('[data-cy=editorjs]')
- *  .find('.ce-paragraph')
- *  .getLineWrapPositions()
- *
- * @returns number[] - array of line wrap positions
- */
-Cypress.Commands.add('getLineWrapPositions', {
-  prevSubject: true,
-}, (subject) => {
-  const element = subject[0];
-  const document = element.ownerDocument;
-  const text = element.textContent;
-  const lineWraps = [];
-
-  let currentLineY = 0;
-
-  /**
-   * Iterate all chars in text, create range for each char and get its position
-   */
-  for (let i = 0; i < text.length; i++) {
-    const range = document.createRange();
-
-    range.setStart(element.firstChild, i);
-    range.setEnd(element.firstChild, i);
-
-    const rect = range.getBoundingClientRect();
-
-    if (i === 0) {
-      currentLineY = rect.top;
-
-      continue;
-    }
-
-    /**
-     * If current char Y position is higher than previously saved line Y, that means a line wrap
-     */
-    if (rect.top > currentLineY) {
-      lineWraps.push(i);
-
-      currentLineY = rect.top;
-    }
-  }
-
-  return cy.wrap(lineWraps);
-});
-
-/**
- * Dispatches keydown event on subject
- * Uses the correct KeyboardEvent object to make it work with our code (see below)
- */
-Cypress.Commands.add('keydown', {
-  prevSubject: true,
-}, (subject, keyCode: number) => {
-  cy.log('Dispatching KeyboardEvent with keyCode: ' + keyCode);
-  /**
-   * We use the "reason instanceof KeyboardEvent" statement in blockSelection.ts
-   * but by default cypress' KeyboardEvent is not an instance of the native KeyboardEvent,
-   * so real-world and Cypress behaviour were different.
-   *
-   * To make it work we need to trigger Cypress event with "eventConstructor: 'KeyboardEvent'",
-   *
-   * @see https://github.com/cypress-io/cypress/issues/5650
-   * @see https://github.com/cypress-io/cypress/pull/8305/files
-   */
-  subject.trigger('keydown', {
-    eventConstructor: 'KeyboardEvent',
-    keyCode,
-    bubbles: false,
-  });
-
-  return cy.wrap(subject);
-});
-
-/**
- * Extract content of pseudo element
- *
- * @example cy.get('element').getPseudoElementContent('::before').should('eq', 'my-test-string')
- */
-Cypress.Commands.add('getPseudoElementContent', {
-  prevSubject: true,
-}, (subject, pseudoElement: 'string') => {
-  const win = subject[0].ownerDocument.defaultView;
-  const computedStyle = win.getComputedStyle(subject[0], pseudoElement);
-  const content = computedStyle.getPropertyValue('content');
-
-  return content.replace(/['"]/g, ''); // Remove quotes around the content
-});
diff --git a/test/cypress/support/e2e.ts b/test/cypress/support/e2e.ts
deleted file mode 100644
index 0ec34b571..000000000
--- a/test/cypress/support/e2e.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import '@cypress/code-coverage/support';
-
-/* global chai */
-// because this file is imported from cypress/support/e2e.js
-// that means all other spec files will have this assertion plugin
-// available to them because the supportFile is bundled and served
-// prior to any spec files loading
-
-import type PartialBlockMutationEvent from '../fixtures/types/PartialBlockMutationEvent';
-
-/**
- * Chai plugin for checking if passed onChange method is called with an array of passed events
- *
- * @param _chai - Chai instance
- */
-const beCalledWithBatchedEvents = (_chai): void => {
-  /**
-   * Check if passed onChange method is called with an array of passed events
-   *
-   * @param expectedEvents - batched events to check
-   */
-  function assertToBeCalledWithBatchedEvents(expectedEvents: PartialBlockMutationEvent[]): void {
-    /**
-     * EditorJS API is passed as the first parameter of the onChange callback
-     */
-    const EditorJSApiMock = Cypress.sinon.match.any;
-    const $onChange = this._obj;
-
-    this.assert(
-      $onChange.calledOnce,
-      'expected #{this} to be called once',
-      'expected #{this} to not be called once'
-    );
-
-    this.assert(
-      $onChange.calledWithMatch(
-        EditorJSApiMock,
-        Cypress.sinon.match((events: PartialBlockMutationEvent[]) => {
-          expect(events).to.be.an('array');
-
-          return events.every((event, index) => {
-            const eventToCheck = expectedEvents[index];
-
-            return expect(event).to.containSubset(eventToCheck);
-          });
-        })
-      ),
-      'expected #{this} to be called with #{exp}, but it was called with #{act}',
-      'expected #{this} to not be called with #{exp}, but it was called with #{act} ',
-      expectedEvents
-    );
-  }
-
-  _chai.Assertion.addMethod('calledWithBatchedEvents', assertToBeCalledWithBatchedEvents);
-};
-
-/**
- * registers our assertion function "beCalledWithBatchedEvents" with Chai
- */
-chai.use(beCalledWithBatchedEvents);
diff --git a/test/cypress/support/index.d.ts b/test/cypress/support/index.d.ts
deleted file mode 100644
index ee8a49544..000000000
--- a/test/cypress/support/index.d.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-// load type definitions that come with Cypress module
-/// <reference types="cypress" />
-
-import type { EditorConfig, OutputData } from './../../../types/index';
-import type EditorJS from '../../../types/index'
-import PartialBlockMutationEvent from '../fixtures/types/PartialBlockMutationEvent';
-
-declare global {
-  namespace Cypress {
-    interface Chainable<Subject = any> {
-      /**
-       * Custom command to select DOM element by data-cy attribute.
-       * @param editorConfig - config to pass to the editor
-       * @example cy.createEditor({})
-       */
-      createEditor(editorConfig: EditorConfig): Chainable<EditorJS>
-
-      /**
-       * Paste command to dispatch paste event
-       *
-       * @usage
-       * cy.get('div').paste({'text/plain': 'Text', 'text/html': '<b>Text</b>'})
-       *
-       * @param data - map with MIME type as a key and data as value
-       */
-      paste(data: {[type: string]: string}): Chainable<Subject>
-
-      /**
-       * Copy command to dispatch copy event on subject
-       *
-       * @usage
-       * cy.get('div').copy().then(data => {})
-       */
-      copy(): Chainable<Subject>;
-
-      /**
-       * Cut command to dispatch cut event on subject
-       *
-       * @usage
-       * cy.get('div').cut().then(data => {})
-       */
-      cut(): Chainable<Subject>;
-
-      /**
-       * Calls EditorJS API render method
-       *
-       * @param data — data to render
-       */
-      render(data: OutputData): Chainable<Subject>;
-
-      /**
-       * Select passed text in element
-       * Note. Previous subject should have 'textNode' as firstChild
-       *
-       * Usage
-       * cy.get('[data-cy=editorjs]')
-       *  .find('.ce-paragraph')
-       *  .selectText('block te')
-       *
-       * @param text - text to select
-       */
-      selectText(text: string): Chainable<Subject>;
-
-      /**
-       * Select element's text by offset
-       * Note. Previous subject should have 'textNode' as firstChild
-       *
-       * Usage
-       * cy.get('[data-cy=editorjs]')
-       *  .find('.ce-paragraph')
-       *  .selectTextByOffset([0, 5])
-       *
-       * @param offset - offset to select
-       */
-      selectTextByOffset(offset: [number, number]): Chainable<Subject>;
-
-      /**
-       * Returns line wrap positions for passed element
-       *
-       * Usage
-       * cy.get('[data-cy=editorjs]')
-       *  .find('.ce-paragraph')
-       *  .getLineWrapPositions()
-       *
-       * @returns number[] - array of line wrap positions
-       */
-      getLineWrapPositions(): Chainable<number[]>;
-
-      /**
-       * Dispatches keydown event on subject
-       * Uses the correct KeyboardEvent object to make it work with our code (see below)
-       *
-       * @param keyCode - key code to dispatch
-       */
-      keydown(keyCode: number): Chainable<Subject>;
-
-      /**
-       * Extract content of pseudo element
-       *
-       * @example cy.get('element').getPseudoElementContent('::before').should('eq', 'my-test-string')
-       */
-      getPseudoElementContent(pseudoElement: string): Chainable<string>;
-    }
-
-    interface ApplicationWindow {
-      EditorJS: typeof EditorJS
-    }
-
-    /**
-     * Extends Cypress assertion Chainer interface with the new assertion methods
-     */
-    interface Chainer<Subject> {
-      /**
-       * Custom Chai assertion that checks if given onChange method is called with an array of passed events
-       *
-       * @example
-       *   ```
-       *   cy.get('@onChange').should('be.calledWithBatchedEvents', [{ type: 'block-added', detail: { index: 0 }}])
-       *   expect(onChange).to.be.calledWithBatchedEvents([{ type: 'block-added', detail: { index: 0 }}])
-       *   ```
-       */
-      (chainer: 'be.calledWithBatchedEvents', expectedEvents: PartialBlockMutationEvent[]): Chainable<Subject>;
-    }
-  }
-
-  /**
-   * Chai plugins
-   */
-  namespace Chai {
-    interface Assertion {
-      /**
-       * "containSubset" object properties matcher
-       */
-      containSubset(subset: any): Assertion;
-
-      /**
-       * Custom Chai assertion that checks if given onChange method is called with an array of passed events
-       *
-       * @example
-       *   ```
-       *   cy.get('@onChange').should('be.calledWithBatchedEvents', [{ type: 'block-added', detail: { index: 0 }}])
-       *   expect(onChange).to.be.calledWithBatchedEvents([{ type: 'block-added', detail: { index: 0 }}])
-       *   ```
-       */
-      calledWithBatchedEvents(expectedEvents: PartialBlockMutationEvent[]): Assertion;
-    }
-  }
-}
diff --git a/test/cypress/support/index.ts b/test/cypress/support/index.ts
deleted file mode 100644
index 395574124..000000000
--- a/test/cypress/support/index.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-/**
- * This file is processed and
- * loaded automatically before the test files.
- *
- * This is a great place to put global configuration and
- * behavior that modifies Cypress.
- */
-
-import '@cypress/code-coverage/support';
-import installLogsCollector from 'cypress-terminal-report/src/installLogsCollector';
-import 'cypress-plugin-tab';
-
-installLogsCollector();
-
-/**
- * File with the helpful commands
- */
-import './commands';
-
-/**
- * File with custom assertions
- */
-import './e2e';
-
-import chaiSubset from 'chai-subset';
-
-/**
- * "containSubset" object properties matcher
- */
-chai.use(chaiSubset);
-
-/**
- * Before-each hook for the cypress tests
- */
-beforeEach((): void => {
-  cy.visit('test/cypress/fixtures/test.html');
-});
diff --git a/test/cypress/support/utils/createEditorWithTextBlocks.ts b/test/cypress/support/utils/createEditorWithTextBlocks.ts
deleted file mode 100644
index 08d0fc49b..000000000
--- a/test/cypress/support/utils/createEditorWithTextBlocks.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import type { EditorConfig } from '../../../../types/index';
-import Chainable = Cypress.Chainable;
-import type EditorJS from '../../../../types/index';
-
-
-/**
- * Creates Editor instance with list of Paragraph blocks of passed texts
- *
- * @param textBlocks - list of texts for Paragraph blocks
- * @param editorConfig - config to pass to the editor
- */
-export function createEditorWithTextBlocks(textBlocks: string[], editorConfig?: Omit<EditorConfig, 'data'>): Chainable<EditorJS> {
-  return cy.createEditor(Object.assign(editorConfig || {}, {
-    data: {
-      blocks: textBlocks.map((text) => ({
-        type: 'paragraph',
-        data: {
-          text,
-        },
-      })),
-    },
-  }));
-}
diff --git a/test/cypress/support/utils/createParagraphMock.ts b/test/cypress/support/utils/createParagraphMock.ts
deleted file mode 100644
index 30166e87e..000000000
--- a/test/cypress/support/utils/createParagraphMock.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { nanoid } from 'nanoid';
-
-/**
- * Creates a paragraph mock
- *
- * @param text - text for the paragraph
- * @returns paragraph mock
- */
-export function createParagraphMock(text: string): {
-  id: string;
-  type: string;
-  data: { text: string };
-} {
-  return {
-    id: nanoid(),
-    type: 'paragraph',
-    data: { text },
-  };
-}
\ No newline at end of file
diff --git a/test/cypress/support/utils/nestedEditorInstance.ts b/test/cypress/support/utils/nestedEditorInstance.ts
deleted file mode 100644
index f335cbcee..000000000
--- a/test/cypress/support/utils/nestedEditorInstance.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import type { BlockTool, BlockToolConstructorOptions } from '../../../../types';
-import { createEditorWithTextBlocks } from './createEditorWithTextBlocks';
-
-export const NESTED_EDITOR_ID = 'nested-editor';
-
-/**
- * Creates nested Editor instance with paragraph block
- */
-export default class NestedEditor implements BlockTool {
-  private data: { text: string };
-
-  constructor(value: BlockToolConstructorOptions) {
-    this.data = value.data;
-  }
-
-  public render(): HTMLDivElement {
-    const editorEl = Object.assign(document.createElement('div'), {
-      id: NESTED_EDITOR_ID,
-    });
-
-    editorEl.setAttribute('data-cy', NESTED_EDITOR_ID);
-
-    createEditorWithTextBlocks([ this.data.text ], { holder: NESTED_EDITOR_ID });
-
-    return editorEl;
-  }
-
-  public save(): string {
-    return this.data.text;
-  }
-}
diff --git a/test/cypress/tests/api/block.cy.ts b/test/cypress/tests/api/block.cy.ts
deleted file mode 100644
index d5d731f11..000000000
--- a/test/cypress/tests/api/block.cy.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-import type EditorJS from '../../../../types';
-import { BlockChangedMutationType } from '../../../../types/events/block/BlockChanged';
-
-/**
- * There will be described test cases of BlockAPI
- */
-describe('BlockAPI', () => {
-  const firstBlock = {
-    id: 'bwnFX5LoX7',
-    type: 'paragraph',
-    data: {
-      text: 'The first block content mock.',
-    },
-  };
-  const editorDataMock = {
-    blocks: [
-      firstBlock,
-    ],
-  };
-
-  /**
-   * EditorJS API is passed as the first parameter of the onChange callback
-   */
-  const EditorJSApiMock = Cypress.sinon.match.any;
-
-  /**
-   * Creates Editor instance
-   *
-   * @param [data] - data to render
-   */
-  function createEditor(data = undefined): void {
-    const config = {
-      onChange: (api, event): void => {
-        console.log('something changed', event);
-      },
-      data,
-    };
-
-    cy.spy(config, 'onChange').as('onChange');
-
-    cy.createEditor(config).as('editorInstance');
-  }
-
-  /**
-   * block.dispatchChange();
-   */
-  describe('.dispatchChange()', () => {
-    /**
-     * Check that blocks.dispatchChange() triggers Editor 'onChange' callback
-     */
-    it('should trigger onChange with corresponded block', () => {
-      createEditor(editorDataMock);
-
-      cy.get<EditorJS>('@editorInstance')
-        .then(async (editor) => {
-          const block = editor.blocks.getById(firstBlock.id);
-
-          block.dispatchChange();
-
-          cy.get('@onChange').should('be.calledWithMatch', EditorJSApiMock, Cypress.sinon.match({
-            type: BlockChangedMutationType,
-            detail: {
-              index: 0,
-            },
-          }));
-        });
-    });
-  });
-});
diff --git a/test/cypress/tests/api/blocks.cy.ts b/test/cypress/tests/api/blocks.cy.ts
deleted file mode 100644
index ab97b8b5c..000000000
--- a/test/cypress/tests/api/blocks.cy.ts
+++ /dev/null
@@ -1,527 +0,0 @@
-import type EditorJS from '../../../../types/index';
-import type { ConversionConfig, ToolboxConfig, ToolConfig } from '../../../../types';
-import ToolMock, { type MockToolData } from '../../fixtures/tools/ToolMock';
-import { nanoid } from 'nanoid';
-
-/**
- * There will be described test cases of 'blocks.*' API
- */
-describe('api.blocks', () => {
-  const firstBlock = {
-    id: 'bwnFX5LoX7',
-    type: 'paragraph',
-    data: {
-      text: 'The first block content mock.',
-    },
-  };
-  const editorDataMock = {
-    blocks: [
-      firstBlock,
-    ],
-  };
-
-  /**
-   * api.blocks.getById(id)
-   */
-  describe('.getById()', () => {
-    /**
-     * Check that api.blocks.getByUd(id) returns the Block for existed id
-     */
-    it('should return Block API for existed id', () => {
-      cy.createEditor({
-        data: editorDataMock,
-      }).as('editorInstance');
-
-      cy.get<EditorJS>('@editorInstance').then(async (editor) => {
-        const block = editor.blocks.getById(firstBlock.id);
-
-        expect(block).not.to.be.undefined;
-        expect(block.id).to.be.eq(firstBlock.id);
-      });
-    });
-
-    /**
-     * Check that api.blocks.getByUd(id) returns null for the not-existed id
-     */
-    it('should return null for not-existed id', () => {
-      cy.createEditor({
-        data: editorDataMock,
-      }).as('editorInstance');
-
-      cy.get<EditorJS>('@editorInstance').then(async (editor) => {
-        expect(editor.blocks.getById('not-existed-id')).to.be.null;
-      });
-    });
-  });
-
-  /**
-   * api.blocks.update(id, newData)
-   */
-  describe('.update()', () => {
-    /**
-     * Check if block is updated in DOM
-     */
-    it('should update block in DOM', () => {
-      cy.createEditor({
-        data: editorDataMock,
-      }).then((editor) => {
-        const idToUpdate = firstBlock.id;
-        const newBlockData = {
-          text: 'Updated text',
-        };
-
-        editor.blocks.update(idToUpdate, newBlockData);
-
-        cy.get('[data-cy=editorjs]')
-          .get('div.ce-block')
-          .should('have.text', newBlockData.text);
-      });
-    });
-
-    /**
-     * Check if block's data is updated after saving
-     */
-    it('should update block in saved data', () => {
-      cy.createEditor({
-        data: editorDataMock,
-      }).then((editor) => {
-        const idToUpdate = firstBlock.id;
-        const newBlockData = {
-          text: 'Updated text',
-        };
-
-        editor.blocks.update(idToUpdate, newBlockData);
-
-        // wait a little since some tools (paragraph) could have async hydration
-        cy.wait(100).then(() => {
-          editor.save().then((output) => {
-            const text = output.blocks[0].data.text;
-
-            expect(text).to.be.eq(newBlockData.text);
-          });
-        });
-      });
-    });
-
-    it('should update tune data when it is provided', () => {
-      /**
-       * Example Tune Class
-       */
-      class ExampleTune {
-        protected data: object;
-        /**
-         *
-         * @param data
-         */
-        constructor({ data }) {
-          this.data = data;
-        }
-
-        /**
-         * Tell editor.js that this Tool is a Block Tune
-         *
-         * @returns {boolean}
-         */
-        public static get isTune(): boolean {
-          return true;
-        }
-
-        /**
-         * Create Tunes controls wrapper that will be appended to the Block Tunes panel
-         *
-         * @returns {Element}
-         */
-        public render(): Element {
-          return document.createElement('div');
-        }
-
-        /**
-         * CSS selectors used in Tune
-         */
-        public static get CSS(): object {
-          return {};
-        }
-
-        /**
-         * Returns Tune state
-         *
-         * @returns {string}
-         */
-        public save(): object | string {
-          return this.data || '';
-        }
-      }
-
-
-      cy.createEditor({
-        tools: {
-          exampleTune: ExampleTune,
-        },
-        tunes: [ 'exampleTune' ],
-        data: {
-          blocks: [
-            {
-              id: nanoid(),
-              type: 'paragraph',
-              data: {
-                text: 'First block',
-              },
-              tunes: {
-                exampleTune: 'citation',
-              },
-            },
-          ],
-        },
-      }).as('editorInstance');
-
-      // Update the tunes data of a block
-      // Check if it is updated
-      cy.get<EditorJS>('@editorInstance')
-        .then(async (editor) => {
-          await editor.blocks.update(editor.blocks.getBlockByIndex(0).id, null, {
-            exampleTune: 'test',
-          });
-          const data = await editor.save();
-
-          const actual = JSON.stringify(data.blocks[0].tunes);
-          const expected = JSON.stringify({ exampleTune: 'test' });
-
-          expect(actual).to.eq(expected);
-        });
-    });
-
-    /**
-     * When incorrect id passed, editor should not update any block
-     */
-    it('shouldn\'t update any block if not-existed id passed', () => {
-      cy.createEditor({
-        data: editorDataMock,
-      }).then((editor) => {
-        const idToUpdate = 'wrong-id-123';
-        const newBlockData = {
-          text: 'Updated text',
-        };
-
-        editor.blocks.update(idToUpdate, newBlockData)
-          .catch(error => {
-            expect(error.message).to.be.eq(`Block with id "${idToUpdate}" not found`);
-          })
-          .finally(() => {
-            cy.get('[data-cy=editorjs]')
-              .get('div.ce-block')
-              .invoke('text')
-              .then(blockText => {
-                expect(blockText).to.be.eq(firstBlock.data.text);
-              });
-          });
-      });
-    });
-  });
-
-  /**
-   * api.blocks.insert(type, data, config, index, needToFocus, replace, id)
-   */
-  describe('.insert()', function () {
-    it('should preserve block id if it is passed', function () {
-      cy.createEditor({
-        data: editorDataMock,
-      }).then((editor) => {
-        const type = 'paragraph';
-        const data = { text: 'codex' };
-        const config = undefined;
-        const index = undefined;
-        const needToFocus = undefined;
-        const replace = undefined;
-        const id = 'test-id-123';
-
-        const block = editor.blocks.insert(type, data, config, index, needToFocus, replace, id);
-
-        expect(block).not.to.be.undefined;
-        expect(block.id).to.be.eq(id);
-      });
-    });
-  });
-
-  /**
-   * api.blocks.insertMany(blocks, index)
-   */
-  describe('.insertMany()', function () {
-    it('should insert several blocks to passed index', function () {
-      cy.createEditor({
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: { text: 'first block' },
-            },
-          ],
-        },
-      }).then((editor) => {
-        const index = 0;
-
-        cy.wrap(editor.blocks.insertMany([
-          {
-            type: 'paragraph',
-            data: { text: 'inserting block #1' },
-          },
-          {
-            type: 'paragraph',
-            data: { text: 'inserting block #2' },
-          },
-        ], index)); // paste to the 0 index
-
-        cy.get('[data-cy=editorjs]')
-          .find('.ce-block')
-          .each(($el, i) => {
-            switch (i) {
-              case 0:
-                cy.wrap($el).should('have.text', 'inserting block #1');
-                break;
-              case 1:
-                cy.wrap($el).should('have.text', 'inserting block #2');
-                break;
-              case 2:
-                cy.wrap($el).should('have.text', 'first block');
-                break;
-            }
-          });
-      });
-    });
-  });
-
-  describe('.convert()', function () {
-    it('should convert a Block to another type if original Tool has "conversionConfig.export" and target Tool has "conversionConfig.import". Should return BlockAPI as well.', function () {
-      /**
-       * Mock of Tool with conversionConfig
-       */
-      class ConvertableTool extends ToolMock {
-        /**
-         * Specify how to import string data to this Tool
-         */
-        public static get conversionConfig(): ConversionConfig {
-          return {
-            import: 'text',
-          };
-        }
-
-        /**
-         * Specify how to display Tool in a Toolbox
-         */
-        public static get toolbox(): ToolboxConfig {
-          return {
-            icon: '',
-            title: 'Convertable tool',
-          };
-        }
-      }
-
-      const existingBlock = {
-        id: 'test-id-123',
-        type: 'paragraph',
-        data: {
-          text: 'Some text',
-        },
-      };
-
-      cy.createEditor({
-        tools: {
-          convertableTool: {
-            class: ConvertableTool,
-          },
-        },
-        data: {
-          blocks: [
-            existingBlock,
-          ],
-        },
-      }).then(async (editor) => {
-        const { convert } = editor.blocks;
-
-        const returnValue = await convert(existingBlock.id, 'convertableTool');
-
-        // wait for block to be converted
-        cy.wait(100).then(async () => {
-          /**
-           * Check that block was converted
-           */
-          const { blocks } = await editor.save();
-
-          expect(blocks.length).to.eq(1);
-          expect(blocks[0].type).to.eq('convertableTool');
-          expect(blocks[0].data.text).to.eq(existingBlock.data.text);
-
-          /**
-           * Check that returned value is BlockAPI
-           */
-          expect(returnValue).to.containSubset({
-            name: 'convertableTool',
-            id: blocks[0].id,
-          });
-        });
-      });
-    });
-
-    it('should throw an error if nonexisting Block id passed', function () {
-      cy.createEditor({})
-        .then((editor) => {
-          /**
-           * Call the 'convert' api method with nonexisting Block id
-           */
-          const fakeId = 'WRNG_ID';
-          const { convert } = editor.blocks;
-
-          return convert(fakeId, 'convertableTool')
-            .catch((error) => {
-              expect(error.message).to.be.eq(`Block with id "${fakeId}" not found`);
-            });
-        });
-    });
-
-    it('should throw an error if nonexisting Tool name passed', function () {
-      const existingBlock = {
-        id: 'test-id-123',
-        type: 'paragraph',
-        data: {
-          text: 'Some text',
-        },
-      };
-
-      cy.createEditor({
-        data: {
-          blocks: [
-            existingBlock,
-          ],
-        },
-      }).then((editor) => {
-        /**
-         * Call the 'convert' api method with nonexisting tool name
-         */
-        const nonexistingToolName = 'WRNG_TOOL_NAME';
-        const { convert } = editor.blocks;
-
-        return convert(existingBlock.id, nonexistingToolName)
-          .catch((error) => {
-            expect(error.message).to.be.eq(`Block Tool with type "${nonexistingToolName}" not found`);
-          });
-      });
-    });
-
-    it('should throw an error if some tool does not provide "conversionConfig"', function () {
-      const existingBlock = {
-        id: 'test-id-123',
-        type: 'paragraph',
-        data: {
-          text: 'Some text',
-        },
-      };
-
-      /**
-       * Mock of Tool without conversionConfig
-       */
-      class ToolWithoutConversionConfig extends ToolMock {}
-
-      cy.createEditor({
-        tools: {
-          nonConvertableTool: {
-            class: ToolWithoutConversionConfig,
-            shortcut: 'CMD+SHIFT+H',
-          },
-        },
-        data: {
-          blocks: [
-            existingBlock,
-          ],
-        },
-      }).then((editor) => {
-        /**
-         * Call the 'convert' api method with tool that does not provide "conversionConfig"
-         */
-        const { convert } = editor.blocks;
-
-        return convert(existingBlock.id, 'nonConvertableTool')
-          .catch((error) => {
-            expect(error.message).to.be.eq(`Conversion from "paragraph" to "nonConvertableTool" is not possible. NonConvertableTool tool(s) should provide a "conversionConfig"`);
-          });
-      });
-    });
-
-    it('should pass tool config to the conversionConfig.import method of the tool', function () {
-      const existingBlock = {
-        id: 'test-id-123',
-        type: 'paragraph',
-        data: {
-          text: 'Some text',
-        },
-      };
-
-      const conversionTargetToolConfig = {
-        defaultStyle: 'defaultStyle',
-      };
-
-      /**
-       * Mock of Tool with conversionConfig
-       */
-      class ToolWithConversionConfig extends ToolMock {
-        /**
-         * Specify conversion config of the tool
-         */
-        public static get conversionConfig(): {
-          /**
-           * Method that is responsible for conversion from data to string
-           */
-          export: (data: string) => string;
-
-          /**
-           * Method that is responsible for conversion from string to data
-           * Should return stringified config to see, if Editor actually passed tool config to it
-           */
-          import: (content: string, config: ToolConfig) => MockToolData;
-          } {
-          return {
-            export: (data) => data,
-            /**
-             * Passed config should be returned
-             */
-            import: (_content, config) => {
-              return { text: JSON.stringify(config) };
-            },
-          };
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          conversionTargetTool: {
-            class: ToolWithConversionConfig,
-            config: conversionTargetToolConfig,
-          },
-        },
-        data: {
-          blocks: [
-            existingBlock,
-          ],
-        },
-      }).then(async (editor) => {
-        const { convert } = editor.blocks;
-
-        await convert(existingBlock.id, 'conversionTargetTool');
-
-        // wait for block to be converted
-        cy.wait(100).then(async () => {
-          /**
-           * Check that block was converted
-           */
-          const { blocks } = await editor.save();
-
-          expect(blocks.length).to.eq(1);
-          expect(blocks[0].type).to.eq('conversionTargetTool');
-
-          /**
-           * Check that tool converted returned config as a result of import
-           */
-          expect(blocks[0].data.text).to.eq(JSON.stringify(conversionTargetToolConfig));
-        });
-      });
-    });
-  });
-});
diff --git a/test/cypress/tests/api/caret.cy.ts b/test/cypress/tests/api/caret.cy.ts
deleted file mode 100644
index 53a7d1fc4..000000000
--- a/test/cypress/tests/api/caret.cy.ts
+++ /dev/null
@@ -1,249 +0,0 @@
-import { createParagraphMock } from '../../support/utils/createParagraphMock';
-import type EditorJS from '../../../../types';
-
-/**
- * Test cases for Caret API
- */
-describe('Caret API', () => {
-  describe('.setToBlock()', () => {
-    describe('first argument', () => {
-      const paragraphDataMock = createParagraphMock('The first block content mock.');
-
-      /**
-       * The arrange part of the following tests are the same:
-       *  - create an editor
-       *  - move caret out of the block by default
-       */
-      beforeEach(() => {
-        cy.createEditor({
-          data: {
-            blocks: [
-              paragraphDataMock,
-            ],
-          },
-        }).as('editorInstance');
-
-        /**
-         * Blur caret from the block before setting via api
-         */
-        cy.get('[data-cy=editorjs]')
-          .click();
-      });
-      it('should set caret to a block (and return true) if block index is passed as argument', () => {
-        cy.get<EditorJS>('@editorInstance')
-          .then(async (editor) => {
-            const returnedValue = editor.caret.setToBlock(0);
-
-            /**
-             * Check that caret belongs block
-             */
-            cy.window()
-              .then((window) => {
-                const selection = window.getSelection();
-                const range = selection.getRangeAt(0);
-
-                cy.get('[data-cy=editorjs]')
-                  .find('.ce-block')
-                  .first()
-                  .should(($block) => {
-                    expect($block[0].contains(range.startContainer)).to.be.true;
-                  });
-              });
-
-            expect(returnedValue).to.be.true;
-          });
-      });
-
-      it('should set caret to a block (and return true) if block id is passed as argument', () => {
-        cy.get<EditorJS>('@editorInstance')
-          .then(async (editor) => {
-            const returnedValue = editor.caret.setToBlock(paragraphDataMock.id);
-
-            /**
-             * Check that caret belongs block
-             */
-            cy.window()
-              .then((window) => {
-                const selection = window.getSelection();
-                const range = selection.getRangeAt(0);
-
-                cy.get('[data-cy=editorjs]')
-                  .find('.ce-block')
-                  .first()
-                  .should(($block) => {
-                    expect($block[0].contains(range.startContainer)).to.be.true;
-                  });
-              });
-
-            expect(returnedValue).to.be.true;
-          });
-      });
-
-      it('should set caret to a block (and return true) if Block API is passed as argument', () => {
-        cy.get<EditorJS>('@editorInstance')
-          .then(async (editor) => {
-            const block = editor.blocks.getById(paragraphDataMock.id);
-            const returnedValue = editor.caret.setToBlock(block);
-
-            /**
-             * Check that caret belongs block
-             */
-            cy.window()
-              .then((window) => {
-                const selection = window.getSelection();
-                const range = selection.getRangeAt(0);
-
-                cy.get('[data-cy=editorjs]')
-                  .find('.ce-block')
-                  .first()
-                  .should(($block) => {
-                    expect($block[0].contains(range.startContainer)).to.be.true;
-                  });
-              });
-
-            expect(returnedValue).to.be.true;
-          });
-      });
-    });
-
-    describe('offset', () => {
-      it('should set caret at specific offset in text content', () => {
-        const paragraphDataMock = createParagraphMock('Plain text content.');
-
-        cy.createEditor({
-          data: {
-            blocks: [
-              paragraphDataMock,
-            ],
-          },
-        }).as('editorInstance');
-
-        cy.get<EditorJS>('@editorInstance')
-          .then(async (editor) => {
-            const block = editor.blocks.getById(paragraphDataMock.id);
-
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            editor.caret.setToBlock(block!, 'default', 5);
-
-            cy.window()
-              .then((window) => {
-                const selection = window.getSelection();
-
-                if (!selection) {
-                  throw new Error('Selection not found');
-                }
-                const range = selection.getRangeAt(0);
-
-                expect(range.startOffset).to.equal(5);
-              });
-          });
-      });
-
-      it('should set caret at correct offset when text contains HTML elements', () => {
-        const paragraphDataMock = createParagraphMock('1234<b>567</b>!');
-
-        cy.createEditor({
-          data: {
-            blocks: [
-              paragraphDataMock,
-            ],
-          },
-        }).as('editorInstance');
-
-        cy.get<EditorJS>('@editorInstance')
-          .then(async (editor) => {
-            const block = editor.blocks.getById(paragraphDataMock.id);
-
-            // Set caret after "12345"
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            editor.caret.setToBlock(block!, 'default', 6);
-
-            cy.window()
-              .then((window) => {
-                const selection = window.getSelection();
-
-                if (!selection) {
-                  throw new Error('Selection not found');
-                }
-                const range = selection.getRangeAt(0);
-
-                expect(range.startContainer.textContent).to.equal('567');
-                expect(range.startOffset).to.equal(2);
-              });
-          });
-      });
-
-      it('should handle offset beyond content length', () => {
-        const paragraphDataMock = createParagraphMock('1234567890');
-
-        cy.createEditor({
-          data: {
-            blocks: [
-              paragraphDataMock,
-            ],
-          },
-        }).as('editorInstance');
-
-        cy.get<EditorJS>('@editorInstance')
-          .then(async (editor) => {
-            const block = editor.blocks.getById(paragraphDataMock.id);
-
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const contentLength = block!.holder.textContent?.length ?? 0;
-
-            // Set caret beyond content length
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            editor.caret.setToBlock(block!, 'default', contentLength + 10);
-
-            cy.window()
-              .then((window) => {
-                const selection = window.getSelection();
-
-                if (!selection) {
-                  throw new Error('Selection not found');
-                }
-                const range = selection.getRangeAt(0);
-
-                // Should be at the end of content
-                expect(range.startOffset).to.equal(contentLength);
-              });
-          });
-      });
-
-      it('should handle offset in nested HTML structure', () => {
-        const paragraphDataMock = createParagraphMock('123<b>456<i>789</i></b>!');
-
-        cy.createEditor({
-          data: {
-            blocks: [
-              paragraphDataMock,
-            ],
-          },
-        }).as('editorInstance');
-
-        cy.get<EditorJS>('@editorInstance')
-          .then(async (editor) => {
-            const block = editor.blocks.getById(paragraphDataMock.id);
-
-
-            // Set caret after "8"
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            editor.caret.setToBlock(block!, 'default', 8);
-
-            cy.window()
-              .then((window) => {
-                const selection = window.getSelection();
-
-                if (!selection) {
-                  throw new Error('Selection not found');
-                }
-                const range = selection.getRangeAt(0);
-
-                expect(range.startContainer.textContent).to.equal('789');
-                expect(range.startOffset).to.equal(2);
-              });
-          });
-      });
-    });
-  });
-});
diff --git a/test/cypress/tests/api/toolbar.cy.ts b/test/cypress/tests/api/toolbar.cy.ts
deleted file mode 100644
index 41da27b14..000000000
--- a/test/cypress/tests/api/toolbar.cy.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * There will be described test cases of 'api.toolbar.*' API
- */
-import type EditorJS from '../../../../types';
-
-describe('api.toolbar', () => {
-  /**
-   * api.toolbar.openToolbox(openingState?: boolean)
-   */
-  const firstBlock = {
-    id: 'bwnFX5LoX7',
-    type: 'paragraph',
-    data: {
-      text: 'The first block content mock.',
-    },
-  };
-  const editorDataMock = {
-    blocks: [
-      firstBlock,
-    ],
-  };
-
-  beforeEach(function () {
-    cy.createEditor({
-      data: editorDataMock,
-      readOnly: false,
-    }).as('editorInstance');
-  });
-
-  afterEach(function () {
-    if (this.editorInstance) {
-      this.editorInstance.destroy();
-    }
-  });
-
-  describe('*.toggleToolbox()', () => {
-    const isToolboxVisible = (): void => {
-      cy.get('[data-cy=editorjs]').find('div.ce-toolbox')
-        .then((toolbox) => {
-          if (toolbox.is(':visible')) {
-            assert.isOk(true, 'Toolbox visible');
-          } else {
-            assert.isNotOk(false, 'Toolbox should be visible');
-          }
-        });
-    };
-
-    const isToolboxNotVisible = (): void => {
-      cy.get('[data-cy=editorjs]').find('div.ce-toolbox')
-        .then((toolbox) => {
-          if (!toolbox.is(':visible')) {
-            assert.isOk(true, 'Toolbox not visible');
-          } else {
-            assert.isNotOk(false, 'Toolbox should not be visible');
-          }
-        });
-    };
-
-    it('should open the toolbox', function () {
-      cy.get<EditorJS>('@editorInstance').then(async function (editor) {
-        editor.toolbar.toggleToolbox(true);
-        isToolboxVisible();
-      });
-    });
-
-    it('should close the toolbox', function () {
-      cy.get<EditorJS>('@editorInstance').then(async function (editor) {
-        editor.toolbar.toggleToolbox(true);
-
-        isToolboxVisible();
-
-        editor.toolbar.toggleToolbox(false);
-        isToolboxNotVisible();
-      });
-    });
-    it('should toggle the toolbox', function () {
-      cy.get<EditorJS>('@editorInstance').then(async function (editor) {
-        editor.toolbar.toggleToolbox();
-        isToolboxVisible();
-
-        editor.toolbar.toggleToolbox();
-        isToolboxNotVisible();
-      });
-    });
-  });
-});
diff --git a/test/cypress/tests/api/tools.cy.ts b/test/cypress/tests/api/tools.cy.ts
deleted file mode 100644
index be6a52c3b..000000000
--- a/test/cypress/tests/api/tools.cy.ts
+++ /dev/null
@@ -1,1004 +0,0 @@
-import type { ToolboxConfig, BlockToolData, ToolboxConfigEntry, PasteConfig } from '../../../../types';
-import type EditorJS from '../../../../types';
-import type { HTMLPasteEvent, TunesMenuConfig } from '../../../../types/tools';
-
-/* eslint-disable @typescript-eslint/no-empty-function */
-
-const ICON = '<svg width="17" height="15" viewBox="0 0 336 276" xmlns="http://www.w3.org/2000/svg"><path d="M291 150V79c0-19-15-34-34-34H79c-19 0-34 15-34 34v42l67-44 81 72 56-29 42 30zm0 52l-43-30-56 30-81-67-66 39v23c0 19 15 34 34 34h178c17 0 31-13 34-29zM79 0h178c44 0 79 35 79 79v118c0 44-35 79-79 79H79c-44 0-79-35-79-79V79C0 35 35 0 79 0z"></path></svg>';
-
-describe('Editor Tools Api', () => {
-  context('Toolbox', () => {
-    it('should render a toolbox entry for tool if configured', () => {
-      /**
-       * Tool with single toolbox entry configured
-       */
-      class TestTool {
-        /**
-         * Returns toolbox config as list of entries
-         */
-        public static get toolbox(): ToolboxConfigEntry {
-          return {
-            title: 'Entry 1',
-            icon: ICON,
-          };
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          testTool: TestTool,
-        },
-      }).as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-toolbar__plus')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover-item[data-item-name=testTool]')
-        .should('have.length', 1);
-
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover-item[data-item-name=testTool] .ce-popover-item__icon')
-        .should('contain.html', TestTool.toolbox.icon);
-    });
-
-    it('should render several toolbox entries for one tool if configured', () => {
-      /**
-       * Tool with several toolbox entries configured
-       */
-      class TestTool {
-        /**
-         * Returns toolbox config as list of entries
-         */
-        public static get toolbox(): ToolboxConfig {
-          return [
-            {
-              title: 'Entry 1',
-              icon: ICON,
-            },
-            {
-              title: 'Entry 2',
-              icon: ICON,
-            },
-          ];
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          testTool: TestTool,
-        },
-      }).as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-toolbar__plus')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover-item[data-item-name=testTool]')
-        .should('have.length', 2);
-
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover-item[data-item-name=testTool]')
-        .first()
-        .should('contain.text', TestTool.toolbox[0].title);
-
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover-item[data-item-name=testTool]')
-        .last()
-        .should('contain.text', TestTool.toolbox[1].title);
-    });
-
-    it('should insert block with overridden data on entry click in case toolbox entry provides data overrides', () => {
-      const text = 'Text';
-      const dataOverrides = {
-        testProp: 'new value',
-      };
-
-      /**
-       * Tool with default data to be overridden
-       */
-      class TestTool {
-        private _data = {
-          testProp: 'default value',
-        };
-
-        /**
-         * Tool constructor
-         *
-         * @param data - previously saved data
-         */
-        constructor({ data }) {
-          this._data = data;
-        }
-
-        /**
-         * Returns toolbox config as list of entries with overridden data
-         */
-        public static get toolbox(): ToolboxConfig {
-          return [
-            {
-              title: 'Entry 1',
-              icon: ICON,
-              data: dataOverrides,
-            },
-          ];
-        }
-
-        /**
-         * Return Tool's view
-         */
-        public render(): HTMLElement {
-          const wrapper = document.createElement('div');
-
-          wrapper.setAttribute('contenteditable', 'true');
-
-          return wrapper;
-        }
-
-        /**
-         * Extracts Tool's data from the view
-         *
-         * @param el - tool view
-         */
-        public save(el: HTMLElement): BlockToolData {
-          return {
-            ...this._data,
-            text: el.innerHTML,
-          };
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          testTool: TestTool,
-        },
-      }).as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-toolbar__plus')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover-item[data-item-name=testTool]')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .last()
-        .click()
-        .type(text);
-
-      cy.get('@editorInstance')
-        .then(async (editor: unknown) => {
-          const editorData = await (editor as EditorJS).save();
-
-          expect(editorData.blocks[0].data).to.be.deep.eq({
-            ...dataOverrides,
-            text,
-          });
-        });
-    });
-  });
-
-  context('Tunes — renderSettings()', () => {
-    it('should contain a single block tune configured in tool\'s renderSettings() method', () => {
-      /** Tool with single tunes menu entry configured */
-      class TestTool {
-        /** Returns toolbox config as list of entries */
-        public static get toolbox(): ToolboxConfigEntry {
-          return {
-            title: 'Test tool',
-            icon: ICON,
-          };
-        }
-
-        /** Returns configuration for block tunes menu */
-        public renderSettings(): TunesMenuConfig {
-          return {
-            label: 'Test tool tune',
-            icon: ICON,
-            name: 'testToolTune',
-
-            onActivate: (): void => { },
-          };
-        }
-
-        /** Save method stub */
-        public save(): void { }
-
-        /** Renders a block */
-        public render(): HTMLElement {
-          const element = document.createElement('div');
-
-          element.contentEditable = 'true';
-          element.setAttribute('data-name', 'testBlock');
-
-          return element;
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          testTool: TestTool,
-        },
-      }).as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-toolbar__plus')
-        .click();
-
-      // Insert test tool block
-      cy.get('[data-cy=editorjs]')
-        .get(`[data-item-name="testTool"]`)
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('[data-name=testBlock]')
-        .type('some text')
-        .click();
-
-      // Open block tunes
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-toolbar__settings-btn')
-        .click();
-
-      // Expect preconfigured tune to exist in tunes menu
-      cy.get('[data-item-name=testToolTune]').should('exist');
-    });
-
-    it('should contain multiple block tunes if configured in tool\'s renderSettings() method', () => {
-      /** Tool with single tunes menu entry configured */
-      class TestTool {
-        /** Returns toolbox config as list of entries */
-        public static get toolbox(): ToolboxConfigEntry {
-          return {
-            title: 'Test tool',
-            icon: ICON,
-          };
-        }
-
-        /** Returns configuration for block tunes menu */
-        public renderSettings(): TunesMenuConfig {
-          return [
-            {
-              label: 'Test tool tune 1',
-              icon: ICON,
-              name: 'testToolTune1',
-
-              onActivate: (): void => { },
-            },
-            {
-              label: 'Test tool tune 2',
-              icon: ICON,
-              name: 'testToolTune2',
-
-              onActivate: (): void => { },
-            },
-          ];
-        }
-
-        /** Save method stub */
-        public save(): void { }
-
-        /** Renders a block */
-        public render(): HTMLElement {
-          const element = document.createElement('div');
-
-          element.contentEditable = 'true';
-          element.setAttribute('data-name', 'testBlock');
-
-          return element;
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          testTool: TestTool,
-        },
-      }).as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-toolbar__plus')
-        .click();
-
-      // Insert test tool block
-      cy.get('[data-cy=editorjs]')
-        .get(`[data-item-name="testTool"]`)
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('[data-name=testBlock]')
-        .type('some text')
-        .click();
-
-      // Open block tunes
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-toolbar__settings-btn')
-        .click();
-
-      // Expect preconfigured tunes to exist in tunes menu
-      cy.get('[data-item-name=testToolTune1]').should('exist');
-      cy.get('[data-item-name=testToolTune2]').should('exist');
-    });
-
-    it('should contain block tunes represented as custom html if so configured in tool\'s renderSettings() method', () => {
-      const sampleText = 'sample text';
-
-      /** Tool with single tunes menu entry configured */
-      class TestTool {
-        /** Returns toolbox config as list of entries */
-        public static get toolbox(): ToolboxConfigEntry {
-          return {
-            title: 'Test tool',
-            icon: ICON,
-          };
-        }
-
-        /** Returns configuration for block tunes menu */
-        public renderSettings(): HTMLElement {
-          const element = document.createElement('div');
-
-          element.textContent = sampleText;
-
-          return element;
-        }
-
-        /** Save method stub */
-        public save(): void { }
-
-        /** Renders a block */
-        public render(): HTMLElement {
-          const element = document.createElement('div');
-
-          element.contentEditable = 'true';
-          element.setAttribute('data-name', 'testBlock');
-
-          return element;
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          testTool: TestTool,
-        },
-      }).as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-toolbar__plus')
-        .click();
-
-      // Insert test tool block
-      cy.get('[data-cy=editorjs]')
-        .get(`[data-item-name="testTool"]`)
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('[data-name=testBlock]')
-        .type('some text')
-        .click();
-
-      // Open block tunes
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-toolbar__settings-btn')
-        .click();
-
-      // Expect preconfigured custom html tunes to exist in tunes menu
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover')
-        .should('contain.text', sampleText);
-    });
-
-    it('should support label alias', () => {
-      /** Tool with single tunes menu entry configured */
-      class TestTool {
-        /** Returns toolbox config as list of entries */
-        public static get toolbox(): ToolboxConfigEntry {
-          return {
-            title: 'Test tool',
-            icon: ICON,
-          };
-        }
-
-        /** Returns configuration for block tunes menu */
-        public renderSettings(): TunesMenuConfig {
-          return [
-            {
-              icon: ICON,
-              name: 'testToolTune1',
-              onActivate: (): void => {},
-
-              // Set text via title property
-              title: 'Test tool tune 1',
-            },
-            {
-              icon: ICON,
-              name: 'testToolTune2',
-              onActivate: (): void => {},
-
-              // Set test via label property
-              label: 'Test tool tune 2',
-            },
-          ];
-        }
-
-        /** Save method stub */
-        public save(): void {}
-
-        /** Renders a block */
-        public render(): HTMLElement {
-          const element = document.createElement('div');
-
-          element.contentEditable = 'true';
-          element.setAttribute('data-name', 'testBlock');
-
-          return element;
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          testTool: TestTool,
-        },
-      }).as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-toolbar__plus')
-        .click();
-
-      // Insert test tool block
-      cy.get('[data-cy=editorjs]')
-        .get(`[data-item-name="testTool"]`)
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('[data-name=testBlock]')
-        .type('some text')
-        .click();
-
-      // Open block tunes
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-toolbar__settings-btn')
-        .click();
-
-      // Expect both tunes to have correct text
-      cy.get('[data-item-name=testToolTune1]').contains('Test tool tune 1');
-      cy.get('[data-item-name=testToolTune2]').contains('Test tool tune 2');
-    });
-  });
-
-  /**
-   * @todo cover all the pasteConfig properties
-   */
-  context('Paste — pasteConfig()', () => {
-    context('tags', () => {
-      /**
-       * tags: ['H1', 'H2']
-       */
-      it('should use corresponding tool when the array of tag names specified', () => {
-        /**
-         * Test tool with pasteConfig.tags specified
-         */
-        class TestImgTool {
-          /** config specified handled tag */
-          public static get pasteConfig(): PasteConfig {
-            return {
-              tags: [ 'img' ], // only tag name specified. Attributes should be sanitized
-            };
-          }
-
-          /** onPaste callback will be stubbed below */
-          public onPaste(): void { }
-
-          /** save is required for correct implementation of the BlockTool class */
-          public save(): void { }
-
-          /** render is required for correct implementation of the BlockTool class */
-          public render(): HTMLElement {
-            return document.createElement('img');
-          }
-        }
-
-        const toolsOnPaste = cy.spy(TestImgTool.prototype, 'onPaste');
-
-        cy.createEditor({
-          tools: {
-            testTool: TestImgTool,
-          },
-        }).as('editorInstance');
-
-        cy.get('[data-cy=editorjs]')
-          .get('div.ce-block')
-          .click()
-          .paste({
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'text/html': '<img>',
-          })
-          .then(() => {
-            expect(toolsOnPaste).to.be.called;
-          });
-      });
-
-      /**
-       * tags: ['img'] -> <img>
-       */
-      it('should sanitize all attributes from tag, if only tag name specified ', () => {
-        /**
-         * Variable used for spying the pasted element we are passing to the Tool
-         */
-        let pastedElement;
-
-        /**
-         * Test tool with pasteConfig.tags specified
-         */
-        class TestImageTool {
-          /** config specified handled tag */
-          public static get pasteConfig(): PasteConfig {
-            return {
-              tags: [ 'img' ], // only tag name specified. Attributes should be sanitized
-            };
-          }
-
-          /** onPaste callback will be stubbed below */
-          public onPaste(): void { }
-
-          /** save is required for correct implementation of the BlockTool class */
-          public save(): void { }
-
-          /** render is required for correct implementation of the BlockTool class */
-          public render(): HTMLElement {
-            return document.createElement('img');
-          }
-        }
-
-        /**
-         * Stub the onPaste method to access the PasteEvent data for assertion
-         */
-        cy.stub(TestImageTool.prototype, 'onPaste').callsFake((event: HTMLPasteEvent) => {
-          pastedElement = event.detail.data;
-        });
-
-        cy.createEditor({
-          tools: {
-            testImageTool: TestImageTool,
-          },
-        });
-
-        cy.get('[data-cy=editorjs]')
-          .get('div.ce-block')
-          .click()
-          .paste({
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'text/html': '<img src="foo" onerror="alert(123)"/>', // all attributes should be sanitized
-          })
-          .then(() => {
-            expect(pastedElement).not.to.be.undefined;
-            expect(pastedElement.tagName.toLowerCase()).eq('img');
-            expect(pastedElement.attributes.length).eq(0);
-          });
-      });
-
-      /**
-       * tags: ['OL','LI',]
-       * -><ol>
-       * <li></li>
-       * <li></li>
-       * </ol>
-       */
-      it('should sanitize all attributes from tags, even if tag names specified in uppercase', () => {
-        /**
-         * Variable used for spying the pasted element we are passing to the Tool
-         */
-        let pastedElement;
-
-        /**
-         * Test tool with pasteConfig.tags specified
-         */
-        class TestListTool {
-          /** config specified handled tag */
-          public static get pasteConfig(): PasteConfig {
-            return {
-              tags: ['OL', 'LI'], // tag names specified in upper case
-            };
-          }
-
-          /** onPaste callback will be stubbed below */
-          public onPaste(): void { }
-
-          /** save is required for correct implementation of the BlockTool class */
-          public save(): void { }
-
-          /** render is required for correct implementation of the BlockTool class */
-          public render(): HTMLElement {
-            return document.createElement('ol');
-          }
-        }
-
-        /**
-         * Stub the onPaste method to access the PasteEvent data for assertion
-         */
-        cy.stub(TestListTool.prototype, 'onPaste').callsFake((event: HTMLPasteEvent) => {
-          pastedElement = event.detail.data;
-        });
-
-        cy.createEditor({
-          tools: {
-            testListTool: TestListTool,
-          },
-        });
-
-        cy.get('[data-cy=editorjs]')
-          .get('div.ce-block')
-          .click()
-          .paste({
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'text/html': '<ol start="50"><li>Orderd List</li><li>Unorderd List</li></ol>', // all attributes should be sanitized, <li> should be preserved
-          })
-          .then(() => {
-            expect(pastedElement).not.to.be.undefined;
-            expect(pastedElement.tagName.toLowerCase()).eq('ol');
-            expect(pastedElement.attributes.length).eq(0);
-            // check number of children
-            expect(pastedElement.children.length).eq(2);
-
-            /**
-             * Check that all children are <li> tags
-             */
-            pastedElement.childNodes.forEach((child) => {
-              expect(child.tagName.toLowerCase()).eq('li');
-              expect(child.attributes.length).eq(0);
-            });
-          });
-      });
-
-      /**
-       * tags: [{
-       *   img: {
-       *     src: true
-       *   }
-       * }]
-       *   ->  <img src="">
-       *
-       */
-      it('should leave attributes if entry specified as a sanitizer config ', () => {
-        /**
-         * Variable used for spying the pasted element we are passing to the Tool
-         */
-        let pastedElement;
-
-        /**
-         * Test tool with pasteConfig.tags specified
-         */
-        class TestImageTool {
-          /** config specified handled tag */
-          public static get pasteConfig(): PasteConfig {
-            return {
-              tags: [
-                {
-                  img: {
-                    src: true,
-                  },
-                },
-              ],
-            };
-          }
-
-          /** onPaste callback will be stubbed below */
-          public onPaste(): void { }
-
-          /** save is required for correct implementation of the BlockTool class */
-          public save(): void { }
-
-          /** render is required for correct implementation of the BlockTool class */
-          public render(): HTMLElement {
-            return document.createElement('img');
-          }
-        }
-
-        /**
-         * Stub the onPaste method to access the PasteEvent data for assertion
-         */
-        cy.stub(TestImageTool.prototype, 'onPaste').callsFake((event: HTMLPasteEvent) => {
-          pastedElement = event.detail.data;
-        });
-
-        cy.createEditor({
-          tools: {
-            testImageTool: TestImageTool,
-          },
-        });
-
-        cy.get('[data-cy=editorjs]')
-          .get('div.ce-block')
-          .click()
-          .paste({
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'text/html': '<img src="foo" onerror="alert(123)"/>',
-          })
-          .then(() => {
-            expect(pastedElement).not.to.be.undefined;
-
-            /**
-             * Check that the <img> has only "src" attribute
-             */
-            expect(pastedElement.tagName.toLowerCase()).eq('img');
-            expect(pastedElement.getAttribute('src')).eq('foo');
-            expect(pastedElement.attributes.length).eq(1);
-          });
-      });
-
-      /**
-       * tags: [
-       *   'video',
-       *   {
-       *     source: {
-       *       src: true
-       *     }
-       *   }
-       * ]
-       */
-      it('should support mixed tag names and sanitizer config ', () => {
-        /**
-         * Variable used for spying the pasted element we are passing to the Tool
-         */
-        let pastedElement;
-
-        /**
-         * Test tool with pasteConfig.tags specified
-         */
-        class TestTool {
-          /** config specified handled tag */
-          public static get pasteConfig(): PasteConfig {
-            return {
-              tags: [
-                'video', // video should not have attributes
-                {
-                  source: { // source should have only src attribute
-                    src: true,
-                  },
-                },
-              ],
-            };
-          }
-
-          /** onPaste callback will be stubbed below */
-          public onPaste(): void { }
-
-          /** save is required for correct implementation of the BlockTool class */
-          public save(): void { }
-
-          /** render is required for correct implementation of the BlockTool class */
-          public render(): HTMLElement {
-            return document.createElement('video');
-          }
-        }
-
-        /**
-         * Stub the onPaste method to access the PasteEvent data for assertion
-         */
-        cy.stub(TestTool.prototype, 'onPaste').callsFake((event: HTMLPasteEvent) => {
-          pastedElement = event.detail.data;
-        });
-
-        cy.createEditor({
-          tools: {
-            testTool: TestTool,
-          },
-        });
-
-        cy.get('[data-cy=editorjs]')
-          .get('div.ce-block')
-          .click()
-          .paste({
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'text/html': '<video width="100"><source src="movie.mp4" type="video/mp4"></video>',
-          })
-          .then(() => {
-            expect(pastedElement).not.to.be.undefined;
-
-            /**
-             * Check that <video>  has no attributes
-             */
-            expect(pastedElement.tagName.toLowerCase()).eq('video');
-            expect(pastedElement.attributes.length).eq(0);
-
-            /**
-             * Check that the <source> has only 'src' attribute
-             */
-            expect(pastedElement.firstChild.tagName.toLowerCase()).eq('source');
-            expect(pastedElement.firstChild.getAttribute('src')).eq('movie.mp4');
-            expect(pastedElement.firstChild.attributes.length).eq(1);
-          });
-      });
-
-      /**
-       * tags: [
-       *   {
-       *     td: { width: true },
-       *     tr: { height: true }
-       *   }
-       * ]
-       */
-      it('should support config with several keys as the single entry', () => {
-        /**
-         * Variable used for spying the pasted element we are passing to the Tool
-         */
-        let pastedElement;
-
-        /**
-         * Test tool with pasteConfig.tags specified
-         */
-        class TestTool {
-          /** config specified handled tag */
-          public static get pasteConfig(): PasteConfig {
-            return {
-              tags: [
-                {
-                  video: {
-                    width: true,
-                  },
-                  source: {
-                    src: true,
-                  },
-                },
-              ],
-            };
-          }
-
-          /** onPaste callback will be stubbed below */
-          public onPaste(): void { }
-
-          /** save is required for correct implementation of the BlockTool class */
-          public save(): void { }
-
-          /** render is required for correct implementation of the BlockTool class */
-          public render(): HTMLElement {
-            return document.createElement('video');
-          }
-        }
-
-        /**
-         * Stub the onPaste method to access the PasteEvent data for assertion
-         */
-        cy.stub(TestTool.prototype, 'onPaste').callsFake((event: HTMLPasteEvent) => {
-          pastedElement = event.detail.data;
-        });
-
-        cy.createEditor({
-          tools: {
-            testTool: TestTool,
-          },
-        });
-
-        cy.get('[data-cy=editorjs]')
-          .get('div.ce-block')
-          .click()
-          .paste({
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'text/html': '<video width="100"><source src="movie.mp4" type="video/mp4"></video>',
-          })
-          .then(() => {
-            expect(pastedElement).not.to.be.undefined;
-            expect(pastedElement.tagName.toLowerCase()).eq('video');
-
-            /**
-             * Check that the <tr> has the 'height' attribute
-             */
-            expect(pastedElement.firstChild.tagName.toLowerCase()).eq('source');
-            expect(pastedElement.firstChild.getAttribute('src')).eq('movie.mp4');
-          });
-      });
-
-      /**
-       * It covers a workaround HTMLJanitor bug with tables (incorrect sanitizing of table.innerHTML)
-       * https://github.com/guardian/html-janitor/issues/3
-       */
-      it('should correctly sanitize Table structure (test for HTMLJanitor bug)', () => {
-        /**
-         * Variable used for spying the pasted element we are passing to the Tool
-         */
-        let pastedElement;
-
-        /**
-         * Test tool with pasteConfig.tags specified
-         */
-        class TestTool {
-          /** config specified handled tag */
-          public static get pasteConfig(): PasteConfig {
-            return {
-              tags: [
-                'table',
-                'tbody',
-                {
-                  td: {
-                    width: true,
-                  },
-                  tr: {
-                    height: true,
-                  },
-                },
-              ],
-            };
-          }
-
-          /** onPaste callback will be stubbed below */
-          public onPaste(): void { }
-
-          /** save is required for correct implementation of the BlockTool class */
-          public save(): void { }
-
-          /** render is required for correct implementation of the BlockTool class */
-          public render(): HTMLElement {
-            return document.createElement('tbody');
-          }
-        }
-
-        /**
-         * Stub the onPaste method to access the PasteEvent data for assertion
-         */
-        cy.stub(TestTool.prototype, 'onPaste').callsFake((event: HTMLPasteEvent) => {
-          pastedElement = event.detail.data;
-        });
-
-        cy.createEditor({
-          tools: {
-            testTool: TestTool,
-          },
-        });
-
-        cy.get('[data-cy=editorjs]')
-          .get('div.ce-block')
-          .click()
-          .paste({
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'text/html': '<table><tr height="50"><td width="300">Ho-Ho-Ho</td></tr></table>',
-          })
-          .then(() => {
-            expect(pastedElement).not.to.be.undefined;
-            expect(pastedElement.tagName.toLowerCase()).eq('table');
-
-            /**
-             * Check that the <tr> has the 'height' attribute
-             */
-            expect(pastedElement.querySelector('tr')).not.to.be.undefined;
-            expect(pastedElement.querySelector('tr').getAttribute('height')).eq('50');
-
-            /**
-             * Check that the <td> has the 'width' attribute
-             */
-            expect(pastedElement.querySelector('td')).not.to.be.undefined;
-            expect(pastedElement.querySelector('td').getAttribute('width')).eq('300');
-          });
-      });
-    });
-  });
-});
diff --git a/test/cypress/tests/api/tunes.cy.ts b/test/cypress/tests/api/tunes.cy.ts
deleted file mode 100644
index 104e4d4ac..000000000
--- a/test/cypress/tests/api/tunes.cy.ts
+++ /dev/null
@@ -1,241 +0,0 @@
-import type { TunesMenuConfig } from '../../../../types/tools';
-
-/* eslint-disable @typescript-eslint/no-empty-function */
-
-describe('Editor Tunes Api', () => {
-  it('should render a popover entry for block tune if configured', () => {
-    /** Test tune that should appear be rendered in block tunes menu */
-    class TestTune {
-      /** Set Tool is Tune */
-      public static readonly isTune = true;
-
-      /** Tune's appearance in block settings menu */
-      public render(): TunesMenuConfig {
-        return {
-          icon: 'ICON',
-          title: 'Test tune',
-          name: 'testTune',
-
-          onActivate: (): void => { },
-        };
-      }
-
-      /** Save method stub */
-      public save(): void {}
-    }
-
-    cy.createEditor({
-      tools: {
-        testTune: TestTune,
-      },
-      tunes: [ 'testTune' ],
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .type('some text')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-    cy.get('[data-item-name=testTune]').should('exist');
-  });
-
-  it('should render several popover entries for block tune if configured', () => {
-    /** Test tune that should appear be rendered in block tunes menu */
-    class TestTune {
-      /** Set Tool is Tune */
-      public static readonly isTune = true;
-
-      /** Tune's appearance in block settings menu */
-      public render(): TunesMenuConfig {
-        return [
-          {
-            icon: 'ICON1',
-            title: 'Tune entry 1',
-            name: 'testTune1',
-
-            onActivate: (): void => { },
-          }, {
-            icon: 'ICON2',
-            title: 'Tune entry 2',
-            name: 'testTune2',
-
-            onActivate: (): void => { },
-          },
-        ];
-      }
-
-      /** Save method stub */
-      public save(): void {}
-    }
-
-    cy.createEditor({
-      tools: {
-        testTune: TestTune,
-      },
-      tunes: [ 'testTune' ],
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .type('some text')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-    cy.get('[data-item-name=testTune1]').should('exist');
-    cy.get('[data-item-name=testTune2]').should('exist');
-  });
-
-  it('should display custom html returned by tune\'s render() method inside tunes menu', () => {
-    const sampleText = 'sample text';
-
-    /** Test tune that should appear be rendered in block tunes menu  */
-    class TestTune {
-      /** Set Tool is Tune */
-      public static readonly isTune = true;
-
-      /** Tune's appearance in block settings menu */
-      public render(): HTMLElement {
-        const element = document.createElement('div');
-
-        element.textContent = sampleText;
-
-        return element;
-      }
-
-      /** Save method stub */
-      public save(): void {}
-    }
-
-    cy.createEditor({
-      tools: {
-        testTune: TestTune,
-      },
-      tunes: [ 'testTune' ],
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .type('some text')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover')
-      .should('contain.text', sampleText);
-  });
-
-  it('should support label alias', () => {
-    /** Test tune that should appear be rendered in block tunes menu */
-    class TestTune {
-      /** Set Tool is Tune */
-      public static readonly isTune = true;
-
-      /** Tune's appearance in block settings menu */
-      public render(): TunesMenuConfig {
-        return [
-          {
-            icon: 'ICON1',
-            name: 'testTune1',
-            onActivate: (): void => { },
-
-            // Set text via title property
-            title: 'Tune entry 1',
-          }, {
-            icon: 'ICON2',
-            name: 'testTune2',
-            onActivate: (): void => { },
-
-            // Set text via label property
-            label: 'Tune entry 2',
-          },
-        ];
-      }
-
-      /** Save method stub */
-      public save(): void {}
-    }
-
-    cy.createEditor({
-      tools: {
-        testTune: TestTune,
-      },
-      tunes: [ 'testTune' ],
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .type('some text')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-
-    /** Check both tunes have correct text */
-    cy.get('[data-item-name=testTune1]').contains('Tune entry 1');
-    cy.get('[data-item-name=testTune2]').contains('Tune entry 2');
-  });
-
-  it('should display installed tunes above default tunes', () => {
-    /** Test tune that should appear be rendered in block tunes menu */
-    class TestTune {
-      /** Set Tool is Tune */
-      public static readonly isTune = true;
-
-      /** Tune's appearance in block settings menu */
-      public render(): TunesMenuConfig {
-        return [
-          {
-            icon: 'ICON',
-            label: 'Tune entry',
-            name: 'test-tune',
-
-            onActivate: (): void => { },
-          },
-        ];
-      }
-
-      /** Save method stub */
-      public save(): void {}
-    }
-
-    cy.createEditor({
-      tools: {
-        testTune: TestTune,
-      },
-      tunes: [ 'testTune' ],
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .type('some text')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-    /** Check test tune is inserted at index 0 */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-settings .ce-popover-item')
-      .eq(0)
-      .should('have.attr', 'data-item-name', 'test-tune' );
-
-    /** Check default Move Up tune is inserted below the test tune */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-settings .ce-popover-item')
-      .eq(1)
-      .should('have.attr', 'data-item-name', 'move-up' );
-  });
-});
diff --git a/test/cypress/tests/block-ids.cy.ts b/test/cypress/tests/block-ids.cy.ts
deleted file mode 100644
index 140f940fb..000000000
--- a/test/cypress/tests/block-ids.cy.ts
+++ /dev/null
@@ -1,160 +0,0 @@
-import Header from '@editorjs/header';
-import { nanoid } from 'nanoid';
-import type EditorJS from '../../../types/index';
-
-
-describe('Block ids', () => {
-  it('Should generate unique block ids for new blocks', () => {
-    cy.createEditor({
-      tools: {
-        header: Header,
-      },
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .click()
-      .type('First block ')
-      .type('{enter}')
-      .get('div.ce-block')
-      .last()
-      .type('Second block ')
-      .type('{enter}');
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-toolbar__plus')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover-item[data-item-name=header]')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .last()
-      .click()
-      .type('Header');
-
-    cy.get<EditorJS>('@editorInstance')
-      .then(async (editor) => {
-        const data = await editor.save();
-
-        data.blocks.forEach(block => {
-          expect(typeof block.id).to.eq('string');
-        });
-      });
-  });
-
-  it('should preserve passed ids', () => {
-    cy.createEditor({})
-      .as('editorInstance');
-
-    const blocks = [
-      {
-        id: nanoid(),
-        type: 'paragraph',
-        data: {
-          text: 'First block',
-        },
-      },
-      {
-        id: nanoid(),
-        type: 'paragraph',
-        data: {
-          text: 'Second block',
-        },
-      },
-    ];
-
-    cy.get<EditorJS>('@editorInstance')
-      .render({
-        blocks,
-      });
-
-    cy.get<EditorJS>('@editorInstance')
-      .then(async (editor) => {
-        const data = await editor.save();
-
-        data.blocks.forEach((block, index) => {
-          expect(block.id).to.eq(blocks[index].id);
-        });
-      });
-  });
-
-  it('should preserve passed ids if blocks were added', () => {
-    cy.createEditor({})
-      .as('editorInstance');
-
-    const blocks = [
-      {
-        id: nanoid(),
-        type: 'paragraph',
-        data: {
-          text: 'First block',
-        },
-      },
-      {
-        id: nanoid(),
-        type: 'paragraph',
-        data: {
-          text: 'Second block',
-        },
-      },
-    ];
-
-    cy.get<EditorJS>('@editorInstance')
-      .render({
-        blocks,
-      });
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .first()
-      .click()
-      .type('{enter}')
-      .next()
-      .type('Middle block');
-
-    cy.get<EditorJS>('@editorInstance')
-      .then(async (editor) => {
-        cy.wrap(await editor.save())
-          .then((data) => {
-            expect(data.blocks[0].id).to.eq(blocks[0].id);
-            expect(data.blocks[2].id).to.eq(blocks[1].id);
-          });
-      });
-  });
-
-  it('should be stored at the Block wrapper\'s data-id attribute', () => {
-    cy.createEditor({})
-      .as('editorInstance');
-
-    const blocks = [
-      {
-        id: nanoid(),
-        type: 'paragraph',
-        data: {
-          text: 'First block',
-        },
-      },
-      {
-        id: nanoid(),
-        type: 'paragraph',
-        data: {
-          text: 'Second block',
-        },
-      },
-    ];
-
-    cy.get<EditorJS>('@editorInstance')
-      .render({
-        blocks,
-      });
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .each(($block, index) => {
-        expect($block.attr('data-id')).to.eq(blocks[index].id);
-      });
-  });
-});
diff --git a/test/cypress/tests/copy-paste.cy.ts b/test/cypress/tests/copy-paste.cy.ts
deleted file mode 100644
index 9a9b4a27c..000000000
--- a/test/cypress/tests/copy-paste.cy.ts
+++ /dev/null
@@ -1,407 +0,0 @@
-import Header from '@editorjs/header';
-import Image from '@editorjs/simple-image';
-import * as _ from '../../../src/components/utils';
-import type { BlockTool, BlockToolData, OutputData } from '../../../types';
-import $ from '../../../src/components/dom';
-import type EditorJS from '../../../types/index';
-
-
-describe('Copy pasting from Editor', function () {
-  context('pasting', function () {
-    it('should paste plain text', function () {
-      cy.createEditor({});
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .as('block')
-        .click()
-        .paste({
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          'text/plain': 'Some plain text',
-        });
-
-      cy.get('@block').should('contain', 'Some plain text');
-    });
-
-    it('should paste inline html data', function () {
-      cy.createEditor({});
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .as('block')
-        .click()
-        .paste({
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          'text/html': '<p><b>Some text</b></p>',
-        });
-
-      cy.get('@block').should('contain.html', '<b>Some text</b>');
-    });
-
-    it('should paste several blocks if plain text contains new lines', function () {
-      cy.createEditor({});
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click()
-        .paste({
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          'text/plain': 'First block\n\nSecond block',
-        });
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .then(blocks => {
-          expect(blocks[0].textContent).to.eq('First block');
-          expect(blocks[1].textContent).to.eq('Second block');
-        });
-    });
-
-    it('should paste several blocks if html contains several paragraphs', function () {
-      cy.createEditor({});
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click()
-        .paste({
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          'text/html': '<p>First block</p><p>Second block</p>',
-        });
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .then(blocks => {
-          expect(blocks[0].textContent).to.eq('First block');
-          expect(blocks[1].textContent).to.eq('Second block');
-        });
-    });
-
-    it('should paste using custom data type', function () {
-      cy.createEditor({});
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click()
-        .paste({
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          'application/x-editor-js': JSON.stringify([
-            {
-              tool: 'paragraph',
-              data: {
-                text: 'First block',
-              },
-            },
-            {
-              tool: 'paragraph',
-              data: {
-                text: 'Second block',
-              },
-            },
-          ]),
-        });
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .then(blocks => {
-          expect(blocks[0].textContent).to.eq('First block');
-          expect(blocks[1].textContent).to.eq('Second block');
-        });
-    });
-
-    it('should parse block tags', function () {
-      cy.createEditor({
-        tools: {
-          header: Header,
-        },
-      }).as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click()
-        .paste({
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          'text/html': '<h2>First block</h2><p>Second block</p>',
-        });
-
-      /**
-       * Check inserted blocks
-       */
-      cy.get('[data-cy=editorjs]')
-        .get('h2.ce-header')
-        .should('contain', 'First block');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-paragraph')
-        .should('contain', 'Second block');
-
-      /**
-       * Check saved data as well
-       */
-      cy.get<EditorJS>('@editorInstance')
-        .then(async (editor) => {
-          cy.wrap<OutputData>(await editor.save())
-            .then((data) => {
-              /**
-               * <h2> has been correctly saved
-               */
-              expect(data.blocks[0].type).to.eq('header');
-              expect(data.blocks[0].data.text).to.eq('First block');
-              expect(data.blocks[0].data.level).to.eq(2);
-
-              /**
-               * <p> has been correctly saved
-               */
-              expect(data.blocks[1].type).to.eq('paragraph');
-              expect(data.blocks[1].data.text).to.eq('Second block');
-            });
-        });
-    });
-
-    it('should parse pattern', function () {
-      cy.createEditor({
-        tools: {
-          image: Image,
-        },
-      });
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click()
-        .paste({
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          'text/plain': 'https://codex.so/public/app/img/external/codex2x.png',
-        });
-
-      cy.get('[data-cy=editorjs]')
-        // In Edge test are performed slower, so we need to increase timeout to wait until image is loaded on the page
-        .get('img', { timeout: 10000 })
-        .should('have.attr', 'src', 'https://codex.so/public/app/img/external/codex2x.png');
-    });
-
-    it('should not prevent default behaviour if block\'s paste config equals false', function () {
-      const onPasteStub = cy.stub().as('onPaste');
-
-      /**
-       * Tool with disabled preventing default behavior of onPaste event
-       */
-      class BlockToolWithPasteHandler implements BlockTool {
-        public static pasteConfig = false;
-
-        /**
-         * Render block
-         */
-        public render(): HTMLElement {
-          const block = $.make('div', 'ce-block-with-disabled-prevent-default', {
-            contentEditable: 'true',
-          });
-
-          block.addEventListener('paste', onPasteStub);
-
-          return block;
-        }
-
-        /**
-         * Save data method
-         */
-        public save(): BlockToolData {
-          return {};
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          blockToolWithPasteHandler: BlockToolWithPasteHandler,
-        },
-      })
-        .as('editorInstanceWithBlockToolWithPasteHandler');
-
-      cy.get('@editorInstanceWithBlockToolWithPasteHandler')
-        .render({
-          blocks: [
-            {
-              type: 'blockToolWithPasteHandler',
-              data: {},
-            },
-          ],
-        })
-        .wait(100);
-
-      cy.get('@editorInstanceWithBlockToolWithPasteHandler')
-        .get('div.ce-block-with-disabled-prevent-default')
-        .click()
-        .paste({
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          'text/plain': 'Hello',
-        });
-
-      cy.get('@onPaste')
-        .should('have.been.calledWithMatch', {
-          defaultPrevented: false,
-        });
-    });
-  });
-
-  context('copying', function () {
-    it('should copy inline fragment', function () {
-      cy.createEditor({});
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click()
-        .type('Some text{selectall}')
-        .copy()
-        .then(clipboardData => {
-          /**
-           * As no blocks selected, clipboard data will be empty as will be handled by browser
-           */
-          expect(clipboardData).to.be.empty;
-        });
-    });
-
-    it('should copy several blocks', function () {
-      cy.createEditor({});
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click()
-        .type('First block{enter}');
-
-      cy.get('[data-cy=editorjs')
-        .get('div.ce-block')
-        .next()
-        .type('Second block')
-        .type('{movetostart}')
-        .trigger('keydown', {
-          shiftKey: true,
-          keyCode: _.keyCodes.UP,
-        })
-        .copy()
-        .then(clipboardData => {
-          expect(clipboardData['text/html']).to.match(/<p>First block(<br>)?<\/p><p>Second block(<br>)?<\/p>/);
-          expect(clipboardData['text/plain']).to.eq(`First block\n\nSecond block`);
-
-          /**
-           * Need to wait for custom data as it is set asynchronously
-           */
-          cy.wait(0).then(function () {
-            expect(clipboardData['application/x-editor-js']).not.to.be.undefined;
-
-            const data = JSON.parse(clipboardData['application/x-editor-js']);
-
-            expect(data[0].tool).to.eq('paragraph');
-            expect(data[0].data.text).to.match(/First block(<br>)?/);
-            expect(data[1].tool).to.eq('paragraph');
-            expect(data[1].data.text).to.match(/Second block(<br>)?/);
-          });
-        });
-    });
-  });
-
-  context('cutting', function () {
-    it('should cut inline fragment', function () {
-      cy.createEditor({});
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click()
-        .type('Some text{selectall}')
-        .cut()
-        .then(clipboardData => {
-          /**
-           * As no blocks selected, clipboard data will be empty as will be handled by browser
-           */
-          expect(clipboardData).to.be.empty;
-        });
-    });
-
-    it('should cut several blocks', function () {
-      cy.createEditor({
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: { text: 'First block' },
-            },
-            {
-              type: 'paragraph',
-              data: { text: 'Second block' },
-            },
-          ],
-        },
-      });
-
-      cy.get('[data-cy=editorjs')
-        .get('div.ce-block')
-        .last()
-        .click()
-        .type('{movetostart}')
-        .trigger('keydown', {
-          shiftKey: true,
-          keyCode: _.keyCodes.UP,
-        })
-        .cut()
-        .then(clipboardData => {
-          expect(clipboardData['text/html']).to.match(/<p>First block(<br>)?<\/p><p>Second block(<br>)?<\/p>/);
-          expect(clipboardData['text/plain']).to.eq(`First block\n\nSecond block`);
-
-          /**
-           * Need to wait for custom data as it is set asynchronously
-           */
-          cy.wait(0).then(function () {
-            expect(clipboardData['application/x-editor-js']).not.to.be.undefined;
-
-            const data = JSON.parse(clipboardData['application/x-editor-js']);
-
-            expect(data[0].tool).to.eq('paragraph');
-            expect(data[0].data.text).to.match(/First block(<br>)?/);
-            expect(data[1].tool).to.eq('paragraph');
-            expect(data[1].data.text).to.match(/Second block(<br>)?/);
-          });
-        });
-
-      cy.get('[data-cy=editorjs]')
-        .should('not.contain', 'First block')
-        .should('not.contain', 'Second block');
-    });
-
-    it('should cut lots of blocks', function () {
-      const numberOfBlocks = 50;
-      const blocks = [];
-
-      for (let i = 0; i < numberOfBlocks; i++) {
-        blocks.push({
-          type: 'paragraph',
-          data: {
-            text: `Block ${i}`,
-          },
-        });
-      }
-
-      cy.createEditor({
-        data: {
-          blocks,
-        },
-      });
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .first()
-        .click()
-        .type('{ctrl+A}')
-        .type('{ctrl+A}')
-        .cut()
-        .then((clipboardData) => {
-          /**
-           * Need to wait for custom data as it is set asynchronously
-           */
-          cy.wait(0).then(function () {
-            expect(clipboardData['application/x-editor-js']).not.to.be.undefined;
-
-            const data = JSON.parse(clipboardData['application/x-editor-js']);
-
-            expect(data.length).to.eq(numberOfBlocks);
-          });
-        });
-    });
-  });
-});
diff --git a/test/cypress/tests/i18n.cy.ts b/test/cypress/tests/i18n.cy.ts
deleted file mode 100644
index 1bcb6b4c7..000000000
--- a/test/cypress/tests/i18n.cy.ts
+++ /dev/null
@@ -1,243 +0,0 @@
-import Header from '@editorjs/header';
-import type { ToolboxConfig } from '../../../types';
-
-describe('Editor i18n', () => {
-  context('Toolbox', () => {
-    it('should translate tool title in a toolbox', function () {
-      if (this && this.editorInstance) {
-        this.editorInstance.destroy();
-      }
-      const toolNamesDictionary = {
-        Heading: 'Заголовок',
-      };
-
-      cy.createEditor({
-        tools: {
-          header: Header,
-        },
-        i18n: {
-          messages: {
-            toolNames: toolNamesDictionary,
-          },
-        },
-      }).as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-toolbar__plus')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-popover-item[data-item-name=header]')
-        .should('contain.text', toolNamesDictionary.Heading);
-    });
-
-    it('should translate titles of toolbox entries', function () {
-      if (this && this.editorInstance) {
-        this.editorInstance.destroy();
-      }
-      const toolNamesDictionary = {
-        Title1: 'Название 1',
-        Title2: 'Название 2',
-      };
-
-      /**
-       * Tool with several toolbox entries configured
-       */
-      class TestTool {
-        /**
-         * Returns toolbox config as list of entries
-         */
-        public static get toolbox(): ToolboxConfig {
-          return [
-            {
-              title: 'Title1',
-              icon: 'Icon 1',
-            },
-            {
-              title: 'Title2',
-              icon: 'Icon 2',
-            },
-          ];
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          testTool: TestTool,
-        },
-        i18n: {
-          messages: {
-            toolNames: toolNamesDictionary,
-          },
-        },
-      }).as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-toolbar__plus')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-popover-item[data-item-name=testTool]')
-        .first()
-        .should('contain.text', toolNamesDictionary.Title1);
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-popover-item[data-item-name=testTool]')
-        .last()
-        .should('contain.text', toolNamesDictionary.Title2);
-    });
-
-    it('should use capitalized tool name as translation key if toolbox title is missing', function () {
-      if (this && this.editorInstance) {
-        this.editorInstance.destroy();
-      }
-
-      /**
-       * Tool class allowing to test case when capitalized tool name is used as translation key if toolbox title is missing
-       */
-      class TestTool {
-        /**
-         * Returns toolbox config without title
-         */
-        public static get toolbox(): ToolboxConfig {
-          return {
-            title: '',
-            icon: '<svg width="17" height="15" viewBox="0 0 336 276" xmlns="http://www.w3.org/2000/svg"><path d="M291 150V79c0-19-15-34-34-34H79c-19 0-34 15-34 34v42l67-44 81 72 56-29 42 30zm0 52l-43-30-56 30-81-67-66 39v23c0 19 15 34 34 34h178c17 0 31-13 34-29zM79 0h178c44 0 79 35 79 79v118c0 44-35 79-79 79H79c-44 0-79-35-79-79V79C0 35 35 0 79 0z"/></svg>',
-          };
-        }
-      }
-      const toolNamesDictionary = {
-        TestTool: 'ТестТул',
-      };
-
-      cy.createEditor({
-        tools: {
-          testTool: TestTool,
-        },
-        i18n: {
-          messages: {
-            toolNames: toolNamesDictionary,
-          },
-        },
-      });
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-toolbar__plus')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-popover-item[data-item-name=testTool]')
-        .should('contain.text', toolNamesDictionary.TestTool);
-    });
-  });
-
-  context('Block Tunes', () => {
-    it('should translate tool name in Convert To', () => {
-      const toolNamesDictionary = {
-        Heading: 'Заголовок',
-      };
-
-      cy.createEditor({
-        tools: {
-          header: Header,
-        },
-        i18n: {
-          messages: {
-            toolNames: toolNamesDictionary,
-          },
-        },
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'Some text',
-                level: 1,
-              },
-            },
-          ],
-        },
-      });
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click();
-
-      /** Open block tunes menu */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-toolbar__settings-btn')
-        .click();
-
-      /** Open "Convert to" menu  */
-      cy.get('[data-cy=editorjs]')
-        .get('[data-item-name=convert-to]')
-        .click();
-
-      /** Check item in convert to menu is internationalized */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover--nested .ce-popover-item[data-item-name=header]')
-        .should('contain.text', toolNamesDictionary.Heading);
-    });
-  });
-
-  context('Inline Toolbar', () => {
-    it('should translate tool name in Convert To', () => {
-      const toolNamesDictionary = {
-        Heading: 'Заголовок',
-      };
-
-      cy.createEditor({
-        tools: {
-          header: Header,
-        },
-        i18n: {
-          messages: {
-            toolNames: toolNamesDictionary,
-          },
-        },
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'Some text',
-                level: 1,
-              },
-            },
-          ],
-        },
-      });
-
-      /** Open Inline Toolbar */
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .selectText('Some text');
-
-      /** Open "Convert to" menu  */
-      cy.get('[data-cy=editorjs]')
-        .get('[data-item-name=convert-to]')
-        .click();
-
-      /** Check item in convert to menu is internationalized */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover--nested .ce-popover-item[data-item-name=header]')
-        .should('contain.text', toolNamesDictionary.Heading);
-    });
-  });
-});
diff --git a/test/cypress/tests/initialization.cy.ts b/test/cypress/tests/initialization.cy.ts
deleted file mode 100644
index 2336595f8..000000000
--- a/test/cypress/tests/initialization.cy.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-// eslint-disable-next-line spaced-comment, @typescript-eslint/triple-slash-reference
-/// <reference path="../support/index.d.ts" />
-
-describe('Editor basic initialization', () => {
-  describe('Zero-config initialization', () => {
-    /**
-     * In this test suite we use zero (omitted) configuration
-     */
-    const editorConfig = {};
-
-    beforeEach(function () {
-      cy.createEditor(editorConfig).as('editorInstance');
-    });
-
-    afterEach(function () {
-      if (this.editorInstance) {
-        this.editorInstance.destroy();
-      }
-    });
-
-    it('should create a visible UI', () => {
-      /**
-       * Assert if created instance is visible or not.
-       */
-      cy.get('[data-cy=editorjs]')
-        .get('div.codex-editor')
-        .should('be.visible');
-    });
-  });
-
-  describe('Configuration', () => {
-    describe('readOnly', () => {
-      beforeEach(() => {
-        if (this && this.editorInstance) {
-          this.editorInstance.destroy();
-        }
-      });
-
-      it('should create editor without editing ability when true passed', () => {
-        cy.createEditor({
-          readOnly: true,
-        }).as('editorInstance');
-
-        cy.get('[data-cy=editorjs]')
-          .get('div.codex-editor')
-          .get('div.ce-paragraph')
-          .invoke('attr', 'contenteditable')
-          .should('eq', 'false');
-      });
-    });
-
-    describe('style', () => {
-      describe('nonce', () => {
-        it('should add passed nonce as attribute to editor style tag', () => {
-          cy.createEditor({
-            style: {
-              nonce: 'test-nonce',
-            },
-          }).as('editorInstance');
-
-          cy.get('[data-cy=editorjs]')
-            .get('#editor-js-styles')
-            .should('have.attr', 'nonce', 'test-nonce');
-        });
-      });
-    });
-  });
-});
diff --git a/test/cypress/tests/inline-tools/link.cy.ts b/test/cypress/tests/inline-tools/link.cy.ts
deleted file mode 100644
index 3077e7d82..000000000
--- a/test/cypress/tests/inline-tools/link.cy.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-describe('Inline Tool Link', () => {
-  it('should create a link by Enter keydown in input', () => {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'First block text',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('div.ce-block')
-      .click()
-      .type('{selectall}')
-      .wait(200)
-      .type('{ctrl}K');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-inline-tool-input')
-      .click()
-      .type('https://codex.so')
-      .type('{enter}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('div.ce-block')
-      .find('a')
-      .should('have.attr', 'href', 'https://codex.so');
-  });
-
-  it('should remove fake background on selection change', () => {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'First block text',
-            },
-          },
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Second block text',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('div.ce-block')
-      .first()
-      .click()
-      .type('{selectall}')
-      .wait(200)
-      .type('{ctrl}K');
-
-    cy.get('[data-cy=editorjs]')
-      .find('div.ce-block')
-      .last()
-      .click()
-      .type('{selectall}')
-      .wait(200);
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph span[style]')
-      .should('not.exist');
-  });
-});
diff --git a/test/cypress/tests/modules/BlockEvents/ArrowLeft.cy.ts b/test/cypress/tests/modules/BlockEvents/ArrowLeft.cy.ts
deleted file mode 100644
index f9081a37a..000000000
--- a/test/cypress/tests/modules/BlockEvents/ArrowLeft.cy.ts
+++ /dev/null
@@ -1,280 +0,0 @@
-import { createEditorWithTextBlocks } from '../../../support/utils/createEditorWithTextBlocks';
-import ContentlessToolMock from '../../../fixtures/tools/ContentlessTool';
-
-describe('Arrow Left', function () {
-  describe('starting whitespaces handling', function () {
-    it('&nbsp;| — should natively move caret over the visible space. Then move to the prev block', function () {
-      createEditorWithTextBlocks([
-        '1',
-        '&nbsp;2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .last() // select second block
-        .click()
-        .type('{leftArrow}') // set caret before "2"
-        .type('{leftArrow}') // move caret over nbsp
-        .type('{leftArrow}'); // move to the prev block
-
-      /**
-       * Caret is set to the end of the previous block
-       */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-paragraph')
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-              expect(range.startOffset).to.eq(1);
-            });
-        });
-    });
-    it(' | — should ignore invisible space before caret and move caret to the prev block', function () {
-      createEditorWithTextBlocks([
-        '1',
-        ' 2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .last() // select second block
-        .click()
-        .type('{leftArrow}') // set caret before "2"
-        .type('{leftArrow}'); // move to the prev block
-
-      /**
-       * Caret is set to the end of the previous block
-       */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-paragraph')
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-              expect(range.startOffset).to.eq(1);
-            });
-        });
-    });
-
-    it('<b></b>| — should ignore empty tags before caret and move caret to the prev block', function () {
-      createEditorWithTextBlocks([
-        '1',
-        '<b></b>2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .last() // select second block
-        .click()
-        .type('{leftArrow}') // set caret before "2"
-        .type('{leftArrow}'); // move to the prev block
-
-      /**
-       * Caret is set to the end of the previous block
-       */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-paragraph')
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-              expect(range.startOffset).to.eq(1);
-            });
-        });
-    });
-    it('<b></b>&nbsp;| — should move caret over the visible space and then to the prev block', function () {
-      createEditorWithTextBlocks([
-        '1',
-        '<b></b>&nbsp;2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .last()
-        .click()
-        .type('{leftArrow}') // set caret before "2"
-        .type('{leftArrow}') // move caret over nbsp
-        .type('{leftArrow}'); // move to the prev block
-
-      /**
-       * Caret is set to the end of the previous block
-       */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-paragraph')
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-              expect(range.startOffset).to.eq(1);
-            });
-        });
-    });
-
-    it('&nbsp;<b></b>| — should ignore empty tag and move caret over the visible space. Then move to the prev block', function () {
-      createEditorWithTextBlocks([
-        '1',
-        '<b></b>&nbsp;2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .last()
-        .click()
-        .type('{leftArrow}') // set caret before "2"
-        .type('{leftArrow}') // ignore empty tag and move caret over nbsp
-        .type('{leftArrow}'); // move to the prev block
-
-      /**
-       * Caret is set to the end of the previous block
-       */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-paragraph')
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-              expect(range.startOffset).to.eq(1);
-            });
-        });
-    });
-
-    it(' &nbsp;| — should move caret over the visible space. Then move to the prev block', function () {
-      createEditorWithTextBlocks([
-        '1',
-        ' &nbsp;2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .last()
-        .click()
-        .type('{leftArrow}') // set caret before "2"
-        .type('{leftArrow}') // remove nbsp
-        .type('{leftArrow}'); // ignore regular space and move to the prev block
-
-      /**
-       * Caret is set to the end of the previous block
-       */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-paragraph')
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-              expect(range.startOffset).to.eq(1);
-            });
-        });
-    });
-  });
-
-  /**
-   * In this test we check case:
-   *
-   * Text Block №1
-   * Delimiter
-   * Text Block №2
-   *
-   * we set caret to the start of the Text Block №2 and press Left Arrow
-   *
-   * Expected: Delimiter is selected
-   *
-   * Then we press Left Arrow again
-   *
-   * Expected: Caret is set to the end of the Text Block №1
-   */
-  it('should move caret to the prev block if currently focused block is contentless (Delimiter)', function () {
-    cy.createEditor({
-      tools: {
-        delimiter: ContentlessToolMock,
-      },
-      data: {
-        blocks: [
-          {
-            id: 'block1',
-            type: 'paragraph',
-            data: {
-              text: '1',
-            },
-          },
-          {
-            id: 'block2',
-            type: 'delimiter',
-            data: {},
-          },
-          {
-            id: 'block3',
-            type: 'paragraph',
-            data: {
-              text: '2',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .as('thirdBlock')
-      .click()
-      .type('{moveToStart}') // set caret before "2"
-      .type('{leftArrow}'); // navigate to the Delimiter
-
-    /**
-     * We navigated to the Delimiter and it is highlighted
-     */
-    cy.get('[data-cy=editorjs]')
-      .find('div[data-cy-type=contentless-tool]')
-      .parents('.ce-block')
-      .as('delimiterBlock')
-      .should('have.class', 'ce-block--selected');
-
-    /**
-     * Now press Left again and we should be navigated to the end of the previous block
-     */
-    cy.get('@thirdBlock')
-      .type('{leftArrow}');
-
-    /**
-     * Delimiter is not selected anymore
-     */
-    cy.get('@delimiterBlock')
-      .should('not.have.class', 'ce-block--selected');
-
-    /**
-     * Caret is set to the end of the first block
-     */
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('[data-cy=editorjs]')
-          .find('.ce-paragraph')
-          .first()
-          .should(($block) => {
-            expect($block[0].contains(range.startContainer)).to.be.true;
-            expect(range.startOffset).to.eq(1);
-          });
-      });
-  });
-});
diff --git a/test/cypress/tests/modules/BlockEvents/ArrowRight.cy.ts b/test/cypress/tests/modules/BlockEvents/ArrowRight.cy.ts
deleted file mode 100644
index ee9f88472..000000000
--- a/test/cypress/tests/modules/BlockEvents/ArrowRight.cy.ts
+++ /dev/null
@@ -1,293 +0,0 @@
-import { createEditorWithTextBlocks } from '../../../support/utils/createEditorWithTextBlocks';
-import ContentlessToolMock from '../../../fixtures/tools/ContentlessTool';
-
-describe('Arrow Right', function () {
-  describe('starting whitespaces handling', function () {
-    it('|&nbsp; — should natively move caret over the visible space. Then move to the next block', function () {
-      createEditorWithTextBlocks([
-        '1&nbsp;',
-        '2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .first() // select first block
-        .as('firstBlock')
-        .click()
-        .type('{moveToStart}')
-        .type('{rightArrow}') // set caret after "1"
-        .type('{rightArrow}') // move caret over nbsp
-        .type('{rightArrow}'); // move to the next block
-
-      /**
-       * Caret is set to the start of the next block
-       */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-paragraph')
-            .last()
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-              expect(range.startOffset).to.eq(0);
-            });
-        });
-    });
-
-    it('"| " — should ignore invisible space after caret and move caret to the next block', function () {
-      createEditorWithTextBlocks([
-        '1 ',
-        '2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .first()
-        .click()
-        .type('{moveToStart}')
-        .type('{rightArrow}') // set caret after "1"
-        .type('{rightArrow}'); // ignore " " and move to the next block
-
-      /**
-       * Caret is set to the start of the next block
-       */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-paragraph')
-            .last()
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-              expect(range.startOffset).to.eq(0);
-            });
-        });
-    });
-
-    it('|<b></b> — should ignore empty tags after caret and move caret to the next block', function () {
-      createEditorWithTextBlocks([
-        '1<b></b>',
-        '2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .first()
-        .click()
-        .type('{moveToStart}')
-        .type('{rightArrow}') // set caret after "1"
-        .type('{rightArrow}'); // ignore empty tag and move to the next block
-
-      /**
-       * Caret is set to the start of the next block
-       */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-paragraph')
-            .last()
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-              expect(range.startOffset).to.eq(0);
-            });
-        });
-    });
-    it('|&nbsp;<b></b> — should move caret over the visible space and then to the next block', function () {
-      createEditorWithTextBlocks([
-        '1&nbsp;<b></b>',
-        '2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .first()
-        .click()
-        .type('{moveToStart}')
-        .type('{rightArrow}') // set caret after "1"
-        .type('{rightArrow}') // move caret over nbsp
-        .type('{rightArrow}'); // move to the next block
-
-      /**
-       * Caret is set to the start of the next block
-       */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-paragraph')
-            .last()
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-              expect(range.startOffset).to.eq(0);
-            });
-        });
-    });
-
-    it('|<b></b>&nbsp; — should ignore empty tag and move caret over the visible space. Then move to the next block', function () {
-      createEditorWithTextBlocks([
-        '1<b></b>&nbsp;',
-        '2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .first()
-        .click()
-        .type('{moveToStart}')
-        .type('{rightArrow}') // set caret after "1"
-        .type('{rightArrow}') // ignore empty tag and move caret over nbsp
-        .type('{rightArrow}'); // move to the next block
-
-      /**
-       * Caret is set to the start of the next block
-       */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-paragraph')
-            .last()
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-              expect(range.startOffset).to.eq(0);
-            });
-        });
-    });
-
-    it('"|&nbsp; " — should move caret over the visible space. Then ignore a trailing space and move to the next block', function () {
-      createEditorWithTextBlocks([
-        '1&nbsp; ',
-        '2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .first()
-        .click()
-        .type('{moveToStart}')
-        .type('{rightArrow}') // set caret after "1"
-        .type('{rightArrow}') // move caret over nbsp
-        .type('{rightArrow}'); // ignore " " and move to the next block
-
-      /**
-       * Caret is set to the start of the next block
-       */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-paragraph')
-            .last()
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-              expect(range.startOffset).to.eq(0);
-            });
-        });
-    });
-  });
-
-  /**
-   * In this test we check case:
-   *
-   * Text Block №1
-   * Delimiter
-   * Text Block №2
-   *
-   * we set caret to the end of the Text Block №1 and press Right Arrow
-   *
-   * Expected: Delimiter is selected
-   *
-   * Then we press Right Arrow again
-   *
-   * Expected: Caret is set to the start of the Text Block №2
-   */
-  it('should move caret to the next block if currently focused block is contentless (Delimiter)', function () {
-    cy.createEditor({
-      tools: {
-        delimiter: ContentlessToolMock,
-      },
-      data: {
-        blocks: [
-          {
-            id: 'block1',
-            type: 'paragraph',
-            data: {
-              text: '1',
-            },
-          },
-          {
-            id: 'block2',
-            type: 'delimiter',
-            data: {},
-          },
-          {
-            id: 'block3',
-            type: 'paragraph',
-            data: {
-              text: '2',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .first()
-      .as('firstBlock')
-      .click() // caret at the end
-      .type('{rightArrow}'); // navigate to the Delimiter
-
-    /**
-     * We navigated to the Delimiter and it is highlighted
-     */
-    cy.get('[data-cy=editorjs]')
-      .find('div[data-cy-type=contentless-tool]')
-      .parents('.ce-block')
-      .as('delimiterBlock')
-      .should('have.class', 'ce-block--selected');
-
-    /**
-     * Now press Right again and we should be navigated to the start of the next block
-     */
-    cy.get('@firstBlock')
-      .type('{rightArrow}');
-
-    /**
-     * Delimiter is not selected anymore
-     */
-    cy.get('@delimiterBlock')
-      .should('not.have.class', 'ce-block--selected');
-
-    /**
-     * Caret is set to the start of the next block
-     */
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('[data-cy=editorjs]')
-          .find('.ce-paragraph')
-          .last()
-          .should(($block) => {
-            expect($block[0].contains(range.startContainer)).to.be.true;
-            expect(range.startOffset).to.eq(0);
-          });
-      });
-  });
-});
diff --git a/test/cypress/tests/modules/BlockEvents/Backspace.cy.ts b/test/cypress/tests/modules/BlockEvents/Backspace.cy.ts
deleted file mode 100644
index bb36e6503..000000000
--- a/test/cypress/tests/modules/BlockEvents/Backspace.cy.ts
+++ /dev/null
@@ -1,717 +0,0 @@
-import type EditorJS from '../../../../../types/index';
-import { SimpleHeader } from '../../../fixtures/tools/SimpleHeader';
-import type { ConversionConfig } from '../../../../../types/index';
-import { createEditorWithTextBlocks } from '../../../support/utils/createEditorWithTextBlocks';
-
-describe('Backspace keydown', function () {
-  describe('starting whitespaces handling', function () {
-    it('&nbsp;| — should delete visible space', function () {
-      createEditorWithTextBlocks([
-        '1',
-        '&nbsp;2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .last()
-        .click()
-        .type('{leftArrow}') // set caret before "2"
-        .type('{backspace}');
-
-      cy.get('[data-cy=editorjs]')
-        .find('div.ce-block')
-        .last()
-        .should('have.text', '2');
-    });
-    it(' | — should ignore invisible space before caret and handle it like regular backspace case (merge with previous)', function () {
-      createEditorWithTextBlocks([
-        '1',
-        ' 2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .last()
-        .click()
-        .type('{leftArrow}') // set caret before "2"
-        .type('{backspace}');
-
-      cy.get('[data-cy=editorjs]')
-        .find('div.ce-block')
-        .last()
-        .should('have.text', '12');
-    });
-    it('<b></b>| — should ignore empty tags before caret and handle it like regular backspace case (merge with previous)', function () {
-      createEditorWithTextBlocks([
-        '1',
-        '<b></b>2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .last()
-        .click()
-        .type('{leftArrow}') // set caret before "2"
-        .type('{backspace}');
-
-      cy.get('[data-cy=editorjs]')
-        .find('div.ce-block')
-        .last()
-        .should('have.text', '12');
-    });
-    it('<b></b>&nbsp;| — should remove visible space and ignore empty tag', function () {
-      createEditorWithTextBlocks([
-        '1',
-        '<b></b>&nbsp;2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .last()
-        .click()
-        .type('{leftArrow}') // set caret before "2"
-        .type('{backspace}') // remove nbsp
-        .type('{backspace}'); // ignore empty tag and merge
-
-      cy.get('[data-cy=editorjs]')
-        .find('div.ce-block')
-        .last()
-        .should('have.text', '12');
-    });
-
-    it('&nbsp;<b></b>| — should remove visible space and ignore empty tag', function () {
-      createEditorWithTextBlocks([
-        '1',
-        '<b></b>&nbsp;2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .last()
-        .click()
-        .type('{leftArrow}') // set caret before "2"
-        .type('{backspace}') // remove nbsp
-        .type('{backspace}'); // ignore empty tag and merge
-
-      cy.get('[data-cy=editorjs]')
-        .find('div.ce-block')
-        .last()
-        .should('have.text', '12');
-    });
-
-    it(' &nbsp;| — should remove visible space and ignore space', function () {
-      createEditorWithTextBlocks([
-        '1',
-        ' &nbsp;2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .last()
-        .click()
-        .type('{leftArrow}') // set caret before "2"
-        .type('{backspace}') // remove nbsp
-        .type('{backspace}'); // ignore regular space and merge
-
-      cy.get('[data-cy=editorjs]')
-        .find('div.ce-block')
-        .last()
-        .should('have.text', '12');
-    });
-
-    it('&nbsp; &nbsp;| — should delete visible and invisble whitespaces in the abscence of any non whitespace characters', function () {
-      createEditorWithTextBlocks([
-        '1',
-        '&nbsp; &nbsp;',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .last()
-        .click()
-        .type('{downArrow}')
-        .type('{backspace}')
-        .type('{backspace}')
-        .type('{backspace}')
-        .type('{backspace}');
-
-      cy.get('[data-cy=editorjs]')
-        .find('div.ce-block')
-        .last()
-        .should('have.text', '1');
-    });
-  });
-
-  it('should just delete chars (native behaviour) when some fragment is selected', function () {
-    createEditorWithTextBlocks([
-      'The first block',
-      'The second block',
-    ]);
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .click()
-      .selectText('The ')
-      .type('{backspace}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('div.ce-block')
-      .last()
-      .should('have.text', 'second block');
-  });
-
-  it('should just delete chars (native behaviour) when Caret is not at the start of the Block', function () {
-    createEditorWithTextBlocks([
-      'The first block',
-      'The second block',
-    ]);
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .click() // caret will be at the end of the block
-      .type('{backspace}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('div.ce-block')
-      .last()
-      .should('have.text', 'The second bloc'); // last char is removed
-  });
-
-  it('should navigate previous input when Caret is not at the first input', function () {
-    /**
-     * Mock of tool with several inputs
-     */
-    class ExampleOfToolWithSeveralInputs {
-      /**
-       * Render method mock
-       */
-      public render(): HTMLElement {
-        const container = document.createElement('div');
-        const input = document.createElement('div');
-        const input2 = document.createElement('div');
-
-        container.setAttribute('data-cy', 'quote-tool');
-
-        input.setAttribute('contenteditable', 'true');
-        input2.setAttribute('contenteditable', 'true');
-
-        container.append(input, input2);
-
-        return container;
-      }
-
-      /**
-       * Saving logic is not necessary for this test
-       */
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      public save(): void { }
-    }
-
-    cy.createEditor({
-      tools: {
-        quote: ExampleOfToolWithSeveralInputs,
-      },
-      data: {
-        blocks: [
-          {
-            type: 'quote',
-            data: {},
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('[data-cy=quote-tool]')
-      .find('div[contenteditable]')
-      .last()
-      .click()
-      .type('{backspace}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('[data-cy=quote-tool]')
-      .find('div[contenteditable]')
-      .first()
-      .as('firstInput');
-
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('@firstInput').should(($div) => {
-          expect($div[0].contains(range.startContainer)).to.be.true;
-        });
-      });
-  });
-
-  it('should remove previous Block if Caret at the start of the Block and previous Block is empty. Also, should close the Toolbox', function () {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            id: 'block1',
-            type: 'paragraph',
-            data: {
-              text: '', // empty block
-            },
-          },
-          {
-            id: 'block2',
-            type: 'paragraph',
-            data: {
-              text: 'Not empty block',
-            },
-          },
-        ],
-      },
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .click()
-      .type('{home}') // move caret to the beginning
-      .type('{backspace}');
-
-    cy.get<EditorJS>('@editorInstance')
-      .then(async (editor) => {
-        const { blocks } = await editor.save();
-
-        expect(blocks.length).to.eq(1); // one block has been removed
-        expect(blocks[0].id).to.eq('block2'); // second block is still here
-      });
-  });
-
-  it('should remove current Block if it is empty, but previous is not. Also, should close the Toolbox and set Caret to the end of the prev Block', function () {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            id: 'block1',
-            type: 'paragraph',
-            data: {
-              text: 'Not empty block',
-            },
-          },
-          {
-            id: 'block2',
-            type: 'paragraph',
-            data: {
-              text: '',  // empty block
-            },
-          },
-        ],
-      },
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .click()
-      .type('{backspace}');
-
-    /**
-     * Current Block has been removed
-     */
-    cy.get<EditorJS>('@editorInstance')
-      .then(async (editor) => {
-        const { blocks } = await editor.save();
-
-        expect(blocks.length).to.eq(1); // one block has been removed
-        expect(blocks[0].id).to.eq('block1'); // second block is still here
-      });
-
-    /**
-     * Caret is set to the end of the previous Block
-     */
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('[data-cy=editorjs]')
-          .find('.ce-paragraph')
-          .should(($block) => {
-            expect($block[0].contains(range.startContainer)).to.be.true;
-            expect(range.startOffset).to.be.eq($block[0].textContent.length);
-          });
-      });
-
-    /**
-     * Toolbox has been closed
-     */
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-toolbar')
-      .should('not.have.class', 'ce-toolbar--opened');
-  });
-
-  it('should merge current Block with the previous one if Caret at the start of the Block and both Blocks are mergeable. Also, should close the Toolbox. Caret should be places in a place of glue', function () {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            id: 'block1',
-            type: 'paragraph',
-            data: {
-              text: 'First block',
-            },
-          },
-          {
-            id: 'block2',
-            type: 'paragraph',
-            data: {
-              text: 'Second block',
-            },
-          },
-        ],
-      },
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .click()
-      .type('{home}') // move caret to the beginning
-      .type('{backspace}');
-
-    /**
-     * Current Block has been removed
-     */
-    cy.get<EditorJS>('@editorInstance')
-      .then(async (editor) => {
-        const { blocks } = await editor.save();
-
-        expect(blocks.length).to.eq(1); // one block has been removed
-        expect(blocks[0].id).to.eq('block1'); // second block is still here
-        expect(blocks[0].data.text).to.eq('First blockSecond block'); // text has been merged
-      });
-
-    /**
-     * Caret is set to the place of merging
-     */
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('[data-cy=editorjs]')
-          .find('.ce-paragraph')
-          .should(($block) => {
-            expect($block[0].contains(range.startContainer)).to.be.true;
-            range.startContainer.normalize(); // glue merged text nodes
-            expect(range.startOffset).to.be.eq('First block'.length);
-          });
-      });
-
-    /**
-     * Toolbox has been closed
-     */
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-toolbar')
-      .should('not.have.class', 'ce-toolbar--opened');
-  });
-
-  it('should merge blocks of different types (Paragraph -> Header) if they have a valid conversion config. Also, should close the Toolbox. Caret should be places in a place of glue', function () {
-    cy.createEditor({
-      tools: {
-        header: SimpleHeader,
-      },
-      data: {
-        blocks: [
-          {
-            id: 'block1',
-            type: 'header',
-            data: {
-              text: 'First block heading',
-            },
-          },
-          {
-            id: 'block2',
-            type: 'paragraph',
-            data: {
-              text: 'Second block paragraph',
-            },
-          },
-        ],
-      },
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .click()
-      .type('{home}') // move caret to the beginning
-      .type('{backspace}');
-
-    cy.get<EditorJS>('@editorInstance')
-      .then(async (editor) => {
-        const { blocks } = await editor.save();
-
-        expect(blocks.length).to.eq(1); // one block has been removed
-        expect(blocks[0].id).to.eq('block1'); // second block is still here
-        expect(blocks[0].data.text).to.eq('First block headingSecond block paragraph'); // text has been merged
-      });
-
-    /**
-     * Caret is set to the place of merging
-     */
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('[data-cy=editorjs]')
-          .find('[data-cy=block-wrapper]')
-          .should(($block) => {
-            expect($block[0].contains(range.startContainer)).to.be.true;
-            range.startContainer.normalize(); // glue merged text nodes
-            expect(range.startOffset).to.be.eq('First block heading'.length);
-          });
-      });
-
-    /**
-     * Toolbox has been closed
-     */
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-toolbar')
-      .should('not.have.class', 'ce-toolbar--opened');
-  });
-
-  it('should merge blocks of different types (Header -> Paragraph) if they have a valid conversion config. Also, should close the Toolbox. Caret should be places in a place of glue', function () {
-    cy.createEditor({
-      tools: {
-        header: SimpleHeader,
-      },
-      data: {
-        blocks: [
-          {
-            id: 'block1',
-            type: 'paragraph',
-            data: {
-              text: 'First block paragraph',
-            },
-          },
-          {
-            id: 'block2',
-            type: 'header',
-            data: {
-              text: 'Second block heading',
-            },
-          },
-        ],
-      },
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .find('[data-cy="block-wrapper"][data-id="block2"]')
-      .click()
-      .type('{home}') // move caret to the beginning
-      .type('{backspace}');
-
-    cy.get<EditorJS>('@editorInstance')
-      .then(async (editor) => {
-        const { blocks } = await editor.save();
-
-        expect(blocks.length).to.eq(1); // one block has been removed
-        expect(blocks[0].id).to.eq('block1'); // second block is still here
-        expect(blocks[0].data.text).to.eq('First block paragraphSecond block heading'); // text has been merged
-      });
-
-    /**
-     * Caret is set to the place of merging
-     */
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('[data-cy=editorjs]')
-          .find('[data-cy=block-wrapper]')
-          .should(($block) => {
-            expect($block[0].contains(range.startContainer)).to.be.true;
-            range.startContainer.normalize(); // glue merged text nodes
-            expect(range.startOffset).to.be.eq('First block paragraph'.length);
-          });
-      });
-
-    /**
-     * Toolbox has been closed
-     */
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-toolbar')
-      .should('not.have.class', 'ce-toolbar--opened');
-  });
-
-  it('should simply set Caret to the end of the previous Block if Caret at the start of the Block but Blocks are not mergeable (target Bock is lack of merge() and conversionConfig). Also, should close the Toolbox.', function () {
-    /**
-     * Mock of tool without merge() method
-     */
-    class UnmergeableToolWithoutConversionConfig {
-      /**
-       * Render method mock
-       */
-      public render(): HTMLElement {
-        const container = document.createElement('div');
-
-        container.dataset.cy = 'unmergeable-tool';
-        container.contentEditable = 'true';
-        container.innerHTML = 'Unmergeable not empty tool';
-
-        return container;
-      }
-
-      /**
-       * Saving logic is not necessary for this test
-       */
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      public save(): void { }
-    }
-
-    cy.createEditor({
-      tools: {
-        code: UnmergeableToolWithoutConversionConfig,
-      },
-      data: {
-        blocks: [
-          {
-            type: 'code',
-            data: {},
-          },
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Second block',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .click()
-      .type('{home}')
-      .type('{backspace}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('[data-cy=unmergeable-tool]')
-      .as('firstBlock');
-
-    /**
-     * Caret is set to the previous Block
-     */
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('@firstBlock').should(($div) => {
-          expect($div[0].contains(range.startContainer)).to.be.true;
-        });
-      });
-  });
-
-  it('should simply set Caret to the end of the previous Block if Caret at the start of the Block but Blocks are not mergeable (target Bock is lack of merge() but has the conversionConfig). Also, should close the Toolbox.', function () {
-    /**
-     * Mock of tool without merge() method
-     */
-    class UnmergeableToolWithConversionConfig {
-      /**
-       * Render method mock
-       */
-      public render(): HTMLElement {
-        const container = document.createElement('div');
-
-        container.dataset.cy = 'unmergeable-tool';
-        container.contentEditable = 'true';
-        container.innerHTML = 'Unmergeable not empty tool';
-
-        return container;
-      }
-
-      /**
-       * Saving logic is not necessary for this test
-       */
-      public save(): { key: string } {
-        return {
-          key: 'value',
-        };
-      }
-
-      /**
-       * Mock of the conversionConfig
-       */
-      public static get conversionConfig(): ConversionConfig {
-        return {
-          export: 'key',
-          import: 'key',
-        };
-      }
-    }
-
-    cy.createEditor({
-      tools: {
-        code: UnmergeableToolWithConversionConfig,
-      },
-      data: {
-        blocks: [
-          {
-            type: 'code',
-            data: {},
-          },
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Second block',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .click()
-      .type('{home}')
-      .type('{backspace}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('[data-cy=unmergeable-tool]')
-      .as('firstBlock');
-
-    /**
-     * Caret is set to the previous Block
-     */
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('@firstBlock').should(($div) => {
-          expect($div[0].contains(range.startContainer)).to.be.true;
-        });
-      });
-  });
-
-  describe('at the start of the first Block', function () {
-    it('should do nothing if Block is not empty', function () {
-      createEditorWithTextBlocks(['The only block. Not empty']);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .click()
-        .type('{home}')
-        .type('{backspace}');
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .should('have.length', 1)
-        .should('have.text', 'The only block. Not empty');
-    });
-  });
-});
diff --git a/test/cypress/tests/modules/BlockEvents/Delete.cy.ts b/test/cypress/tests/modules/BlockEvents/Delete.cy.ts
deleted file mode 100644
index 816649c5d..000000000
--- a/test/cypress/tests/modules/BlockEvents/Delete.cy.ts
+++ /dev/null
@@ -1,492 +0,0 @@
-import type EditorJS from '../../../../../types/index';
-import { createEditorWithTextBlocks } from '../../../support/utils/createEditorWithTextBlocks';
-
-describe('Delete keydown', function () {
-  describe('ending whitespaces handling', function () {
-    it('|&nbsp; — should delete visible space', function () {
-      createEditorWithTextBlocks([
-        '1&nbsp;',
-        '2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .first()
-        .click()
-        .type('{moveToStart}')
-        .type('{rightArrow}') // set caret after "1";
-        .type('{del}') // delete visible space
-        .type('{del}') // merge with next block
-
-        .should('have.text', '12');
-    });
-    it('"| " — should ignore invisible space after caret and handle it like regular delete case (merge with next)', function () {
-      createEditorWithTextBlocks([
-        '1 ',
-        '2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .first()
-        .click()
-        .type('{moveToStart}')
-        .type('{rightArrow}') // set caret after "1";
-        .type('{del}');
-
-      cy.get('[data-cy=editorjs]')
-        .find('div.ce-block')
-        .last()
-        .should('have.text', '1 2');
-    });
-    it('|<b></b> — should ignore empty tags after caret and handle it like regular delete case (merge)', function () {
-      createEditorWithTextBlocks([
-        '1<b></b>',
-        '2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .first()
-        .click()
-        .type('{moveToStart}')
-        .type('{rightArrow}') // set caret after "1";
-        .type('{del}');
-
-      cy.get('[data-cy=editorjs]')
-        .find('div.ce-block')
-        .last()
-        .should('have.text', '12');
-    });
-    it('|&nbsp;<b></b> — should remove visible space and ignore empty tag', function () {
-      createEditorWithTextBlocks([
-        '1&nbsp;<b></b>',
-        '2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .first()
-        .click()
-        .type('{moveToStart}')
-        .type('{rightArrow}') // set caret after "1";
-        .type('{del}') // remove nbsp
-        .type('{del}'); // ignore empty tag and merge
-
-      cy.get('[data-cy=editorjs]')
-        .find('div.ce-block')
-        .last()
-        .should('have.text', '12');
-    });
-
-    it('|<b></b>&nbsp; — should remove visible space and ignore empty tag', function () {
-      createEditorWithTextBlocks([
-        '1<b></b>&nbsp;',
-        '2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .first()
-        .click()
-        .type('{moveToStart}')
-        .type('{rightArrow}') // set caret after "1";
-        .type('{del}') // remove nbsp
-        .type('{del}'); // ignore empty tag and merge
-
-      cy.get('[data-cy=editorjs]')
-        .find('div.ce-block')
-        .last()
-        .should('have.text', '12');
-    });
-
-    it('"|&nbsp; " — should remove visible space and ignore space', function () {
-      createEditorWithTextBlocks([
-        '1&nbsp; ',
-        '2',
-      ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .first()
-        .click()
-        .type('{moveToStart}')
-        .type('{rightArrow}') // set caret after "1";
-        .type('{del}') // remove nbsp
-        .type('{del}'); // ignore regular space and merge
-
-      cy.get('[data-cy=editorjs]')
-        .find('div.ce-block')
-        .last()
-        /**
-         * In current implementation, we have different behaviour in Firefox:
-         * - Safari, Chrome merge blocks and without whitespace - "12"
-         * - Firefox merge blocks and with whitespace - "1 2"
-         *
-         * So, we have to check both variants.
-         *
-         * @todo remove this check after fixing the Firefox merge behaviour
-         */
-        .should(($block) => {
-          const text = $block.text();
-
-          expect(text).to.match(/12|1 2/);
-        });
-    });
-  });
-  it('should just delete chars (native behaviour) when some fragment is selected', function () {
-    createEditorWithTextBlocks([
-      'The first block',
-      'The second block',
-    ]);
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .first()
-      .click()
-      .selectText('The ')
-      .type('{del}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('div.ce-block')
-      .first()
-      .should('have.text', 'first block');
-  });
-
-  it('should just delete chars (native behaviour) when Caret is not at the end of the Block', function () {
-    createEditorWithTextBlocks([
-      'The first block',
-      'The second block',
-    ]);
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .first()
-      .click() // caret will be at the end of the block
-      .type('{leftarrow}') // now caret is not at the end
-      .type('{del}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('div.ce-block')
-      .first()
-      .should('have.text', 'The first bloc'); // last char is removed
-  });
-
-  it('should navigate next input when Caret is not at the last input', function () {
-    /**
-     * Mock of tool with several inputs
-     */
-    class ExampleOfToolWithSeveralInputs {
-      /**
-       * Render method mock
-       */
-      public render(): HTMLElement {
-        const container = document.createElement('div');
-        const input = document.createElement('div');
-        const input2 = document.createElement('div');
-
-        container.setAttribute('data-cy', 'quote-tool');
-
-        input.setAttribute('contenteditable', 'true');
-        input2.setAttribute('contenteditable', 'true');
-
-        container.append(input, input2);
-
-        return container;
-      }
-
-      /**
-       * Saving logic is not necessary for this test
-       */
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      public save(): void {}
-    }
-
-    cy.createEditor({
-      tools: {
-        quote: ExampleOfToolWithSeveralInputs,
-      },
-      data: {
-        blocks: [
-          {
-            type: 'quote',
-            data: {},
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('[data-cy=quote-tool]')
-      .find('div[contenteditable]')
-      .first()
-      .click()
-      .type('{del}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('[data-cy=quote-tool]')
-      .find('div[contenteditable]')
-      .last()
-      .as('secondInput');
-
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('@secondInput').should(($div) => {
-          expect($div[0].contains(range.startContainer)).to.be.true;
-        });
-      });
-  });
-
-  it('should remove next Block if Caret at the end of the Block and next Block is empty. Also, should close the Toolbox', function () {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            id: 'block1',
-            type: 'paragraph',
-            data: {
-              text: 'Not empty block',
-            },
-          },
-          {
-            id: 'block2',
-            type: 'paragraph',
-            data: {
-              text: '', // empty block
-            },
-          },
-        ],
-      },
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .first()
-      .click()
-      .type('{del}');
-
-    cy.get<EditorJS>('@editorInstance')
-      .then(async (editor) => {
-        const { blocks } = await editor.save();
-
-        expect(blocks.length).to.eq(1); // one block has been removed
-        expect(blocks[0].id).to.eq('block1'); // first block is still here
-      });
-  });
-
-  it('should remove current Block if it is empty, but next is not. Also, should close the Toolbox and set Caret to the start of the next Block', function () {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            id: 'block1',
-            type: 'paragraph',
-            data: {
-              text: '1',
-            },
-          },
-          {
-            id: 'block2',
-            type: 'paragraph',
-            data: {
-              text: 'Not empty block',
-            },
-          },
-        ],
-      },
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .first()
-      .click()
-      .type('{backspace}') // remove '1' to make block empty
-      .type('{del}');
-
-    /**
-     * Current Block has been removed
-     */
-    cy.get<EditorJS>('@editorInstance')
-      .then(async (editor) => {
-        const { blocks } = await editor.save();
-
-        expect(blocks.length).to.eq(1); // one block has been removed
-        expect(blocks[0].id).to.eq('block2'); // second block is still here
-      });
-
-    /**
-     * Caret is set to the start of the next Block
-     */
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('[data-cy=editorjs]')
-          .find('.ce-paragraph')
-          .should(($block) => {
-            expect($block[0].contains(range.startContainer)).to.be.true;
-            expect(range.startOffset).to.be.eq(0);
-          });
-      });
-
-    /**
-     * Toolbox has been closed
-     */
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-toolbar')
-      .should('not.have.class', 'ce-toolbar--opened');
-  });
-
-  it('should merge current Block with the next one if Caret at the end of the Block and both Blocks are mergeable. Also, should close the Toolbox.', function () {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            id: 'block1',
-            type: 'paragraph',
-            data: {
-              text: 'First block',
-            },
-          },
-          {
-            id: 'block2',
-            type: 'paragraph',
-            data: {
-              text: 'Second block',
-            },
-          },
-        ],
-      },
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .first()
-      .click()
-      .type('{del}');
-
-    /**
-     * Current Block has been removed
-     */
-    cy.get<EditorJS>('@editorInstance')
-      .then(async (editor) => {
-        const { blocks } = await editor.save();
-
-        expect(blocks.length).to.eq(1); // one block has been removed
-        expect(blocks[0].id).to.eq('block1'); // second block is still here
-        expect(blocks[0].data.text).to.eq('First blockSecond block'); // text has been merged
-      });
-
-    /**
-     * Caret is set to the place of merging
-     */
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('[data-cy=editorjs]')
-          .find('.ce-paragraph')
-          .should(($block) => {
-            expect($block[0].contains(range.startContainer)).to.be.true;
-            range.startContainer.normalize(); // glue merged text nodes
-            expect(range.startOffset).to.be.eq('First block'.length);
-          });
-      });
-
-    /**
-     * Toolbox has been closed
-     */
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-toolbar')
-      .should('not.have.class', 'ce-toolbar--opened');
-  });
-
-  it('should simply set Caret to the start of the next Block if Caret at the end of the Block but Blocks are not mergeable. Also, should close the Toolbox.', function () {
-    /**
-     * Mock of tool without merge method
-     */
-    class ExampleOfUnmergeableTool {
-      /**
-       * Render method mock
-       */
-      public render(): HTMLElement {
-        const container = document.createElement('div');
-
-        container.dataset.cy = 'unmergeable-tool';
-        container.contentEditable = 'true';
-        container.innerHTML = 'Unmergeable not empty tool';
-
-        return container;
-      }
-
-      /**
-       * Saving logic is not necessary for this test
-       */
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      public save(): void {}
-    }
-
-    cy.createEditor({
-      tools: {
-        code: ExampleOfUnmergeableTool,
-      },
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Second block',
-            },
-          },
-          {
-            type: 'code',
-            data: {},
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .click()
-      .type('{del}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('[data-cy=unmergeable-tool]')
-      .as('secondBlock');
-
-    /**
-     * Caret is set to the previous Block
-     */
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('@secondBlock').should(($div) => {
-          expect($div[0].contains(range.startContainer)).to.be.true;
-        });
-      });
-  });
-
-  describe('at the end of the last Block', function () {
-    it('should do nothing', function () {
-      createEditorWithTextBlocks([ 'The only block. Not empty' ]);
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .click()
-        .type('{del}');
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .should('have.length', 1)
-        .should('have.text', 'The only block. Not empty');
-    });
-  });
-});
diff --git a/test/cypress/tests/modules/BlockEvents/Enter.cy.ts b/test/cypress/tests/modules/BlockEvents/Enter.cy.ts
deleted file mode 100644
index 3dde743e3..000000000
--- a/test/cypress/tests/modules/BlockEvents/Enter.cy.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-describe('Enter keydown', function () {
-  it('should split block and remove selected fragment if some text fragment selected', function () {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'The block with some text',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .click()
-      .selectText('with so')
-      .wait(0)
-      .type('{enter}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('div.ce-block')
-      .then((blocks) => {
-        /**
-         * Check that there is two blocks after split
-         */
-        expect(blocks.length).to.equal(2);
-
-        /**
-         * Check that selected text fragment has been removed
-         */
-        expect(blocks[0].textContent).to.equal('The block ');
-        expect(blocks[1].textContent).to.equal('me text');
-      });
-  });
-
-  it('should set caret to the new block if it was created after Enter key press at very end of the block', function () {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'The block with some text',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .click()
-      .type('{enter}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('div.ce-block')
-      .last()
-      .as('lastBlock');
-
-    cy.window()
-      .then((window) => {
-        const selection = window.getSelection();
-        const range = selection.getRangeAt(0);
-
-        cy.get('@lastBlock').should(($block) => {
-          expect($block[0].contains(range.startContainer)).to.be.true;
-        });
-      });
-  });
-});
diff --git a/test/cypress/tests/modules/BlockEvents/Slash.cy.ts b/test/cypress/tests/modules/BlockEvents/Slash.cy.ts
deleted file mode 100644
index 49fe1fddb..000000000
--- a/test/cypress/tests/modules/BlockEvents/Slash.cy.ts
+++ /dev/null
@@ -1,174 +0,0 @@
-describe('Slash keydown', function () {
-  describe('pressed in empty block', function () {
-    it('should add "/" in a block and open Toolbox', () => {
-      cy.createEditor({
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: '',
-              },
-            },
-          ],
-        },
-      });
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .click()
-        .type('/');
-
-      /**
-       * Block content should contain slash
-       */
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .invoke('text')
-        .should('eq', '/');
-
-      cy.get('[data-cy="toolbox"] .ce-popover__container')
-        .should('be.visible');
-    });
-
-    [
-      'ctrl',
-      'cmd',
-    ].forEach((key) => {
-      it(`should not open Toolbox if Slash pressed with ${key}`, () => {
-        cy.createEditor({
-          data: {
-            blocks: [
-              {
-                type: 'paragraph',
-                data: {
-                  text: '',
-                },
-              },
-            ],
-          },
-        });
-
-        cy.get('[data-cy=editorjs]')
-          .find('.ce-paragraph')
-          .click()
-          .type(`{${key}}/`);
-
-        cy.get('[data-cy="toolbox"] .ce-popover__container')
-          .should('not.be.visible');
-      });
-    });
-  });
-
-  describe('pressed in non-empty block', function () {
-    it('should not open Toolbox and just add the / char', () => {
-      cy.createEditor({
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'Hello',
-              },
-            },
-          ],
-        },
-      });
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .click()
-        .type('/');
-
-      cy.get('[data-cy="toolbox"] .ce-popover__container')
-        .should('not.be.visible');
-
-      /**
-       * Block content should contain slash
-       */
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .invoke('text')
-        .should('eq', 'Hello/');
-    });
-  });
-
-  describe('pressed outside editor', function () {
-    it('should not modify any text outside editor when text block is selected', () => {
-      cy.createEditor({
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: '',
-              },
-            },
-          ],
-        },
-      });
-
-      cy.document().then((doc) => {
-        const title = doc.querySelector('h1');
-
-        if (title) {
-          title.setAttribute('data-cy', 'page-title');
-        }
-      });
-
-      // Step 1
-      // Click on the plus button and select the text option
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .click();
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-toolbar__plus')
-        .click({ force: true });
-      cy.get('[data-cy="toolbox"] .ce-popover__container')
-        .contains('Text')
-        .click();
-
-      // Step 2
-      // Select the 'Editor.js test page' text
-      cy.get('[data-cy=page-title]')
-        .invoke('attr', 'contenteditable', 'true')
-        .click()
-        .type('{selectall}')
-        .invoke('removeAttr', 'contenteditable');
-
-      // Step 3
-      // Press the Slash key
-      cy.get('[data-cy=page-title]')
-        .trigger('keydown', { key: '/',
-          code: 'Slash',
-          which: 191 });
-
-      cy.get('[data-cy=page-title]').should('have.text', 'Editor.js test page');
-    });
-  });
-});
-
-describe('CMD+Slash keydown', function () {
-  it('should open Block Tunes', () => {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: '',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .click()
-      .type('{cmd}/');
-
-    cy.get('[data-cy="block-tunes"] .ce-popover__container')
-      .should('be.visible');
-  });
-});
diff --git a/test/cypress/tests/modules/BlockEvents/Tab.cy.ts b/test/cypress/tests/modules/BlockEvents/Tab.cy.ts
deleted file mode 100644
index bb2051cf6..000000000
--- a/test/cypress/tests/modules/BlockEvents/Tab.cy.ts
+++ /dev/null
@@ -1,370 +0,0 @@
-import ToolMock from '../../../fixtures/tools/ToolMock';
-
-/**
- * Mock of tool that contains two inputs
- */
-class ToolWithTwoInputs extends ToolMock {
-  /**
-   * Create element with two inputs
-   */
-  public render(): HTMLElement {
-    const wrapper = document.createElement('div');
-    const input1 = document.createElement('div');
-    const input2 = document.createElement('div');
-
-    input1.contentEditable = 'true';
-    input2.contentEditable = 'true';
-
-    wrapper.setAttribute('data-cy', 'tool-with-two-inputs');
-
-    wrapper.appendChild(input1);
-    wrapper.appendChild(input2);
-
-    return wrapper;
-  }
-}
-
-/**
- * Mock of tool without inputs
- */
-class ContentlessTool extends ToolMock {
-  public static contentless = true;
-  /**
-   * Create element without inputs
-   */
-  public render(): HTMLElement {
-    const wrapper = document.createElement('div');
-
-    wrapper.setAttribute('data-cy', 'contentless-tool');
-
-    wrapper.textContent = '***';
-
-    return wrapper;
-  }
-}
-
-/**
- * Time to wait for caret to finish moving
- */
-const CARET_MOVE_TIME = 100;
-
-describe('Tab keydown', function () {
-  it('should focus next Block if Block contains only one input', () => {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'first paragraph',
-            },
-          },
-          {
-            type: 'paragraph',
-            data: {
-              text: 'second paragraph',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .first()
-      .click()
-      .trigger('keydown', { keyCode: 9 })
-      .wait(CARET_MOVE_TIME);
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .then(($secondBlock) => {
-        const editorWindow = $secondBlock.get(0).ownerDocument.defaultView;
-        const selection = editorWindow.getSelection();
-
-        const range = selection.getRangeAt(0);
-
-        /**
-         * Check that second block contains range
-         */
-        expect(range.startContainer.parentElement).to.equal($secondBlock.get(0));
-      });
-  });
-
-  it('should focus next input if Block contains several inputs', () => {
-    cy.createEditor({
-      tools: {
-        toolWithTwoInputs: {
-          class: ToolWithTwoInputs,
-        },
-      },
-      data: {
-        blocks: [
-          {
-            type: 'toolWithTwoInputs',
-            data: {},
-          },
-          {
-            type: 'paragraph',
-            data: {
-              text: 'second paragraph',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=tool-with-two-inputs]')
-      .find('[contenteditable=true]')
-      .first()
-      .click()
-      .trigger('keydown', { keyCode: 9 })
-      .wait(CARET_MOVE_TIME);
-
-    cy.get('[data-cy=tool-with-two-inputs]')
-      .find('[contenteditable=true]')
-      .last()
-      .then(($secondInput) => {
-        const editorWindow = $secondInput.get(0).ownerDocument.defaultView;
-        const selection = editorWindow.getSelection();
-
-        const range = selection.getRangeAt(0);
-
-        /**
-         * Check that second block contains range
-         */
-        expect(range.startContainer).to.equal($secondInput.get(0));
-      });
-  });
-
-  it('should highlight next Block if it does not contain any inputs (contentless Block)', () => {
-    cy.createEditor({
-      tools: {
-        contentlessTool: {
-          class: ContentlessTool,
-        },
-      },
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'second paragraph',
-            },
-          },
-          {
-            type: 'contentlessTool',
-            data: {},
-          },
-          {
-            type: 'paragraph',
-            data: {
-              text: 'third paragraph',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .first()
-      .click()
-      .trigger('keydown', { keyCode: 9 })
-      .wait(CARET_MOVE_TIME);
-
-    cy.get('[data-cy=contentless-tool]')
-      .parents('.ce-block')
-      .should('have.class', 'ce-block--selected');
-  });
-
-  it('should focus next input after Editor when pressed in last Block', () => {
-    cy.createEditor({});
-
-    /**
-     * Add regular input after Editor
-     */
-    cy.window()
-      .then((window) => {
-        const input = window.document.createElement('input');
-
-        input.setAttribute('data-cy', 'regular-input');
-
-        window.document.body.appendChild(input);
-      });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .click()
-      .tab();
-
-    cy.get('[data-cy=regular-input]')
-      .should('have.focus');
-  });
-});
-
-describe('Shift+Tab keydown', function () {
-  it('should focus previous Block if Block contains only one input', () => {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'first paragraph',
-            },
-          },
-          {
-            type: 'paragraph',
-            data: {
-              text: 'second paragraph',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .click()
-      .trigger('keydown', {
-        keyCode: 9,
-        shiftKey: true,
-      })
-      .wait(CARET_MOVE_TIME);
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .first()
-      .then(($firstBlock) => {
-        const editorWindow = $firstBlock.get(0).ownerDocument.defaultView;
-        const selection = editorWindow.getSelection();
-
-        const range = selection.getRangeAt(0);
-
-        /**
-         * Check that second block contains range
-         */
-        expect(range.startContainer.parentElement).to.equal($firstBlock.get(0));
-      });
-  });
-
-  it('should focus previous input if Block contains several inputs', () => {
-    cy.createEditor({
-      tools: {
-        toolWithTwoInputs: {
-          class: ToolWithTwoInputs,
-        },
-      },
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'second paragraph',
-            },
-          },
-          {
-            type: 'toolWithTwoInputs',
-            data: {},
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=tool-with-two-inputs]')
-      .find('[contenteditable=true]')
-      .last()
-      .click()
-      .trigger('keydown', {
-        keyCode: 9,
-        shiftKey: true,
-      })
-      .wait(CARET_MOVE_TIME);
-
-    cy.get('[data-cy=tool-with-two-inputs]')
-      .find('[contenteditable=true]')
-      .first()
-      .then(($firstInput) => {
-        const editorWindow = $firstInput.get(0).ownerDocument.defaultView;
-        const selection = editorWindow.getSelection();
-
-        const range = selection.getRangeAt(0);
-
-        /**
-         * Check that second block contains range
-         */
-        expect(range.startContainer).to.equal($firstInput.get(0));
-      });
-  });
-
-  it('should highlight previous Block if it does not contain any inputs (contentless Block)', () => {
-    cy.createEditor({
-      tools: {
-        contentlessTool: {
-          class: ContentlessTool,
-        },
-      },
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'second paragraph',
-            },
-          },
-          {
-            type: 'contentlessTool',
-            data: {},
-          },
-          {
-            type: 'paragraph',
-            data: {
-              text: 'third paragraph',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .click()
-      .trigger('keydown', {
-        keyCode: 9,
-        shiftKey: true,
-      })
-      .wait(CARET_MOVE_TIME);
-
-    cy.get('[data-cy=contentless-tool]')
-      .parents('.ce-block')
-      .should('have.class', 'ce-block--selected');
-  });
-
-  it('should focus previous input before Editor when pressed in first Block', () => {
-    cy.createEditor({});
-
-    /**
-     * Add regular input before Editor
-     */
-    cy.window()
-      .then((window) => {
-        const input = window.document.createElement('input');
-
-        input.setAttribute('data-cy', 'regular-input');
-
-        window.document.body.insertBefore(input, window.document.body.firstChild);
-      });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .click()
-      .tab({ shift: true });
-
-    cy.get('[data-cy=regular-input]')
-      .should('have.focus');
-  });
-});
diff --git a/test/cypress/tests/modules/InlineToolbar.cy.ts b/test/cypress/tests/modules/InlineToolbar.cy.ts
deleted file mode 100644
index c68cd0399..000000000
--- a/test/cypress/tests/modules/InlineToolbar.cy.ts
+++ /dev/null
@@ -1,274 +0,0 @@
-import Header from '@editorjs/header';
-import NestedEditor, { NESTED_EDITOR_ID } from '../../support/utils/nestedEditorInstance';
-import type { MenuConfig } from '@/types/tools';
-
-describe('Inline Toolbar', () => {
-  it('should appear aligned with left coord of selection rect', () => {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'First block text',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .selectText('block');
-
-    cy.get('[data-cy="inline-toolbar"] .ce-popover__container')
-      .should('be.visible')
-      .then(($toolbar) => {
-        const editorWindow = $toolbar.get(0).ownerDocument.defaultView;
-        const selection = editorWindow.getSelection();
-
-        const range = selection.getRangeAt(0);
-        const rect = range.getBoundingClientRect();
-
-        expect($toolbar.offset().left).to.be.closeTo(rect.left, 1);
-      });
-  });
-
-  it('should appear aligned with right side of text column when toolbar\'s width is not fit at right', () => {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris. Maecenas congue ligula ac quam viverra nec consectetur ante hendrerit. Donec et mollis dolor.',
-            },
-          },
-        ],
-      },
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .as('blockWrapper')
-      .getLineWrapPositions()
-      .then((lineWrapIndexes) => {
-        const firstLineWrapIndex = lineWrapIndexes[0];
-
-        /**
-         * Select last 5 chars of the first line
-         */
-        cy.get('[data-cy=editorjs]')
-          .find('.ce-paragraph')
-          .selectTextByOffset([firstLineWrapIndex - 5, firstLineWrapIndex - 1]);
-      });
-
-    cy.get('[data-cy="inline-toolbar"] .ce-popover__container')
-      .should('be.visible')
-      .then(($toolbar) => {
-        cy.get('@blockWrapper')
-          .then(($blockWrapper) => {
-            const blockWrapperRect = $blockWrapper.get(0).getBoundingClientRect();
-
-            /**
-             * Toolbar should be aligned with right side of text column
-             */
-            expect($toolbar.offset().left + $toolbar.width()).to.closeTo(blockWrapperRect.right, 10);
-          });
-      });
-  });
-
-  it('should be displayed in read-only mode if at least one inline tool of block supports it', () => {
-    cy.createEditor({
-      tools: {
-        header: {
-          class: Header,
-          inlineToolbar: ['bold', 'testTool'],
-        },
-        testTool: {
-          class: class {
-            public static isInline = true;
-            public static isReadOnlySupported = true;
-            // eslint-disable-next-line jsdoc/require-jsdoc
-            public render(): MenuConfig {
-              return {
-                title: 'Test Tool',
-                name: 'test-tool',
-                // eslint-disable-next-line @typescript-eslint/no-empty-function
-                onActivate: () => {},
-              };
-            }
-          },
-        },
-      },
-      readOnly: true,
-      data: {
-        blocks: [
-          {
-            type: 'header',
-            data: {
-              text: 'First block text',
-            },
-          },
-        ],
-      },
-    });
-
-    /** Open Inline Toolbar */
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-header')
-      .selectText('block');
-
-    cy.get('[data-cy=editorjs]')
-      .get('[data-cy=inline-toolbar]')
-      .get('.ce-popover--opened')
-      .as('toolbar')
-      .should('exist');
-
-    cy.get('@toolbar')
-      .get('.ce-popover-item')
-      .should('have.length', 1)
-      .should('have.attr', 'data-item-name', 'test-tool');
-  });
-
-  it('should not submit form nesting editor when inline tool clicked', () => {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Some text',
-            },
-          },
-        ],
-      },
-    });
-
-    const onSubmit = cy.stub();
-
-    cy.document().then(doc => {
-      const form = doc.createElement('form');
-
-      form.onsubmit = onSubmit;
-      doc.body.appendChild(form);
-
-      /* Move editor to form */
-      form.appendChild(doc.getElementById('editorjs'));
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .selectText('Some text');
-
-      cy.get('[data-item-name=bold]')
-        .click();
-
-      expect(onSubmit).to.be.not.called;
-    });
-  });
-
-  describe('Conversion toolbar', () => {
-    it('should restore caret after converting of a block', () => {
-      cy.createEditor({
-        tools: {
-          header: {
-            class: Header,
-          },
-        },
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'Some text',
-              },
-            },
-          ],
-        },
-      });
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .selectText('Some text');
-
-      cy.get('[data-item-name=convert-to]')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-inline-toolbar')
-        .find('.ce-popover-item[data-item-name=header]')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-header')
-        .should('have.text', 'Some text');
-
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-
-          expect(selection.rangeCount).to.be.equal(1);
-
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-header')
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-            });
-        });
-    });
-  });
-
-  describe('Nested Editor instance inline toolbar', () => {
-    it('should not close inline toolbar of the nested Editor instance when clicking within that toolbar', () => {
-      cy.createEditor({
-        tools: {
-          nestedEditor: {
-            class: NestedEditor,
-          },
-        },
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
-              },
-            },
-            {
-              type: 'nestedEditor',
-              data: {
-                text: 'Nunc pellentesque, tortor nec luctus venenatis',
-              },
-            },
-          ],
-        },
-      });
-
-      cy.get(`[data-cy=${NESTED_EDITOR_ID}]`)
-        .find('.ce-paragraph')
-        .selectText('tortor nec luctus');
-
-      cy.get(`[data-cy=${NESTED_EDITOR_ID}]`)
-        .find('[data-item-name=link]')
-        .click();
-
-      // `wait()` function below is required. without it the test will always pass
-      // because cypress types the text in the field without delay, while we need some delay (just like user)
-      // to test the actual case that nested editor inline toolbar is still visible and not closed
-
-      cy.get(`[data-cy=${NESTED_EDITOR_ID}]`)
-        .find('.ce-inline-tool-input')
-        .click()
-        .wait(100)
-        .type('https://editorjs.io');
-
-      cy.get(`[data-cy=${NESTED_EDITOR_ID}]`)
-        .find('.ce-popover__container')
-        .then(($toolbar) => {
-          expect($toolbar).to.be.visible;
-        });
-    });
-  });
-});
diff --git a/test/cypress/tests/modules/Renderer.cy.ts b/test/cypress/tests/modules/Renderer.cy.ts
deleted file mode 100644
index e81271e6d..000000000
--- a/test/cypress/tests/modules/Renderer.cy.ts
+++ /dev/null
@@ -1,179 +0,0 @@
-import ToolMock from '../../fixtures/tools/ToolMock';
-import type EditorJS from '../../../../types/index';
-
-describe('Renderer module', function () {
-  it('should not cause onChange firing during initial rendering', function () {
-    const config = {
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'some text',
-            },
-          },
-          {
-            type: 'paragraph',
-            data: {
-              text: 'some other text',
-            },
-          },
-        ],
-      },
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      onChange: () => {},
-    };
-
-    cy.createEditor(config)
-      .as('editorInstance');
-
-    cy.spy(config, 'onChange').as('onChange');
-
-    cy.get('@onChange').should('not.be.called');
-  });
-
-  it('should show Stub block if block tool is not registered', function () {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'some text',
-            },
-          },
-          {
-            type: 'non-existing tool',
-            data: {},
-          },
-          {
-            type: 'paragraph',
-            data: {
-              text: 'some other text',
-            },
-          },
-        ],
-      },
-    })
-      .as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-block')
-      .should('have.length', 3);
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-block')
-      .each(($el, index) => {
-        /**
-         * Check that the second block is stub
-         */
-        if (index === 1) {
-          cy.wrap($el)
-            .find('.ce-stub')
-            .should('have.length', 1);
-
-          /**
-           * Tool title displayed
-           */
-          cy.wrap($el)
-            .find('.ce-stub__title')
-            .should('have.text', 'non-existing tool');
-        }
-      });
-  });
-
-  it('should show Stub block if block tool throws error during construction', function () {
-    /**
-     * Mock of tool that triggers error during construction
-     */
-    class ToolWithError extends ToolMock {
-      /**
-       * @param options - tool options
-       */
-      constructor(options) {
-        super(options);
-        throw new Error('Tool error');
-      }
-    }
-
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'some text',
-            },
-          },
-          {
-            type: 'failedTool',
-            data: {},
-          },
-          {
-            type: 'paragraph',
-            data: {
-              text: 'some other text',
-            },
-          },
-        ],
-      },
-      tools: {
-        failedTool: ToolWithError,
-      },
-    })
-      .as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-block')
-      .should('have.length', 3);
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-block')
-      .each(($el, index) => {
-        /**
-         * Check that the second block is stub
-         */
-        if (index === 1) {
-          cy.wrap($el)
-            .find('.ce-stub')
-            .should('have.length', 1);
-
-          /**
-           * Tool title displayed
-           */
-          cy.wrap($el)
-            .find('.ce-stub__title')
-            .should('have.text', 'failedTool');
-        }
-      });
-  });
-
-  it('should insert default empty block when [] passed as data.blocks', function () {
-    cy.createEditor({
-      data: {
-        blocks: [],
-      },
-    })
-      .as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-block')
-      .should('have.length', 1);
-  });
-
-  it('should insert default empty block when [] passed via blocks.render() API', function () {
-    cy.createEditor({})
-      .as('editorInstance');
-
-    cy.get<EditorJS>('@editorInstance')
-      .then((editor) => {
-        editor.blocks.render({
-          blocks: [],
-        });
-      });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-block')
-      .should('have.length', 1);
-  });
-});
diff --git a/test/cypress/tests/modules/Saver.cy.ts b/test/cypress/tests/modules/Saver.cy.ts
deleted file mode 100644
index dcebe6f5e..000000000
--- a/test/cypress/tests/modules/Saver.cy.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-import type EditorJS from '../../../../types/index';
-import Header from '@editorjs/header';
-
-describe('Saver module', function () {
-  describe('save()', function () {
-    it('should correctly save block if there are some 3rd party (eg. browser extensions) nodes inserted into the layout', function () {
-      cy.createEditor({
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'The block with some text',
-              },
-            },
-          ],
-        },
-      }).then((editor: EditorJS) => {
-        /**
-         * Add some node just like browser extensions doing
-         */
-        const extensionNode = document.createElement('extension-node');
-
-        cy.get('[data-cy=editorjs]')
-          .find('.ce-block__content')
-          .then((blockContent) => {
-            blockContent.append(extensionNode);
-          })
-          .then(async () => {
-            const savedData = await editor.save();
-
-            expect(savedData.blocks.length).to.equal(1);
-            expect(savedData.blocks[0].data.text).to.equal('The block with some text');
-          });
-      });
-    });
-
-    /**
-     * This test case covers Block@detectToolRootChange
-     */
-    it('should correctly save block data if block\'s main container element have been changed', function () {
-      cy.createEditor({
-        tools: {
-          header: Header,
-        },
-        data: {
-          blocks: [
-            {
-              type: 'header',
-              data: {
-                text: 'The block with some text',
-                level: 1,
-              },
-            },
-          ],
-        },
-      })
-        .as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('span.ce-toolbar__settings-btn')
-        .click();
-
-      /**
-       * Change header level
-       */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-settings .ce-popover-item:nth-child(3)')
-        .click();
-
-      cy.get<EditorJS>('@editorInstance')
-        .then(async (editor) => {
-          const data = await editor.save();
-
-          expect(data.blocks[0].type).to.equal('header');
-          expect(data.blocks[0].data.text).to.equal('The block with some text');
-          // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-          expect(data.blocks[0].data.level).to.equal(3);
-        });
-    });
-  });
-});
diff --git a/test/cypress/tests/modules/Tools.cy.ts b/test/cypress/tests/modules/Tools.cy.ts
deleted file mode 100644
index b4d7770b4..000000000
--- a/test/cypress/tests/modules/Tools.cy.ts
+++ /dev/null
@@ -1,326 +0,0 @@
-/* tslint:disable:max-classes-per-file */
-/* eslint-disable @typescript-eslint/no-explicit-any, jsdoc/require-jsdoc */
-import Tools from '../../../../src/components/modules/tools';
-import type { EditorConfig } from '../../../../types';
-import BlockToolAdapter from '../../../../src/components/tools/block';
-
-describe('Tools module', () => {
-  const defaultConfig = {
-    tools: {},
-  };
-
-  /**
-   * Construct Tools module for testing purposes
-   *
-   * @param config - Editor config
-   */
-  function constructModule(config: EditorConfig = defaultConfig): Tools {
-    const module = new Tools({
-      config,
-      eventsDispatcher: {},
-    } as any);
-
-    const APIMethods = {
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      method(): void {},
-    };
-
-    /**
-     * Module state should be Editor modules, so we mock required ones only
-     */
-    module.state = {
-      API: {
-        getMethodsForTool(): typeof APIMethods {
-          return APIMethods;
-        },
-      },
-    } as any;
-
-    return module;
-  }
-
-  context('.prepare()', () => {
-    it('should return Promise resolved to void', async () => {
-      const module = constructModule();
-
-      let err;
-
-      try {
-        await module.prepare();
-      } catch (e) {
-        err = e;
-      }
-
-      expect(err).to.be.undefined;
-    });
-
-    it('should throw an error if tools config is corrupted', async () => {
-      const module = constructModule({
-        tools: {
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-ignore
-          corruptedTool: 'value',
-        },
-      });
-
-      let err;
-
-      try {
-        await module.prepare();
-      } catch (e) {
-        err = e;
-      }
-
-      expect(err).to.be.instanceOf(Error);
-    });
-
-    // eslint-disable-next-line cypress/no-async-tests
-    it('should call Tools prepare method with user config', async () => {
-      class WithSuccessfulPrepare {
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
-        public static prepare = cy.stub();
-      }
-
-      const config = {
-        property: 'value',
-      };
-
-      const module = constructModule({
-        defaultBlock: 'withSuccessfulPrepare',
-        tools: {
-          withSuccessfulPrepare: {
-            class: WithSuccessfulPrepare as any,
-            config,
-          },
-        },
-      });
-
-      await module.prepare();
-
-      expect(WithSuccessfulPrepare.prepare).to.be.calledWithExactly({
-        toolName: 'withSuccessfulPrepare',
-        config,
-      });
-    });
-  });
-
-  context('collection accessors', () => {
-    let module: Tools;
-
-    beforeEach(async () => {
-      module = constructModule({
-        defaultBlock: 'withoutPrepare',
-        tools: {
-          withSuccessfulPrepare: {
-            class: class {
-              // eslint-disable-next-line @typescript-eslint/no-empty-function
-              public static prepare(): void {}
-            } as any,
-            inlineToolbar: [ 'inlineTool2' ],
-            tunes: [ 'blockTune2' ],
-          },
-          withFailedPrepare: class {
-            public static prepare(): void {
-              throw new Error();
-            }
-          } as any,
-          withoutPrepare: {
-            class: class {} as any,
-            inlineToolbar: false,
-            tunes: false,
-          },
-          blockTool: {
-            class: class {} as any,
-            inlineToolbar: true,
-          },
-          blockToolWithoutSettings: class {} as any,
-          inlineTool: class {
-            public static isInline = true;
-
-            // eslint-disable-next-line @typescript-eslint/no-empty-function
-            public render(): void {}
-
-            // eslint-disable-next-line @typescript-eslint/no-empty-function
-            public surround(): void {}
-
-            // eslint-disable-next-line @typescript-eslint/no-empty-function
-            public checkState(): void {}
-          } as any,
-          inlineTool2: class {
-            public static isInline = true;
-
-            // eslint-disable-next-line @typescript-eslint/no-empty-function
-            public render(): void {}
-
-            // eslint-disable-next-line @typescript-eslint/no-empty-function
-            public surround(): void {}
-
-            // eslint-disable-next-line @typescript-eslint/no-empty-function
-            public checkState(): void {}
-          } as any,
-          /**
-           * This tool will be unavailable as it doesn't have required methods
-           */
-          unavailableInlineTool: class {
-            public static isInline = true;
-          } as any,
-          blockTune: class {
-            public static isTune = true;
-          } as any,
-          blockTune2: class {
-            public static isTune = true;
-          } as any,
-          unavailableBlockTune: class {
-            public static isTune = true;
-
-            public static prepare(): void {
-              throw new Error();
-            }
-          } as any,
-        },
-        inlineToolbar: ['inlineTool2', 'inlineTool'],
-        tunes: ['blockTune2', 'blockTune'],
-      });
-
-      await module.prepare();
-    });
-
-    context('.available', () => {
-      it('should return Map instance', () => {
-        expect(module.available).to.be.instanceOf(Map);
-      });
-
-      it('should contain only ready to use Tools', () => {
-        expect(module.available.has('withSuccessfulPrepare')).to.be.true;
-        expect(module.available.has('withoutPrepare')).to.be.true;
-        expect(module.available.has('withFailedPrepare')).to.be.false;
-        expect(module.available.has('unavailableInlineTool')).to.be.false;
-      });
-    });
-
-    context('.unavailable', () => {
-      it('should return Map instance', () => {
-        expect(module.unavailable).to.be.instanceOf(Map);
-      });
-
-      it('should contain unavailable Tools', () => {
-        expect(module.unavailable.has('withSuccessfulPrepare')).to.be.false;
-        expect(module.unavailable.has('withoutPrepare')).to.be.false;
-        expect(module.unavailable.has('withFailedPrepare')).to.be.true;
-        expect(module.unavailable.has('unavailableInlineTool')).to.be.true;
-      });
-    });
-
-    context('.inlineTools', () => {
-      it('should return Map instance', () => {
-        expect(module.inlineTools).to.be.instanceOf(Map);
-      });
-
-      it('should contain only available Inline Tools', () => {
-        expect(module.inlineTools.has('inlineTool')).to.be.true;
-        expect(module.inlineTools.has('unavailableInlineTool')).to.be.false;
-        expect(Array.from(module.inlineTools.values()).every(tool => tool.isInline())).to.be.true;
-      });
-    });
-
-    context('.blockTools', () => {
-      it('should return Map instance', () => {
-        expect(module.blockTools).to.be.instanceOf(Map);
-      });
-
-      it('should contain only available Block Tools', () => {
-        expect(module.blockTools.has('withSuccessfulPrepare')).to.be.true;
-        expect(module.blockTools.has('withoutPrepare')).to.be.true;
-        expect(module.blockTools.has('withFailedPrepare')).to.be.false;
-        expect(Array.from(module.blockTools.values()).every(tool => tool.isBlock())).to.be.true;
-      });
-
-      it('Block Tools should contain default tunes if no settings is specified', () => {
-        const tool = module.blockTools.get('blockToolWithoutSettings');
-
-        expect(tool.tunes.has('delete')).to.be.true;
-        expect(tool.tunes.has('moveUp')).to.be.true;
-        expect(tool.tunes.has('moveDown')).to.be.true;
-      });
-
-      it('Block Tools should contain default tunes', () => {
-        const tool = module.blockTools.get('blockTool');
-
-        expect(tool.tunes.has('delete')).to.be.true;
-        expect(tool.tunes.has('moveUp')).to.be.true;
-        expect(tool.tunes.has('moveDown')).to.be.true;
-      });
-
-      it('Block Tools should contain tunes in correct order', () => {
-        let tool = module.blockTools.get('blockTool');
-
-        expect(tool.tunes.has('blockTune')).to.be.true;
-        expect(tool.tunes.has('blockTune2')).to.be.true;
-        expect(Array.from(tool.tunes.keys())).to.be.deep.eq(['blockTune2', 'blockTune', 'moveUp', 'delete', 'moveDown']);
-
-        tool = module.blockTools.get('withSuccessfulPrepare');
-
-        expect(tool.tunes.has('blockTune')).to.be.false;
-        expect(tool.tunes.has('blockTune2')).to.be.true;
-
-        tool = module.blockTools.get('withoutPrepare');
-
-        expect(tool.tunes.has('blockTune')).to.be.false;
-        expect(tool.tunes.has('blockTune2')).to.be.false;
-      });
-
-      it('Block Tools should contain inline tools in correct order', () => {
-        let tool = module.blockTools.get('blockTool');
-
-        expect(tool.inlineTools.has('inlineTool')).to.be.true;
-        expect(tool.inlineTools.has('inlineTool2')).to.be.true;
-        expect(Array.from(tool.inlineTools.keys())).to.be.deep.eq(['inlineTool2', 'inlineTool']);
-
-        tool = module.blockTools.get('withSuccessfulPrepare');
-
-        expect(tool.inlineTools.has('inlineTool')).to.be.false;
-        expect(tool.inlineTools.has('inlineTool2')).to.be.true;
-
-        tool = module.blockTools.get('withoutPrepare');
-
-        expect(tool.inlineTools.has('inlineTool')).to.be.false;
-        expect(tool.inlineTools.has('inlineTool2')).to.be.false;
-      });
-    });
-
-    context('.blockTunes', () => {
-      it('should return Map instance', () => {
-        expect(module.blockTunes).to.be.instanceOf(Map);
-      });
-
-      it('should contain only available Block Tunes', () => {
-        expect(module.blockTunes.has('blockTune')).to.be.true;
-        expect(module.blockTunes.has('unavailableBlockTune')).to.be.false;
-        expect(Array.from(module.blockTunes.values()).every(tool => tool.isTune())).to.be.true;
-      });
-    });
-
-    context('.internal', () => {
-      it('should return Map instance', () => {
-        expect(module.internal).to.be.instanceOf(Map);
-      });
-
-      it('should contain only internal tunes', () => {
-        expect(Array.from(module.internal.values()).every(tool => tool.isInternal)).to.be.true;
-      });
-    });
-
-    context('.defaultTools', () => {
-      /**
-       * @todo add check if user provided default tool is not Block Tool
-       */
-      it('should return BlockTool instance', () => {
-        expect(module.defaultTool).to.be.instanceOf(BlockToolAdapter);
-      });
-
-      it('should return default Tool', () => {
-        expect(module.defaultTool.isDefault).to.be.true;
-      });
-    });
-  });
-});
diff --git a/test/cypress/tests/modules/Ui.cy.ts b/test/cypress/tests/modules/Ui.cy.ts
deleted file mode 100644
index eaf2246a8..000000000
--- a/test/cypress/tests/modules/Ui.cy.ts
+++ /dev/null
@@ -1,143 +0,0 @@
-import { createEditorWithTextBlocks } from '../../support/utils/createEditorWithTextBlocks';
-import type EditorJS from '../../../../types/index';
-
-describe('Ui module', function () {
-  describe('documentKeydown', function () {
-    describe('Backspace', function () {
-      it('should remove selected blocks', function () {
-        cy.createEditor({
-          data: {
-            blocks: [
-              {
-                id: 'block1',
-                type: 'paragraph',
-                data: {
-                  text: 'The first block',
-                },
-              },
-              {
-                id: 'block2',
-                type: 'paragraph',
-                data: {
-                  text: 'The second block',
-                },
-              },
-            ],
-          },
-        }).as('editorInstance');
-
-        /**
-         * Select two blocks by shift+down
-         */
-        cy.get('[data-cy=editorjs]')
-          .find('.ce-paragraph')
-          .first()
-          .click()
-          .type('{shift+downArrow}')
-          .type('{backspace}');
-
-
-        cy.get<EditorJS>('@editorInstance')
-          .then(async (editor) => {
-            const { blocks } = await editor.save();
-
-            /**
-             * Actually editor will contain 1 empty block, but save wont return it since it is empty
-             */
-            expect(blocks.length).to.eq(0);
-          });
-      });
-    });
-
-    describe('Delete', function () {
-      it('should remove selected blocks', function () {
-        cy.createEditor({
-          data: {
-            blocks: [
-              {
-                id: 'block1',
-                type: 'paragraph',
-                data: {
-                  text: 'The first block',
-                },
-              },
-              {
-                id: 'block2',
-                type: 'paragraph',
-                data: {
-                  text: 'The second block',
-                },
-              },
-            ],
-          },
-        }).as('editorInstance');
-
-        /**
-         * Select two blocks by shift+down
-         */
-        cy.get('[data-cy=editorjs]')
-          .find('.ce-paragraph')
-          .first()
-          .click()
-          .type('{shift+downArrow}')
-          .type('{del}');
-
-        cy.get<EditorJS>('@editorInstance')
-          .then(async (editor) => {
-            const { blocks } = await editor.save();
-
-            /**
-             * Actually editor will contain 1 empty block, but save wont return it since it is empty
-             */
-            expect(blocks.length).to.eq(0);
-          });
-      });
-    });
-  });
-
-  describe('mousedown', function () {
-    it('should update current block by click on block', function () {
-      createEditorWithTextBlocks([
-        'first block',
-        'second block',
-        'third block',
-      ])
-        .as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .eq(1)
-        .click();
-
-      cy.get<EditorJS>('@editorInstance')
-        .then(async (editor) => {
-          const currentBlockIndex = await editor.blocks.getCurrentBlockIndex();
-
-          expect(currentBlockIndex).to.eq(1);
-        });
-    });
-
-    it('(in readonly) should update current block by click on block', function () {
-      createEditorWithTextBlocks([
-        'first block',
-        'second block',
-        'third block',
-      ], {
-        readOnly: true,
-      })
-        .as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .eq(1)
-        .click();
-
-      cy.get<EditorJS>('@editorInstance')
-        .then(async (editor) => {
-          const currentBlockIndex = await editor.blocks.getCurrentBlockIndex();
-
-          expect(currentBlockIndex).to.eq(1);
-        });
-    });
-  });
-});
diff --git a/test/cypress/tests/onchange.cy.ts b/test/cypress/tests/onchange.cy.ts
deleted file mode 100644
index 6727aea8d..000000000
--- a/test/cypress/tests/onchange.cy.ts
+++ /dev/null
@@ -1,907 +0,0 @@
-import Header from '@editorjs/header';
-import Code from '@editorjs/code';
-import ToolMock from '../fixtures/tools/ToolMock';
-import Delimiter from '@editorjs/delimiter';
-import { BlockAddedMutationType } from '../../../types/events/block/BlockAdded';
-import { BlockChangedMutationType } from '../../../types/events/block/BlockChanged';
-import { BlockRemovedMutationType } from '../../../types/events/block/BlockRemoved';
-import { BlockMovedMutationType } from '../../../types/events/block/BlockMoved';
-import type EditorJS from '../../../types/index';
-import { modificationsObserverBatchTimeout } from '../../../src/components/constants';
-
-/**
- * EditorJS API is passed as the first parameter of the onChange callback
- */
-const EditorJSApiMock = Cypress.sinon.match.any;
-
-/**
- * @todo Add checks that correct block API object is passed to onChange
- * @todo Add cases for native inputs changes
- * @todo debug onChange firing on Block Tune toggling (see below)
- */
-describe('onChange callback', () => {
-  /**
-   * Creates Editor instance
-   *
-   * @param blocks - list of blocks to prefill the editor
-   */
-  function createEditor(blocks = null): void {
-    const config = {
-      tools: {
-        header: Header,
-        code: Code,
-      },
-      onChange: (api, event): void => {
-        console.log('something changed', event);
-      },
-      data: blocks ? {
-        blocks,
-      } : null,
-    };
-
-    cy.spy(config, 'onChange').as('onChange');
-
-    cy.createEditor(config).as('editorInstance');
-  }
-
-  /**
-   * Creates Editor instance with save inside the onChange event.
-   *
-   * @param blocks - list of blocks to prefill the editor
-   */
-  function createEditorWithSave(blocks = null): void {
-    const config = {
-      tools: {
-        header: Header,
-        code: Code,
-        delimiter: Delimiter,
-      },
-      onChange: (api, event): void => {
-        console.log('something changed', event);
-        api.saver.save();
-      },
-      data: blocks ? {
-        blocks,
-      } : null,
-    };
-
-    cy.spy(config, 'onChange').as('onChange');
-
-    cy.createEditor(config).as('editorInstance');
-  }
-
-  it('should batch events when several changes happened at once', () => {
-    createEditor([
-      {
-        type: 'paragraph',
-        data: {
-          text: 'The first paragraph',
-        },
-      },
-    ]);
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .click()
-      .type('change')
-      .type('{enter}');
-
-    cy.get('@onChange').should('be.calledWithBatchedEvents', [
-      {
-        type: BlockChangedMutationType,
-        detail: {
-          index: 0,
-        },
-      },
-      {
-        type: BlockAddedMutationType,
-        detail: {
-          index: 1,
-        },
-      },
-    ]);
-  });
-
-  it('should filter out similar events on batching', () => {
-    createEditor([
-      {
-        type: 'paragraph',
-        data: {
-          text: 'The first paragraph',
-        },
-      },
-    ]);
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .click()
-      .type('first change')
-      // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-      .wait(100)
-      .type('second change');
-
-    cy.get('@onChange').should('be.calledOnce');
-    cy.get('@onChange').should('be.calledWithMatch', EditorJSApiMock, Cypress.sinon.match({
-      type: BlockChangedMutationType,
-      detail: {
-        target: {
-          name: 'paragraph',
-        },
-        index: 0,
-      },
-    }));
-  });
-
-  it('should be fired with correct index on block insertion above the current (by pressing Enter at the start)', () => {
-    createEditor();
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .click()
-      .type('{enter}');
-
-    cy.get('@onChange').should('be.calledWithMatch', EditorJSApiMock, Cypress.sinon.match({
-      type: BlockAddedMutationType,
-      detail: {
-        target: {
-          name: 'paragraph',
-        },
-        index: 0,
-      },
-    }));
-  });
-
-  it('should be fired with only single "block-added" event by pressing Enter at the end of a block', () => {
-    createEditor([ {
-      type: 'paragraph',
-      data: {
-        text: 'some text',
-      },
-    } ]);
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .click()
-      .type('{enter}');
-
-    cy.get('@onChange').should('be.calledOnce');
-    cy.get('@onChange').should('be.calledWithMatch', EditorJSApiMock, Cypress.sinon.match({
-      type: BlockAddedMutationType,
-    }));
-  });
-
-  it('should be fired with correct index on block insertion after the current (by pressing enter at the end)', () => {
-    createEditor([ {
-      type: 'paragraph',
-      data: {
-        text: 'some text',
-      },
-    } ]);
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .click()
-      .type('{enter}');
-
-    cy.get('@onChange').should('be.calledWithMatch', EditorJSApiMock, Cypress.sinon.match({
-      type: BlockAddedMutationType,
-      detail: {
-        index: 1,
-      },
-    }));
-  });
-
-  it('should be fired on typing into block', () => {
-    createEditor();
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .click()
-      .type('some text');
-
-    cy.get('@onChange').should('be.calledWithMatch', EditorJSApiMock, Cypress.sinon.match({
-      type: BlockChangedMutationType,
-      detail: {
-        index: 0,
-      },
-    }));
-  });
-
-  it('should be fired on block insertion with save inside onChange', () => {
-    createEditorWithSave();
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-toolbar__plus')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover-item[data-item-name=delimiter]')
-      .click();
-
-    cy.get('@onChange').should('be.calledWithBatchedEvents', [
-      {
-        type: BlockRemovedMutationType,
-        detail: {
-          index: 0,
-          target: {
-            name: 'paragraph',
-          },
-        },
-      },
-      {
-        type: BlockAddedMutationType,
-        detail: {
-          index: 0,
-          target: {
-            name: 'delimiter',
-          },
-        },
-      },
-      {
-        type: BlockAddedMutationType,
-        detail: {
-          index: 1,
-          target: {
-            name: 'paragraph',
-          },
-        },
-      },
-    ]);
-  });
-
-  it('should be fired on block replacement for both of blocks', () => {
-    createEditor();
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-toolbar__plus')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover-item[data-item-name=header]')
-      .click();
-
-    cy.get('@onChange').should('be.calledWithBatchedEvents', [
-      {
-        type: BlockRemovedMutationType,
-        detail: {
-          index: 0,
-          target: {
-            name: 'paragraph',
-          },
-        },
-      },
-      {
-        type: BlockAddedMutationType,
-        detail: {
-          index: 0,
-          target: {
-            name: 'header',
-          },
-        },
-      },
-    ]);
-  });
-
-  it('should be fired on tune modifying', () => {
-    createEditor([
-      {
-        type: 'header',
-        data: {
-          text: 'Header block',
-        },
-      },
-    ]);
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('span.ce-toolbar__settings-btn')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-settings .ce-popover-item:nth-child(4)')
-      .click();
-
-    cy.get('@onChange').should('be.calledWithMatch', EditorJSApiMock, Cypress.sinon.match({
-      type: BlockChangedMutationType,
-      detail: {
-        index: 0,
-        target: {
-          name: 'header',
-        },
-      },
-    }));
-  });
-
-  it('should be fired when block is removed', () => {
-    createEditor([
-      {
-        type: 'paragraph',
-        data: {
-          text: 'some text',
-        },
-      },
-    ]);
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('span.ce-toolbar__settings-btn')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('[data-item-name=delete]')
-      .click();
-
-    /** Second click for confirmation */
-    cy.get('[data-cy=editorjs]')
-      .get('[data-item-name=delete]')
-      .click();
-
-    cy.get('@onChange').should('be.calledWithBatchedEvents', [
-      /**
-       * "block-removed" fired since we have deleted a block
-       */
-      {
-        type: BlockRemovedMutationType,
-        detail: {
-          index: 0,
-        },
-      },
-      /**
-       * "block-added" fired since we have deleted the last block, so the new one is created
-       */
-      {
-        type: BlockAddedMutationType,
-        detail: {
-          index: 0,
-        },
-      },
-    ]);
-  });
-
-  it('should be fired when block is moved', () => {
-    createEditor([
-      {
-        type: 'paragraph',
-        data: {
-          text: 'first block',
-        },
-      },
-      {
-        type: 'paragraph',
-        data: {
-          text: 'second block',
-        },
-      },
-    ]);
-
-    cy.get('[data-cy=editorjs]')
-      .get('div.ce-block')
-      .last()
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('span.ce-toolbar__settings-btn')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('[data-item-name=move-up]')
-      .click();
-
-    cy.get('@onChange').should('be.calledWithMatch', EditorJSApiMock, Cypress.sinon.match({
-      type: BlockMovedMutationType,
-      detail: {
-        fromIndex: 1,
-        toIndex: 0,
-      },
-    }));
-  });
-
-  it('should be fired if something changed inside native input', () => {
-    createEditor([ {
-      type: 'code',
-      data: {
-        code: '',
-      },
-    } ]);
-
-    cy.get('[data-cy=editorjs')
-      .get('textarea')
-      .type('Some input to the textarea');
-
-    cy.get('@onChange').should('be.calledWithMatch', EditorJSApiMock, Cypress.sinon.match({
-      type: BlockChangedMutationType,
-      detail: {
-        index: 0,
-      },
-    }));
-  });
-
-  it('should not be fired on fake cursor adding and removing', () => {
-    createEditor([ {
-      type: 'paragraph',
-      data: {
-        text: 'some text',
-      },
-    } ]);
-
-    cy.get('[data-cy=editorjs')
-      .get('div.ce-block')
-      .click();
-
-    /**
-     * Open Block Tunes, add fake cursor
-     */
-    cy.get('[data-cy=editorjs]')
-      .get('span.ce-toolbar__settings-btn')
-      .click();
-
-    /**
-     * Close Block Tunes, remove fake cursor
-     */
-    cy.get('[data-cy=editorjs')
-      .get('div.ce-block')
-      .click();
-
-    cy.wait(modificationsObserverBatchTimeout).then(() => {
-      cy.get('@onChange').should('have.callCount', 0);
-    });
-  });
-
-  it('should be fired when the whole text inside block is removed', () => {
-    createEditor([ {
-      type: 'paragraph',
-      data: {
-        text: 'a',
-      },
-    } ]);
-
-    cy.get('[data-cy=editorjs')
-      .get('div.ce-block')
-      .click()
-      .type('{backspace}');
-
-    cy.get('@onChange').should('be.calledWithMatch', EditorJSApiMock, Cypress.sinon.match({
-      type: BlockChangedMutationType,
-      detail: {
-        index: 0,
-      },
-    }));
-  });
-
-  it('should not be fired when element with the "data-mutation-free" mark changes some attribute', () => {
-    /**
-     * Mock for tool wrapper which we will mutate in a test
-     */
-    const toolWrapper = document.createElement('div');
-
-    /**
-     * Mark it as mutation-free
-     */
-    toolWrapper.dataset.mutationFree = 'true';
-
-    /**
-     * Mock of tool with data-mutation-free attribute
-     */
-    class ToolWithMutationFreeAttribute {
-      /**
-       * Simply return mocked element
-       */
-      public render(): HTMLElement {
-        return toolWrapper;
-      }
-
-      /**
-       * Saving logic is not necessary for this test
-       */
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      public save(): void {}
-    }
-
-    const editorConfig = {
-      tools: {
-        testTool: ToolWithMutationFreeAttribute,
-      },
-      onChange: (api, event): void => {
-        console.log('something changed', event);
-      },
-      data: {
-        blocks: [
-          {
-            type: 'testTool',
-            data: {},
-          },
-        ],
-      },
-    };
-
-    cy.spy(editorConfig, 'onChange').as('onChange');
-    cy.createEditor(editorConfig).as('editorInstance');
-
-    /**
-     * Emulate tool's internal attribute mutation
-     */
-    cy.wait(100).then(() => {
-      toolWrapper.setAttribute('some-changed-attr', 'some-new-value');
-    });
-
-    /**
-     * Check that onChange callback was not called
-     */
-    cy.wait(modificationsObserverBatchTimeout).then(() => {
-      cy.get('@onChange').should('have.callCount', 0);
-    });
-  });
-
-  it('should not be fired when mutation happened in a child of element with the "data-mutation-free" mark', () => {
-    /**
-     * Mock for tool wrapper which we will mutate in a test
-     */
-    const toolWrapper = document.createElement('div');
-    const toolChild = document.createElement('div');
-
-    toolWrapper.appendChild(toolChild);
-
-    /**
-     * Mark it as mutation-free
-     */
-    toolWrapper.dataset.mutationFree = 'true';
-
-    /**
-     * Mock of tool with data-mutation-free attribute
-     */
-    class ToolWithMutationFreeAttribute {
-      /**
-       * Simply return mocked element
-       */
-      public render(): HTMLElement {
-        return toolWrapper;
-      }
-
-      /**
-       * Saving logic is not necessary for this test
-       */
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      public save(): void {}
-    }
-
-    const editorConfig = {
-      tools: {
-        testTool: ToolWithMutationFreeAttribute,
-      },
-      onChange: (api, event): void => {
-        console.log('something changed', event);
-      },
-      data: {
-        blocks: [
-          {
-            type: 'testTool',
-            data: {},
-          },
-        ],
-      },
-    };
-
-    cy.spy(editorConfig, 'onChange').as('onChange');
-    cy.createEditor(editorConfig).as('editorInstance');
-
-    /**
-     * Emulate tool's internal attribute mutation
-     */
-    cy.wait(100).then(() => {
-      toolChild.setAttribute('some-changed-attr', 'some-new-value');
-    });
-
-    /**
-     * Check that onChange callback was not called
-     */
-    cy.wait(modificationsObserverBatchTimeout).then(() => {
-      cy.get('@onChange').should('have.callCount', 0);
-    });
-  });
-
-  it('should not be fired when "characterData" mutation happened in a child of element with the "data-mutation-free" mark', () => {
-    /**
-     * Mock for tool wrapper which we will mutate in a test
-     */
-    const toolWrapper = document.createElement('div');
-    const toolChild = document.createElement('div');
-
-    toolChild.setAttribute('data-cy', 'tool-child');
-    toolChild.setAttribute('contenteditable', 'true');
-
-    toolWrapper.appendChild(toolChild);
-
-    /**
-     * Mark it as mutation-free
-     */
-    toolWrapper.dataset.mutationFree = 'true';
-
-    /**
-     * Mock of tool with data-mutation-free attribute
-     */
-    class ToolWithMutationFreeAttribute {
-      /**
-       * Simply return mocked element
-       */
-      public render(): HTMLElement {
-        return toolWrapper;
-      }
-
-      /**
-       * Saving logic is not necessary for this test
-       */
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      public save(): void {}
-    }
-
-    const editorConfig = {
-      tools: {
-        testTool: ToolWithMutationFreeAttribute,
-      },
-      onChange: function (api, event) {
-        console.log('something changed!!!!!!!!', event);
-      },
-      data: {
-        blocks: [
-          {
-            type: 'testTool',
-            data: {},
-          },
-        ],
-      },
-    };
-
-    cy.spy(editorConfig, 'onChange').as('onChange');
-    cy.createEditor(editorConfig).as('editorInstance');
-
-    /**
-     * Emulate tool's child-element text typing
-     */
-    cy.get('[data-cy=editorjs')
-      .get('[data-cy=tool-child]')
-      .click()
-      .type('some text');
-
-    /**
-     * Check that onChange callback was not called
-     */
-    cy.wait(modificationsObserverBatchTimeout).then(() => {
-      cy.get('@onChange').should('have.callCount', 0);
-    });
-  });
-
-  it('should be called on blocks.clear() with removed and added blocks', () => {
-    createEditor([
-      {
-        type: 'paragraph',
-        data: {
-          text: 'The first paragraph',
-        },
-      },
-      {
-        type: 'paragraph',
-        data: {
-          text: 'The second paragraph',
-        },
-      },
-    ]);
-
-    cy.get<EditorJS>('@editorInstance')
-      .then(async editor => {
-        cy.wrap(editor.blocks.clear());
-      });
-
-    cy.get('@onChange').should('be.calledWithBatchedEvents', [
-      {
-        type: BlockRemovedMutationType,
-      },
-      {
-        type: BlockRemovedMutationType,
-      },
-      {
-        type: BlockAddedMutationType,
-      },
-    ]);
-  });
-
-  it('should not be called on blocks.render() on non-empty editor', () => {
-    createEditor([
-      {
-        type: 'paragraph',
-        data: {
-          text: 'The first paragraph',
-        },
-      },
-      {
-        type: 'paragraph',
-        data: {
-          text: 'The second paragraph',
-        },
-      },
-    ]);
-
-    cy.get<EditorJS>('@editorInstance')
-      .then(async editor => {
-        cy.wrap(editor.blocks.render({
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'The new paragraph',
-              },
-            },
-          ],
-        }));
-      });
-
-    cy.wait(modificationsObserverBatchTimeout);
-
-    cy.get('@onChange').should('have.callCount', 0);
-  });
-
-  it('should be called on blocks.update() with "block-changed" event', () => {
-    const block = {
-      id: 'bwnFX5LoX7',
-      type: 'paragraph',
-      data: {
-        text: 'The first block mock.',
-      },
-    };
-    const config = {
-      data: {
-        blocks: [
-          block,
-        ],
-      },
-      onChange: (api, event): void => {
-        console.log('something changed', event);
-      },
-    };
-
-    cy.spy(config, 'onChange').as('onChange');
-
-    cy.createEditor(config)
-      .then((editor) => {
-        editor.blocks.update(block.id, {
-          text: 'Updated text',
-        });
-
-        cy.get('@onChange').should('be.calledWithMatch', EditorJSApiMock, Cypress.sinon.match({
-          type: BlockChangedMutationType,
-          detail: {
-            index: 0,
-            target: {
-              id: block.id,
-            },
-          },
-        }));
-      });
-  });
-
-  it('should be fired when the whole text inside some descendant of the block is removed', () => {
-    /**
-     * Mock of Tool with nested contenteditable element
-     */
-    class ToolWithContentEditableDescendant extends ToolMock {
-      /**
-       * Creates element with nested contenteditable element
-       */
-      public render(): HTMLElement {
-        const contenteditable = document.createElement('div');
-
-        contenteditable.contentEditable = 'true';
-        contenteditable.innerText = 'a';
-        contenteditable.setAttribute('data-cy', 'nested-contenteditable');
-
-        const wrapper = document.createElement('div');
-
-        wrapper.appendChild(contenteditable);
-
-        return wrapper;
-      }
-    }
-
-    const config = {
-      tools: {
-        testTool: {
-          class: ToolWithContentEditableDescendant,
-        },
-      },
-      data: {
-        blocks: [
-          {
-            type: 'testTool',
-            data: 'a',
-          },
-        ],
-      },
-      onChange: (): void => {
-        console.log('something changed');
-      },
-    };
-
-    cy.spy(config, 'onChange').as('onChange');
-    cy.createEditor(config).as('editorInstance');
-
-    cy.get('[data-cy=nested-contenteditable]')
-      .click()
-      .clear();
-
-    cy.get('@onChange').should('be.calledWithMatch', EditorJSApiMock, Cypress.sinon.match({
-      type: BlockChangedMutationType,
-      detail: {
-        index: 0,
-      },
-    }));
-  });
-
-  it('should not be called when editor is initialized with readOnly mode', () => {
-    const config = {
-      readOnly: true,
-      onChange: (api, event): void => {
-        console.log('something changed', event);
-      },
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'The first paragraph',
-            },
-          },
-        ],
-      },
-    };
-
-    cy.spy(config, 'onChange').as('onChange');
-
-    cy.createEditor(config);
-
-    cy.wait(modificationsObserverBatchTimeout);
-
-    cy.get('@onChange').should('have.callCount', 0);
-  });
-
-  it('should not be called when editor is switched to/from readOnly mode', () => {
-    createEditor([
-      {
-        type: 'paragraph',
-        data: {
-          text: 'The first paragraph',
-        },
-      },
-    ]);
-
-    cy.get<EditorJS>('@editorInstance')
-      .then(async editor => {
-        editor.readOnly.toggle(true);
-      });
-
-    cy.wait(modificationsObserverBatchTimeout);
-
-    cy.get('@onChange').should('have.callCount', 0);
-
-    cy.get<EditorJS>('@editorInstance')
-      .then(async editor => {
-        editor.readOnly.toggle(false);
-      });
-
-    cy.wait(modificationsObserverBatchTimeout);
-
-    cy.get('@onChange').should('have.callCount', 0);
-  });
-});
diff --git a/test/cypress/tests/readOnly.cy.ts b/test/cypress/tests/readOnly.cy.ts
deleted file mode 100644
index f1f8e496c..000000000
--- a/test/cypress/tests/readOnly.cy.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import type { EditorConfig } from '../../../types';
-import type EditorJS from '../../../types';
-
-describe('ReadOnly API spec', () => {
-  /**
-   * Creates the new editor instance
-   *
-   * @param config - Editor Config
-   */
-  function createEditor(config?: EditorConfig): void {
-    const editorConfig = Object.assign({}, config || {});
-
-    cy.createEditor(editorConfig).as('editorInstance');
-  }
-
-  it('should return correct value for readOnly.isEnabled when editor initialized in normal mode', () => {
-    createEditor();
-
-    cy
-      .get<EditorJS>('@editorInstance')
-      .then(editor => {
-        expect(editor.readOnly.isEnabled).to.be.false;
-      });
-  });
-
-  it('should return correct value for readOnly.isEnabled when editor initialized in read-only mode', () => {
-    createEditor({
-      readOnly: true,
-    });
-
-    cy
-      .get<EditorJS>('@editorInstance')
-      .then(editor => {
-        expect(editor.readOnly.isEnabled).to.be.true;
-      });
-  });
-
-  it('should return correct value for readOnly.isEnabled when read-only mode toggled', () => {
-    createEditor();
-
-    cy
-      .get<EditorJS>('@editorInstance')
-      .then(async editor => {
-        expect(editor.readOnly.isEnabled).to.be.false;
-
-        editor.readOnly.toggle()
-          .then(() => {
-            expect(editor.readOnly.isEnabled).to.be.true;
-          })
-          .then(() => editor.readOnly.toggle())
-          .then(() => {
-            expect(editor.readOnly.isEnabled).to.be.false;
-          });
-      });
-  });
-});
diff --git a/test/cypress/tests/sanitisation.cy.ts b/test/cypress/tests/sanitisation.cy.ts
deleted file mode 100644
index f0653b870..000000000
--- a/test/cypress/tests/sanitisation.cy.ts
+++ /dev/null
@@ -1,118 +0,0 @@
-import type EditorJS from '../../../types/index';
-import type { OutputData } from '../../../types/index';
-
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-describe('Sanitizing', () => {
-  context('Output should save inline formatting', () => {
-    it('should save initial formatting for paragraph', () => {
-      cy.createEditor({
-        data: {
-          blocks: [ {
-            type: 'paragraph',
-            data: { text: '<b>Bold text</b>' },
-          } ],
-        },
-      })
-        .then(async editor => {
-          cy.wrap<OutputData>(await editor.save())
-            .then((output) => {
-              const boldText = output.blocks[0].data.text;
-
-              expect(boldText).to.eq('<b>Bold text</b>');
-            });
-        });
-    });
-
-    it('should save formatting for paragraph', () => {
-      cy.createEditor({})
-        .as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click()
-        .type('This text should be bold.{selectall}');
-
-      cy.get('[data-cy=editorjs]')
-        .get('[data-item-name="bold"]')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .click();
-
-      cy.get<EditorJS>('@editorInstance')
-        .then(async editorInstance => {
-          cy.wrap(await editorInstance.save())
-            .then((output) => {
-              const text = output.blocks[0].data.text;
-
-              expect(text).to.match(/<b>This text should be bold\.(<br>)?<\/b>/);
-            });
-        });
-    });
-
-    it('should save formatting for paragraph on paste', () => {
-      cy.createEditor({})
-        .as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .get('div.ce-block')
-        .paste({
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          'text/html': '<p>Text</p><p><b>Bold text</b></p>',
-        });
-
-      cy.get<EditorJS>('@editorInstance')
-        .then(async editorInstance => {
-          cy.wrap<OutputData>(await editorInstance.save())
-            .then((output) => {
-              const boldText = output.blocks[1].data.text;
-
-              expect(boldText).to.eq('<b>Bold text</b>');
-            });
-        });
-    });
-  });
-
-  it('should sanitize unwanted html on blocks merging', function () {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            id: 'block1',
-            type: 'paragraph',
-            data: {
-              text: 'First block',
-            },
-          },
-          {
-            id: 'paragraph',
-            type: 'paragraph',
-            data: {
-              /**
-               * Tool does not support spans in its sanitization config
-               */
-              text: 'Second <span id="taint-html">XSS<span> block',
-            },
-          },
-        ],
-      },
-    }).as('editorInstance');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .click()
-      .type('{home}')
-      .type('{backspace}');
-
-    cy.get<EditorJS>('@editorInstance')
-      .then(async (editor) => {
-        const { blocks } = await editor.save();
-
-        expect(blocks[0].data.text).to.eq('First blockSecond XSS block'); // text has been merged, span has been removed
-      });
-  });
-});
-
diff --git a/test/cypress/tests/selection.cy.ts b/test/cypress/tests/selection.cy.ts
deleted file mode 100644
index c9017351a..000000000
--- a/test/cypress/tests/selection.cy.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import * as _ from '../../../src/components/utils';
-
-describe('Blocks selection', () => {
-  beforeEach(function () {
-    cy.createEditor({}).as('editorInstance');
-  });
-
-  afterEach(function () {
-    if (this.editorInstance) {
-      this.editorInstance.destroy();
-    }
-  });
-
-  it('should remove block selection on click', () => {
-    cy.get('[data-cy=editorjs]')
-      .find('div.ce-block')
-      .click()
-      .type('First block{enter}');
-
-    cy.get('[data-cy=editorjs')
-      .find('div.ce-block')
-      .next()
-      .type('Second block')
-      .type('{movetostart}')
-      .trigger('keydown', {
-        shiftKey: true,
-        keyCode: _.keyCodes.UP,
-      });
-
-    cy.get('[data-cy=editorjs')
-      .click()
-      .find('div.ce-block')
-      .should('not.have.class', '.ce-block--selected');
-  });
-});
diff --git a/test/cypress/tests/tools/BlockTool.cy.ts b/test/cypress/tests/tools/BlockTool.cy.ts
deleted file mode 100644
index f1ec19243..000000000
--- a/test/cypress/tests/tools/BlockTool.cy.ts
+++ /dev/null
@@ -1,588 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* tslint:disable:max-classes-per-file */
-import type { BlockToolData, ToolSettings } from '@/types';
-import { ToolType } from '@/types/tools/adapters/tool-type';
-import BlockToolAdapter from '../../../../src/components/tools/block';
-import InlineToolAdapter from '../../../../src/components/tools/inline';
-import ToolsCollection from '../../../../src/components/tools/collection';
-
-describe('BlockTool', () => {
-  /**
-   * Mock for BlockTool constructor options
-   */
-  const options = {
-    name: 'blockTool',
-    constructable: class {
-      public static sanitize = {
-        rule1: {
-          div: true,
-        },
-      };
-
-      public static toolbox = {
-        icon: 'Tool icon',
-        title: 'Tool title',
-      };
-
-      public static enableLineBreaks = true;
-
-      public static pasteConfig = {
-        tags: [ 'div' ],
-      };
-
-      public static conversionConfig = {
-        import: 'import',
-        export: 'export',
-      };
-
-      public static isReadOnlySupported = true;
-
-      public static reset;
-      public static prepare;
-
-      public static shortcut = 'CTRL+N';
-
-      public data: BlockToolData;
-      public block: object;
-      public readonly: boolean;
-      public api: object;
-      public config: ToolSettings;
-
-      // eslint-disable-next-line jsdoc/require-jsdoc
-      constructor({ data, block, readOnly, api, config }) {
-        this.data = data;
-        this.block = block;
-        this.readonly = readOnly;
-        this.api = api;
-        this.config = config;
-      }
-    },
-    config: {
-      config: {
-        option1: 'option1',
-        option2: 'option2',
-      },
-      inlineToolbar: ['link', 'bold'],
-      tunes: ['anchor', 'favorites'],
-      shortcut: 'CMD+SHIFT+B',
-      toolbox: {
-        title: 'User Block Tool',
-        icon: 'User icon',
-      },
-    },
-    api: {
-      prop1: 'prop1',
-      prop2: 'prop2',
-    },
-    isDefault: false,
-    isInternal: false,
-    defaultPlaceholder: 'Default placeholder',
-  };
-
-  it('.type should return ToolType.Block', () => {
-    const tool = new BlockToolAdapter(options as any);
-
-    expect(tool.type).to.be.eq(ToolType.Block);
-  });
-
-  it('.name should return correct value', () => {
-    const tool = new BlockToolAdapter(options as any);
-
-    expect(tool.name).to.be.eq(options.name);
-  });
-
-  it('.isDefault should return correct value', () => {
-    const tool1 = new BlockToolAdapter(options as any);
-    const tool2 = new BlockToolAdapter({
-      ...options,
-      isDefault: true,
-    } as any);
-
-    expect(tool1.isDefault).to.be.false;
-    expect(tool2.isDefault).to.be.true;
-  });
-
-  it('.isInternal should return correct value', () => {
-    const tool1 = new BlockToolAdapter(options as any);
-    const tool2 = new BlockToolAdapter({
-      ...options,
-      isInternal: true,
-    } as any);
-
-    expect(tool1.isInternal).to.be.false;
-    expect(tool2.isInternal).to.be.true;
-  });
-
-  context('.settings', () => {
-    it('should return correct value', () => {
-      const tool = new BlockToolAdapter(options as any);
-
-      expect(tool.settings).to.be.deep.eq(options.config.config);
-    });
-
-    it('should add default placeholder if Tool is default', () => {
-      const tool = new BlockToolAdapter({
-        ...options,
-        isDefault: true,
-      } as any);
-
-      expect(tool.settings).to.have.property('placeholder').that.eq(options.defaultPlaceholder);
-    });
-  });
-
-  context('.sanitizeConfig', () => {
-    it('should return correct value', () => {
-      const tool = new BlockToolAdapter(options as any);
-
-      expect(tool.sanitizeConfig).to.be.deep.eq(options.constructable.sanitize);
-    });
-
-    it('should return composed config if there are enabled inline tools', () => {
-      const tool = new BlockToolAdapter(options as any);
-
-      const inlineTool = new InlineToolAdapter({
-        name: 'inlineTool',
-        constructable: class {
-          public static sanitize = {
-            b: true,
-          };
-        },
-        api: {},
-        config: {},
-      } as any);
-
-      tool.inlineTools = new ToolsCollection([ ['inlineTool', inlineTool] ]);
-
-      const expected = options.constructable.sanitize;
-
-      // tslint:disable-next-line:forin
-      for (const key in expected) {
-        expected[key] = {
-          ...expected[key],
-          b: true,
-        };
-      }
-
-      expect(tool.sanitizeConfig).to.be.deep.eq(expected);
-    });
-
-    it('should return inline tools config if block one is not set', () => {
-      const tool = new BlockToolAdapter({
-        ...options,
-        constructable: class {},
-      } as any);
-
-      const inlineTool1 = new InlineToolAdapter({
-        name: 'inlineTool',
-        constructable: class {
-          public static sanitize = {
-            b: true,
-          };
-        },
-        api: {},
-        config: {},
-      } as any);
-
-      const inlineTool2 = new InlineToolAdapter({
-        name: 'inlineTool',
-        constructable: class {
-          public static sanitize = {
-            a: true,
-          };
-        },
-        api: {},
-        config: {},
-      } as any);
-
-      tool.inlineTools = new ToolsCollection([ ['inlineTool', inlineTool1], ['inlineTool2', inlineTool2] ]);
-
-      expect(tool.sanitizeConfig).to.be.deep.eq(Object.assign(
-        {},
-        inlineTool1.sanitizeConfig,
-        inlineTool2.sanitizeConfig
-      ));
-    });
-
-    it('should return empty object by default', () => {
-      const tool = new BlockToolAdapter({
-        ...options,
-        constructable: class {},
-      } as any);
-
-      expect(tool.sanitizeConfig).to.be.deep.eq({});
-    });
-  });
-
-  it('.isBlock() should return true', () => {
-    const tool = new BlockToolAdapter(options as any);
-
-    expect(tool.isBlock()).to.be.true;
-  });
-
-  it('.isInline() should return false', () => {
-    const tool = new BlockToolAdapter(options as any);
-
-    expect(tool.isInline()).to.be.false;
-  });
-
-  it('.isTune() should return false', () => {
-    const tool = new BlockToolAdapter(options as any);
-
-    expect(tool.isTune()).to.be.false;
-  });
-
-  it('.isReadOnlySupported should return correct value', () => {
-    const tool = new BlockToolAdapter(options as any);
-
-    expect(tool.isReadOnlySupported).to.be.eq(options.constructable.isReadOnlySupported);
-  });
-
-  it('.isLineBreaksEnabled should return correct value', () => {
-    const tool = new BlockToolAdapter(options as any);
-
-    expect(tool.isLineBreaksEnabled).to.be.eq(options.constructable.enableLineBreaks);
-  });
-
-  it('.conversionConfig should return correct value', () => {
-    const tool = new BlockToolAdapter(options as any);
-
-    expect(tool.conversionConfig).to.be.deep.eq(options.constructable.conversionConfig);
-  });
-
-  describe('.pasteConfig', () => {
-    it('should return correct value', () => {
-      const tool = new BlockToolAdapter(options as any);
-
-      expect(tool.pasteConfig).to.be.deep.eq(options.constructable.pasteConfig);
-    });
-
-    it('should return false if `false` value was provided', () => {
-      const optionsWithDisabledPaste = {
-        ...options,
-        constructable: class extends (options.constructable as any) {
-          public static pasteConfig = false;
-        },
-      };
-      const tool = new BlockToolAdapter(optionsWithDisabledPaste as any);
-
-      expect(tool.pasteConfig).to.be.deep.eq(optionsWithDisabledPaste.constructable.pasteConfig);
-    });
-
-    it('should return empty object if getter isn\'t provided', () => {
-      const optionsWithoutPasteConfig = {
-        ...options,
-        constructable: class extends (options.constructable as any) {
-          public static pasteConfig = undefined;
-        },
-      };
-      const tool = new BlockToolAdapter(optionsWithoutPasteConfig as any);
-
-      expect(tool.pasteConfig).to.be.deep.eq({});
-    });
-  });
-
-  context('.enabledInlineTools', () => {
-    it('should return correct value', () => {
-      const tool = new BlockToolAdapter(options as any);
-
-      expect(tool.enabledInlineTools).to.be.deep.eq(options.config.inlineToolbar);
-    });
-
-    it('should return false by default', () => {
-      const tool = new BlockToolAdapter({
-        ...options,
-        config: {
-          ...options.config,
-          inlineToolbar: undefined,
-        },
-      } as any);
-
-      expect(tool.enabledInlineTools).to.be.false;
-    });
-  });
-
-  it('.enabledBlockTunes should return correct value', () => {
-    const tool = new BlockToolAdapter(options as any);
-
-    expect(tool.enabledBlockTunes).to.be.deep.eq(options.config.tunes);
-  });
-
-  context('.prepare()', () => {
-    it('should call Tool prepare method', () => {
-      options.constructable.prepare = cy.stub();
-      const tool = new BlockToolAdapter(options as any);
-
-      tool.prepare();
-
-      expect(options.constructable.prepare).to.have.been.calledWithMatch({
-        toolName: tool.name,
-        config: tool.settings,
-      });
-    });
-
-    it('should not fail if Tool prepare method is not exist', () => {
-      const tool = new BlockToolAdapter({
-        ...options,
-        constructable: {},
-      } as any);
-
-      expect(tool.prepare).to.not.throw;
-    });
-  });
-
-  context('.reset()', () => {
-    it('should call Tool reset method', () => {
-      options.constructable.reset = cy.stub();
-      const tool = new BlockToolAdapter(options as any);
-
-      tool.reset();
-
-      expect(options.constructable.reset).to.be.calledOnce;
-    });
-
-    it('should not fail if Tool reset method is not exist', () => {
-      const tool = new BlockToolAdapter({
-        ...options,
-        constructable: {},
-      } as any);
-
-      expect(tool.reset).to.not.throw;
-    });
-  });
-
-  context('.shortcut', () => {
-    it('should return user provided shortcut', () => {
-      const tool = new BlockToolAdapter(options as any);
-
-      expect(tool.shortcut).to.be.eq(options.config.shortcut);
-    });
-
-    it('should return Tool provided shortcut if user one is not specified', () => {
-      const tool = new BlockToolAdapter({
-        ...options,
-        config: {
-          ...options.config,
-          shortcut: undefined,
-        },
-      } as any);
-
-      expect(tool.shortcut).to.be.eq(options.constructable.shortcut);
-    });
-  });
-
-  context('.toolbox', () => {
-    it('should return user provided toolbox config wrapped in array', () => {
-      const tool = new BlockToolAdapter(options as any);
-
-      expect(tool.toolbox).to.be.deep.eq([ options.config.toolbox ]);
-    });
-
-    it('should return Tool provided toolbox config wrapped in array if user one is not specified', () => {
-      const tool = new BlockToolAdapter({
-        ...options,
-        config: {
-          ...options.config,
-          toolbox: undefined,
-        },
-      } as any);
-
-      expect(tool.toolbox).to.be.deep.eq([ options.constructable.toolbox ]);
-    });
-
-    it('should merge Tool provided toolbox config and user one and wrap result in array in case both are objects', () => {
-      const tool1 = new BlockToolAdapter({
-        ...options,
-        config: {
-          ...options.config,
-          toolbox: {
-            title: options.config.toolbox.title,
-          },
-        },
-      } as any);
-      const tool2 = new BlockToolAdapter({
-        ...options,
-        config: {
-          ...options.config,
-          toolbox: {
-            icon: options.config.toolbox.icon,
-          },
-        },
-      } as any);
-
-      expect(tool1.toolbox).to.be.deep.eq([ Object.assign({}, options.constructable.toolbox, { title: options.config.toolbox.title }) ]);
-      expect(tool2.toolbox).to.be.deep.eq([ Object.assign({}, options.constructable.toolbox, { icon: options.config.toolbox.icon }) ]);
-    });
-
-    it('should replace Tool provided toolbox config with user defined config in case the first is an array and the second is an object', () => {
-      const toolboxEntries = [
-        {
-          title: 'Toolbox entry 1',
-        },
-        {
-          title: 'Toolbox entry 2',
-        },
-      ];
-      const userDefinedToolboxConfig = {
-        icon: options.config.toolbox.icon,
-        title: options.config.toolbox.title,
-      };
-      const tool = new BlockToolAdapter({
-        ...options,
-        constructable: {
-          ...options.constructable,
-          toolbox: toolboxEntries,
-        },
-        config: {
-          ...options.config,
-          toolbox: userDefinedToolboxConfig,
-        },
-      } as any);
-
-      expect(tool.toolbox).to.be.deep.eq([ userDefinedToolboxConfig ]);
-    });
-
-    it('should replace Tool provided toolbox config with user defined config in case the first is an object and the second is an array', () => {
-      const userDefinedToolboxConfig = [
-        {
-          title: 'Toolbox entry 1',
-        },
-        {
-          title: 'Toolbox entry 2',
-        },
-      ];
-      const tool = new BlockToolAdapter({
-        ...options,
-        config: {
-          ...options.config,
-          toolbox: userDefinedToolboxConfig,
-        },
-      } as any);
-
-      expect(tool.toolbox).to.be.deep.eq(userDefinedToolboxConfig);
-    });
-
-    it('should merge Tool provided toolbox config with user defined config in case both are arrays', () => {
-      const toolboxEntries = [
-        {
-          title: 'Toolbox entry 1',
-        },
-      ];
-
-      const userDefinedToolboxConfig = [
-        {
-          icon: 'Icon 1',
-        },
-        {
-          icon: 'Icon 2',
-          title: 'Toolbox entry 2',
-        },
-      ];
-
-      const tool = new BlockToolAdapter({
-        ...options,
-        constructable: {
-          ...options.constructable,
-          toolbox: toolboxEntries,
-        },
-        config: {
-          ...options.config,
-          toolbox: userDefinedToolboxConfig,
-        },
-      } as any);
-
-      const expected = userDefinedToolboxConfig.map((item, i) => {
-        const toolToolboxEntry = toolboxEntries[i];
-
-        if (toolToolboxEntry) {
-          return {
-            ...toolToolboxEntry,
-            ...item,
-          };
-        }
-
-        return item;
-      });
-
-      expect(tool.toolbox).to.be.deep.eq(expected);
-    });
-
-    it('should return undefined if user specifies false as a value', () => {
-      const tool = new BlockToolAdapter({
-        ...options,
-        config: {
-          ...options.config,
-          toolbox: false,
-        },
-      } as any);
-
-      expect(tool.toolbox).to.be.undefined;
-    });
-
-    it('should return undefined if Tool specifies false as a value', () => {
-      const tool = new BlockToolAdapter({
-        ...options,
-        constructable: class {
-          public static toolbox = false;
-        },
-      } as any);
-
-      expect(tool.toolbox).to.be.undefined;
-    });
-
-    it('should return undefined if Tool provides empty config', () => {
-      const tool = new BlockToolAdapter({
-        ...options,
-        constructable: class {
-          public static toolbox = {};
-        },
-      } as any);
-
-      expect(tool.toolbox).to.be.undefined;
-    });
-  });
-
-  context('.create()', () => {
-    const tool = new BlockToolAdapter(options as any);
-    const data = { text: 'text' };
-    const blockAPI = {
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      method(): void {},
-    };
-
-    it('should return Tool instance', () => {
-      expect(tool.create(data, blockAPI as any, false)).to.be.instanceOf(options.constructable);
-    });
-
-    it('should return Tool instance with passed data', () => {
-      const instance = tool.create(data, blockAPI as any, false) as any;
-
-      expect(instance.data).to.be.deep.eq(data);
-    });
-
-    it('should return Tool instance with passed BlockAPI object', () => {
-      const instance = tool.create(data, blockAPI as any, false) as any;
-
-      expect(instance.block).to.be.deep.eq(blockAPI);
-    });
-
-    it('should return Tool instance with passed readOnly flag', () => {
-      const instance1 = tool.create(data, blockAPI as any, false) as any;
-      const instance2 = tool.create(data, blockAPI as any, true) as any;
-
-      expect(instance1.readonly).to.be.eq(false);
-      expect(instance2.readonly).to.be.eq(true);
-    });
-
-    it('should return Tool instance with passed API object', () => {
-      const instance = tool.create(data, blockAPI as any, false) as any;
-
-      expect(instance.api).to.be.deep.eq(options.api);
-    });
-
-    it('should return Tool instance with passed config', () => {
-      const instance = tool.create(data, blockAPI as any, false) as any;
-
-      expect(instance.config).to.be.deep.eq(options.config.config);
-    });
-  });
-});
diff --git a/test/cypress/tests/tools/BlockTune.cy.ts b/test/cypress/tests/tools/BlockTune.cy.ts
deleted file mode 100644
index c0001b4a3..000000000
--- a/test/cypress/tests/tools/BlockTune.cy.ts
+++ /dev/null
@@ -1,173 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* tslint:disable:max-classes-per-file */
-import type { ToolSettings } from '@/types';
-import { ToolType } from '@/types/tools/adapters/tool-type';
-import BlockTuneAdapter from '../../../../src/components/tools/tune';
-import type { BlockTuneData } from '@/types/block-tunes/block-tune-data';
-
-describe('BlockTune', () => {
-  /**
-   * Mock for BlockTune constructor options
-   */
-  const options = {
-    name: 'blockTune',
-    constructable: class {
-      public static reset;
-      public static prepare;
-
-      public api: object;
-      public config: ToolSettings;
-      public data: BlockTuneData;
-      public block: object;
-
-      // eslint-disable-next-line jsdoc/require-jsdoc
-      constructor({ api, config, block, data }) {
-        this.api = api;
-        this.config = config;
-        this.block = block;
-        this.data = data;
-      }
-    },
-    config: {
-      config: {
-        option1: 'option1',
-        option2: 'option2',
-      },
-      shortcut: 'CMD+SHIFT+B',
-    },
-    api: {
-      prop1: 'prop1',
-      prop2: 'prop2',
-    },
-    isDefault: false,
-    isInternal: false,
-    defaultPlaceholder: 'Default placeholder',
-  };
-
-  it('.type should return ToolType.Tune', () => {
-    const tool = new BlockTuneAdapter(options as any);
-
-    expect(tool.type).to.be.eq(ToolType.Tune);
-  });
-
-  it('.name should return correct value', () => {
-    const tool = new BlockTuneAdapter(options as any);
-
-    expect(tool.name).to.be.eq(options.name);
-  });
-
-  it('.isInternal should return correct value', () => {
-    const tool1 = new BlockTuneAdapter(options as any);
-    const tool2 = new BlockTuneAdapter({
-      ...options,
-      isInternal: true,
-    } as any);
-
-    expect(tool1.isInternal).to.be.false;
-    expect(tool2.isInternal).to.be.true;
-  });
-
-  it('.settings should return correct value', () => {
-    const tool = new BlockTuneAdapter(options as any);
-
-    expect(tool.settings).to.be.deep.eq(options.config.config);
-  });
-
-  it('.isBlock() should return false', () => {
-    const tool = new BlockTuneAdapter(options as any);
-
-    expect(tool.isBlock()).to.be.false;
-  });
-
-  it('.isInline() should return false', () => {
-    const tool = new BlockTuneAdapter(options as any);
-
-    expect(tool.isInline()).to.be.false;
-  });
-
-  it('.isTune() should return true', () => {
-    const tool = new BlockTuneAdapter(options as any);
-
-    expect(tool.isTune()).to.be.true;
-  });
-
-  context('.prepare()', () => {
-    it('should call Tool prepare method', () => {
-      options.constructable.prepare = cy.stub();
-      const tool = new BlockTuneAdapter(options as any);
-
-      tool.prepare();
-
-      expect(options.constructable.prepare).to.have.been.calledWithMatch({
-        toolName: tool.name,
-        config: tool.settings,
-      });
-    });
-
-    it('should not fail if Tool prepare method is not exist', () => {
-      const tool = new BlockTuneAdapter({
-        ...options,
-        constructable: {},
-      } as any);
-
-      expect(tool.prepare).to.not.throw;
-    });
-  });
-
-  context('.reset()', () => {
-    it('should call Tool reset method', () => {
-      options.constructable.reset = cy.stub();
-      const tool = new BlockTuneAdapter(options as any);
-
-      tool.reset();
-
-      expect(options.constructable.reset).to.be.calledOnce;
-    });
-
-    it('should not fail if Tool reset method is not exist', () => {
-      const tool = new BlockTuneAdapter({
-        ...options,
-        constructable: {},
-      } as any);
-
-      expect(tool.reset).to.not.throw;
-    });
-  });
-
-  context('.create()', () => {
-    const tool = new BlockTuneAdapter(options as any);
-    const data = { text: 'text' };
-    const blockAPI = {
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      method(): void {},
-    };
-
-    it('should return Tool instance', () => {
-      expect(tool.create(data, blockAPI as any)).to.be.instanceOf(options.constructable);
-    });
-
-    it('should return Tool instance with passed data', () => {
-      const instance = tool.create(data, blockAPI as any) as any;
-
-      expect(instance.data).to.be.deep.eq(data);
-    });
-
-    it('should return Tool instance with passed BlockAPI object', () => {
-      const instance = tool.create(data, blockAPI as any) as any;
-
-      expect(instance.block).to.be.deep.eq(blockAPI);
-    });
-
-    it('should return Tool instance with passed API object', () => {
-      const instance = tool.create(data, blockAPI as any) as any;
-
-      expect(instance.api).to.be.deep.eq(options.api);
-    });
-
-    it('should return Tool instance with passed settings', () => {
-      const instance = tool.create(data, blockAPI as any) as any;
-
-      expect(instance.config).to.be.deep.eq(options.config.config);
-    });
-  });
-});
diff --git a/test/cypress/tests/tools/InlineTool.cy.ts b/test/cypress/tests/tools/InlineTool.cy.ts
deleted file mode 100644
index e220f2108..000000000
--- a/test/cypress/tests/tools/InlineTool.cy.ts
+++ /dev/null
@@ -1,213 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* tslint:disable:max-classes-per-file */
-import type { ToolSettings } from '@/types';
-import { ToolType } from '@/types/tools/adapters/tool-type';
-import InlineToolAdapter from '../../../../src/components/tools/inline';
-
-describe('InlineTool', () => {
-  /**
-   * Mock for InlineTool constructor options
-   */
-  const options = {
-    name: 'inlineTool',
-    constructable: class {
-      public static sanitize = {
-        rule1: 'rule1',
-      };
-
-      public static title = 'Title';
-
-      public static reset;
-      public static prepare;
-
-      public static shortcut = 'CTRL+N';
-      public static isReadOnlySupported = true;
-
-      public api: object;
-      public config: ToolSettings;
-
-      /**
-       * @param options - constructor options
-       * @param options.api - EditorAPI
-       * @param options.config - tool config
-       */
-      constructor({ api, config }) {
-        this.api = api;
-        this.config = config;
-      }
-    },
-    config: {
-      config: {
-        option1: 'option1',
-        option2: 'option2',
-      },
-      shortcut: 'CMD+SHIFT+B',
-    },
-    api: {
-      prop1: 'prop1',
-      prop2: 'prop2',
-    },
-    isDefault: false,
-    isInternal: false,
-    defaultPlaceholder: 'Default placeholder',
-  };
-
-  it('.type should return ToolType.Inline', () => {
-    const tool = new InlineToolAdapter(options as any);
-
-    expect(tool.type).to.be.eq(ToolType.Inline);
-  });
-
-  it('.name should return correct value', () => {
-    const tool = new InlineToolAdapter(options as any);
-
-    expect(tool.name).to.be.eq(options.name);
-  });
-
-  it('.title should return correct title', () => {
-    const tool = new InlineToolAdapter(options as any);
-
-    expect(tool.title).to.be.eq(options.constructable.title);
-  });
-
-  it('.isInternal should return correct value', () => {
-    const tool1 = new InlineToolAdapter(options as any);
-    const tool2 = new InlineToolAdapter({
-      ...options,
-      isInternal: true,
-    } as any);
-
-    expect(tool1.isInternal).to.be.false;
-    expect(tool2.isInternal).to.be.true;
-  });
-
-  it('.settings should return correct value', () => {
-    const tool = new InlineToolAdapter(options as any);
-
-    expect(tool.settings).to.be.deep.eq(options.config.config);
-  });
-
-  it('.sanitizeConfig should return correct value', () => {
-    const tool = new InlineToolAdapter(options as any);
-
-    expect(tool.sanitizeConfig).to.be.deep.eq(options.constructable.sanitize);
-  });
-
-  it('.isBlock() should return false', () => {
-    const tool = new InlineToolAdapter(options as any);
-
-    expect(tool.isBlock()).to.be.false;
-  });
-
-  it('.isInline() should return true', () => {
-    const tool = new InlineToolAdapter(options as any);
-
-    expect(tool.isInline()).to.be.true;
-  });
-
-  it('.isTune() should return false', () => {
-    const tool = new InlineToolAdapter(options as any);
-
-    expect(tool.isTune()).to.be.false;
-  });
-
-  context('.prepare()', () => {
-    it('should call Tool prepare method', () => {
-      options.constructable.prepare = cy.stub();
-      const tool = new InlineToolAdapter(options as any);
-
-      tool.prepare();
-
-      expect(options.constructable.prepare).to.have.been.calledWithMatch({
-        toolName: tool.name,
-        config: tool.settings,
-      });
-    });
-
-    it('should not fail if Tool prepare method is not exist', () => {
-      const tool = new InlineToolAdapter({
-        ...options,
-        constructable: {},
-      } as any);
-
-      expect(tool.prepare).to.not.throw;
-    });
-  });
-
-  context('.reset()', () => {
-    it('should call Tool reset method', () => {
-      options.constructable.reset = cy.stub();
-      const tool = new InlineToolAdapter(options as any);
-
-      tool.reset();
-
-      expect(options.constructable.reset).to.be.calledOnce;
-    });
-
-    it('should not fail if Tool reset method is not exist', () => {
-      const tool = new InlineToolAdapter({
-        ...options,
-        constructable: {},
-      } as any);
-
-      expect(tool.reset).to.not.throw;
-    });
-  });
-
-  context('.shortcut', () => {
-    it('should return user provided shortcut', () => {
-      const tool = new InlineToolAdapter(options as any);
-
-      expect(tool.shortcut).to.be.eq(options.config.shortcut);
-    });
-
-    it('should return Tool provided shortcut if user one is not specified', () => {
-      const tool = new InlineToolAdapter({
-        ...options,
-        config: {
-          ...options.config,
-          shortcut: undefined,
-        },
-      } as any);
-
-      expect(tool.shortcut).to.be.eq(options.constructable.shortcut);
-    });
-  });
-
-  context('.create()', () => {
-    const tool = new InlineToolAdapter(options as any);
-
-    it('should return Tool instance', () => {
-      expect(tool.create()).to.be.instanceOf(options.constructable);
-    });
-
-    it('should return Tool instance with passed API object', () => {
-      const instance = tool.create() as any;
-
-      expect(instance.api).to.be.deep.eq(options.api);
-    });
-
-    it('should return Tool instance with passed config', () => {
-      const instance = tool.create() as any;
-
-      expect(instance.config).to.be.deep.eq(options.config.config);
-    });
-  });
-
-  context('.isReadOnlySupported', () => {
-    it('should return Tool provided value', () => {
-      const tool = new InlineToolAdapter(options as any);
-
-      expect(tool.isReadOnlySupported).to.be.eq(options.constructable.isReadOnlySupported);
-    });
-
-    it('should return false if Tool provided value is not exist', () => {
-      const tool = new InlineToolAdapter({
-        ...options,
-        constructable: {},
-      } as any);
-
-      expect(tool.isReadOnlySupported).to.be.false;
-    });
-  });
-});
diff --git a/test/cypress/tests/tools/ToolsCollection.cy.ts b/test/cypress/tests/tools/ToolsCollection.cy.ts
deleted file mode 100644
index b6dcb37e4..000000000
--- a/test/cypress/tests/tools/ToolsCollection.cy.ts
+++ /dev/null
@@ -1,186 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import ToolsCollection from '../../../../src/components/tools/collection';
-import type BlockToolAdapter from '../../../../src/components/tools/block';
-import type InlineToolAdapter from '../../../../src/components/tools/inline';
-import type BlockTuneAdapter from '../../../../src/components/tools/tune';
-import type BaseToolAdapter from '../../../../src/components/tools/base';
-
-const FakeTool = {
-  isBlock(): boolean {
-    return false;
-  },
-  isInline(): boolean {
-    return false;
-  },
-  isTune(): boolean {
-    return false;
-  },
-  isInternal: false,
-};
-
-const FakeBlockTool = {
-  ...FakeTool,
-  isBlock(): boolean {
-    return true;
-  },
-};
-
-const FakeInlineTool = {
-  ...FakeTool,
-  isInline(): boolean {
-    return true;
-  },
-};
-
-const FakeBlockTune = {
-  ...FakeTool,
-  isTune(): boolean {
-    return true;
-  },
-};
-
-/**
- * Unit tests for ToolsCollection class
- */
-describe('ToolsCollection', (): void => {
-  let collection;
-
-  /**
-   * Mock for Tools in collection
-   */
-  const fakeTools = [
-    ['block1', FakeBlockTool],
-    ['inline1', FakeInlineTool],
-    ['block2', {
-      ...FakeBlockTool,
-      isInternal: true,
-    } ],
-    ['tune1', FakeBlockTune],
-    ['block3', FakeBlockTool],
-    ['inline2', {
-      ...FakeInlineTool,
-      isInternal: true,
-    } ],
-    ['tune2', FakeBlockTune],
-    ['tune3', {
-      ...FakeBlockTune,
-      isInternal: true,
-    } ],
-    ['block3', FakeInlineTool],
-    ['block4', FakeBlockTool],
-  ];
-
-  beforeEach((): void => {
-    collection = new ToolsCollection(fakeTools as any);
-  });
-
-  it('should be instance of Map', (): void => {
-    expect(collection instanceof Map).to.be.true;
-  });
-
-  context('.blockTools', (): void => {
-    it('should return new instance of ToolsCollection', (): void => {
-      expect(collection.blockTools instanceof ToolsCollection).to.be.true;
-    });
-
-    it('result should contain only block tools', (): void => {
-      expect(
-        Array
-          .from(
-            collection.blockTools.values()
-          )
-          .every((tool: BlockToolAdapter) => tool.isBlock())
-      ).to.be.true;
-    });
-  });
-
-  context('.inlineTools', (): void => {
-    it('should return new instance of ToolsCollection', (): void => {
-      expect(collection.inlineTools instanceof ToolsCollection).to.be.true;
-    });
-
-    it('result should contain only inline tools', (): void => {
-      expect(
-        Array
-          .from(
-            collection.inlineTools.values()
-          )
-          .every((tool: InlineToolAdapter) => tool.isInline())
-      ).to.be.true;
-    });
-  });
-
-  context('.blockTunes', (): void => {
-    it('should return new instance of ToolsCollection', (): void => {
-      expect(collection.blockTunes instanceof ToolsCollection).to.be.true;
-    });
-
-    it('result should contain only block tools', (): void => {
-      expect(
-        Array
-          .from(
-            collection.blockTunes.values()
-          )
-          .every((tool: BlockTuneAdapter) => tool.isTune())
-      ).to.be.true;
-    });
-  });
-
-  context('.internalTools', (): void => {
-    it('should return new instance of ToolsCollection', (): void => {
-      expect(collection.internalTools instanceof ToolsCollection).to.be.true;
-    });
-
-    it('result should contain only internal tools', (): void => {
-      expect(
-        Array
-          .from(
-            collection.internalTools.values()
-          )
-          .every((tool: BaseToolAdapter) => tool.isInternal)
-      ).to.be.true;
-    });
-  });
-
-  context('.externalTools', (): void => {
-    it('should return new instance of ToolsCollection', (): void => {
-      expect(collection.externalTools instanceof ToolsCollection).to.be.true;
-    });
-
-    it('result should contain only external tools', (): void => {
-      expect(
-        Array
-          .from(
-            collection.externalTools.values()
-          )
-          .every((tool: BaseToolAdapter) => !tool.isInternal)
-      ).to.be.true;
-    });
-  });
-
-  context('mixed access', (): void => {
-    context('.blockTunes.internalTools', (): void => {
-      it('should return only internal tunes', (): void => {
-        expect(
-          Array
-            .from(
-              collection.blockTunes.internalTools.values()
-            )
-            .every((tool: BlockTuneAdapter) => tool.isTune() && tool.isInternal)
-        ).to.be.true;
-      });
-    });
-
-    context('.externalTools.blockTools', (): void => {
-      it('should return only external block tools', (): void => {
-        expect(
-          Array
-            .from(
-              collection.externalTools.blockTools.values()
-            )
-            .every((tool: BlockToolAdapter) => tool.isBlock() && !tool.isInternal)
-        ).to.be.true;
-      });
-    });
-  });
-});
diff --git a/test/cypress/tests/tools/ToolsFactory.cy.ts b/test/cypress/tests/tools/ToolsFactory.cy.ts
deleted file mode 100644
index 6bb5aed98..000000000
--- a/test/cypress/tests/tools/ToolsFactory.cy.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import LinkInlineTool from '../../../../src/components/inline-tools/inline-tool-link';
-import MoveUpTune from '../../../../src/components/block-tunes/block-tune-move-up';
-import ToolsFactory from '../../../../src/components/tools/factory';
-import InlineToolAdapter from '../../../../src/components/tools/inline';
-import BlockToolAdapter from '../../../../src/components/tools/block';
-import BlockTuneAdapter from '../../../../src/components/tools/tune';
-import Paragraph from '@editorjs/paragraph';
-
-describe('ToolsFactory', (): void => {
-  let factory;
-  const config = {
-    paragraph: {
-      class: Paragraph,
-    },
-    link: {
-      class: LinkInlineTool,
-    },
-    moveUp: {
-      class: MoveUpTune,
-    },
-  };
-
-  beforeEach((): void => {
-    factory = new ToolsFactory(
-      config,
-      {
-        placeholder: 'Placeholder',
-        defaultBlock: 'paragraph',
-      } as any,
-      {
-        getMethodsForTool(): object {
-          return {
-            prop1: 'prop1',
-            prop2: 'prop2',
-          };
-        },
-      } as any
-    );
-  });
-
-  context('.get', (): void => {
-    it('should return appropriate tool object', (): void => {
-      const tool = factory.get('link');
-
-      expect(tool.name).to.be.eq('link');
-    });
-
-    it('should return InlineTool object for inline tool', (): void => {
-      const tool = factory.get('link');
-
-      expect(tool instanceof InlineToolAdapter).to.be.true;
-    });
-
-    it('should return BlockTool object for block tool', (): void => {
-      const tool = factory.get('paragraph');
-
-      expect(tool instanceof BlockToolAdapter).to.be.true;
-    });
-
-    it('should return BlockTune object for tune', (): void => {
-      const tool = factory.get('moveUp');
-
-      expect(tool instanceof BlockTuneAdapter).to.be.true;
-    });
-  });
-});
diff --git a/test/cypress/tests/ui/BlockTunes.cy.ts b/test/cypress/tests/ui/BlockTunes.cy.ts
deleted file mode 100644
index 43d7e0e5f..000000000
--- a/test/cypress/tests/ui/BlockTunes.cy.ts
+++ /dev/null
@@ -1,477 +0,0 @@
-import { selectionChangeDebounceTimeout } from '../../../../src/components/constants';
-import Header from '@editorjs/header';
-import type { ConversionConfig, ToolboxConfig } from '../../../../types';
-import type { MenuConfig } from '../../../../types/tools';
-import { ToolWithoutConversionExport } from '../../fixtures/tools/ToolWithoutConversionExport';
-
-describe('BlockTunes', function () {
-  describe('Search', () => {
-    it('should be focused after popover opened', () => {
-      cy.createEditor({
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'Some text',
-              },
-            },
-          ],
-        },
-      });
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .click()
-        .type('{cmd}/')
-        .wait(selectionChangeDebounceTimeout);
-
-      /**
-       * Caret is set to the search input
-       */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-
-          expect(selection.rangeCount).to.be.equal(1);
-
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('[data-cy="block-tunes"] .cdx-search-field')
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-            });
-        });
-    });
-  });
-
-  describe('Keyboard only', function () {
-    it('should not delete the currently selected block when Enter pressed on a search input (or any block tune)', function () {
-      const ENTER_KEY_CODE = 13;
-
-      cy.createEditor({
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'Some text',
-              },
-            },
-          ],
-        },
-      });
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .click()
-        .type('{cmd}/')
-        .wait(selectionChangeDebounceTimeout)
-        .keydown(ENTER_KEY_CODE);
-
-      /**
-       * Block should have same text
-       */
-      cy.get('[data-cy="block-wrapper"')
-        .should('have.text', 'Some text');
-    });
-
-    it('should not unselect currently selected block when Enter pressed on a block tune', function () {
-      const ENTER_KEY_CODE = 13;
-
-      cy.createEditor({
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'Some text',
-              },
-            },
-          ],
-        },
-      });
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .click()
-        .type('{cmd}/')
-        .wait(selectionChangeDebounceTimeout)
-        .keydown(ENTER_KEY_CODE);
-
-      /**
-       * Block should not be selected
-       */
-      cy.get('[data-cy="block-wrapper"')
-        .first()
-        .should('have.class', 'ce-block--selected');
-    });
-  });
-
-  describe('Convert to', () => {
-    it('should display Convert to inside Block Tunes', () => {
-      cy.createEditor({
-        tools: {
-          header: Header,
-        },
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'Some text',
-              },
-            },
-          ],
-        },
-      });
-
-      /** Open block tunes menu */
-      cy.get('[data-cy=editorjs]')
-        .get('.cdx-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-toolbar__settings-btn')
-        .click();
-
-      /** Check "Convert to" option is present  */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover-item')
-        .contains('Convert to')
-        .should('exist');
-
-      /** Click "Convert to" option*/
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover-item')
-        .contains('Convert to')
-        .click();
-
-      /** Check nected popover with "Heading" option is present */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover--nested [data-item-name=header]')
-        .should('exist');
-    });
-
-    it('should not display Convert to inside Block Tunes if there is nothing to convert to', () => {
-      /** Editor instance with single default tool */
-      cy.createEditor({
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'Some text',
-              },
-            },
-          ],
-        },
-      });
-
-      /** Open block tunes menu */
-      cy.get('[data-cy=editorjs]')
-        .get('.cdx-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-toolbar__settings-btn')
-        .click();
-
-      /** Check "Convert to" option is not present  */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover-item')
-        .contains('Convert to')
-        .should('not.exist');
-    });
-
-    it('should not display the ConvertTo control if block has no conversionConfig.export specified', () => {
-      cy.createEditor({
-        tools: {
-          testTool: ToolWithoutConversionExport,
-        },
-        data: {
-          blocks: [
-            {
-              type: 'testTool',
-              data: {
-                text: 'Some text',
-              },
-            },
-          ],
-        },
-      }).as('editorInstance');
-
-      cy.get('@editorInstance')
-        .get('[data-cy=editorjs]')
-        .find('.ce-block')
-        .click();
-
-      cy.get('@editorInstance')
-        .get('[data-cy=editorjs]')
-        .find('.ce-toolbar__settings-btn')
-        .click();
-
-      cy.get('@editorInstance')
-        .get('[data-cy=editorjs]')
-        .find('.ce-popover-item[data-item-name=convert-to]')
-        .should('not.exist');
-    });
-
-    it('should not display tool with the same data in "Convert to" menu', () => {
-      /**
-       * Tool with several toolbox entries configured
-       */
-      class TestTool {
-        /**
-         * Tool is convertable
-         */
-        public static get conversionConfig(): ConversionConfig {
-          return {
-            import: 'text',
-            export: 'text',
-          };
-        }
-
-        /**
-         * TestTool contains several toolbox options
-         */
-        public static get toolbox(): ToolboxConfig {
-          return [
-            {
-              title: 'Title 1',
-              icon: 'Icon1',
-              data: {
-                level: 1,
-              },
-            },
-            {
-              title: 'Title 2',
-              icon: 'Icon2',
-              data: {
-                level: 2,
-              },
-            },
-          ];
-        }
-
-        /**
-         * Tool can render itself
-         */
-        public render(): HTMLDivElement {
-          const div = document.createElement('div');
-
-          div.innerText = 'Some text';
-
-          return div;
-        }
-
-        /**
-         * Tool can save it's data
-         */
-        public save(): { text: string; level: number } {
-          return {
-            text: 'Some text',
-            level: 1,
-          };
-        }
-      }
-
-      /** Editor instance with TestTool installed and one block of TestTool type */
-      cy.createEditor({
-        tools: {
-          testTool: TestTool,
-        },
-        data: {
-          blocks: [
-            {
-              type: 'testTool',
-              data: {
-                text: 'Some text',
-                level: 1,
-              },
-            },
-          ],
-        },
-      });
-
-      /** Open block tunes menu */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-toolbar__settings-btn')
-        .click();
-
-      /** Open "Convert to" menu  */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover-item')
-        .contains('Convert to')
-        .click();
-
-      /** Check TestTool option with SAME data is NOT present */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover--nested [data-item-name=testTool]')
-        .contains('Title 1')
-        .should('not.exist');
-
-      /** Check TestTool option with DIFFERENT data IS present */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover--nested [data-item-name=testTool]')
-        .contains('Title 2')
-        .should('exist');
-    });
-
-    it('should convert block to another type and set caret to the new block', () => {
-      cy.createEditor({
-        tools: {
-          header: Header,
-        },
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'Some text',
-              },
-            },
-          ],
-        },
-      });
-
-      /** Open block tunes menu */
-      cy.get('[data-cy=editorjs]')
-        .get('.cdx-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-toolbar__settings-btn')
-        .click();
-
-      /** Click "Convert to" option*/
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover-item')
-        .contains('Convert to')
-        .click();
-
-      /** Click "Heading" option */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover--nested [data-item-name=header]')
-        .click();
-
-      /** Check the block was converted to the second option */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-header')
-        .should('have.text', 'Some text');
-
-      /** Check that caret set to the end of the new block */
-      cy.window()
-        .then((window) => {
-          const selection = window.getSelection();
-          const range = selection.getRangeAt(0);
-
-          cy.get('[data-cy=editorjs]')
-            .find('.ce-header')
-            .should(($block) => {
-              expect($block[0].contains(range.startContainer)).to.be.true;
-            });
-        });
-    });
-  });
-
-  describe('Tunes order', () => {
-    it('should display block specific tunes before common tunes', () => {
-      /**
-       * Tool with several toolbox entries configured
-       */
-      class TestTool {
-        /**
-         * TestTool contains several toolbox options
-         */
-        public static get toolbox(): ToolboxConfig {
-          return [
-            {
-              title: 'Title 1',
-              icon: 'Icon1',
-              data: {
-                level: 1,
-              },
-            },
-          ];
-        }
-
-        /**
-         * Tool can render itself
-         */
-        public render(): HTMLDivElement {
-          const div = document.createElement('div');
-
-          div.innerText = 'Some text';
-
-          return div;
-        }
-
-        /**
-         *
-         */
-        public renderSettings(): MenuConfig {
-          return {
-            icon: 'Icon',
-            title: 'Tune',
-            // eslint-disable-next-line @typescript-eslint/no-empty-function
-            onActivate: () => {},
-          };
-        }
-
-        /**
-         * Tool can save it's data
-         */
-        public save(): { text: string; level: number } {
-          return {
-            text: 'Some text',
-            level: 1,
-          };
-        }
-      }
-
-      /** Editor instance with TestTool installed and one block of TestTool type */
-      cy.createEditor({
-        tools: {
-          testTool: TestTool,
-        },
-        data: {
-          blocks: [
-            {
-              type: 'testTool',
-              data: {
-                text: 'Some text',
-                level: 1,
-              },
-            },
-          ],
-        },
-      });
-
-      /** Open block tunes menu */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-block')
-        .click();
-
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-toolbar__settings-btn')
-        .click();
-
-      /** Check there are more than 1 tune */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover-item')
-        .should('have.length.above', 1);
-
-      /** Check the first tune is tool specific tune */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover-item:first-child')
-        .contains('Tune')
-        .should('exist');
-    });
-  });
-});
diff --git a/test/cypress/tests/ui/DataEmpty.cy.ts b/test/cypress/tests/ui/DataEmpty.cy.ts
deleted file mode 100644
index 51ab5614f..000000000
--- a/test/cypress/tests/ui/DataEmpty.cy.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-import { createEditorWithTextBlocks } from '../../support/utils/createEditorWithTextBlocks';
-
-describe('inputs [data-empty] mark', function () {
-  it('should be added to inputs of editor on initialization', function () {
-    createEditorWithTextBlocks([
-      'First', // not empty block
-      '', // empty block
-    ]);
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .first()
-      .should('have.attr', 'data-empty', 'false');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .should('have.attr', 'data-empty', 'true');
-  });
-
-  it('should be added as "false" to the input on typing', function () {
-    createEditorWithTextBlocks([
-      'First', // not empty block
-      '', // empty block
-    ]);
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .type('Some text');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .should('have.attr', 'data-empty', 'false');
-  });
-
-  it('should be added as "true" to the input on chars removal', function () {
-    createEditorWithTextBlocks([
-      '', // empty block
-      'Some text', // not empty block
-    ]);
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .type('{selectall}{backspace}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .should('have.attr', 'data-empty', 'true');
-  });
-
-  it('should be added to the new block inputs', function () {
-    createEditorWithTextBlocks([
-      'First', // not empty block
-      '', // empty block
-    ]);
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .type('{enter}');
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .last()
-      .should('have.attr', 'data-empty', 'true');
-  });
-});
diff --git a/test/cypress/tests/ui/InlineToolbar.cy.ts b/test/cypress/tests/ui/InlineToolbar.cy.ts
deleted file mode 100644
index 5c337b196..000000000
--- a/test/cypress/tests/ui/InlineToolbar.cy.ts
+++ /dev/null
@@ -1,231 +0,0 @@
-import Header from '@editorjs/header';
-import type { InlineTool, MenuConfig } from '../../../../types/tools';
-import { createEditorWithTextBlocks } from '../../support/utils/createEditorWithTextBlocks';
-
-describe('Inline Toolbar', () => {
-  describe('Separators', () => {
-    it('should have a separator after the first item if it has children', () => {
-      cy.createEditor({
-        tools: {
-          header: {
-            class: Header,
-          },
-        },
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'First block text',
-              },
-            },
-          ],
-        },
-      });
-
-      /** Open Inline Toolbar */
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .selectText('block');
-
-      /** Check that first item (which is convert-to and has children) has a separator after it */
-      cy.get('[data-cy=editorjs]')
-        .get('[data-cy=inline-toolbar] .ce-popover__items')
-        .children()
-        .first()
-        .should('have.attr', 'data-item-name', 'convert-to');
-
-      cy.get('[data-cy=editorjs]')
-        .get('[data-cy=inline-toolbar] .ce-popover__items')
-        .children()
-        .eq(1)
-        .should('have.class', 'ce-popover-item-separator');
-    });
-
-    it('should have separators from both sides of item if it is in the middle and has children', () => {
-      cy.createEditor({
-        tools: {
-          header: {
-            class: Header,
-            inlineToolbar: ['bold', 'testTool', 'link'],
-
-          },
-          testTool: {
-            class: class {
-              public static isInline = true;
-              // eslint-disable-next-line jsdoc/require-jsdoc
-              public render(): MenuConfig {
-                return {
-                  icon: 'n',
-                  title: 'Test Tool',
-                  name: 'test-tool',
-                  children: {
-                    items: [
-                      {
-                        icon: 'm',
-                        title: 'Test Tool Item',
-                        // eslint-disable-next-line  @typescript-eslint/no-empty-function
-                        onActivate: () => {},
-                      },
-                    ],
-                  },
-                };
-              }
-            },
-          },
-        },
-        data: {
-          blocks: [
-            {
-              type: 'header',
-              data: {
-                text: 'First block text',
-              },
-            },
-          ],
-        },
-      });
-
-      /** Open Inline Toolbar */
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-header')
-        .selectText('block');
-
-      /** Check that item with children is surrounded by separators */
-      cy.get('[data-cy=editorjs]')
-        .get('[data-cy=inline-toolbar] .ce-popover__items')
-        .children()
-        .eq(3)
-        .should('have.class', 'ce-popover-item-separator');
-
-      cy.get('[data-cy=editorjs]')
-        .get('[data-cy=inline-toolbar] .ce-popover__items')
-        .children()
-        .eq(4)
-        .should('have.attr', 'data-item-name', 'test-tool');
-
-      cy.get('[data-cy=editorjs]')
-        .get('[data-cy=inline-toolbar] .ce-popover__items')
-        .children()
-        .eq(5)
-        .should('have.class', 'ce-popover-item-separator');
-    });
-
-    it('should have separator before the item with children if it is the last of all items', () => {
-      cy.createEditor({
-        tools: {
-          header: {
-            class: Header,
-            inlineToolbar: ['bold', 'testTool'],
-
-          },
-          testTool: {
-            class: class {
-              public static isInline = true;
-              // eslint-disable-next-line jsdoc/require-jsdoc
-              public render(): MenuConfig {
-                return {
-                  icon: 'n',
-                  title: 'Test Tool',
-                  name: 'test-tool',
-                  children: {
-                    items: [
-                      {
-                        icon: 'm',
-                        title: 'Test Tool Item',
-                        // eslint-disable-next-line  @typescript-eslint/no-empty-function
-                        onActivate: () => {},
-                      },
-                    ],
-                  },
-                };
-              }
-            },
-          },
-        },
-        data: {
-          blocks: [
-            {
-              type: 'header',
-              data: {
-                text: 'First block text',
-              },
-            },
-          ],
-        },
-      });
-
-      /** Open Inline Toolbar */
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-header')
-        .selectText('block');
-
-      /** Check that item with children is surrounded by separators */
-      cy.get('[data-cy=editorjs]')
-        .get('[data-cy=inline-toolbar] .ce-popover__items')
-        .children()
-        .eq(3)
-        .should('have.class', 'ce-popover-item-separator');
-
-      cy.get('[data-cy=editorjs]')
-        .get('[data-cy=inline-toolbar] .ce-popover__items')
-        .children()
-        .eq(4)
-        .should('have.attr', 'data-item-name', 'test-tool');
-    });
-  });
-
-  describe('Shortcuts', () => {
-    it('should work in read-only mode', () => {
-      const toolSurround = cy.stub().as('toolSurround');
-
-      /* eslint-disable jsdoc/require-jsdoc */
-      class Marker implements InlineTool {
-        public static isInline = true;
-        public static shortcut = 'CMD+SHIFT+M';
-        public static isReadOnlySupported = true;
-        public render(): MenuConfig {
-          return {
-            icon: 'm',
-            title: 'Marker',
-            onActivate: () => {
-              toolSurround();
-            },
-          };
-        }
-      }
-      /* eslint-enable jsdoc/require-jsdoc */
-
-      createEditorWithTextBlocks([
-        'some text',
-      ], {
-        tools: {
-          marker: Marker,
-        },
-        readOnly: true,
-      });
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .selectText('text');
-
-      cy.wait(300);
-
-      cy.document().then((doc) => {
-        doc.dispatchEvent(new KeyboardEvent('keydown', {
-          bubbles: true,
-          cancelable: true,
-          key: 'M',
-          code: 'KeyM',
-          keyCode: 77,
-          which: 77,
-          metaKey: true,
-          shiftKey: true,
-        }));
-      });
-
-      cy.get('@toolSurround').should('have.been.called');
-    });
-  });
-});
-
diff --git a/test/cypress/tests/ui/Placeholders.cy.ts b/test/cypress/tests/ui/Placeholders.cy.ts
deleted file mode 100644
index d4a7ce968..000000000
--- a/test/cypress/tests/ui/Placeholders.cy.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-/**
- * Text will be passed as a placeholder to the editor
- */
-const PLACEHOLDER_TEXT = 'Write something or press / to select a tool';
-
-describe('Placeholders', function () {
-  /**
-   * There is no ability to get pseudo elements content in Firefox
-   * It will return CSS-bases value (attr(data-placeholder) instead of DOM-based
-   */
-  if (Cypress.browser.family === 'firefox') {
-    return;
-  }
-
-  it('should be shown near first block if passed via editor config', function () {
-    cy.createEditor({
-      placeholder: PLACEHOLDER_TEXT,
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .getPseudoElementContent('::before')
-      .should('eq', PLACEHOLDER_TEXT);
-  });
-
-  it('should be shown when editor is autofocusable', function () {
-    cy.createEditor({
-      placeholder: PLACEHOLDER_TEXT,
-      autofocus: true,
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .getPseudoElementContent('::before')
-      .should('eq', PLACEHOLDER_TEXT);
-  });
-
-  it('should be shown event if input is focused', function () {
-    cy.createEditor({
-      placeholder: PLACEHOLDER_TEXT,
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .click()
-      .as('firstBlock')
-      .getPseudoElementContent('::before')
-      .should('eq', PLACEHOLDER_TEXT);
-  });
-
-  it('should be shown event when user removes all text by cmd+a and delete', function () {
-    cy.createEditor({
-      placeholder: PLACEHOLDER_TEXT,
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .type('aaa')
-      .type('{selectall}{backspace}')
-      .getPseudoElementContent('::before')
-      .should('eq', PLACEHOLDER_TEXT);
-  });
-
-  it('should be hidden when user starts typing', function () {
-    cy.createEditor({
-      placeholder: PLACEHOLDER_TEXT,
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .as('firstBlock')
-      .getPseudoElementContent('::before')
-      .should('eq', PLACEHOLDER_TEXT);
-
-    cy.get('@firstBlock')
-      .type('a')
-      .getPseudoElementContent('::before')
-      .should('eq', 'none');
-  });
-
-  it('should be hidden when user adds trailing whitespace characters', function () {
-    cy.createEditor({
-      placeholder: PLACEHOLDER_TEXT,
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .find('.ce-paragraph')
-      .as('firstBlock')
-      .getPseudoElementContent('::before')
-      .should('eq', PLACEHOLDER_TEXT);
-
-    cy.get('@firstBlock')
-      .type('   ')
-      .getPseudoElementContent('::before')
-      .should('eq', 'none');
-  });
-});
diff --git a/test/cypress/tests/ui/toolbox.cy.ts b/test/cypress/tests/ui/toolbox.cy.ts
deleted file mode 100644
index 127b50907..000000000
--- a/test/cypress/tests/ui/toolbox.cy.ts
+++ /dev/null
@@ -1,218 +0,0 @@
-import type EditorJS from '../../../../types/index';
-import type { ConversionConfig, ToolboxConfig } from '../../../../types/index';
-import ToolMock from '../../fixtures/tools/ToolMock';
-
-describe('Toolbox', function () {
-  describe('Shortcuts', function () {
-    it('should convert current Block to the Shortcuts\'s Block if both tools provides a "conversionConfig". Caret should be restored after conversion.', function () {
-      /**
-       * Mock of Tool with conversionConfig
-       */
-      class ConvertableTool extends ToolMock {
-        /**
-         * Specify how to import string data to this Tool
-         */
-        public static get conversionConfig(): ConversionConfig {
-          return {
-            import: 'text',
-          };
-        }
-
-        /**
-         * Specify how to display Tool in a Toolbox
-         */
-        public static get toolbox(): ToolboxConfig {
-          return {
-            icon: '',
-            title: 'Convertable tool',
-          };
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          convertableTool: {
-            class: ConvertableTool,
-            shortcut: 'CMD+SHIFT+H',
-          },
-        },
-      }).as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .click()
-        .type('Some text')
-        .type('{cmd}{shift}H'); // call a shortcut
-
-      /**
-       * Check that block was converted
-       */
-      cy.get<EditorJS>('@editorInstance')
-        .then(async (editor) => {
-          const { blocks } = await editor.save();
-
-          expect(blocks.length).to.eq(1);
-          expect(blocks[0].type).to.eq('convertableTool');
-          expect(blocks[0].data.text).to.eq('Some text');
-
-          /**
-           * Check that caret belongs to the new block after conversion
-           */
-          cy.window()
-            .then((window) => {
-              const selection = window.getSelection();
-              const range = selection.getRangeAt(0);
-
-              cy.get('[data-cy=editorjs]')
-                .find(`.ce-block[data-id=${blocks[0].id}]`)
-                .should(($block) => {
-                  expect($block[0].contains(range.startContainer)).to.be.true;
-                });
-            });
-        });
-    });
-
-    it('should insert a Shortcuts\'s Block below the current if some (original or target) tool does not provide a "conversionConfig" ', function () {
-      /**
-       * Mock of Tool with conversionConfig
-       */
-      class ToolWithoutConversionConfig extends ToolMock {
-        /**
-         * Specify how to display Tool in a Toolbox
-         */
-        public static get toolbox(): ToolboxConfig {
-          return {
-            icon: '',
-            title: 'Convertable tool',
-          };
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          nonConvertableTool: {
-            class: ToolWithoutConversionConfig,
-            shortcut: 'CMD+SHIFT+H',
-          },
-        },
-      }).as('editorInstance');
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .click()
-        .type('Some text')
-        .type('{cmd}{shift}H'); // call a shortcut
-
-      /**
-       * Check that the new block was appended
-       */
-      cy.get<EditorJS>('@editorInstance')
-        .then(async (editor) => {
-          const { blocks } = await editor.save();
-
-          expect(blocks.length).to.eq(2);
-          expect(blocks[1].type).to.eq('nonConvertableTool');
-        });
-    });
-
-    it('should display shortcut only for the first toolbox item if tool exports toolbox with several items', function () {
-      /**
-       * Mock of Tool with conversionConfig
-       */
-      class ToolWithSeveralToolboxItems extends ToolMock {
-        /**
-         * Specify toolbox with several items related to one tool
-         */
-        public static get toolbox(): ToolboxConfig {
-          return [
-            {
-              icon: '',
-              title: 'first tool',
-            },
-            {
-              icon: '',
-              title: 'second tool',
-            },
-          ];
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          severalToolboxItemsTool: {
-            class: ToolWithSeveralToolboxItems,
-            shortcut: 'CMD+SHIFT+L',
-          },
-        },
-      });
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .click()
-        .type('Some text')
-        .type('/'); // call a shortcut for toolbox
-
-      /**
-       * Secondary title (shortcut) should exist for first toolbox item of the tool
-       */
-      /* eslint-disable-next-line cypress/require-data-selectors */
-      cy.get('.ce-popover')
-        .find('.ce-popover-item[data-item-name="severalToolboxItemsTool"]')
-        .first()
-        .find('.ce-popover-item__secondary-title')
-        .should('exist');
-
-      /**
-       * Secondary title (shortcut) should not exist for second toolbox item of the same tool
-       */
-      /* eslint-disable-next-line cypress/require-data-selectors */
-      cy.get('.ce-popover')
-        .find('.ce-popover-item[data-item-name="severalToolboxItemsTool"]')
-        .eq(1)
-        .find('.ce-popover-item__secondary-title')
-        .should('not.exist');
-    });
-
-    it('should display shortcut for the item if tool exports toolbox as an one item object', function () {
-      /**
-       * Mock of Tool with conversionConfig
-       */
-      class ToolWithOneToolboxItems extends ToolMock {
-        /**
-         * Specify toolbox with several items related to one tool
-         */
-        public static get toolbox(): ToolboxConfig {
-          return {
-            icon: '',
-            title: 'tool',
-          };
-        }
-      }
-
-      cy.createEditor({
-        tools: {
-          oneToolboxItemTool: {
-            class: ToolWithOneToolboxItems,
-            shortcut: 'CMD+SHIFT+L',
-          },
-        },
-      });
-
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .click()
-        .type('Some text')
-        .type('/'); // call a shortcut for toolbox
-
-      /**
-       * Secondary title (shortcut) should exist for toolbox item of the tool
-       */
-      /* eslint-disable-next-line cypress/require-data-selectors */
-      cy.get('.ce-popover')
-        .find('.ce-popover-item[data-item-name="oneToolboxItemTool"]')
-        .first()
-        .find('.ce-popover-item__secondary-title')
-        .should('exist');
-    });
-  });
-});
diff --git a/test/cypress/tests/utils.cy.ts b/test/cypress/tests/utils.cy.ts
deleted file mode 100644
index 8d5e5ef67..000000000
--- a/test/cypress/tests/utils.cy.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-function */
-import { isFunction } from '../../../src/components/utils';
-
-/**
- * Example of typical synchronous function
- */
-function syncFunction(): void {}
-
-/**
- * Example of typical asynchronous function
- */
-async function asyncFunction(): Promise<void> {}
-
-const syncArrowFunction = (): void => {};
-
-const asyncArrowFunction = async (): Promise<void> => {};
-
-describe('isFunction function', () => {
-  it('should recognize sync functions', () => {
-    /**
-     * Act
-     */
-    const commonFunctionResult = isFunction(syncFunction);
-    const arrowFunctionResult = isFunction(syncArrowFunction);
-
-    /**
-     * Assert
-     */
-    expect(commonFunctionResult).to.eq(true);
-    expect(arrowFunctionResult).to.eq(true);
-  });
-
-  it('should recognize async functions', () => {
-    /**
-     * Act
-     */
-    const commonFunctionResult = isFunction(asyncFunction);
-    const arrowFunctionResult = isFunction(asyncArrowFunction);
-
-    /**
-     * Assert
-     */
-    expect(commonFunctionResult).to.eq(true);
-    expect(arrowFunctionResult).to.eq(true);
-  });
-
-  it('should return false if it isn\'t a function', () => {
-    /**
-     * Arrange
-     */
-    const obj = {};
-    const num = 123;
-    const str = '123';
-
-    /**
-     * Act
-     */
-    const objResult = isFunction(obj);
-    const numResult = isFunction(num);
-    const strResult = isFunction(str);
-
-    /**
-     * Assert
-     */
-    expect(objResult).to.eq(false);
-    expect(numResult).to.eq(false);
-    expect(strResult).to.eq(false);
-  });
-});
diff --git a/test/cypress/tests/utils/flipper.cy.ts b/test/cypress/tests/utils/flipper.cy.ts
deleted file mode 100644
index 1fad530d6..000000000
--- a/test/cypress/tests/utils/flipper.cy.ts
+++ /dev/null
@@ -1,140 +0,0 @@
-import type { PopoverItemParams } from '../../../../types/index.js';
-
-/**
- * Mock of some Block Tool
- */
-class SomePlugin {
-  /**
-   * Event handler to be spied in test
-   */
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  public static pluginInternalKeydownHandler(): void {}
-
-  /**
-   * Mocked render method
-   */
-  public render(): HTMLElement {
-    const wrapper = document.createElement('div');
-
-    wrapper.classList.add('cdx-some-plugin');
-    wrapper.contentEditable = 'true';
-    wrapper.addEventListener('keydown', SomePlugin.pluginInternalKeydownHandler);
-
-    return wrapper;
-  }
-
-  /**
-   * Used to display our tool in the Toolbox
-   */
-  public static get toolbox(): PopoverItemParams {
-    return {
-      icon: '₷',
-      title: 'Some tool',
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      onActivate: (): void => {},
-    };
-  }
-
-  /**
-   * Extracts data from the plugin's UI
-   */
-  public save(): {data: string} {
-    return {
-      data: '123',
-    };
-  }
-}
-
-describe('Flipper', () => {
-  const ARROW_DOWN_KEY_CODE = 40;
-  const ENTER_KEY_CODE = 13;
-
-  it('should prevent plugins event handlers from being called while keyboard navigation', () => {
-    const sampleText = 'sample text';
-
-    cy.createEditor({
-      tools: {
-        sometool: SomePlugin,
-      },
-      data: {
-        blocks: [
-          {
-            type: 'sometool',
-            data: {
-            },
-          },
-        ],
-      },
-    });
-
-    cy.spy(SomePlugin, 'pluginInternalKeydownHandler');
-
-    cy.get('[data-cy=editorjs]')
-      .get('.cdx-some-plugin')
-      .as('pluginInput')
-      .focus()
-      .type(sampleText)
-      .wait(100);
-
-    // Try to delete the block via keyboard
-    cy.get('[data-cy=editorjs]')
-      .get('.cdx-some-plugin')
-      // Open tunes menu
-      .trigger('keydown', { code: 'Slash',
-        ctrlKey: true })
-      // Navigate to delete button (the second button)
-      .trigger('keydown', { keyCode: ARROW_DOWN_KEY_CODE })
-      .trigger('keydown', { keyCode: ARROW_DOWN_KEY_CODE });
-
-    /**
-     * Check whether we focus the Delete Tune or not
-     */
-    cy.get('[data-item-name="delete"]')
-      .should('have.class', 'ce-popover-item--focused');
-
-    cy.get('[data-cy=editorjs]')
-      .get('.cdx-some-plugin')
-      // Click delete
-      .trigger('keydown', { keyCode: ENTER_KEY_CODE })
-      // // Confirm delete
-      .trigger('keydown', { keyCode: ENTER_KEY_CODE });
-
-    expect(SomePlugin.pluginInternalKeydownHandler).to.have.not.been.called;
-  });
-
-  it('should not flip when shift key is pressed', () => {
-    cy.createEditor({
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Workspace in classic editors is made of a single contenteditable element, used to create different HTML markups. Editor.js workspace consists of separate Blocks: paragraphs, headings, images, lists, quotes, etc. Each of them is an independent contenteditable element (or more complex structure) provided by Plugin and united by Editor\'s Core.',
-            },
-          },
-        ],
-      },
-      autofocus: true,
-    });
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-paragraph')
-      .as('paragraph')
-      .selectTextByOffset([0, 10])
-      .wait(200);
-
-    cy.get('@paragraph')
-      .trigger('keydown', { keyCode: ARROW_DOWN_KEY_CODE,
-        shiftKey: true });
-
-    // eslint-disable-next-line cypress/require-data-selectors
-    cy.get('[data-cy="inline-toolbar"]')
-      .get('.ce-popover--opened')
-      .as('popover')
-      .should('exist');
-
-    cy.get('@popover')
-      .get('.ce-popover-item--focused')
-      .should('not.exist');
-  });
-});
diff --git a/test/cypress/tests/utils/popover.cy.ts b/test/cypress/tests/utils/popover.cy.ts
deleted file mode 100644
index 5d42a492f..000000000
--- a/test/cypress/tests/utils/popover.cy.ts
+++ /dev/null
@@ -1,1137 +0,0 @@
-import { PopoverDesktop as Popover, PopoverItemType } from '../../../../src/components/utils/popover';
-import type { PopoverItemParams } from '@/types/utils/popover';
-import type { MenuConfig } from '../../../../types/tools';
-import Header from '@editorjs/header';
-
-/* eslint-disable @typescript-eslint/no-empty-function */
-
-describe('Popover', () => {
-  it('should support confirmation chains', () => {
-    const actionIcon = 'Icon 1';
-    const actionTitle = 'Action';
-    const confirmActionIcon = 'Icon 2';
-    const confirmActionTitle = 'Confirm action';
-
-    /**
-     * Confirmation is moved to separate variable to be able to test it's callback execution.
-     * (Inside popover null value is set to confirmation property, so, object becomes unavailable otherwise)
-     */
-    const confirmation: PopoverItemParams = {
-      icon: confirmActionIcon,
-      title: confirmActionTitle,
-      onActivate: cy.stub(),
-    };
-
-    const items: PopoverItemParams[] = [
-      {
-        icon: actionIcon,
-        title: actionTitle,
-        name: 'testItem',
-        confirmation,
-      },
-    ];
-
-    const popover = new Popover({
-      items,
-    });
-
-    cy.document().then(doc => {
-      doc.body.append(popover.getElement());
-
-      cy.get('[data-item-name=testItem]')
-        .get('.ce-popover-item__icon')
-        .should('have.text', actionIcon);
-
-      cy.get('[data-item-name=testItem]')
-        .get('.ce-popover-item__title')
-        .should('have.text', actionTitle);
-
-      // First click on item
-      cy.get('[data-item-name=testItem]').click();
-
-      // Check icon has changed
-      cy.get('[data-item-name=testItem]')
-        .get('.ce-popover-item__icon')
-        .should('have.text', confirmActionIcon);
-
-      // Check label has changed
-      cy.get('[data-item-name=testItem]')
-        .get('.ce-popover-item__title')
-        .should('have.text', confirmActionTitle);
-
-      // Second click
-      cy.get('[data-item-name=testItem]')
-        .click()
-        .then(() => {
-          // Check onActivate callback has been called
-          expect(confirmation.onActivate).to.have.been.calledOnce;
-        });
-    });
-  });
-
-  it('should render the items with true isActive property value as active', () => {
-    const items = [
-      {
-        icon: 'Icon',
-        title: 'Title',
-        isActive: true,
-        name: 'testItem',
-        onActivate: (): void => {},
-      },
-    ];
-
-    const popover = new Popover({
-      items,
-    });
-
-    cy.document().then(doc => {
-      doc.body.append(popover.getElement());
-
-      /* Check item has active class */
-      cy.get('[data-item-name=testItem]')
-        .should('have.class', 'ce-popover-item--active');
-    });
-  });
-
-  it('should not execute item\'s onActivate callback if the item is disabled', () => {
-    const items: PopoverItemParams[] = [
-      {
-        icon: 'Icon',
-        title: 'Title',
-        isDisabled: true,
-        name: 'testItem',
-        onActivate: cy.stub(),
-      },
-    ];
-
-    const popover = new Popover({
-      items,
-    });
-
-    cy.document().then(doc => {
-      doc.body.append(popover.getElement());
-
-      /* Check item has disabled class */
-      cy.get('[data-item-name=testItem]')
-        .should('have.class', 'ce-popover-item--disabled')
-        .click()
-        .then(() => {
-          if (items[0].type !== PopoverItemType.Default) {
-            return;
-          }
-
-          // Check onActivate callback has never been called
-          expect(items[0].onActivate).to.have.not.been.called;
-        });
-    });
-  });
-
-  it('should close once item with closeOnActivate property set to true is activated', () => {
-    const items = [
-      {
-        icon: 'Icon',
-        title: 'Title',
-        closeOnActivate: true,
-        name: 'testItem',
-        onActivate: (): void => {},
-      },
-    ];
-    const popover = new Popover({
-      items,
-    });
-
-    cy.spy(popover, 'hide');
-
-    cy.document().then(doc => {
-      doc.body.append(popover.getElement());
-
-      cy.get('[data-item-name=testItem]')
-        .click()
-        .then(() => {
-          expect(popover.hide).to.have.been.called;
-        });
-    });
-  });
-
-  it('should highlight as active the item with toggle property set to true once activated', () => {
-    const items = [
-      {
-        icon: 'Icon',
-        title: 'Title',
-        toggle: true,
-        name: 'testItem',
-        onActivate: (): void => {},
-      },
-    ];
-    const popover = new Popover({
-      items,
-    });
-
-    cy.document().then(doc => {
-      doc.body.append(popover.getElement());
-
-      /* Check item has active class */
-      cy.get('[data-item-name=testItem]')
-        .click()
-        .should('have.class', 'ce-popover-item--active');
-    });
-  });
-
-  it('should perform radiobutton-like behavior among the items that have toggle property value set to the same string value', () => {
-    const items = [
-      {
-        icon: 'Icon 1',
-        title: 'Title 1',
-        toggle: 'group-name',
-        name: 'testItem1',
-        isActive: true,
-        onActivate: (): void => {},
-      },
-      {
-        icon: 'Icon 2',
-        title: 'Title 2',
-        toggle: 'group-name',
-        name: 'testItem2',
-        onActivate: (): void => {},
-      },
-    ];
-
-    const popover = new Popover({
-      items,
-    });
-
-    cy.document().then(doc => {
-      doc.body.append(popover.getElement());
-
-      /** Check first item is active */
-      cy.get('[data-item-name=testItem1]')
-        .should('have.class', 'ce-popover-item--active');
-
-      /** Check second item is not active */
-      cy.get('[data-item-name=testItem2]')
-        .should('not.have.class', 'ce-popover-item--active');
-
-      /* Click second item and check it became active */
-      cy.get('[data-item-name=testItem2]')
-        .click()
-        .should('have.class', 'ce-popover-item--active');
-
-      /** Check first item became not active */
-      cy.get('[data-item-name=testItem1]')
-        .should('not.have.class', 'ce-popover-item--active');
-    });
-  });
-
-  it('should toggle item if it is the only item in toggle group', () => {
-    const items = [
-      {
-        icon: 'Icon',
-        title: 'Title',
-        toggle: 'key',
-        name: 'testItem',
-        onActivate: (): void => {},
-      },
-    ];
-    const popover = new Popover({
-      items,
-    });
-
-    cy.document().then(doc => {
-      doc.body.append(popover.getElement());
-
-      /* Check item has active class */
-      cy.get('[data-item-name=testItem]')
-        .click()
-        .should('have.class', 'ce-popover-item--active');
-    });
-  });
-
-  it('should display item with custom html', () => {
-    /**
-     * Block Tune with html as return type of render() method
-     */
-    class TestTune {
-      public static isTune = true;
-
-      /** Tune control displayed in block tunes popover */
-      public render(): HTMLElement {
-        const button = document.createElement('button');
-
-        button.classList.add('ce-settings__button');
-        button.innerText = 'Tune';
-
-        return button;
-      }
-    }
-
-    /** Create editor instance */
-    cy.createEditor({
-      tools: {
-        testTool: TestTune,
-      },
-      tunes: [ 'testTool' ],
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Hello',
-            },
-          },
-        ],
-      },
-    });
-
-    /** Open block tunes menu */
-    cy.get('[data-cy=editorjs]')
-      .get('.cdx-block')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-    /** Check item with custom html content is displayed */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover .ce-popover-item-html')
-      .contains('Tune')
-      .should('be.visible');
-  });
-
-  it('should support flipping between custom content items', () => {
-    /**
-     * Block Tune with html as return type of render() method
-     */
-    class TestTune1 {
-      public static isTune = true;
-
-      /** Tune control displayed in block tunes popover */
-      public render(): HTMLElement {
-        const button = document.createElement('button');
-
-        button.classList.add('ce-settings__button');
-        button.innerText = 'Tune1';
-
-        return button;
-      }
-    }
-
-    /**
-     * Block Tune with html as return type of render() method
-     */
-    class TestTune2 {
-      public static isTune = true;
-
-      /** Tune control displayed in block tunes popover */
-      public render(): HTMLElement {
-        const button = document.createElement('button');
-
-        button.classList.add('ce-settings__button');
-        button.innerText = 'Tune2';
-
-        return button;
-      }
-    }
-
-    /** Create editor instance */
-    cy.createEditor({
-      tools: {
-        testTool1: TestTune1,
-        testTool2: TestTune2,
-      },
-      tunes: ['testTool1', 'testTool2'],
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Hello',
-            },
-          },
-        ],
-      },
-    });
-
-    /** Open block tunes menu */
-    cy.get('[data-cy=editorjs]')
-      .get('.cdx-block')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-    /** Press Tab */
-    // eslint-disable-next-line cypress/require-data-selectors -- cy.tab() not working here
-    cy.get('body').tab();
-
-    /** Check the first custom html item is focused */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover .ce-popover-item-html .ce-settings__button')
-      .contains('Tune1')
-      .should('have.class', 'ce-popover-item--focused');
-
-    /** Press Tab */
-    // eslint-disable-next-line cypress/require-data-selectors -- cy.tab() not working here
-    cy.get('body').tab();
-
-    /** Check the second custom html item is focused */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover .ce-popover-item-html .ce-settings__button')
-      .contains('Tune2')
-      .should('have.class', 'ce-popover-item--focused');
-
-    /** Press Tab */
-    // eslint-disable-next-line cypress/require-data-selectors -- cy.tab() not working here
-    cy.get('body').tab();
-
-    /** Check that default popover item got focused */
-    cy.get('[data-cy=editorjs]')
-      .get('[data-item-name=move-up]')
-      .should('have.class', 'ce-popover-item--focused');
-  });
-
-  it('should display nested popover (desktop)', () => {
-    /** Tool class to test how it is displayed inside block tunes popover */
-    class TestTune {
-      public static isTune = true;
-
-      /** Tool data displayed in block tunes popover */
-      public render(): MenuConfig {
-        return  {
-          icon: 'Icon',
-          title: 'Title',
-          toggle: 'key',
-          name: 'test-item',
-          children: {
-            items: [
-              {
-                icon: 'Icon',
-                title: 'Title',
-                name: 'nested-test-item',
-                onActivate: (): void => {},
-              },
-            ],
-          },
-        };
-      }
-    }
-
-    /** Create editor instance */
-    cy.createEditor({
-      tools: {
-        testTool: TestTune,
-      },
-      tunes: [ 'testTool' ],
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Hello',
-            },
-          },
-        ],
-      },
-    });
-
-    /** Open block tunes menu */
-    cy.get('[data-cy=editorjs]')
-      .get('.cdx-block')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-    /** Check item with children has arrow icon */
-    cy.get('[data-cy=editorjs]')
-      .get('[data-item-name="test-item"]')
-      .get('.ce-popover-item__icon--chevron-right')
-      .should('be.visible');
-
-    /** Click the item */
-    cy.get('[data-cy=editorjs]')
-      .get('[data-item-name="test-item"]')
-      .click();
-
-    /** Check nested popover opened */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover--nested .ce-popover__container')
-      .should('be.visible');
-
-    /** Check child item displayed */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover--nested .ce-popover__container')
-      .get('[data-item-name="nested-test-item"]')
-      .should('be.visible');
-  });
-
-  it('should display children items, back button and item header and correctly switch between parent and child states (mobile)', () => {
-    /** Tool class to test how it is displayed inside block tunes popover */
-    class TestTune {
-      public static isTune = true;
-
-      /** Tool data displayed in block tunes popover */
-      public render(): MenuConfig {
-        return  {
-          icon: 'Icon',
-          title: 'Tune',
-          toggle: 'key',
-          name: 'test-item',
-          children: {
-            items: [
-              {
-                icon: 'Icon',
-                title: 'Title',
-                name: 'nested-test-item',
-                onActivate: (): void => {},
-              },
-            ],
-          },
-        };
-      }
-    }
-
-    cy.viewport('iphone-6+');
-
-
-    /** Create editor instance */
-    cy.createEditor({
-      tools: {
-        testTool: TestTune,
-      },
-      tunes: [ 'testTool' ],
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Hello',
-            },
-          },
-        ],
-      },
-    });
-
-    /** Open block tunes menu */
-    cy.get('[data-cy=editorjs]')
-      .get('.cdx-block')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-    /** Check item with children has arrow icon */
-    cy.get('[data-cy=editorjs]')
-      .get('[data-item-name="test-item"]')
-      .get('.ce-popover-item__icon--chevron-right')
-      .should('be.visible');
-
-    /** Click the item */
-    cy.get('[data-cy=editorjs]')
-      .get('[data-item-name="test-item"]')
-      .click();
-
-    /** Check child item displayed */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('[data-item-name="nested-test-item"]')
-      .should('be.visible');
-
-    /** Check header displayed */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover-header')
-      .should('have.text', 'Tune');
-
-    /** Check back button displayed */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('.ce-popover-header__back-button')
-      .should('be.visible');
-
-    /** Click back button */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('.ce-popover-header__back-button')
-      .click();
-
-    /** Check child item is not displayed */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('[data-item-name="nested-test-item"]')
-      .should('not.exist');
-
-    /** Check back button is not displayed */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('.ce-popover-header__back-button')
-      .should('not.exist');
-
-    /** Check header is not displayed */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover-header')
-      .should('not.exist');
-  });
-
-
-  it('should display default (non-separator) items without specifying type: default', () => {
-    /** Tool class to test how it is displayed inside block tunes popover */
-    class TestTune {
-      public static isTune = true;
-
-      /** Tool data displayed in block tunes popover */
-      public render(): MenuConfig {
-        return  {
-          onActivate: (): void => {},
-          icon: 'Icon',
-          title: 'Tune',
-          toggle: 'key',
-          name: 'test-item',
-        };
-      }
-    }
-
-    /** Create editor instance */
-    cy.createEditor({
-      tools: {
-        testTool: TestTune,
-      },
-      tunes: [ 'testTool' ],
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Hello',
-            },
-          },
-        ],
-      },
-    });
-
-    /** Open block tunes menu */
-    cy.get('[data-cy=editorjs]')
-      .get('.cdx-block')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-    /** Check item displayed */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('[data-item-name="test-item"]')
-      .should('be.visible');
-  });
-
-  it('should display separator', () => {
-    /** Tool class to test how it is displayed inside block tunes popover */
-    class TestTune {
-      public static isTune = true;
-
-      /** Tool data displayed in block tunes popover */
-      public render(): MenuConfig {
-        return  [
-          {
-            onActivate: (): void => {},
-            icon: 'Icon',
-            title: 'Tune',
-            toggle: 'key',
-            name: 'test-item',
-          },
-          {
-            type: PopoverItemType.Separator,
-          },
-        ];
-      }
-    }
-
-
-    /** Create editor instance */
-    cy.createEditor({
-      tools: {
-        testTool: TestTune,
-      },
-      tunes: [ 'testTool' ],
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Hello',
-            },
-          },
-        ],
-      },
-    });
-
-    /** Open block tunes menu */
-    cy.get('[data-cy=editorjs]')
-      .get('.cdx-block')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-    /** Check item displayed */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('[data-item-name="test-item"]')
-      .should('be.visible');
-
-    /** Check separator displayed */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('.ce-popover-item-separator')
-      .should('be.visible');
-  });
-
-  it('should perform keyboard navigation between items ignoring separators', () => {
-    /** Tool class to test how it is displayed inside block tunes popover */
-    class TestTune {
-      public static isTune = true;
-
-      /** Tool data displayed in block tunes popover */
-      public render(): MenuConfig {
-        return  [
-          {
-            onActivate: (): void => {},
-            icon: 'Icon',
-            title: 'Tune 1',
-            name: 'test-item-1',
-          },
-          {
-            type: PopoverItemType.Separator,
-          },
-          {
-            onActivate: (): void => {},
-            icon: 'Icon',
-            title: 'Tune 2',
-            name: 'test-item-2',
-          },
-        ];
-      }
-    }
-
-    /** Create editor instance */
-    cy.createEditor({
-      tools: {
-        testTool: TestTune,
-      },
-      tunes: [ 'testTool' ],
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Hello',
-            },
-          },
-        ],
-      },
-    });
-
-    /** Open block tunes menu */
-    cy.get('[data-cy=editorjs]')
-      .get('.cdx-block')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-    /** Press Tab */
-    // eslint-disable-next-line cypress/require-data-selectors -- cy.tab() not working here
-    cy.get('body').tab();
-
-    /** Check first item is focused */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('[data-item-name="test-item-1"].ce-popover-item--focused')
-      .should('exist');
-
-    /** Check second item is not focused */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('[data-item-name="test-item-2"].ce-popover-item--focused')
-      .should('not.exist');
-
-    /** Press Tab */
-    // eslint-disable-next-line cypress/require-data-selectors -- cy.tab() not working here
-    cy.get('body').tab();
-
-    /** Check first item is not focused */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('[data-item-name="test-item-1"].ce-popover-item--focused')
-      .should('not.exist');
-
-    /** Check second item is focused */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('[data-item-name="test-item-2"].ce-popover-item--focused')
-      .should('exist');
-  });
-
-  it('should perform keyboard navigation between items ignoring separators when search query is applied', () => {
-    /** Tool class to test how it is displayed inside block tunes popover */
-    class TestTune {
-      public static isTune = true;
-
-      /** Tool data displayed in block tunes popover */
-      public render(): MenuConfig {
-        return  [
-          {
-            onActivate: (): void => {},
-            icon: 'Icon',
-            title: 'Tune 1',
-            name: 'test-item-1',
-          },
-          {
-            type: PopoverItemType.Separator,
-          },
-          {
-            onActivate: (): void => {},
-            icon: 'Icon',
-            title: 'Tune 2',
-            name: 'test-item-2',
-          },
-        ];
-      }
-    }
-
-    /** Create editor instance */
-    cy.createEditor({
-      tools: {
-        testTool: TestTune,
-      },
-      tunes: [ 'testTool' ],
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Hello',
-            },
-          },
-        ],
-      },
-    });
-
-    /** Open block tunes menu */
-    cy.get('[data-cy=editorjs]')
-      .get('.cdx-block')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-    /** Check separator displayed */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('.ce-popover-item-separator')
-      .should('be.visible');
-
-    /** Enter search query */
-    cy.get('[data-cy=editorjs]')
-      .get('[data-cy=block-tunes] .cdx-search-field__input')
-      .type('Tune');
-
-    /** Check separator not displayed */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('.ce-popover-item-separator')
-      .should('not.be.visible');
-
-    /** Press Tab */
-    // eslint-disable-next-line cypress/require-data-selectors -- cy.tab() not working here
-    cy.get('body').tab();
-
-    /** Check first item is focused */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('[data-item-name="test-item-1"].ce-popover-item--focused')
-      .should('exist');
-
-    /** Check second item is not focused */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('[data-item-name="test-item-2"].ce-popover-item--focused')
-      .should('not.exist');
-
-    /** Press Tab */
-    // eslint-disable-next-line cypress/require-data-selectors -- cy.tab() not working here
-    cy.get('body').tab();
-
-    /** Check first item is not focused */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('[data-item-name="test-item-1"].ce-popover-item--focused')
-      .should('not.exist');
-
-    /** Check second item is focused */
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-popover__container')
-      .get('[data-item-name="test-item-2"].ce-popover-item--focused')
-      .should('exist');
-  });
-
-  it('shoould support i18n in nested popover', () => {
-    /**
-     *
-     */
-    class TestTune {
-      public static isTune = true;
-
-      /** Tool data displayed in block tunes popover */
-      public render(): MenuConfig {
-        return  {
-          icon: 'Icon',
-          title: 'Title',
-          toggle: 'key',
-          name: 'test-item',
-          children: {
-            searchable: true,
-            items: [
-              {
-                icon: 'Icon',
-                title: 'Title',
-                name: 'nested-test-item',
-                onActivate: (): void => {},
-              },
-            ],
-          },
-        };
-      }
-    }
-
-    /** Create editor instance */
-    cy.createEditor({
-      tools: {
-        testTool: TestTune,
-      },
-      tunes: [ 'testTool' ],
-      data: {
-        blocks: [
-          {
-            type: 'paragraph',
-            data: {
-              text: 'Hello',
-            },
-          },
-        ],
-      },
-      i18n: {
-        messages: {
-          ui: {
-            popover: {
-              'Filter': 'Искать',
-              // eslint-disable-next-line @typescript-eslint/naming-convention -- i18n
-              'Nothing found': 'Ничего не найдено',
-            },
-          },
-        },
-      },
-    });
-
-    /** Open block tunes menu */
-    cy.get('[data-cy=editorjs]')
-      .get('.cdx-block')
-      .click();
-
-    cy.get('[data-cy=editorjs]')
-      .get('.ce-toolbar__settings-btn')
-      .click();
-
-    /** Click the item */
-    cy.get('[data-cy=editorjs]')
-      .get('[data-item-name="test-item"]')
-      .click();
-
-    /** Check nested popover search input has placeholder text with i18n */
-    cy.get('[data-cy=editorjs]')
-      .get('[data-cy=block-tunes] .ce-popover--nested .cdx-search-field__input')
-      .invoke('attr', 'placeholder')
-      .should('eq', 'Искать');
-
-    /** Enter search query */
-    cy.get('[data-cy=editorjs]')
-      .get('[data-cy=block-tunes] .ce-popover--nested .cdx-search-field__input')
-      .type('Some text');
-
-    /** Check nested popover has nothing found message with i18n */
-    cy.get('[data-cy=editorjs]')
-      .get('[data-cy=block-tunes] .ce-popover--nested .ce-popover__nothing-found-message')
-      .should('have.text', 'Ничего не найдено');
-  });
-
-  describe('Inline Popover', () => {
-    it('should open nested popover on click instead of hover', () => {
-      cy.createEditor({
-        tools: {
-          header: {
-            class: Header,
-          },
-        },
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'First block text',
-              },
-            },
-          ],
-        },
-      });
-
-      /** Open Inline Toolbar */
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .selectText('block');
-
-      /** Hover Convert To item which has nested popover */
-      cy.get('[data-cy=editorjs]')
-        .get('[data-item-name=convert-to]')
-        .trigger('mouseover');
-
-      /** Check nested popover didn't open */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover--nested .ce-popover__container')
-        .should('not.exist');
-
-      /** Click Convert To item which has nested popover */
-      cy.get('[data-cy=editorjs]')
-        .get('[data-item-name=convert-to]')
-        .click();
-
-      /** Check nested popover opened */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover--nested .ce-popover__container')
-        .should('exist');
-    });
-
-    it('should support keyboard nevigation between items', () => {
-      cy.createEditor({
-        tools: {
-          header: {
-            class: Header,
-          },
-        },
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'First block text',
-              },
-            },
-          ],
-        },
-      });
-
-      /** Open Inline Toolbar */
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .selectText('block');
-
-      /** Check Inline Popover opened */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-inline-toolbar .ce-popover__container')
-        .should('be.visible');
-
-      /** Check first item is NOT focused */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-inline-toolbar .ce-popover__container')
-        .get('[data-item-name="convert-to"].ce-popover-item--focused')
-        .should('not.exist');
-
-      /** Press Tab */
-      cy.tab();
-
-      /** Check first item became focused after tab */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-inline-toolbar .ce-popover__container')
-        .get('[data-item-name="convert-to"].ce-popover-item--focused')
-        .should('exist');
-
-      /** Check second item is NOT focused */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-inline-toolbar .ce-popover__container')
-        .get('[data-item-name="link"] .ce-popover-item--focused')
-        .should('not.exist');
-
-      /** Press Tab */
-      cy.tab();
-
-      /** Check second item became focused after tab */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-inline-toolbar .ce-popover__container')
-        .get('[data-item-name="link"] .ce-popover-item--focused')
-        .should('exist');
-    });
-
-    it('should allow to reach nested popover via keyboard', () => {
-      cy.createEditor({
-        tools: {
-          header: {
-            class: Header,
-          },
-        },
-        data: {
-          blocks: [
-            {
-              type: 'paragraph',
-              data: {
-                text: 'First block text',
-              },
-            },
-          ],
-        },
-      });
-
-      /** Open Inline Toolbar */
-      cy.get('[data-cy=editorjs]')
-        .find('.ce-paragraph')
-        .selectText('block');
-
-      /** Check Inline Popover opened */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-inline-toolbar .ce-popover__container')
-        .should('be.visible');
-
-      /** Press Tab */
-      cy.tab();
-
-      /** Press Tab */
-      cy.get('[data-item-name="convert-to"]')
-        .type('{enter}');
-
-      /** Check Inline Popover opened */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-inline-toolbar .ce-popover--nested .ce-popover__container')
-        .should('be.visible');
-
-      /** Check first item is NOT focused */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover__container')
-        .get('[data-item-name="header"].ce-popover-item--focused')
-        .should('not.exist');
-
-      /** Press Tab */
-      // eslint-disable-next-line cypress/require-data-selectors -- cy.tab() not working here
-      cy.get('body').tab();
-
-      /** Check first item is focused */
-      cy.get('[data-cy=editorjs]')
-        .get('.ce-popover__container')
-        .get('[data-item-name="header"].ce-popover-item--focused')
-        .should('exist');
-    });
-  });
-});
diff --git a/test/cypress/tsconfig.json b/test/cypress/tsconfig.json
deleted file mode 100644
index 7ccaeff75..000000000
--- a/test/cypress/tsconfig.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "types": ["cypress", "node"],
-  },
-  "include": [
-    "**/*.ts"
-  ]
-}
diff --git a/test/cypress/fixtures/test.html b/test/playwright/fixtures/test.html
similarity index 80%
rename from test/cypress/fixtures/test.html
rename to test/playwright/fixtures/test.html
index 38d93ec7c..73e4e8568 100644
--- a/test/cypress/fixtures/test.html
+++ b/test/playwright/fixtures/test.html
@@ -1,8 +1,12 @@
 <!DOCTYPE html>
 <html lang="en">
+<head>
+  <meta charset="utf-8" />
+</head>
 <body>
   <!-- Load Editor.js's Core -->
   <script src="./../../../dist/editorjs.umd.js"></script>
   <h1>Editor.js test page</h1>
 </body>
 </html>
+
diff --git a/test/playwright/tests/api/blocks.spec.ts b/test/playwright/tests/api/blocks.spec.ts
new file mode 100644
index 000000000..06ad342b7
--- /dev/null
+++ b/test/playwright/tests/api/blocks.spec.ts
@@ -0,0 +1,1790 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { nanoid } from 'nanoid';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+import { BlockChangedMutationType } from '../../../../types/events/block/BlockChanged';
+import type { BlockMutationEvent } from '../../../../types';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const BLOCK_WRAPPER_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-cy="block-wrapper"]`;
+const getBlockWrapperSelectorByIndex = (index: number): string => {
+  return `:nth-match(${BLOCK_WRAPPER_SELECTOR}, ${index + 1})`;
+};
+
+type ToolDefinition = {
+  name: string;
+  classSource: string;
+  config?: Record<string, unknown>;
+};
+
+type EditorSetupOptions = {
+  data?: Record<string, unknown>;
+  config?: Record<string, unknown>;
+  tools?: ToolDefinition[];
+  tunes?: string[];
+  onChange?: boolean; // If true, track onChange events in window.onChangeEvents
+};
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditor = async (page: Page, options: EditorSetupOptions = {}): Promise<void> => {
+  const { data, config, tools = [], tunes, onChange } = options;
+
+  await resetEditor(page);
+  await page.waitForFunction(() => typeof window.EditorJS === 'function');
+
+  // Initialize onChange tracking in window if onChange callback is provided
+  if (onChange) {
+    await page.evaluate(() => {
+      (window as unknown as { onChangeEvents?: unknown[]; onChangeCalled?: boolean }).onChangeEvents = [];
+      (window as unknown as { onChangeEvents?: unknown[]; onChangeCalled?: boolean }).onChangeCalled = false;
+    });
+  }
+
+  await page.evaluate(
+    async ({ holderId, rawData, rawConfig, serializedTools, tunes: tunesArray, hasOnChange }) => {
+      const reviveToolClass = (classSource: string): unknown => {
+        return new Function(`return (${classSource});`)();
+      };
+
+      const revivedTools = serializedTools.reduce<Record<string, Record<string, unknown>>>((accumulator, toolConfig) => {
+        const revivedClass = reviveToolClass(toolConfig.classSource);
+
+        const toolSettings: Record<string, unknown> = {
+          class: revivedClass,
+        };
+
+        if (toolConfig.config !== undefined) {
+          toolSettings.config = toolConfig.config;
+        }
+
+        return {
+          ...accumulator,
+          [toolConfig.name]: toolSettings,
+        };
+      }, {});
+
+      const editorConfig: Record<string, unknown> = {
+        holder: holderId,
+        ...rawConfig,
+        ...(serializedTools.length > 0 ? { tools: revivedTools } : {}),
+        ...(rawData ? { data: rawData } : {}),
+      };
+
+      if (tunesArray && tunesArray.length > 0) {
+        editorConfig.tunes = tunesArray;
+      }
+
+      if (hasOnChange) {
+        editorConfig.onChange = (api: unknown, event: unknown) => {
+          const windowObj = window as unknown as { onChangeEvents?: unknown[]; onChangeCalled?: boolean };
+
+          if (windowObj.onChangeEvents) {
+            windowObj.onChangeEvents.push(event);
+            windowObj.onChangeCalled = true;
+          }
+        };
+      }
+
+      const editor = new window.EditorJS(editorConfig);
+
+      window.editorInstance = editor;
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      rawData: data ?? null,
+      rawConfig: config ?? {},
+      serializedTools: tools,
+      tunes: tunes ?? [],
+      hasOnChange: onChange !== undefined,
+    }
+  );
+};
+
+const focusBlockByIndex = async (page: Page, index: number = 0): Promise<void> => {
+  await page.evaluate(({ blockIndex }) => {
+    if (!window.editorInstance) {
+      throw new Error('Editor instance not found');
+    }
+
+    const didSetCaret = window.editorInstance.caret.setToBlock(blockIndex);
+
+    if (!didSetCaret) {
+      throw new Error(`Failed to set caret to block at index ${blockIndex}`);
+    }
+  }, { blockIndex: index });
+};
+
+const openBlockSettings = async (page: Page, index: number = 0): Promise<void> => {
+  await focusBlockByIndex(page, index);
+
+  const block = page.locator(getBlockWrapperSelectorByIndex(index));
+
+  await block.scrollIntoViewIfNeeded();
+  await block.click();
+  await block.hover();
+
+  const settingsButton = page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__settings-btn`);
+
+  await settingsButton.waitFor({ state: 'visible' });
+  await settingsButton.click();
+};
+
+
+/**
+ * There will be described test cases of 'blocks.*' API
+ */
+test.describe('api.blocks', () => {
+  const firstBlock = {
+    id: 'bwnFX5LoX7',
+    type: 'paragraph',
+    data: {
+      text: 'The first block content mock.',
+    },
+  };
+  const editorDataMock = {
+    blocks: [
+      firstBlock,
+    ],
+  };
+
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+  });
+
+  /**
+   * api.blocks.getById(id)
+   */
+  test.describe('.getById()', () => {
+    /**
+     * Check that api.blocks.getById(id) returns the Block for existed id
+     */
+    test('should return Block API for existed id', async ({ page }) => {
+      await createEditor(page, {
+        data: editorDataMock,
+      });
+
+      const result = await page.evaluate(({ blockId }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const block = window.editorInstance.blocks.getById(blockId);
+
+        return {
+          blockExists: block !== null && block !== undefined,
+          blockId: block?.id,
+        };
+      }, { blockId: firstBlock.id });
+
+      expect(result.blockExists).toBe(true);
+      expect(result.blockId).toBe(firstBlock.id);
+    });
+
+    /**
+     * Check that api.blocks.getById(id) returns null for the not-existed id
+     */
+    test('should return null for not-existed id', async ({ page }) => {
+      await createEditor(page, {
+        data: editorDataMock,
+      });
+
+      const result = await page.evaluate(() => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        return window.editorInstance.blocks.getById('not-existed-id');
+      });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  /**
+   * api.blocks.update(id, newData)
+   */
+  test.describe('.update()', () => {
+    /**
+     * Check if block is updated in DOM
+     */
+    test('should update block in DOM', async ({ page }) => {
+      await createEditor(page, {
+        data: editorDataMock,
+      });
+
+      const idToUpdate = firstBlock.id;
+      const newBlockData = {
+        text: 'Updated text',
+      };
+
+      await page.evaluate(async ({ id, newData }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        await window.editorInstance.blocks.update(id, newData);
+      }, { id: idToUpdate,
+        newData: newBlockData });
+
+      await expect(page.locator(BLOCK_WRAPPER_SELECTOR)).toHaveText(newBlockData.text);
+    });
+
+    /**
+     * Check if block's data is updated after saving
+     */
+    test('should update block in saved data', async ({ page }) => {
+      await createEditor(page, {
+        data: editorDataMock,
+      });
+
+      const idToUpdate = firstBlock.id;
+      const newBlockData = {
+        text: 'Updated text',
+      };
+
+      await page.evaluate(async ({ id, newData }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        await window.editorInstance.blocks.update(id, newData);
+      }, { id: idToUpdate,
+        newData: newBlockData });
+
+      // wait for async hydration - wait for DOM to reflect the update
+      await expect(page.locator(BLOCK_WRAPPER_SELECTOR)).toHaveText(newBlockData.text);
+
+      const output = await page.evaluate(async () => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        return await window.editorInstance.save();
+      });
+
+      const text = output.blocks[0].data.text;
+
+      expect(text).toBe(newBlockData.text);
+    });
+
+    test('should update tune data when it is provided', async ({ page }) => {
+      /**
+       * Example Tune Class
+       */
+      const EXAMPLE_TUNE_SOURCE = `class ExampleTune {
+        constructor({ data }) {
+          this.data = data;
+        }
+
+        static get isTune() {
+          return true;
+        }
+
+        static get CSS() {
+          return {};
+        }
+
+        render() {
+          return document.createElement('div');
+        }
+
+        save() {
+          return this.data ?? '';
+        }
+      }`;
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'exampleTune',
+            classSource: EXAMPLE_TUNE_SOURCE,
+          },
+        ],
+        tunes: [ 'exampleTune' ],
+        data: {
+          blocks: [
+            {
+              id: nanoid(),
+              type: 'paragraph',
+              data: {
+                text: 'First block',
+              },
+              tunes: {
+                exampleTune: 'citation',
+              },
+            },
+          ],
+        },
+      });
+
+      // Update the tunes data of a block
+      // Check if it is updated
+      const data = await page.evaluate(async () => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const block = window.editorInstance.blocks.getBlockByIndex(0);
+
+        if (!block) {
+          throw new Error('Block at index 0 not found');
+        }
+
+        await window.editorInstance.blocks.update(block.id, undefined, {
+          exampleTune: 'test',
+        });
+
+        return await window.editorInstance.save();
+      });
+
+      const actual = JSON.stringify(data.blocks[0].tunes);
+      const expected = JSON.stringify({ exampleTune: 'test' });
+
+      expect(actual).toBe(expected);
+    });
+
+    /**
+     * When incorrect id passed, editor should not update any block
+     */
+    test('shouldn\'t update any block if not-existed id passed', async ({ page }) => {
+      await createEditor(page, {
+        data: editorDataMock,
+      });
+
+      const idToUpdate = 'wrong-id-123';
+      const newBlockData = {
+        text: 'Updated text',
+      };
+
+      const error = await page.evaluate(async ({ id, newData }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        try {
+          await window.editorInstance.blocks.update(id, newData);
+
+          return null;
+        } catch (err) {
+          return {
+            message: (err as Error).message,
+          };
+        }
+      }, { id: idToUpdate,
+        newData: newBlockData }).catch(() => null);
+
+      expect(error?.message).toBe(`Block with id "${idToUpdate}" not found`);
+
+      await expect(page.locator(BLOCK_WRAPPER_SELECTOR)).toHaveText(firstBlock.data.text);
+    });
+  });
+
+  /**
+   * api.blocks.insert(type, data, config, index, needToFocus, replace, id)
+   */
+  test.describe('.insert()', () => {
+    test('should preserve block id if it is passed', async ({ page }) => {
+      await createEditor(page, {
+        data: editorDataMock,
+      });
+
+      const result = await page.evaluate(() => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const type = 'paragraph';
+        const data = { text: 'codex' };
+        const config = undefined;
+        const index = undefined;
+        const needToFocus = undefined;
+        const replace = undefined;
+        const id = 'test-id-123';
+
+        const block = window.editorInstance.blocks.insert(type, data, config, index, needToFocus, replace, id);
+
+        return {
+          blockExists: block !== null && block !== undefined,
+          blockId: block.id,
+        };
+      });
+
+      expect(result.blockExists).toBe(true);
+      expect(result.blockId).toBe('test-id-123');
+    });
+  });
+
+  /**
+   * api.blocks.insertMany(blocks, index)
+   */
+  test.describe('.insertMany()', () => {
+    test('should insert several blocks to passed index', async ({ page }) => {
+      await createEditor(page, {
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: { text: 'first block' },
+            },
+          ],
+        },
+      });
+
+      await page.evaluate(() => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const index = 0;
+
+        window.editorInstance.blocks.insertMany([
+          {
+            type: 'paragraph',
+            data: { text: 'inserting block #1' },
+          },
+          {
+            type: 'paragraph',
+            data: { text: 'inserting block #2' },
+          },
+        ], index); // paste to the 0 index
+      });
+
+      const blocks = page.locator(BLOCK_WRAPPER_SELECTOR);
+
+      await expect(blocks).toHaveText([
+        'inserting block #1',
+        'inserting block #2',
+        'first block',
+      ]);
+    });
+  });
+
+  test.describe('.convert()', () => {
+    test('should convert a Block to another type if original Tool has "conversionConfig.export" and target Tool has "conversionConfig.import". Should return BlockAPI as well.', async ({ page }) => {
+      /**
+       * Mock of Tool with conversionConfig
+       */
+      const CONVERTABLE_TOOL_SOURCE = `class ConvertableTool {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            import: 'text',
+          };
+        }
+
+        static get toolbox() {
+          return {
+            icon: '',
+            title: 'Convertable tool',
+          };
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+
+          contenteditable.contentEditable = 'true';
+
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      const existingBlock = {
+        id: 'test-id-123',
+        type: 'paragraph',
+        data: {
+          text: 'Some text',
+        },
+      };
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'convertableTool',
+            classSource: CONVERTABLE_TOOL_SOURCE,
+          },
+        ],
+        data: {
+          blocks: [
+            existingBlock,
+          ],
+        },
+      });
+
+      const convertedBlock = await page.evaluate(async ({ blockId }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const { convert } = window.editorInstance.blocks;
+
+        const result = await convert(blockId, 'convertableTool');
+
+        return {
+          id: result?.id ?? null,
+          name: result?.name ?? null,
+        };
+      }, { blockId: existingBlock.id });
+
+      // wait for block to be converted - wait until saved data shows converted type
+      await page.waitForFunction(async () => {
+        if (!window.editorInstance) {
+          return false;
+        }
+
+        const { blocks } = await window.editorInstance.save();
+
+        return blocks.length > 0 && blocks[0].type === 'convertableTool';
+      });
+
+      /**
+       * Check that block was converted
+       */
+      const { blocks } = await page.evaluate(async () => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        return await window.editorInstance.save();
+      });
+
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].type).toBe('convertableTool');
+      expect(blocks[0].data.text).toBe(existingBlock.data.text);
+
+      /**
+       * Check that returned value is BlockAPI
+       */
+      expect(convertedBlock.name).toBe('convertableTool');
+      expect(convertedBlock.id).toBe(blocks[0].id);
+    });
+
+    test('should throw an error if nonexisting Block id passed', async ({ page }) => {
+      await createEditor(page, {});
+
+      const error = await page.evaluate(async () => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        /**
+         * Call the 'convert' api method with nonexisting Block id
+         */
+        const fakeId = 'WRONG_ID';
+        const { convert } = window.editorInstance.blocks;
+
+        try {
+          await convert(fakeId, 'convertableTool');
+
+          return null;
+        } catch (err) {
+          return {
+            message: (err as Error).message,
+          };
+        }
+      });
+
+      expect(error?.message).toBe(`Block with id "WRONG_ID" not found`);
+    });
+
+    test('should throw an error if nonexisting Tool name passed', async ({ page }) => {
+      const existingBlock = {
+        id: 'test-id-123',
+        type: 'paragraph',
+        data: {
+          text: 'Some text',
+        },
+      };
+
+      await createEditor(page, {
+        data: {
+          blocks: [
+            existingBlock,
+          ],
+        },
+      });
+
+      const error = await page.evaluate(async ({ blockId }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        /**
+         * Call the 'convert' api method with nonexisting tool name
+         */
+        const nonexistingToolName = 'WRONG_TOOL_NAME';
+        const { convert } = window.editorInstance.blocks;
+
+        try {
+          await convert(blockId, nonexistingToolName);
+
+          return null;
+        } catch (err) {
+          return {
+            message: (err as Error).message,
+          };
+        }
+      }, { blockId: existingBlock.id });
+
+      expect(error?.message).toBe(`Block Tool with type "WRONG_TOOL_NAME" not found`);
+    });
+
+    test('should throw an error if some tool does not provide "conversionConfig"', async ({ page }) => {
+      const existingBlock = {
+        id: 'test-id-123',
+        type: 'paragraph',
+        data: {
+          text: 'Some text',
+        },
+      };
+
+      /**
+       * Mock of Tool without conversionConfig
+       */
+      const TOOL_WITHOUT_CONVERSION_CONFIG_SOURCE = `class ToolWithoutConversionConfig {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+
+          contenteditable.contentEditable = 'true';
+
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'nonConvertableTool',
+            classSource: TOOL_WITHOUT_CONVERSION_CONFIG_SOURCE,
+            config: {
+              shortcut: 'CMD+SHIFT+H',
+            },
+          },
+        ],
+        data: {
+          blocks: [
+            existingBlock,
+          ],
+        },
+      });
+
+      const error = await page.evaluate(async ({ blockId }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        /**
+         * Call the 'convert' api method with tool that does not provide "conversionConfig"
+         */
+        const { convert } = window.editorInstance.blocks;
+
+        try {
+          await convert(blockId, 'nonConvertableTool');
+
+          return null;
+        } catch (err) {
+          return {
+            message: (err as Error).message,
+          };
+        }
+      }, { blockId: existingBlock.id });
+
+      expect(error?.message).toBe(`Conversion from "paragraph" to "nonConvertableTool" is not possible. NonConvertableTool tool(s) should provide a "conversionConfig"`);
+    });
+
+    test('should pass tool config to the conversionConfig.import method of the tool', async ({ page }) => {
+      const existingBlock = {
+        id: 'test-id-123',
+        type: 'paragraph',
+        data: {
+          text: 'Some text',
+        },
+      };
+
+      const conversionTargetToolConfig = {
+        defaultStyle: 'defaultStyle',
+      };
+
+      /**
+       * Mock of Tool with conversionConfig
+       */
+      const TOOL_WITH_CONVERSION_CONFIG_SOURCE = `class ToolWithConversionConfig {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            export: (data) => data,
+            import: (_content, config) => {
+              return { text: JSON.stringify(config) };
+            },
+          };
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+
+          contenteditable.contentEditable = 'true';
+
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'conversionTargetTool',
+            classSource: TOOL_WITH_CONVERSION_CONFIG_SOURCE,
+            config: conversionTargetToolConfig,
+          },
+        ],
+        data: {
+          blocks: [
+            existingBlock,
+          ],
+        },
+      });
+
+      await page.evaluate(async ({ blockId }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const { convert } = window.editorInstance.blocks;
+
+        await convert(blockId, 'conversionTargetTool');
+      }, { blockId: existingBlock.id });
+
+      // wait for block to be converted - wait until saved data shows converted type
+      await page.waitForFunction(async () => {
+        if (!window.editorInstance) {
+          return false;
+        }
+
+        const { blocks } = await window.editorInstance.save();
+
+        return blocks.length > 0 && blocks[0].type === 'conversionTargetTool';
+      });
+
+      /**
+       * Check that block was converted
+       */
+      const { blocks } = await page.evaluate(async () => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        return await window.editorInstance.save();
+      });
+
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].type).toBe('conversionTargetTool');
+
+      /**
+       * Check that tool converted returned config as a result of import
+       */
+      expect(blocks[0].data.text).toBe(JSON.stringify(conversionTargetToolConfig));
+    });
+  });
+
+  /**
+   * Tests for getConvertibleToolsForBlock utility function
+   * These test the conversion options UI which uses getConvertibleToolsForBlock
+   */
+  test.describe('getConvertibleToolsForBlock (via UI)', () => {
+    const BLOCK_TUNES_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-cy=block-tunes]`;
+    const CONVERT_TO_SELECTOR = `${BLOCK_TUNES_SELECTOR} [data-item-name="convert-to"]`;
+
+    const openConvertToMenu = async (page: Page): Promise<Locator> => {
+      const convertToItem = page.locator(CONVERT_TO_SELECTOR);
+
+      await expect(convertToItem).toBeVisible();
+      await convertToItem.hover();
+
+      const nestedMenu = page.locator(`${BLOCK_TUNES_SELECTOR} .ce-popover--nested`);
+
+      await nestedMenu.waitFor({ state: 'attached' });
+
+      return nestedMenu;
+    };
+
+    test('should show conversion options in block settings when block has export config', async ({ page }) => {
+      const HEADER_TOOL_SOURCE = `class HeaderTool {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            export: 'text',
+            import: 'text',
+          };
+        }
+
+        static get toolbox() {
+          return {
+            icon: 'H',
+            title: 'Header',
+          };
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+          contenteditable.contentEditable = 'true';
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      const LIST_TOOL_SOURCE = `class ListTool {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            export: 'text',
+            import: 'text',
+          };
+        }
+
+        static get toolbox() {
+          return {
+            icon: '•',
+            title: 'List',
+          };
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+          contenteditable.contentEditable = 'true';
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'header',
+            classSource: HEADER_TOOL_SOURCE,
+          },
+          {
+            name: 'list',
+            classSource: LIST_TOOL_SOURCE,
+          },
+        ],
+        data: {
+          blocks: [
+            {
+              id: 'block-1',
+              type: 'paragraph',
+              data: {
+                text: 'Test paragraph',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockSettings(page);
+
+      // Check that "Convert to" menu item is visible
+      await expect(page.locator(CONVERT_TO_SELECTOR)).toBeVisible();
+
+      // Open "Convert to" submenu
+      const convertToMenu = await openConvertToMenu(page);
+
+      // Check that both header and list tools are available
+      await expect(convertToMenu.locator('[data-item-name="header"]')).toBeVisible();
+      await expect(convertToMenu.locator('[data-item-name="list"]')).toBeVisible();
+    });
+
+    test('should not show conversion options when block has no export config', async ({ page }) => {
+      const NON_CONVERTABLE_TOOL_SOURCE = `class NonConvertableTool {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get toolbox() {
+          return {
+            icon: 'X',
+            title: 'Non-convertable',
+          };
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+          contenteditable.contentEditable = 'true';
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      const CONVERTABLE_TOOL_SOURCE = `class ConvertableTool {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            import: 'text',
+          };
+        }
+
+        static get toolbox() {
+          return {
+            icon: 'C',
+            title: 'Convertable',
+          };
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+          contenteditable.contentEditable = 'true';
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'nonConvertable',
+            classSource: NON_CONVERTABLE_TOOL_SOURCE,
+          },
+          {
+            name: 'convertable',
+            classSource: CONVERTABLE_TOOL_SOURCE,
+          },
+        ],
+        data: {
+          blocks: [
+            {
+              id: 'block-1',
+              type: 'nonConvertable',
+              data: {
+                text: 'Test',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockSettings(page);
+
+      // Check that "Convert to" menu item is NOT visible (block has no export config)
+      await expect(page.locator(CONVERT_TO_SELECTOR)).toBeHidden();
+    });
+
+    test('should filter out tools without import config from conversion options', async ({ page }) => {
+      const HEADER_TOOL_SOURCE = `class HeaderTool {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            export: 'text',
+            import: 'text',
+          };
+        }
+
+        static get toolbox() {
+          return {
+            icon: 'H',
+            title: 'Header',
+          };
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+          contenteditable.contentEditable = 'true';
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      const TOOL_WITHOUT_IMPORT_SOURCE = `class ToolWithoutImport {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            export: 'text',
+            // No import config
+          };
+        }
+
+        static get toolbox() {
+          return {
+            icon: 'X',
+            title: 'No Import',
+          };
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+          contenteditable.contentEditable = 'true';
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'header',
+            classSource: HEADER_TOOL_SOURCE,
+          },
+          {
+            name: 'noImport',
+            classSource: TOOL_WITHOUT_IMPORT_SOURCE,
+          },
+        ],
+        data: {
+          blocks: [
+            {
+              id: 'block-1',
+              type: 'paragraph',
+              data: {
+                text: 'Test paragraph',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockSettings(page);
+
+      const convertToMenu = await openConvertToMenu(page);
+
+      // Check that header tool is available
+      await expect(convertToMenu.locator('[data-item-name="header"]')).toBeVisible();
+
+      // Check that tool without import config is NOT shown
+      await expect(convertToMenu.locator('[data-item-name="noImport"]')).toBeHidden();
+    });
+
+    test('should filter out duplicate toolbox items with same data (isSameBlockData)', async ({ page }) => {
+      const HEADER_TOOL_SOURCE = `class HeaderTool {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            export: 'text',
+            import: 'text',
+          };
+        }
+
+        static get toolbox() {
+          return [
+            {
+              icon: 'H1',
+              title: 'Header 1',
+              data: {
+                level: 1,
+              },
+            },
+            {
+              icon: 'H2',
+              title: 'Header 2',
+              data: {
+                level: 2,
+              },
+            },
+            {
+              icon: 'H3',
+              title: 'Header 3',
+              data: {
+                level: 3,
+              },
+            },
+          ];
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+          contenteditable.contentEditable = 'true';
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+            level: this.data?.level || 1,
+          };
+        }
+      }`;
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'header',
+            classSource: HEADER_TOOL_SOURCE,
+          },
+        ],
+        data: {
+          blocks: [
+            {
+              id: 'block-1',
+              type: 'paragraph',
+              data: {
+                text: 'Test paragraph',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockSettings(page);
+
+      const convertToMenu = await openConvertToMenu(page);
+
+      const headerItems = convertToMenu.locator('[data-item-name="header"]');
+      const firstHeaderItem = convertToMenu.locator(':nth-match([data-item-name="header"], 1)');
+
+      await expect(headerItems).toHaveCount(3);
+      await expect(firstHeaderItem).toBeVisible();
+    });
+
+    test('should filter out toolbox item with same data as current block (isSameBlockData)', async ({ page }) => {
+      const HEADER_TOOL_SOURCE = `class HeaderTool {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            export: 'text',
+            import: 'text',
+          };
+        }
+
+        static get toolbox() {
+          return [
+            {
+              icon: 'H1',
+              title: 'Header 1',
+              data: {
+                level: 1,
+              },
+            },
+            {
+              icon: 'H2',
+              title: 'Header 2',
+              data: {
+                level: 2,
+              },
+            },
+          ];
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+          contenteditable.contentEditable = 'true';
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+            level: this.data?.level || 1,
+          };
+        }
+      }`;
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'header',
+            classSource: HEADER_TOOL_SOURCE,
+          },
+        ],
+        data: {
+          blocks: [
+            {
+              id: 'block-1',
+              type: 'header',
+              data: {
+                text: 'Test header',
+                level: 1,
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockSettings(page);
+
+      const convertToMenu = await openConvertToMenu(page);
+
+      // Header tool should be available, but H1 option should be filtered out (same data)
+      // H2 should still be available
+      await expect(convertToMenu.locator('[data-item-name="header"]')).toBeVisible();
+    });
+
+    test('should filter out tools without toolbox from conversion options', async ({ page }) => {
+      const HEADER_TOOL_SOURCE = `class HeaderTool {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            export: 'text',
+            import: 'text',
+          };
+        }
+
+        static get toolbox() {
+          return {
+            icon: 'H',
+            title: 'Header',
+          };
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+          contenteditable.contentEditable = 'true';
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      const TOOL_WITHOUT_TOOLBOX_SOURCE = `class ToolWithoutToolbox {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            export: 'text',
+            import: 'text',
+          };
+        }
+
+        // No toolbox property
+
+        render() {
+          const contenteditable = document.createElement('div');
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+          contenteditable.contentEditable = 'true';
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'header',
+            classSource: HEADER_TOOL_SOURCE,
+          },
+          {
+            name: 'noToolbox',
+            classSource: TOOL_WITHOUT_TOOLBOX_SOURCE,
+          },
+        ],
+        data: {
+          blocks: [
+            {
+              id: 'block-1',
+              type: 'paragraph',
+              data: {
+                text: 'Test paragraph',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockSettings(page);
+
+      const convertToMenu = await openConvertToMenu(page);
+
+      // Check that header tool is available
+      await expect(convertToMenu.locator('[data-item-name="header"]')).toBeVisible();
+
+      // Check that tool without toolbox is NOT shown
+      await expect(convertToMenu.locator('[data-item-name="noToolbox"]')).toBeHidden();
+    });
+
+    test('should filter out toolbox items without icon', async ({ page }) => {
+      const HEADER_TOOL_SOURCE = `class HeaderTool {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            export: 'text',
+            import: 'text',
+          };
+        }
+
+        static get toolbox() {
+          return [
+            {
+              icon: 'H',
+              title: 'Header with icon',
+            },
+            {
+              title: 'Header without icon',
+              // No icon property
+            },
+          ];
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+          contenteditable.contentEditable = 'true';
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'header',
+            classSource: HEADER_TOOL_SOURCE,
+          },
+        ],
+        data: {
+          blocks: [
+            {
+              id: 'block-1',
+              type: 'paragraph',
+              data: {
+                text: 'Test paragraph',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockSettings(page);
+
+      const convertToMenu = await openConvertToMenu(page);
+
+      // Only the item with icon should be available
+      await expect(convertToMenu.locator('[data-item-name="header"]')).toBeVisible();
+    });
+  });
+
+  /**
+   * Additional tests for conversion edge cases
+   */
+  test.describe('conversion edge cases', () => {
+    test('should handle function-based export conversion config', async ({ page }) => {
+      const FUNCTION_EXPORT_TOOL_SOURCE = `class FunctionExportTool {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            export: (data) => {
+              return data.text || '';
+            },
+            import: 'text',
+          };
+        }
+
+        static get toolbox() {
+          return {
+            icon: 'F',
+            title: 'Function Export',
+          };
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+          contenteditable.contentEditable = 'true';
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      const existingBlock = {
+        id: 'test-id-123',
+        type: 'paragraph',
+        data: {
+          text: 'Some text',
+        },
+      };
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'functionExport',
+            classSource: FUNCTION_EXPORT_TOOL_SOURCE,
+          },
+        ],
+        data: {
+          blocks: [
+            existingBlock,
+          ],
+        },
+      });
+
+      await page.evaluate(async ({ blockId }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const { convert } = window.editorInstance.blocks;
+
+        await convert(blockId, 'functionExport');
+      }, { blockId: existingBlock.id });
+
+      // Wait for conversion
+      await page.waitForFunction(async () => {
+        if (!window.editorInstance) {
+          return false;
+        }
+
+        const { blocks } = await window.editorInstance.save();
+
+        return blocks.length > 0 && blocks[0].type === 'functionExport';
+      });
+
+      const { blocks } = await page.evaluate(async () => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        return await window.editorInstance.save();
+      });
+
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].type).toBe('functionExport');
+      expect(blocks[0].data.text).toBe(existingBlock.data.text);
+    });
+
+    test('should handle function-based import conversion config', async ({ page }) => {
+      const FUNCTION_IMPORT_TOOL_SOURCE = `class FunctionImportTool {
+        constructor(options) {
+          this.data = options.data;
+        }
+
+        static get conversionConfig() {
+          return {
+            export: 'text',
+            import: (content) => {
+              return {
+                text: content.toUpperCase(),
+              };
+            },
+          };
+        }
+
+        static get toolbox() {
+          return {
+            icon: 'F',
+            title: 'Function Import',
+          };
+        }
+
+        render() {
+          const contenteditable = document.createElement('div');
+          if (this.data && this.data.text) {
+            contenteditable.innerHTML = this.data.text;
+          }
+          contenteditable.contentEditable = 'true';
+          return contenteditable;
+        }
+
+        save(block) {
+          return {
+            text: block.innerHTML,
+          };
+        }
+      }`;
+
+      const existingBlock = {
+        id: 'test-id-123',
+        type: 'paragraph',
+        data: {
+          text: 'some text',
+        },
+      };
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'functionImport',
+            classSource: FUNCTION_IMPORT_TOOL_SOURCE,
+          },
+        ],
+        data: {
+          blocks: [
+            existingBlock,
+          ],
+        },
+      });
+
+      await page.evaluate(async ({ blockId }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const { convert } = window.editorInstance.blocks;
+
+        await convert(blockId, 'functionImport');
+      }, { blockId: existingBlock.id });
+
+      // Wait for conversion
+      await page.waitForFunction(async () => {
+        if (!window.editorInstance) {
+          return false;
+        }
+
+        const { blocks } = await window.editorInstance.save();
+
+        return blocks.length > 0 && blocks[0].type === 'functionImport';
+      });
+
+      const { blocks } = await page.evaluate(async () => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        return await window.editorInstance.save();
+      });
+
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].type).toBe('functionImport');
+      // Function import should transform the text
+      expect(blocks[0].data.text).toBe('SOME TEXT');
+    });
+  });
+
+  /**
+   * block.dispatchChange()
+   */
+  test.describe('block.dispatchChange()', () => {
+    /**
+     * Check that block.dispatchChange() triggers Editor 'onChange' callback
+     */
+    test('should trigger onChange with corresponded block', async ({ page }) => {
+      await createEditor(page, {
+        data: editorDataMock,
+        onChange: true,
+      });
+
+      const result = await page.evaluate(({ blockId }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const block = window.editorInstance.blocks.getById(blockId);
+
+        if (!block) {
+          throw new Error(`Block with id ${blockId} not found`);
+        }
+
+        block.dispatchChange();
+
+        return {
+          blockExists: block !== null && block !== undefined,
+          blockId: block.id,
+        };
+      }, { blockId: firstBlock.id });
+
+      expect(result.blockExists).toBe(true);
+      expect(result.blockId).toBe(firstBlock.id);
+
+      // Wait for onChange to be called
+      await page.waitForFunction(() => {
+        const windowObj = window as unknown as { onChangeCalled?: boolean };
+
+        return windowObj.onChangeCalled === true;
+      }, { timeout: 1000 });
+
+      // Get the onChange events from the browser context
+      const onChangeData = await page.evaluate(() => {
+        const windowObj = window as unknown as { onChangeEvents?: unknown[]; onChangeCalled?: boolean };
+
+        return {
+          called: windowObj.onChangeCalled ?? false,
+          events: windowObj.onChangeEvents ?? [],
+        };
+      });
+
+      expect(onChangeData.called).toBe(true);
+      expect(onChangeData.events.length).toBeGreaterThan(0);
+
+      // Single dispatchChange() call should result in a single unwrapped event (not batched)
+      const firstEvent = onChangeData.events[0];
+
+      expect(Array.isArray(firstEvent)).toBe(false);
+      const event = firstEvent as BlockMutationEvent;
+
+      expect(event).toBeDefined();
+      expect(event.type).toBe(BlockChangedMutationType);
+      expect(event.detail).toBeDefined();
+      expect(typeof event.detail).toBe('object');
+      expect(event.detail).not.toBeNull();
+      expect('index' in event.detail).toBe(true);
+      expect((event.detail as { index: number }).index).toBe(0);
+    });
+  });
+});
+
diff --git a/test/playwright/tests/api/caret.spec.ts b/test/playwright/tests/api/caret.spec.ts
new file mode 100644
index 000000000..46f27ac18
--- /dev/null
+++ b/test/playwright/tests/api/caret.spec.ts
@@ -0,0 +1,688 @@
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-block`;
+const BLOCK_SELECTED_CLASS = 'ce-block--selected';
+
+type ToolDefinition = {
+  name: string;
+  classSource: string;
+  config?: Record<string, unknown>;
+};
+
+type EditorSetupOptions = {
+  data?: Record<string, unknown>;
+  config?: Record<string, unknown>;
+  tools?: ToolDefinition[];
+};
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditor = async (page: Page, options: EditorSetupOptions = {}): Promise<void> => {
+  const { data, config, tools = [] } = options;
+
+  await resetEditor(page);
+
+  await page.evaluate(
+    async ({ holderId, rawData, rawConfig, serializedTools }) => {
+      const reviveToolClass = (classSource: string): unknown => {
+        return new Function(`return (${classSource});`)();
+      };
+
+      const revivedTools = serializedTools.reduce<Record<string, unknown>>((accumulator, toolConfig) => {
+        const revivedClass = reviveToolClass(toolConfig.classSource);
+
+        return {
+          ...accumulator,
+          [toolConfig.name]: toolConfig.config
+            ? {
+              ...toolConfig.config,
+              class: revivedClass,
+            }
+            : revivedClass,
+        };
+      }, {});
+
+      const editorConfig = {
+        holder: holderId,
+        ...rawConfig,
+        ...(serializedTools.length > 0 ? { tools: revivedTools } : {}),
+        ...(rawData ? { data: rawData } : {}),
+      };
+
+      const editor = new window.EditorJS(editorConfig);
+
+      window.editorInstance = editor;
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      rawData: data ?? null,
+      rawConfig: config ?? {},
+      serializedTools: tools,
+    }
+  );
+};
+
+const clearSelection = async (page: Page): Promise<void> => {
+  await page.evaluate(() => {
+    window.getSelection()?.removeAllRanges();
+
+    const activeElement = document.activeElement as HTMLElement | null;
+
+    activeElement?.blur?.();
+  });
+};
+
+const createParagraphBlock = (id: string, text: string): Record<string, unknown> => {
+  return {
+    id,
+    type: 'paragraph',
+    data: { text },
+  };
+};
+
+const NonFocusableBlockTool = class {
+  /**
+   *
+   */
+  public static get toolbox(): { title: string } {
+    return {
+      title: 'Static',
+    };
+  }
+
+  /**
+   *
+   */
+  public render(): HTMLElement {
+    const wrapper = document.createElement('div');
+
+    wrapper.textContent = 'Static block without inputs';
+
+    return wrapper;
+  }
+
+  /**
+   *
+   */
+  public save(): Record<string, never> {
+    return {};
+  }
+};
+
+const NON_FOCUSABLE_TOOL_SOURCE = NonFocusableBlockTool.toString();
+
+test.describe('caret API', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+  });
+
+  test.describe('.setToBlock', () => {
+    test('sets caret to a block when block index is passed', async ({ page }) => {
+      const blockId = 'block-index';
+      const paragraphBlock = createParagraphBlock(blockId, 'The first block content mock.');
+
+      await createEditor(page, {
+        data: {
+          blocks: [ paragraphBlock ],
+        },
+      });
+
+      await clearSelection(page);
+
+      const result = await page.evaluate(({ blockSelector }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const returnedValue = window.editorInstance.caret.setToBlock(0);
+        const selection = window.getSelection();
+        const range = selection && selection.rangeCount > 0 ? selection.getRangeAt(0) : null;
+        const blockElement = document.querySelectorAll(blockSelector).item(0) as HTMLElement | null;
+
+        return {
+          returnedValue,
+          rangeExists: !!range,
+          selectionInBlock: !!(range && blockElement && blockElement.contains(range.startContainer)),
+        };
+      }, { blockSelector: BLOCK_SELECTOR });
+
+      expect(result.returnedValue).toBe(true);
+      expect(result.rangeExists).toBe(true);
+      expect(result.selectionInBlock).toBe(true);
+    });
+
+    test('sets caret to a block when block id is passed', async ({ page }) => {
+      const blockId = 'block-id';
+      const paragraphBlock = createParagraphBlock(blockId, 'Paragraph content.');
+
+      await createEditor(page, {
+        data: {
+          blocks: [ paragraphBlock ],
+        },
+      });
+
+      await clearSelection(page);
+
+      const result = await page.evaluate(({ blockSelector, id }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const returnedValue = window.editorInstance.caret.setToBlock(id);
+        const selection = window.getSelection();
+        const range = selection && selection.rangeCount > 0 ? selection.getRangeAt(0) : null;
+        const blockElement = document.querySelectorAll(blockSelector).item(0) as HTMLElement | null;
+
+        return {
+          returnedValue,
+          rangeExists: !!range,
+          selectionInBlock: !!(range && blockElement && blockElement.contains(range.startContainer)),
+        };
+      }, { blockSelector: BLOCK_SELECTOR,
+        id: blockId });
+
+      expect(result.returnedValue).toBe(true);
+      expect(result.rangeExists).toBe(true);
+      expect(result.selectionInBlock).toBe(true);
+    });
+
+    test('sets caret to a block when Block API is passed', async ({ page }) => {
+      const blockId = 'block-api';
+      const paragraphBlock = createParagraphBlock(blockId, 'Paragraph api block.');
+
+      await createEditor(page, {
+        data: {
+          blocks: [ paragraphBlock ],
+        },
+      });
+
+      await clearSelection(page);
+
+      const result = await page.evaluate(({ blockSelector }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const block = window.editorInstance.blocks.getBlockByIndex(0);
+
+        if (!block) {
+          throw new Error('Block not found');
+        }
+
+        const returnedValue = window.editorInstance.caret.setToBlock(block);
+        const selection = window.getSelection();
+        const range = selection && selection.rangeCount > 0 ? selection.getRangeAt(0) : null;
+        const blockElement = document.querySelectorAll(blockSelector).item(0) as HTMLElement | null;
+
+        return {
+          returnedValue,
+          rangeExists: !!range,
+          selectionInBlock: !!(range && blockElement && blockElement.contains(range.startContainer)),
+        };
+      }, { blockSelector: BLOCK_SELECTOR });
+
+      expect(result.returnedValue).toBe(true);
+      expect(result.rangeExists).toBe(true);
+      expect(result.selectionInBlock).toBe(true);
+    });
+
+    test('sets caret at specific offset in text content', async ({ page }) => {
+      const blockId = 'offset-text';
+      const paragraphBlock = createParagraphBlock(blockId, 'Plain text content.');
+
+      await createEditor(page, {
+        data: {
+          blocks: [ paragraphBlock ],
+        },
+      });
+
+      await clearSelection(page);
+
+      const result = await page.evaluate(({ id, offset }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const block = window.editorInstance.blocks.getById(id);
+
+        if (!block) {
+          throw new Error('Block not found');
+        }
+
+        window.editorInstance.caret.setToBlock(block, 'default', offset);
+
+        const selection = window.getSelection();
+
+        if (!selection || selection.rangeCount === 0) {
+          throw new Error('Selection was not set');
+        }
+
+        const range = selection.getRangeAt(0);
+
+        return {
+          startOffset: range.startOffset,
+          startContainerText: range.startContainer.textContent,
+        };
+      }, { id: blockId,
+        offset: 5 });
+
+      expect(result.startOffset).toBe(5);
+      expect(result.startContainerText).toBe('Plain text content.');
+    });
+
+    test('sets caret at correct offset when text contains HTML elements', async ({ page }) => {
+      const blockId = 'offset-html';
+      const paragraphBlock = createParagraphBlock(blockId, '1234<b>567</b>!');
+
+      await createEditor(page, {
+        data: {
+          blocks: [ paragraphBlock ],
+        },
+      });
+
+      await clearSelection(page);
+
+      const result = await page.evaluate(({ id, offset }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const block = window.editorInstance.blocks.getById(id);
+
+        if (!block) {
+          throw new Error('Block not found');
+        }
+
+        window.editorInstance.caret.setToBlock(block, 'default', offset);
+
+        const selection = window.getSelection();
+
+        if (!selection || selection.rangeCount === 0) {
+          throw new Error('Selection was not set');
+        }
+
+        const range = selection.getRangeAt(0);
+
+        return {
+          startOffset: range.startOffset,
+          startContainerText: range.startContainer.textContent,
+        };
+      }, { id: blockId,
+        offset: 6 });
+
+      expect(result.startContainerText).toBe('567');
+      expect(result.startOffset).toBe(2);
+    });
+
+    test('limits caret position to the end when offset exceeds content length', async ({ page }) => {
+      const blockId = 'offset-beyond';
+      const paragraphBlock = createParagraphBlock(blockId, '1234567890');
+
+      await createEditor(page, {
+        data: {
+          blocks: [ paragraphBlock ],
+        },
+      });
+
+      await clearSelection(page);
+
+      const contentLength = '1234567890'.length;
+
+      const result = await page.evaluate(({ id, offset }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const block = window.editorInstance.blocks.getById(id);
+
+        if (!block) {
+          throw new Error('Block not found');
+        }
+
+        window.editorInstance.caret.setToBlock(block, 'default', offset);
+
+        const selection = window.getSelection();
+
+        if (!selection || selection.rangeCount === 0) {
+          throw new Error('Selection was not set');
+        }
+
+        const range = selection.getRangeAt(0);
+
+        return {
+          startOffset: range.startOffset,
+        };
+      }, { id: blockId,
+        offset: contentLength + 10 });
+
+      expect(result.startOffset).toBe(contentLength);
+    });
+
+    test('handles offsets within nested HTML structure', async ({ page }) => {
+      const blockId = 'offset-nested';
+      const paragraphBlock = createParagraphBlock(blockId, '123<b>456<i>789</i></b>!');
+
+      await createEditor(page, {
+        data: {
+          blocks: [ paragraphBlock ],
+        },
+      });
+
+      await clearSelection(page);
+
+      const result = await page.evaluate(({ id, offset }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const block = window.editorInstance.blocks.getById(id);
+
+        if (!block) {
+          throw new Error('Block not found');
+        }
+
+        window.editorInstance.caret.setToBlock(block, 'default', offset);
+
+        const selection = window.getSelection();
+
+        if (!selection || selection.rangeCount === 0) {
+          throw new Error('Selection was not set');
+        }
+
+        const range = selection.getRangeAt(0);
+
+        return {
+          startOffset: range.startOffset,
+          startContainerText: range.startContainer.textContent,
+        };
+      }, { id: blockId,
+        offset: 8 });
+
+      expect(result.startContainerText).toBe('789');
+      expect(result.startOffset).toBe(2);
+    });
+
+    test('respects "start" position regardless of provided offset', async ({ page }) => {
+      const blockId = 'position-start';
+      const paragraphBlock = createParagraphBlock(blockId, 'Starts at the beginning.');
+
+      await createEditor(page, {
+        data: {
+          blocks: [ paragraphBlock ],
+        },
+      });
+
+      await clearSelection(page);
+
+      const result = await page.evaluate(({ id, offset }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const block = window.editorInstance.blocks.getById(id);
+
+        if (!block) {
+          throw new Error('Block not found');
+        }
+
+        window.editorInstance.caret.setToBlock(block, 'start', offset);
+
+        const selection = window.getSelection();
+
+        if (!selection || selection.rangeCount === 0) {
+          throw new Error('Selection was not set');
+        }
+
+        const range = selection.getRangeAt(0);
+
+        return {
+          startOffset: range.startOffset,
+          startContainerText: range.startContainer.textContent,
+        };
+      }, { id: blockId,
+        offset: 10 });
+
+      expect(result.startOffset).toBe(0);
+      expect(result.startContainerText).toBe('Starts at the beginning.');
+    });
+
+    test('places caret at the last text node when "end" position is used', async ({ page }) => {
+      const blockId = 'position-end';
+      const paragraphBlock = createParagraphBlock(blockId, 'Hello <b>world</b>!');
+
+      await createEditor(page, {
+        data: {
+          blocks: [ paragraphBlock ],
+        },
+      });
+
+      await clearSelection(page);
+
+      const result = await page.evaluate(({ id }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const block = window.editorInstance.blocks.getById(id);
+
+        if (!block) {
+          throw new Error('Block not found');
+        }
+
+        window.editorInstance.caret.setToBlock(block, 'end');
+
+        const selection = window.getSelection();
+
+        if (!selection || selection.rangeCount === 0) {
+          throw new Error('Selection was not set');
+        }
+
+        const range = selection.getRangeAt(0);
+
+        return {
+          startOffset: range.startOffset,
+          startContainerText: range.startContainer.textContent,
+        };
+      }, { id: blockId });
+
+      expect(result.startContainerText).toBe('world');
+      expect(result.startOffset).toBe('world'.length);
+    });
+
+    test('does not change selection when block index cannot be resolved', async ({ page }) => {
+      const blockId = 'invalid-index';
+      const paragraphBlock = createParagraphBlock(blockId, 'Block index invalid.');
+
+      await createEditor(page, {
+        data: {
+          blocks: [ paragraphBlock ],
+        },
+      });
+
+      await clearSelection(page);
+
+      const result = await page.evaluate(({ blockSelector, selectedClass }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        window.getSelection()?.removeAllRanges();
+
+        const returnedValue = window.editorInstance.caret.setToBlock(99);
+        const selection = window.getSelection();
+        const selectedBlocks = document.querySelectorAll(`${blockSelector}.${selectedClass}`).length;
+
+        return {
+          returnedValue,
+          rangeCount: selection?.rangeCount ?? 0,
+          selectedBlocks,
+        };
+      }, { blockSelector: BLOCK_SELECTOR,
+        selectedClass: BLOCK_SELECTED_CLASS });
+
+      expect(result.returnedValue).toBe(false);
+      expect(result.rangeCount).toBe(0);
+      expect(result.selectedBlocks).toBe(0);
+    });
+
+    test('does not change selection when block id cannot be resolved', async ({ page }) => {
+      const blockId = 'invalid-id';
+      const paragraphBlock = createParagraphBlock(blockId, 'Block id invalid.');
+
+      await createEditor(page, {
+        data: {
+          blocks: [ paragraphBlock ],
+        },
+      });
+
+      await clearSelection(page);
+
+      const result = await page.evaluate(({ blockSelector, selectedClass }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        window.getSelection()?.removeAllRanges();
+
+        const returnedValue = window.editorInstance.caret.setToBlock('missing-block-id');
+        const selection = window.getSelection();
+        const selectedBlocks = document.querySelectorAll(`${blockSelector}.${selectedClass}`).length;
+
+        return {
+          returnedValue,
+          rangeCount: selection?.rangeCount ?? 0,
+          selectedBlocks,
+        };
+      }, { blockSelector: BLOCK_SELECTOR,
+        selectedClass: BLOCK_SELECTED_CLASS });
+
+      expect(result.returnedValue).toBe(false);
+      expect(result.rangeCount).toBe(0);
+      expect(result.selectedBlocks).toBe(0);
+    });
+
+    test('does not change selection when Block API instance is stale', async ({ page }) => {
+      const paragraphBlock = createParagraphBlock('stale-block', 'Block api stale.');
+
+      await createEditor(page, {
+        data: {
+          blocks: [paragraphBlock, createParagraphBlock('second-block', 'Second block')],
+        },
+      });
+
+      await clearSelection(page);
+
+      const result = await page.evaluate(({ blockSelector, selectedClass }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const block = window.editorInstance.blocks.getBlockByIndex(0);
+
+        if (!block) {
+          throw new Error('Block not found');
+        }
+
+        window.editorInstance.blocks.delete(0);
+        window.getSelection()?.removeAllRanges();
+
+        const returnedValue = window.editorInstance.caret.setToBlock(block);
+        const selection = window.getSelection();
+        const selectedBlocks = document.querySelectorAll(`${blockSelector}.${selectedClass}`).length;
+
+        return {
+          returnedValue,
+          rangeCount: selection?.rangeCount ?? 0,
+          selectedBlocks,
+        };
+      }, { blockSelector: BLOCK_SELECTOR,
+        selectedClass: BLOCK_SELECTED_CLASS });
+
+      expect(result.returnedValue).toBe(false);
+      expect(result.rangeCount).toBe(0);
+      expect(result.selectedBlocks).toBe(0);
+    });
+
+    test('highlights non-focusable blocks instead of placing a caret', async ({ page }) => {
+      const paragraphBlock = createParagraphBlock('focusable-block', 'Focusable content');
+      const staticBlockId = 'static-block';
+      const staticBlock = {
+        id: staticBlockId,
+        type: 'nonFocusable',
+        data: {},
+      };
+
+      await createEditor(page, {
+        data: {
+          blocks: [paragraphBlock, staticBlock],
+        },
+        tools: [
+          {
+            name: 'nonFocusable',
+            classSource: NON_FOCUSABLE_TOOL_SOURCE,
+          },
+        ],
+      });
+
+      await clearSelection(page);
+
+      const result = await page.evaluate(({ blockSelector, selectedClass }) => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        const returnedValue = window.editorInstance.caret.setToBlock(1);
+        const selection = window.getSelection();
+        const blocks = document.querySelectorAll(blockSelector);
+        const secondBlock = blocks.item(1) as HTMLElement | null;
+        const firstBlock = blocks.item(0) as HTMLElement | null;
+
+        return {
+          returnedValue,
+          rangeCount: selection?.rangeCount ?? 0,
+          secondBlockSelected: !!secondBlock && secondBlock.classList.contains(selectedClass),
+          firstBlockSelected: !!firstBlock && firstBlock.classList.contains(selectedClass),
+        };
+      }, { blockSelector: BLOCK_SELECTOR,
+        selectedClass: BLOCK_SELECTED_CLASS });
+
+      expect(result.returnedValue).toBe(true);
+      expect(result.rangeCount).toBe(0);
+      expect(result.secondBlockSelected).toBe(true);
+      expect(result.firstBlockSelected).toBe(false);
+    });
+  });
+});
+
diff --git a/test/playwright/tests/api/toolbar.spec.ts b/test/playwright/tests/api/toolbar.spec.ts
new file mode 100644
index 000000000..54ec54435
--- /dev/null
+++ b/test/playwright/tests/api/toolbar.spec.ts
@@ -0,0 +1,155 @@
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { OutputData } from '@/types';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const TOOLBOX_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbox`;
+const TOOLBOX_POPOVER_SELECTOR = `${TOOLBOX_SELECTOR} .ce-popover__container`;
+
+/**
+ * Reset the editor holder and destroy any existing instance
+ *
+ * @param page - The Playwright page object
+ */
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ * Create editor with initial data
+ *
+ * @param page - The Playwright page object
+ * @param data - Initial editor data
+ */
+const createEditor = async (page: Page, data?: OutputData): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(
+    async ({ holderId, editorData }) => {
+      const editor = new window.EditorJS({
+        holder: holderId,
+        ...(editorData ? { data: editorData } : {}),
+      });
+
+      window.editorInstance = editor;
+      await editor.isReady;
+      editor.caret.setToFirstBlock();
+    },
+    { holderId: HOLDER_ID,
+      editorData: data }
+  );
+};
+
+test.describe('api.toolbar', () => {
+  /**
+   * api.toolbar.toggleToolbox(openingState?: boolean)
+   */
+  const firstBlock = {
+    id: 'bwnFX5LoX7',
+    type: 'paragraph',
+    data: {
+      text: 'The first block content mock.',
+    },
+  };
+  const editorDataMock: OutputData = {
+    blocks: [
+      firstBlock,
+    ],
+  };
+
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await createEditor(page, editorDataMock);
+  });
+
+  test.describe('*.toggleToolbox()', () => {
+    test('should open the toolbox', async ({ page }) => {
+      await page.evaluate(() => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        window.editorInstance.toolbar.toggleToolbox(true);
+      });
+
+      const toolboxPopover = page.locator(TOOLBOX_POPOVER_SELECTOR);
+
+      await expect(toolboxPopover).toBeVisible();
+    });
+
+    test('should close the toolbox', async ({ page }) => {
+      await page.evaluate(() => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        window.editorInstance.toolbar.toggleToolbox(true);
+      });
+
+      // Wait for toolbox to be visible
+      await expect(page.locator(TOOLBOX_POPOVER_SELECTOR)).toBeVisible();
+
+      await page.evaluate(() => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        window.editorInstance.toolbar.toggleToolbox(false);
+      });
+
+      // Wait for toolbox to be hidden
+      await expect(page.locator(TOOLBOX_POPOVER_SELECTOR)).toBeHidden();
+    });
+
+    test('should toggle the toolbox', async ({ page }) => {
+      await page.evaluate(() => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        window.editorInstance.toolbar.toggleToolbox();
+      });
+
+      // Wait for toolbox to be visible
+      await expect(page.locator(TOOLBOX_POPOVER_SELECTOR)).toBeVisible();
+
+      await page.evaluate(() => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        window.editorInstance.toolbar.toggleToolbox();
+      });
+
+      // Wait for toolbox to be hidden
+      await expect(page.locator(TOOLBOX_POPOVER_SELECTOR)).toBeHidden();
+    });
+  });
+});
+
diff --git a/test/playwright/tests/api/toolbox-entries.spec.ts b/test/playwright/tests/api/toolbox-entries.spec.ts
new file mode 100644
index 000000000..d964000d0
--- /dev/null
+++ b/test/playwright/tests/api/toolbox-entries.spec.ts
@@ -0,0 +1,492 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { ToolboxConfig, ToolboxConfigEntry, BlockToolData, OutputData } from '@/types';
+import type { BlockToolConstructable } from '@/types/tools';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .cdx-block`;
+const PLUS_BUTTON_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__plus`;
+const POPOVER_ITEM_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-popover-item`;
+const POPOVER_ITEM_ICON_SELECTOR = '.ce-popover-item__icon';
+
+const ICON = '<svg width="17" height="15" viewBox="0 0 336 276" xmlns="http://www.w3.org/2000/svg"><path d="M291 150V79c0-19-15-34-34-34H79c-19 0-34 15-34 34v42l67-44 81 72 56-29 42 30zm0 52l-43-30-56 30-81-67-66 39v23c0 19 15 34 34 34h178c17 0 31-13 34-29zM79 0h178c44 0 79 35 79 79v118c0 44-35 79-79 79H79c-44 0-79-35-79-79V79C0 35 35 0 79 0z"></path></svg>';
+
+const getLocatorOrThrow = (locators: Locator[], index: number, errorMessage: string): Locator => {
+  const locator = locators[index];
+
+  if (!locator) {
+    throw new Error(errorMessage);
+  }
+
+  return locator;
+};
+
+const getFirstBlock = async (page: Page): Promise<Locator> => {
+  const blocks = await page.locator(BLOCK_SELECTOR).all();
+  const firstBlock = blocks[0];
+
+  if (!firstBlock) {
+    throw new Error('No editor blocks were rendered');
+  }
+
+  return firstBlock;
+};
+
+const getLastBlock = async (page: Page): Promise<Locator> => {
+  const blocks = await page.locator(BLOCK_SELECTOR).all();
+  const lastBlock = blocks[blocks.length - 1];
+
+  if (!lastBlock) {
+    throw new Error('No editor blocks were rendered');
+  }
+
+  return lastBlock;
+};
+
+/**
+ * Reset the editor holder and destroy any existing instance
+ *
+ * @param page - The Playwright page object
+ */
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ * Create editor with custom tools
+ *
+ * @param page - The Playwright page object
+ * @param tools - Tools configuration
+ */
+type ToolRegistrationOptions = {
+  globals?: Record<string, unknown>;
+};
+
+type SerializedToolConfig = {
+  name: string;
+  classSource: string;
+  config?: Record<string, unknown>;
+};
+
+const serializeTools = (
+  tools: Record<string, BlockToolConstructable | { class: BlockToolConstructable }>
+): SerializedToolConfig[] => {
+  return Object.entries(tools).map(([name, tool]) => {
+    if (typeof tool === 'function') {
+      return {
+        name,
+        classSource: tool.toString(),
+      };
+    }
+
+    const { class: toolClass, ...config } = tool;
+
+    return {
+      name,
+      classSource: toolClass.toString(),
+      config,
+    };
+  });
+};
+
+const createEditorWithTools = async (
+  page: Page,
+  tools: Record<string, BlockToolConstructable | { class: BlockToolConstructable }>,
+  options: ToolRegistrationOptions = {}
+): Promise<void> => {
+  await resetEditor(page);
+  const serializedTools = serializeTools(tools);
+
+  const registeredToolNames = await page.evaluate(
+    async ({ holderId, editorTools, globals }) => {
+      const reviveToolClass = (classSource: string, classGlobals: Record<string, unknown>): BlockToolConstructable => {
+        const globalKeys = Object.keys(classGlobals);
+        const factoryBody = `${globalKeys
+          .map((key) => `const ${key} = globals[${JSON.stringify(key)}];`)
+          .join('\n')}
+return (${classSource});
+`;
+
+        return new Function('globals', factoryBody)(classGlobals) as BlockToolConstructable;
+      };
+
+      const toolsMap = editorTools.reduce<Record<string, BlockToolConstructable | { class: BlockToolConstructable }>>(
+        (accumulated, toolConfig) => {
+          const toolClass = reviveToolClass(toolConfig.classSource, globals);
+
+          if (toolConfig.config) {
+            return {
+              ...accumulated,
+              [toolConfig.name]: {
+                ...toolConfig.config,
+                class: toolClass,
+              },
+            };
+          }
+
+          return {
+            ...accumulated,
+            [toolConfig.name]: toolClass,
+          };
+        },
+        {}
+      );
+
+      const editor = new window.EditorJS({
+        holder: holderId,
+        tools: toolsMap,
+      });
+
+      window.editorInstance = editor;
+      await editor.isReady;
+
+      return Object.keys(toolsMap);
+    },
+    {
+      holderId: HOLDER_ID,
+      editorTools: serializedTools,
+      globals: options.globals ?? {},
+    }
+  );
+
+  const missingTools = Object.keys(tools).filter((toolName) => !registeredToolNames.includes(toolName));
+
+  if (missingTools.length > 0) {
+    throw new Error(`Failed to register tools: ${missingTools.join(', ')}`);
+  }
+};
+
+/**
+ * Save editor data
+ *
+ * @param page - The Playwright page object
+ * @returns The saved output data
+ */
+const saveEditor = async (page: Page): Promise<OutputData> => {
+  return await page.evaluate(async () => {
+    if (!window.editorInstance) {
+      throw new Error('Editor instance not found');
+    }
+
+    return await window.editorInstance.save();
+  });
+};
+
+test.describe('editor Tools Api', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+  });
+
+  test.describe('toolbox', () => {
+    test('should render a toolbox entry for tool if configured', async ({ page }) => {
+      /**
+       * Tool with single toolbox entry configured
+       */
+      const TestTool = class {
+        /**
+         * Returns toolbox config as list of entries
+         */
+        public static get toolbox(): ToolboxConfigEntry {
+          return {
+            title: 'Entry 1',
+            icon: ICON,
+          };
+        }
+
+        private data: { text: string };
+
+        /**
+         * Tool constructor
+         *
+         * @param root0 - Constructor parameters
+         * @param root0.data - Tool data
+         */
+        constructor({ data }: { data: { text: string } }) {
+          this.data = { text: data.text };
+        }
+
+        /**
+         * Return Tool's view
+         */
+        public render(): HTMLElement {
+          const contenteditable = document.createElement('div');
+
+          contenteditable.contentEditable = 'true';
+          contenteditable.classList.add('cdx-block');
+          // Always initialize textContent to ensure it's never null
+          contenteditable.textContent = this.data.text;
+
+          return contenteditable;
+        }
+
+        /**
+         * Extracts Tool's data from the view
+         *
+         * @param el - Tool view element
+         */
+        public save(el: HTMLElement): { text: string } {
+          // textContent is initialized in render with this.data.text which is always a string
+          const textContent = el.textContent;
+
+          return {
+            text: textContent as string,
+          };
+        }
+      };
+
+      await createEditorWithTools(
+        page,
+        {
+          testTool: TestTool as unknown as BlockToolConstructable,
+        },
+        { globals: { ICON } }
+      );
+
+      const block = await getFirstBlock(page);
+
+      await block.click();
+
+      const plusButton = page.locator(PLUS_BUTTON_SELECTOR);
+
+      await expect(plusButton).toBeVisible();
+      await plusButton.click();
+
+      const toolboxItems = page.locator(`${POPOVER_ITEM_SELECTOR}[data-item-name="testTool"]`);
+
+      await expect(toolboxItems).toHaveCount(1);
+
+      const icons = await toolboxItems.locator(POPOVER_ITEM_ICON_SELECTOR).all();
+      const icon = getLocatorOrThrow(icons, 0, 'Toolbox icon was not rendered');
+      const iconHTML = await icon.innerHTML();
+
+      expect(iconHTML).toContain(TestTool.toolbox.icon);
+    });
+
+    test('should render several toolbox entries for one tool if configured', async ({ page }) => {
+      /**
+       * Tool with several toolbox entries configured
+       */
+      const TestTool = class {
+        /**
+         * Returns toolbox config as list of entries
+         */
+        public static get toolbox(): ToolboxConfig {
+          return [
+            {
+              title: 'Entry 1',
+              icon: ICON,
+            },
+            {
+              title: 'Entry 2',
+              icon: ICON,
+            },
+          ];
+        }
+
+        private data: { text: string };
+
+        /**
+         * Tool constructor
+         *
+         * @param root0 - Constructor parameters
+         * @param root0.data - Tool data
+         */
+        constructor({ data }: { data: { text: string } }) {
+          this.data = { text: data.text };
+        }
+
+        /**
+         * Return Tool's view
+         */
+        public render(): HTMLElement {
+          const contenteditable = document.createElement('div');
+
+          contenteditable.contentEditable = 'true';
+          contenteditable.classList.add('cdx-block');
+          // Always initialize textContent to ensure it's never null
+          contenteditable.textContent = this.data.text;
+
+          return contenteditable;
+        }
+
+        /**
+         * Extracts Tool's data from the view
+         *
+         * @param el - Tool view element
+         */
+        public save(el: HTMLElement): { text: string } {
+          // textContent is initialized in render with this.data.text which is always a string
+          const textContent = el.textContent;
+
+          return {
+            text: textContent as string,
+          };
+        }
+      };
+
+      await createEditorWithTools(
+        page,
+        {
+          testTool: TestTool as unknown as BlockToolConstructable,
+        },
+        { globals: { ICON } }
+      );
+
+      const block = await getFirstBlock(page);
+
+      await block.click();
+
+      const plusButton = page.locator(PLUS_BUTTON_SELECTOR);
+
+      await expect(plusButton).toBeVisible();
+      await plusButton.click();
+
+      const toolboxItems = page.locator(`${POPOVER_ITEM_SELECTOR}[data-item-name="testTool"]`);
+
+      await expect(toolboxItems).toHaveCount(2);
+
+      const toolboxConfig = TestTool.toolbox as ToolboxConfigEntry[];
+
+      const toolboxEntries = await toolboxItems.all();
+      const firstEntry = getLocatorOrThrow(toolboxEntries, 0, 'First toolbox entry was not rendered');
+      const secondEntry = getLocatorOrThrow(toolboxEntries, 1, 'Second toolbox entry was not rendered');
+
+      await expect(firstEntry).toContainText(toolboxConfig[0].title ?? '');
+      await expect(secondEntry).toContainText(toolboxConfig[1].title ?? '');
+    });
+
+    test('should insert block with overridden data on entry click in case toolbox entry provides data overrides', async ({ page }) => {
+      const text = 'Text';
+      const dataOverrides = {
+        testProp: 'new value',
+      };
+
+      /**
+       * Tool with default data to be overridden
+       */
+      const TestTool = class {
+        private _data: { testProp: string; text?: string };
+
+        /**
+         * Tool constructor
+         *
+         * @param data - previously saved data
+         */
+        constructor({ data }: { data: { testProp: string; text?: string } }) {
+          this._data = data;
+        }
+
+        /**
+         * Returns toolbox config as list of entries with overridden data
+         */
+        public static get toolbox(): ToolboxConfig {
+          return [
+            {
+              title: 'Entry 1',
+              icon: ICON,
+              data: dataOverrides,
+            },
+          ];
+        }
+
+        /**
+         * Return Tool's view
+         */
+        public render(): HTMLElement {
+          const wrapper = document.createElement('div');
+
+          wrapper.setAttribute('contenteditable', 'true');
+          wrapper.classList.add('cdx-block');
+
+          return wrapper;
+        }
+
+        /**
+         * Extracts Tool's data from the view
+         *
+         * @param el - tool view
+         */
+        public save(el: HTMLElement): BlockToolData {
+          return {
+            ...this._data,
+            text: el.innerHTML,
+          };
+        }
+      };
+
+      await createEditorWithTools(
+        page,
+        {
+          testTool: TestTool as unknown as BlockToolConstructable,
+        },
+        {
+          globals: {
+            ICON,
+            dataOverrides,
+          },
+        }
+      );
+
+      const block = await getFirstBlock(page);
+
+      await block.click();
+
+      const plusButton = page.locator(PLUS_BUTTON_SELECTOR);
+
+      await expect(plusButton).toBeVisible();
+      await plusButton.click();
+
+      const toolboxEntryLocators = await page
+        .locator(`${POPOVER_ITEM_SELECTOR}[data-item-name="testTool"]`)
+        .all();
+      const toolboxItem = getLocatorOrThrow(
+        toolboxEntryLocators,
+        0,
+        'Toolbox entry was not rendered'
+      );
+
+      await toolboxItem.click();
+
+      const insertedBlock = await getLastBlock(page);
+
+      await insertedBlock.waitFor({ state: 'visible' });
+      await insertedBlock.click();
+      await insertedBlock.type(text);
+
+      const editorData = await saveEditor(page);
+
+      expect(editorData.blocks[0].data).toStrictEqual({
+        ...dataOverrides,
+        text,
+      });
+    });
+  });
+});
+
diff --git a/test/playwright/tests/api/tools.spec.ts b/test/playwright/tests/api/tools.spec.ts
new file mode 100644
index 000000000..ad4ced9b6
--- /dev/null
+++ b/test/playwright/tests/api/tools.spec.ts
@@ -0,0 +1,794 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import type EditorJS from '@/types';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const BLOCK_WRAPPER_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-cy="block-wrapper"]`;
+const DEFAULT_BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} div.ce-block`;
+const ICON = '<svg width="17" height="15" viewBox="0 0 336 276" xmlns="http://www.w3.org/2000/svg"><path d="M291 150V79c0-19-15-34-34-34H79c-19 0-34 15-34 34v42l67-44 81 72 56-29 42 30zm0 52l-43-30-56 30-81-67-66 39v23c0 19 15 34 34 34h178c17 0 31-13 34-29zM79 0h178c44 0 79 35 79 79v118c0 44-35 79-79 79H79c-44 0-79-35-79-79V79C0 35 35 0 79 0z"></path></svg>';
+
+type ToolDefinition = {
+  name: string;
+  classSource: string;
+  config?: Record<string, unknown>;
+};
+
+type EditorSetupOptions = {
+  data?: Record<string, unknown>;
+  tools?: ToolDefinition[];
+  config?: Record<string, unknown>;
+};
+
+interface ElementSnapshot {
+  tagName: string;
+  attributes: Array<{ name: string; value: string }>;
+  children: ElementSnapshot[];
+  text: string;
+}
+
+const getBlockWrapperSelectorByIndex = (index: number): string => {
+  return `:nth-match(${BLOCK_WRAPPER_SELECTOR}, ${index + 1})`;
+};
+
+const getBlockByIndex = (page: Page, index: number): Locator => {
+  return page.locator(`${DEFAULT_BLOCK_SELECTOR}:nth-of-type(${index + 1})`);
+};
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditor = async (page: Page, options: EditorSetupOptions = {}): Promise<void> => {
+  const { data, tools = [], config = {} } = options;
+
+  await resetEditor(page);
+  await page.waitForFunction(() => typeof window.EditorJS === 'function');
+
+  await page.evaluate(
+    async ({ holderId, rawData, serializedTools, rawConfig }) => {
+      const reviveToolClass = (classSource: string): unknown => {
+        // eslint-disable-next-line no-new-func -- constructing helper class inside page context
+        return new Function(`return (${classSource});`)();
+      };
+
+      const revivedTools = serializedTools.reduce<Record<string, Record<string, unknown>>>(
+        (accumulator, toolConfig) => {
+          const revivedClass = reviveToolClass(toolConfig.classSource);
+
+          const toolSettings: Record<string, unknown> = {
+            class: revivedClass,
+          };
+
+          if (toolConfig.config !== undefined) {
+            toolSettings.config = toolConfig.config;
+          }
+
+          return {
+            ...accumulator,
+            [toolConfig.name]: toolSettings,
+          };
+        },
+        {}
+      );
+
+      const editorConfig: Record<string, unknown> = {
+        holder: holderId,
+        ...rawConfig,
+      };
+
+      if (rawData) {
+        editorConfig.data = rawData;
+      }
+
+      if (serializedTools.length > 0) {
+        editorConfig.tools = revivedTools;
+      }
+
+      const editor = new window.EditorJS(editorConfig);
+
+      window.editorInstance = editor;
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      rawData: data ?? null,
+      serializedTools: tools,
+      rawConfig: config,
+    }
+  );
+};
+
+const focusBlockByIndex = async (page: Page, index: number = 0): Promise<void> => {
+  await page.evaluate(({ blockIndex }) => {
+    if (!window.editorInstance) {
+      throw new Error('Editor instance not found');
+    }
+
+    const didSetCaret = window.editorInstance.caret.setToBlock(blockIndex);
+
+    if (!didSetCaret) {
+      throw new Error(`Failed to set caret to block at index ${blockIndex}`);
+    }
+  }, { blockIndex: index });
+};
+
+const openBlockSettings = async (page: Page, index: number = 0): Promise<void> => {
+  await focusBlockByIndex(page, index);
+
+  const block = page.locator(getBlockWrapperSelectorByIndex(index));
+
+  await block.scrollIntoViewIfNeeded();
+  await block.click();
+  await block.hover();
+
+  const settingsButton = page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__settings-btn`);
+
+  await settingsButton.waitFor({ state: 'visible' });
+  await settingsButton.click();
+
+  await expect(
+    page
+      .locator(`${EDITOR_INTERFACE_SELECTOR} [data-cy="block-tunes"] .ce-popover[data-popover-opened="true"]`)
+  ).toHaveCount(1);
+};
+
+const paste = async (page: Page, target: Locator, data: Record<string, string>): Promise<void> => {
+  await target.evaluate((element: HTMLElement, pasteData: Record<string, string>) => {
+    const pasteEvent = Object.assign(new Event('paste', {
+      bubbles: true,
+      cancelable: true,
+    }), {
+      clipboardData: {
+        getData: (type: string): string => pasteData[type] ?? '',
+        types: Object.keys(pasteData),
+      },
+    });
+
+    element.dispatchEvent(pasteEvent);
+  }, data);
+
+  await page.evaluate(() => {
+    return new Promise((resolve) => {
+      setTimeout(resolve, 200);
+    });
+  });
+};
+
+const createTuneToolSource = (renderSettingsBody: string): string => {
+  return `
+class TestTool {
+  constructor({ data }) {
+    this.data = data ?? {};
+  }
+
+  static get toolbox() {
+    return {
+      title: 'Test tool',
+      icon: '${ICON}',
+    };
+  }
+
+  render() {
+    const element = document.createElement('div');
+
+    element.contentEditable = 'true';
+    element.setAttribute('data-name', 'testBlock');
+    element.textContent = this.data?.text ?? '';
+
+    return element;
+  }
+
+  save(element) {
+    return {
+      text: element.textContent ?? '',
+    };
+  }
+
+  renderSettings() {
+    ${renderSettingsBody}
+  }
+}
+`;
+};
+
+const createPasteToolSource = ({
+  pasteConfig,
+  renderBody,
+}: {
+  pasteConfig: string;
+  renderBody: string;
+}): string => {
+  return `
+class TestTool {
+  constructor({ data }) {
+    this.data = data ?? {};
+  }
+
+  static get pasteConfig() {
+    return ${pasteConfig};
+  }
+
+  render() {
+    ${renderBody}
+  }
+
+  save() {
+    return {};
+  }
+
+  onPaste(event) {
+    window.__onPasteCalls = (window.__onPasteCalls ?? 0) + 1;
+
+    const data = event.detail?.data ?? null;
+
+    window.__lastPasteSnapshot = this.createSnapshot(data);
+  }
+
+  createSnapshot(element) {
+    if (!(element instanceof HTMLElement)) {
+      return null;
+    }
+
+    return {
+      tagName: element.tagName.toLowerCase(),
+      attributes: Array.from(element.attributes).map((attr) => ({
+        name: attr.name,
+        value: attr.value,
+      })),
+      children: Array.from(element.children).map((child) => this.createSnapshot(child)),
+      text: element.textContent ?? '',
+    };
+  }
+}
+`;
+};
+
+test.describe('api.tools', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+    await page.evaluate(() => {
+      window.__onPasteCalls = 0;
+      window.__lastPasteSnapshot = null;
+    });
+  });
+
+  test.describe('renderSettings', () => {
+    test('should render single tune configured via renderSettings()', async ({ page }) => {
+      const singleTuneToolSource = createTuneToolSource(`
+        return {
+          label: 'Test tool tune',
+          icon: '${ICON}',
+          name: 'testToolTune',
+          onActivate: () => {},
+        };
+      `);
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'testTool',
+            classSource: singleTuneToolSource,
+          },
+        ],
+        data: {
+          blocks: [
+            {
+              type: 'testTool',
+              data: {
+                text: 'some text',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockSettings(page, 0);
+
+      await expect(page.locator('[data-item-name="testToolTune"]')).toBeVisible();
+    });
+
+    test('should render multiple tunes when renderSettings() returns array', async ({ page }) => {
+      const multipleTunesToolSource = createTuneToolSource(`
+        return [
+          {
+            label: 'Test tool tune 1',
+            icon: '${ICON}',
+            name: 'testToolTune1',
+            onActivate: () => {},
+          },
+          {
+            label: 'Test tool tune 2',
+            icon: '${ICON}',
+            name: 'testToolTune2',
+            onActivate: () => {},
+          },
+        ];
+      `);
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'testTool',
+            classSource: multipleTunesToolSource,
+          },
+        ],
+        data: {
+          blocks: [
+            {
+              type: 'testTool',
+              data: {
+                text: 'some text',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockSettings(page, 0);
+
+      await expect(page.locator('[data-item-name="testToolTune1"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="testToolTune2"]')).toBeVisible();
+    });
+
+    test('should support custom html returned from renderSettings()', async ({ page }) => {
+      const sampleText = 'sample text';
+      const customHtmlToolSource = createTuneToolSource(`
+        const element = document.createElement('div');
+
+        element.textContent = '${sampleText}';
+
+        return element;
+      `);
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'testTool',
+            classSource: customHtmlToolSource,
+          },
+        ],
+        data: {
+          blocks: [
+            {
+              type: 'testTool',
+              data: {
+                text: 'some text',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockSettings(page, 0);
+
+      await expect(
+        page.locator(
+          `${EDITOR_INTERFACE_SELECTOR} [data-cy="block-tunes"] .ce-popover[data-popover-opened="true"]`
+        )
+      ).toContainText(sampleText);
+    });
+
+    test('should support title and label aliases for tune text', async ({ page }) => {
+      const labelAliasToolSource = createTuneToolSource(`
+        return [
+          {
+            icon: '${ICON}',
+            name: 'testToolTune1',
+            onActivate: () => {},
+            title: 'Test tool tune 1',
+          },
+          {
+            icon: '${ICON}',
+            name: 'testToolTune2',
+            onActivate: () => {},
+            label: 'Test tool tune 2',
+          },
+        ];
+      `);
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'testTool',
+            classSource: labelAliasToolSource,
+          },
+        ],
+        data: {
+          blocks: [
+            {
+              type: 'testTool',
+              data: {
+                text: 'some text',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockSettings(page, 0);
+
+      await expect(page.locator('[data-item-name="testToolTune1"]')).toContainText('Test tool tune 1');
+      await expect(page.locator('[data-item-name="testToolTune2"]')).toContainText('Test tool tune 2');
+    });
+  });
+
+  test.describe('pasteConfig', () => {
+    test('should use corresponding tool when tag names are specified', async ({ page }) => {
+      const toolSource = createPasteToolSource({
+        pasteConfig: `{
+          tags: ['img'],
+        }`,
+        renderBody: `
+          return document.createElement('img');
+        `,
+      });
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'testTool',
+            classSource: toolSource,
+          },
+        ],
+      });
+
+      const block = getBlockByIndex(page, 0);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<img>',
+      });
+
+      const onPasteCalls = await page.evaluate(() => {
+        return window.__onPasteCalls ?? 0;
+      });
+
+      expect(onPasteCalls).toBeGreaterThan(0);
+    });
+
+    test('should sanitize attributes when only tag name is specified', async ({ page }) => {
+      const toolSource = createPasteToolSource({
+        pasteConfig: `{
+          tags: ['img'],
+        }`,
+        renderBody: `
+          return document.createElement('img');
+        `,
+      });
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'testTool',
+            classSource: toolSource,
+          },
+        ],
+      });
+
+      const block = getBlockByIndex(page, 0);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<img src="foo" onerror="alert(123)"/>',
+      });
+
+      const snapshot = await page.evaluate<ElementSnapshot | null>(() => {
+        return (window.__lastPasteSnapshot ?? null) as ElementSnapshot | null;
+      });
+
+      expect(snapshot).not.toBeNull();
+      expect(snapshot?.tagName).toBe('img');
+      expect(snapshot?.attributes).toHaveLength(0);
+    });
+
+    test('should sanitize uppercase tag names and preserve children', async ({ page }) => {
+      const toolSource = createPasteToolSource({
+        pasteConfig: `{
+          tags: ['OL', 'LI'],
+        }`,
+        renderBody: `
+          return document.createElement('ol');
+        `,
+      });
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'testTool',
+            classSource: toolSource,
+          },
+        ],
+      });
+
+      const block = getBlockByIndex(page, 0);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<ol start="50"><li>Ordered List</li><li>Unordered List</li></ol>',
+      });
+
+      const snapshot = await page.evaluate<ElementSnapshot | null>(() => {
+        return (window.__lastPasteSnapshot ?? null) as ElementSnapshot | null;
+      });
+
+      expect(snapshot).not.toBeNull();
+      expect(snapshot?.tagName).toBe('ol');
+      expect(snapshot?.attributes).toHaveLength(0);
+      expect(snapshot?.children).toHaveLength(2);
+      snapshot?.children.forEach((child) => {
+        expect(child.tagName).toBe('li');
+        expect(child.attributes).toHaveLength(0);
+      });
+    });
+
+    test('should preserve attributes defined in sanitizer config', async ({ page }) => {
+      const toolSource = createPasteToolSource({
+        pasteConfig: `{
+          tags: [
+            {
+              img: {
+                src: true,
+              },
+            },
+          ],
+        }`,
+        renderBody: `
+          return document.createElement('img');
+        `,
+      });
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'testTool',
+            classSource: toolSource,
+          },
+        ],
+      });
+
+      const block = getBlockByIndex(page, 0);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<img src="foo" onerror="alert(123)"/>',
+      });
+
+      const snapshot = await page.evaluate<ElementSnapshot | null>(() => {
+        return (window.__lastPasteSnapshot ?? null) as ElementSnapshot | null;
+      });
+
+      expect(snapshot).not.toBeNull();
+      expect(snapshot?.tagName).toBe('img');
+      expect(snapshot?.attributes).toHaveLength(1);
+      expect(snapshot?.attributes[0]).toStrictEqual({
+        name: 'src',
+        value: 'foo',
+      });
+    });
+
+    test('should support mixed tag names and sanitizer config', async ({ page }) => {
+      const toolSource = createPasteToolSource({
+        pasteConfig: `{
+          tags: [
+            'video',
+            {
+              source: {
+                src: true,
+              },
+            },
+          ],
+        }`,
+        renderBody: `
+          return document.createElement('video');
+        `,
+      });
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'testTool',
+            classSource: toolSource,
+          },
+        ],
+      });
+
+      const block = getBlockByIndex(page, 0);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<video width="100"><source src="movie.mp4" type="video/mp4"></video>',
+      });
+
+      const snapshot = await page.evaluate<ElementSnapshot | null>(() => {
+        return (window.__lastPasteSnapshot ?? null) as ElementSnapshot | null;
+      });
+
+      expect(snapshot).not.toBeNull();
+      expect(snapshot?.tagName).toBe('video');
+      expect(snapshot?.attributes).toHaveLength(0);
+      expect(snapshot?.children).toHaveLength(1);
+      const sourceSnapshot = snapshot?.children[0];
+
+      expect(sourceSnapshot?.tagName).toBe('source');
+      expect(sourceSnapshot?.attributes).toHaveLength(1);
+      expect(sourceSnapshot?.attributes[0]).toStrictEqual({
+        name: 'src',
+        value: 'movie.mp4',
+      });
+    });
+
+    test('should support configs with several keys as single entry', async ({ page }) => {
+      const toolSource = createPasteToolSource({
+        pasteConfig: `{
+          tags: [
+            {
+              video: {
+                width: true,
+              },
+              source: {
+                src: true,
+              },
+            },
+          ],
+        }`,
+        renderBody: `
+          return document.createElement('video');
+        `,
+      });
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'testTool',
+            classSource: toolSource,
+          },
+        ],
+      });
+
+      const block = getBlockByIndex(page, 0);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<video width="100"><source src="movie.mp4" type="video/mp4"></video>',
+      });
+
+      const snapshot = await page.evaluate<ElementSnapshot | null>(() => {
+        return (window.__lastPasteSnapshot ?? null) as ElementSnapshot | null;
+      });
+
+      expect(snapshot).not.toBeNull();
+      expect(snapshot?.tagName).toBe('video');
+      expect(snapshot?.attributes).toHaveLength(1);
+      expect(snapshot?.attributes[0]).toStrictEqual({
+        name: 'width',
+        value: '100',
+      });
+
+      const sourceSnapshot = snapshot?.children[0];
+
+      expect(sourceSnapshot?.tagName).toBe('source');
+      expect(sourceSnapshot?.attributes).toHaveLength(1);
+      expect(sourceSnapshot?.attributes[0]).toStrictEqual({
+        name: 'src',
+        value: 'movie.mp4',
+      });
+    });
+
+    test('should correctly sanitize table structure', async ({ page }) => {
+      const toolSource = createPasteToolSource({
+        pasteConfig: `{
+          tags: [
+            'table',
+            'tbody',
+            {
+              td: {
+                width: true,
+              },
+              tr: {
+                height: true,
+              },
+            },
+          ],
+        }`,
+        renderBody: `
+          return document.createElement('tbody');
+        `,
+      });
+
+      await createEditor(page, {
+        tools: [
+          {
+            name: 'testTool',
+            classSource: toolSource,
+          },
+        ],
+      });
+
+      const block = getBlockByIndex(page, 0);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<table><tr height="50"><td width="300">Ho-Ho-Ho</td></tr></table>',
+      });
+
+      const snapshot = await page.evaluate<ElementSnapshot | null>(() => {
+        return (window.__lastPasteSnapshot ?? null) as ElementSnapshot | null;
+      });
+
+      expect(snapshot).not.toBeNull();
+      expect(snapshot?.tagName).toBe('table');
+      expect(snapshot?.children).toBeDefined();
+
+      const tbodySnapshot = snapshot?.children[0];
+
+      expect(tbodySnapshot?.tagName).toBe('tbody');
+      const trSnapshot = tbodySnapshot?.children[0];
+
+      expect(trSnapshot?.tagName).toBe('tr');
+      expect(trSnapshot?.attributes).toHaveLength(1);
+      expect(trSnapshot?.attributes[0]).toStrictEqual({
+        name: 'height',
+        value: '50',
+      });
+
+      const tdSnapshot = trSnapshot?.children[0];
+
+      expect(tdSnapshot?.tagName).toBe('td');
+      expect(tdSnapshot?.attributes).toHaveLength(1);
+      expect(tdSnapshot?.attributes[0]).toStrictEqual({
+        name: 'width',
+        value: '300',
+      });
+      expect(tdSnapshot?.text.trim()).toBe('Ho-Ho-Ho');
+    });
+  });
+});
+
+const ON_PASTE_CALLS_KEY = '__onPasteCalls';
+const LAST_PASTE_SNAPSHOT_KEY = '__lastPasteSnapshot';
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+    [ON_PASTE_CALLS_KEY]?: number;
+    [LAST_PASTE_SNAPSHOT_KEY]?: unknown;
+  }
+}
+
+
diff --git a/test/playwright/tests/api/tunes.spec.ts b/test/playwright/tests/api/tunes.spec.ts
new file mode 100644
index 000000000..c9eb856a5
--- /dev/null
+++ b/test/playwright/tests/api/tunes.spec.ts
@@ -0,0 +1,277 @@
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import type EditorJS from '@/types';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const FIRST_BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-block:first-of-type`;
+const SETTINGS_BUTTON_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__settings-btn`;
+const POPOVER_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-popover.ce-popover--opened`;
+const POPOVER_ITEM_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-settings .ce-popover-item`;
+const FIRST_POPOVER_ITEM_SELECTOR = `${POPOVER_ITEM_SELECTOR}:nth-of-type(1)`;
+const SECOND_POPOVER_ITEM_SELECTOR = `${POPOVER_ITEM_SELECTOR}:nth-of-type(2)`;
+
+type SerializableTuneMenuItem = {
+  icon?: string;
+  title?: string;
+  label?: string;
+  name: string;
+};
+
+type SerializableTuneRenderConfig =
+  | { type: 'single'; item: SerializableTuneMenuItem }
+  | { type: 'multiple'; items: SerializableTuneMenuItem[] }
+  | { type: 'html'; text: string };
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+  }
+}
+
+/**
+ * Reset the editor holder and destroy existing editor instance.
+ *
+ * @param page - The Playwright page object
+ */
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }: { holderId: string }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ * Create an Editor instance configured with a tune that returns the provided render config.
+ *
+ * @param page - The Playwright page object
+ * @param renderConfig - Serializable configuration describing tune render output
+ */
+const createEditorWithTune = async (
+  page: Page,
+  renderConfig: SerializableTuneRenderConfig
+): Promise<void> => {
+  await resetEditor(page);
+
+  await page.waitForFunction(() => typeof window.EditorJS === 'function');
+
+  await page.evaluate(
+    async ({
+      holderId,
+      config,
+    }: {
+      holderId: string;
+      config: SerializableTuneRenderConfig;
+    }) => {
+      const tuneConfig = config;
+
+      /**
+       * Tune implementation for testing purposes.
+       */
+      class TestTune {
+        public static readonly isTune = true;
+
+        /**
+         * Render tune configuration for block tunes popover.
+         *
+         * @returns Tune menu configuration or custom element
+         */
+        public render(): unknown {
+          if (tuneConfig.type === 'html') {
+            const element = document.createElement('div');
+
+            element.textContent = tuneConfig.text;
+
+            return element;
+          }
+
+          const baseItems = tuneConfig.type === 'single'
+            ? [ tuneConfig.item ]
+            : tuneConfig.items;
+
+          const mappedItems = baseItems.map((item) => ({
+            ...item,
+            onActivate: (): void => {},
+          }));
+
+          return tuneConfig.type === 'single'
+            ? mappedItems[0]
+            : mappedItems;
+        }
+
+        /**
+         * Save hook stub required by the tune contract.
+         */
+        public save(): void {}
+      }
+
+      const editor = new window.EditorJS({
+        holder: holderId,
+        tools: {
+          testTune: TestTune,
+        },
+        tunes: [ 'testTune' ],
+      });
+
+      window.editorInstance = editor;
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      config: renderConfig,
+    }
+  );
+};
+
+/**
+ * Focus the first block and type provided text to expose block tunes controls.
+ *
+ * @param page - The Playwright page object
+ * @param text - Text to type into the block
+ */
+const focusBlockAndType = async (page: Page, text: string): Promise<void> => {
+  const firstBlock = page.locator(FIRST_BLOCK_SELECTOR);
+
+  await firstBlock.click();
+  await page.keyboard.type(text);
+  await firstBlock.click();
+};
+
+/**
+ * Open block tunes popover from the currently focused block.
+ *
+ * @param page - The Playwright page object
+ */
+const openBlockTunes = async (page: Page): Promise<void> => {
+  const settingsButton = page.locator(SETTINGS_BUTTON_SELECTOR);
+
+  await expect(settingsButton).toBeVisible();
+  await settingsButton.click();
+};
+
+test.describe('api.tunes', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+  });
+
+  test('renders a popover entry for block tune if configured', async ({ page }) => {
+    await createEditorWithTune(page, {
+      type: 'single',
+      item: {
+        icon: 'ICON',
+        title: 'Test tune',
+        name: 'testTune',
+      },
+    });
+
+    await focusBlockAndType(page, 'some text');
+    await openBlockTunes(page);
+
+    await expect(page.locator('[data-item-name="testTune"]')).toBeVisible();
+  });
+
+  test('renders several popover entries for block tune if configured', async ({ page }) => {
+    await createEditorWithTune(page, {
+      type: 'multiple',
+      items: [
+        {
+          icon: 'ICON1',
+          title: 'Tune entry 1',
+          name: 'testTune1',
+        },
+        {
+          icon: 'ICON2',
+          title: 'Tune entry 2',
+          name: 'testTune2',
+        },
+      ],
+    });
+
+    await focusBlockAndType(page, 'some text');
+    await openBlockTunes(page);
+
+    await expect(page.locator('[data-item-name="testTune1"]')).toBeVisible();
+    await expect(page.locator('[data-item-name="testTune2"]')).toBeVisible();
+  });
+
+  test('displays custom HTML returned by tune render method inside tunes menu', async ({ page }) => {
+    const sampleText = 'sample text';
+
+    await createEditorWithTune(page, {
+      type: 'html',
+      text: sampleText,
+    });
+
+    await focusBlockAndType(page, 'some text');
+    await openBlockTunes(page);
+
+    await expect(page.locator(POPOVER_SELECTOR)).toContainText(sampleText);
+  });
+
+  test('supports label alias when rendering tunes', async ({ page }) => {
+    await createEditorWithTune(page, {
+      type: 'multiple',
+      items: [
+        {
+          icon: 'ICON1',
+          title: 'Tune entry 1',
+          name: 'testTune1',
+        },
+        {
+          icon: 'ICON2',
+          label: 'Tune entry 2',
+          name: 'testTune2',
+        },
+      ],
+    });
+
+    await focusBlockAndType(page, 'some text');
+    await openBlockTunes(page);
+
+    await expect(page.locator('[data-item-name="testTune1"]')).toContainText('Tune entry 1');
+    await expect(page.locator('[data-item-name="testTune2"]')).toContainText('Tune entry 2');
+  });
+
+  test('displays installed tunes above default tunes', async ({ page }) => {
+    await createEditorWithTune(page, {
+      type: 'single',
+      item: {
+        icon: 'ICON',
+        label: 'Tune entry',
+        name: 'test-tune',
+      },
+    });
+
+    await focusBlockAndType(page, 'some text');
+    await openBlockTunes(page);
+
+    await expect(page.locator(FIRST_POPOVER_ITEM_SELECTOR)).toHaveAttribute('data-item-name', 'test-tune');
+    await expect(page.locator(SECOND_POPOVER_ITEM_SELECTOR)).toHaveAttribute('data-item-name', 'move-up');
+  });
+});
+
+
diff --git a/test/playwright/tests/copy-paste.spec.ts b/test/playwright/tests/copy-paste.spec.ts
new file mode 100644
index 000000000..679794824
--- /dev/null
+++ b/test/playwright/tests/copy-paste.spec.ts
@@ -0,0 +1,623 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type EditorJS from '@/types';
+import type { EditorConfig, OutputData } from '@/types';
+import { ensureEditorBundleBuilt } from './helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../fixtures/test.html')
+).href;
+
+const HEADER_TOOL_UMD_PATH = path.resolve(
+  __dirname,
+  '../../../node_modules/@editorjs/header/dist/header.umd.js'
+);
+
+const SIMPLE_IMAGE_TOOL_UMD_PATH = path.resolve(
+  __dirname,
+  '../../../node_modules/@editorjs/simple-image/dist/simple-image.umd.js'
+);
+
+const HOLDER_ID = 'editorjs';
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} div.ce-block`;
+const getBlockByIndex = (page: Page, index: number): Locator => {
+  return page.locator(`${BLOCK_SELECTOR}:nth-of-type(${index + 1})`);
+};
+
+const getParagraphByIndex = (page: Page, index: number): Locator => {
+  return getBlockByIndex(page, index).locator('.ce-paragraph');
+};
+
+type SerializableToolConfig = {
+  className?: string;
+  classCode?: string;
+  config?: Record<string, unknown>;
+};
+
+type CreateEditorOptions = Pick<EditorConfig, 'data' | 'inlineToolbar' | 'placeholder' | 'readOnly'> & {
+  tools?: Record<string, SerializableToolConfig>;
+};
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditor = async (page: Page, options: CreateEditorOptions = {}): Promise<void> => {
+  await resetEditor(page);
+
+  const { tools = {}, ...editorOptions } = options;
+
+  const serializedTools = Object.entries(tools).map(([name, tool]) => {
+    return {
+      name,
+      className: tool.className ?? null,
+      classCode: tool.classCode ?? null,
+      toolConfig: tool.config ?? {},
+    };
+  });
+
+  await page.evaluate(
+    async ({ holderId, editorOptions: rawOptions, serializedTools: toolsConfig }) => {
+      const { data, ...restOptions } = rawOptions;
+      const config: Record<string, unknown> = {
+        holder: holderId,
+        ...restOptions,
+      };
+
+      if (data) {
+        config.data = data;
+      }
+
+      if (toolsConfig.length > 0) {
+        const resolvedTools = toolsConfig.reduce<Record<string, { class: unknown } & Record<string, unknown>>>(
+          (accumulator, { name, className, classCode, toolConfig }) => {
+            let toolClass: unknown;
+
+            if (className) {
+              toolClass = (window as unknown as Record<string, unknown>)[className] ?? null;
+            }
+
+            if (!toolClass && classCode) {
+              // eslint-disable-next-line no-new-func -- constructing helper class inside page context
+              toolClass = new Function(`return (${classCode});`)();
+            }
+
+            if (!toolClass) {
+              throw new Error(`Tool "${name}" is not available globally`);
+            }
+
+            return {
+              ...accumulator,
+              [name]: {
+                class: toolClass,
+                ...toolConfig,
+              },
+            };
+          },
+          {}
+        );
+
+        config.tools = resolvedTools;
+      }
+
+      const editor = new window.EditorJS(config as EditorConfig);
+
+      window.editorInstance = editor;
+
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      editorOptions,
+      serializedTools,
+    }
+  );
+};
+
+const createEditorWithBlocks = async (page: Page, blocks: OutputData['blocks']): Promise<void> => {
+  await createEditor(page, {
+    data: {
+      blocks,
+    },
+  });
+};
+
+const saveEditor = async (page: Page): Promise<OutputData> => {
+  return await page.evaluate(async () => {
+    if (!window.editorInstance) {
+      throw new Error('Editor instance not found');
+    }
+
+    return await window.editorInstance.save();
+  });
+};
+
+const paste = async (page: Page, locator: Locator, data: Record<string, string>): Promise<void> => {
+  await locator.evaluate((element: HTMLElement, pasteData: Record<string, string>) => {
+    const pasteEvent = Object.assign(new Event('paste', {
+      bubbles: true,
+      cancelable: true,
+    }), {
+      clipboardData: {
+        getData: (type: string): string => pasteData[type] ?? '',
+        types: Object.keys(pasteData),
+      },
+    });
+
+    element.dispatchEvent(pasteEvent);
+  }, data);
+
+  await page.evaluate(() => {
+    return new Promise((resolve) => {
+      setTimeout(resolve, 200);
+    });
+  });
+};
+
+const selectAllText = async (locator: Locator): Promise<void> => {
+  await locator.evaluate((element) => {
+    const ownerDocument = element.ownerDocument;
+
+    if (!ownerDocument) {
+      throw new Error('Owner document is not available');
+    }
+
+    const selection = ownerDocument.getSelection();
+
+    if (!selection) {
+      throw new Error('Selection API is not available');
+    }
+
+    const walker = ownerDocument.createTreeWalker(element, NodeFilter.SHOW_TEXT);
+    const textNodes: Node[] = [];
+    let currentNode = walker.nextNode();
+
+    while (currentNode) {
+      textNodes.push(currentNode);
+      currentNode = walker.nextNode();
+    }
+
+    if (textNodes.length === 0) {
+      throw new Error('Nothing to select');
+    }
+
+    const startNode = textNodes[0];
+    const endNode = textNodes[textNodes.length - 1];
+    const endOffset = endNode.textContent?.length ?? 0;
+
+    const range = ownerDocument.createRange();
+
+    range.setStart(startNode, 0);
+    range.setEnd(endNode, endOffset);
+
+    selection.removeAllRanges();
+    selection.addRange(range);
+    ownerDocument.dispatchEvent(new Event('selectionchange'));
+  });
+};
+
+const withClipboardEvent = async (
+  locator: Locator,
+  eventName: 'copy' | 'cut'
+): Promise<Record<string, string>> => {
+  return await locator.evaluate((element, type) => {
+    return new Promise<Record<string, string>>((resolve) => {
+      const clipboardData: Record<string, string> = {};
+      const event = Object.assign(new Event(type, {
+        bubbles: true,
+        cancelable: true,
+      }), {
+        clipboardData: {
+          setData: (format: string, value: string) => {
+            clipboardData[format] = value;
+          },
+        },
+      });
+
+      element.dispatchEvent(event);
+
+      setTimeout(() => {
+        resolve(clipboardData);
+      }, 0);
+    });
+  }, eventName);
+};
+
+const copyFromElement = async (locator: Locator): Promise<Record<string, string>> => {
+  return await withClipboardEvent(locator, 'copy');
+};
+
+const cutFromElement = async (locator: Locator): Promise<Record<string, string>> => {
+  return await withClipboardEvent(locator, 'cut');
+};
+
+test.describe('copy and paste', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test.describe('pasting', () => {
+    test('should paste plain text', async ({ page }) => {
+      await createEditor(page);
+
+      const block = getBlockByIndex(page, 0);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/plain': 'Some plain text',
+      });
+
+      await expect(block).toContainText('Some plain text');
+    });
+
+    test('should paste inline html data', async ({ page }) => {
+      await createEditor(page);
+
+      const block = getBlockByIndex(page, 0);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<p><b>Some text</b></p>',
+      });
+
+      await expect(block.locator('b')).toHaveText('Some text');
+    });
+
+    test('should paste several blocks if plain text contains new lines', async ({ page }) => {
+      await createEditor(page);
+
+      const block = getBlockByIndex(page, 0);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/plain': 'First block\n\nSecond block',
+      });
+
+      const blocks = page.locator(BLOCK_SELECTOR);
+      const texts = (await blocks.allTextContents()).map((text) => text.trim()).filter(Boolean);
+
+      expect(texts).toStrictEqual(['First block', 'Second block']);
+    });
+
+    test('should paste several blocks if html contains several paragraphs', async ({ page }) => {
+      await createEditor(page);
+
+      const block = getBlockByIndex(page, 0);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<p>First block</p><p>Second block</p>',
+      });
+
+      const blocks = page.locator(BLOCK_SELECTOR);
+      const texts = (await blocks.allTextContents()).map((text) => text.trim()).filter(Boolean);
+
+      expect(texts).toStrictEqual(['First block', 'Second block']);
+    });
+
+    test('should paste using custom data type', async ({ page }) => {
+      await createEditor(page);
+
+      const block = getBlockByIndex(page, 0);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'application/x-editor-js': JSON.stringify([
+          {
+            tool: 'paragraph',
+            data: { text: 'First block' },
+          },
+          {
+            tool: 'paragraph',
+            data: { text: 'Second block' },
+          },
+        ]),
+      });
+
+      const blocks = page.locator(BLOCK_SELECTOR);
+      const texts = (await blocks.allTextContents()).map((text) => text.trim()).filter(Boolean);
+
+      expect(texts).toStrictEqual(['First block', 'Second block']);
+    });
+
+    test('should parse block tags', async ({ page }) => {
+      await page.addScriptTag({ path: HEADER_TOOL_UMD_PATH });
+
+      await createEditor(page, {
+        tools: {
+          header: {
+            className: 'Header',
+          },
+        },
+      });
+
+      const block = getBlockByIndex(page, 0);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<h2>First block</h2><p>Second block</p>',
+      });
+
+      const headerBlock = page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-header`);
+      const paragraphBlock = page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-paragraph:nth-last-of-type(1)`);
+
+      await expect(headerBlock).toHaveText('First block');
+      await expect(paragraphBlock).toHaveText('Second block');
+
+      const output = await saveEditor(page);
+
+      expect(output.blocks[0]?.type).toBe('header');
+      expect(output.blocks[0]?.data).toMatchObject({
+        text: 'First block',
+        level: 2,
+      });
+      expect(output.blocks[1]?.type).toBe('paragraph');
+      expect(output.blocks[1]?.data).toMatchObject({
+        text: 'Second block',
+      });
+    });
+
+    test('should parse pattern', async ({ page }) => {
+      await page.addScriptTag({ path: SIMPLE_IMAGE_TOOL_UMD_PATH });
+
+      await createEditor(page, {
+        tools: {
+          image: {
+            className: 'SimpleImage',
+          },
+        },
+      });
+
+      const block = getBlockByIndex(page, 0);
+      const imageUrl = 'https://codex.so/public/app/img/external/codex2x.png';
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/plain': imageUrl,
+      });
+
+      const image = page.locator(`${EDITOR_INTERFACE_SELECTOR} img`);
+
+      await expect(image).toHaveAttribute('src', imageUrl, {
+        timeout: 10_000,
+      });
+    });
+
+    test('should not prevent default behaviour if block paste config equals false', async ({ page }) => {
+      const blockToolSource = `
+      class BlockToolWithPasteHandler {
+        static get pasteConfig() {
+          return false;
+        }
+
+        render() {
+          const block = document.createElement('div');
+
+          block.className = 'ce-block-with-disabled-prevent-default';
+          block.contentEditable = 'true';
+
+          block.addEventListener('paste', (event) => {
+            if (!Array.isArray(window.blockToolPasteEvents)) {
+              window.blockToolPasteEvents = [];
+            }
+
+            window.blockToolPasteEvents.push({
+              defaultPrevented: event.defaultPrevented,
+            });
+          });
+
+          return block;
+        }
+
+        save() {
+          return {};
+        }
+      }
+      `;
+
+      await createEditor(page, {
+        tools: {
+          blockToolWithPasteHandler: {
+            classCode: blockToolSource,
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'blockToolWithPasteHandler',
+              data: {},
+            },
+          ],
+        },
+      });
+
+      const block = page.locator('.ce-block-with-disabled-prevent-default');
+
+      await expect(block).toHaveCount(1);
+
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/plain': 'Hello',
+      });
+
+      const events = await page.evaluate(() => {
+        return window.blockToolPasteEvents ?? [];
+      });
+
+      expect(events).toHaveLength(1);
+      expect(events[0]?.defaultPrevented).toBe(false);
+    });
+  });
+
+  test.describe('copying', () => {
+    test('should copy inline fragment', async ({ page }) => {
+      await createEditor(page);
+
+      const paragraph = getParagraphByIndex(page, 0);
+
+      await paragraph.click();
+      await paragraph.type('Some text');
+      await selectAllText(paragraph);
+
+      const clipboardData = await copyFromElement(paragraph);
+
+      expect(clipboardData).toStrictEqual({});
+    });
+
+    test('should copy several blocks', async ({ page }) => {
+      await createEditor(page);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      await firstParagraph.click();
+      await firstParagraph.type('First block');
+      await page.keyboard.press('Enter');
+
+      const secondParagraph = getParagraphByIndex(page, 1);
+
+      await secondParagraph.type('Second block');
+      await page.keyboard.press('Home');
+      await page.keyboard.down('Shift');
+      await page.keyboard.press('ArrowUp');
+      await page.keyboard.up('Shift');
+
+      const clipboardData = await copyFromElement(secondParagraph);
+
+      expect(clipboardData['text/html']).toMatch(/<p>First block(<br>)?<\/p><p>Second block(<br>)?<\/p>/);
+      expect(clipboardData['text/plain']).toBe('First block\n\nSecond block');
+
+      expect(clipboardData['application/x-editor-js']).toBeDefined();
+
+      const data = JSON.parse(clipboardData['application/x-editor-js']);
+
+      expect(data[0]?.tool).toBe('paragraph');
+      expect(data[0]?.data?.text).toMatch(/First block(<br>)?/);
+      expect(data[1]?.tool).toBe('paragraph');
+      expect(data[1]?.data?.text).toMatch(/Second block(<br>)?/);
+    });
+  });
+
+  test.describe('cutting', () => {
+    test('should cut inline fragment', async ({ page }) => {
+      await createEditor(page);
+
+      const paragraph = getParagraphByIndex(page, 0);
+
+      await paragraph.click();
+      await paragraph.type('Some text');
+      await selectAllText(paragraph);
+
+      const clipboardData = await cutFromElement(paragraph);
+
+      expect(clipboardData).toStrictEqual({});
+    });
+
+    test('should cut several blocks', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: 'First block' },
+        },
+        {
+          type: 'paragraph',
+          data: { text: 'Second block' },
+        },
+      ]);
+
+      const secondParagraph = getParagraphByIndex(page, 1);
+
+      await secondParagraph.click();
+      await page.keyboard.press('Home');
+      await page.keyboard.down('Shift');
+      await page.keyboard.press('ArrowUp');
+      await page.keyboard.up('Shift');
+
+      const clipboardData = await cutFromElement(secondParagraph);
+
+      expect(clipboardData['text/html']).toMatch(/<p>First block(<br>)?<\/p><p>Second block(<br>)?<\/p>/);
+      expect(clipboardData['text/plain']).toBe('First block\n\nSecond block');
+
+      const serializedBlocks = clipboardData['application/x-editor-js'];
+
+      expect(serializedBlocks).toBeDefined();
+
+      const data = JSON.parse(serializedBlocks);
+
+      expect(data[0]?.tool).toBe('paragraph');
+      expect(data[0]?.data?.text).toMatch(/First block(<br>)?/);
+      expect(data[1]?.tool).toBe('paragraph');
+      expect(data[1]?.data?.text).toMatch(/Second block(<br>)?/);
+
+      await expect(page.locator(EDITOR_INTERFACE_SELECTOR)).not.toContainText('First block');
+      await expect(page.locator(EDITOR_INTERFACE_SELECTOR)).not.toContainText('Second block');
+    });
+
+    test('should cut lots of blocks', async ({ page }) => {
+      const numberOfBlocks = 50;
+      const blocks: OutputData['blocks'] = Array.from({ length: numberOfBlocks }, (_, index) => ({
+        type: 'paragraph',
+        data: {
+          text: `Block ${index}`,
+        },
+      }));
+
+      await createEditorWithBlocks(page, blocks);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      await firstParagraph.click();
+      await page.keyboard.press('Control+A');
+      await page.keyboard.press('Control+A');
+
+      const clipboardData = await cutFromElement(firstParagraph);
+      const serializedBlocks = clipboardData['application/x-editor-js'];
+
+      expect(serializedBlocks).toBeDefined();
+
+      const data = JSON.parse(serializedBlocks);
+
+      expect(Array.isArray(data)).toBe(true);
+      expect(data).toHaveLength(numberOfBlocks);
+    });
+  });
+});
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+    EditorJS: new (...args: unknown[]) => EditorJS;
+    blockToolPasteEvents?: Array<{ defaultPrevented: boolean }>;
+  }
+}
+
+
diff --git a/test/playwright/tests/helpers/ensure-build.ts b/test/playwright/tests/helpers/ensure-build.ts
new file mode 100644
index 000000000..156918673
--- /dev/null
+++ b/test/playwright/tests/helpers/ensure-build.ts
@@ -0,0 +1,34 @@
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+
+let didBuild = false;
+
+/**
+ * Ensure the Editor.js bundle is freshly built before running Playwright tests.
+ *
+ * Necessary because the Playwright fixtures load the UMD bundle directly from the dist folder.
+ * Without rebuilding we might exercise stale code that doesn't match the current TypeScript sources.
+ */
+export const ensureEditorBundleBuilt = (): void => {
+  if (didBuild) {
+    return;
+  }
+
+  const projectRoot = path.resolve(__dirname, '../../../..');
+  const result = spawnSync('yarn', [ 'build:test' ], {
+    cwd: projectRoot,
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    throw new Error(`Building Editor.js for Playwright failed with exit code ${result.status ?? 'unknown'}.`);
+  }
+
+  didBuild = true;
+};
+
diff --git a/test/playwright/tests/i18n.spec.ts b/test/playwright/tests/i18n.spec.ts
new file mode 100644
index 000000000..67cf76f18
--- /dev/null
+++ b/test/playwright/tests/i18n.spec.ts
@@ -0,0 +1,1512 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { OutputData } from '@/types';
+import { ensureEditorBundleBuilt } from './helpers/ensure-build';
+import { TOOLTIP_INTERFACE_SELECTOR, EDITOR_INTERFACE_SELECTOR, INLINE_TOOLBAR_INTERFACE_SELECTOR, MODIFIER_KEY } from '../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} div.ce-block`;
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-block-tool="paragraph"]`;
+const SETTINGS_BUTTON_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__settings-btn`;
+const PLUS_BUTTON_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__plus`;
+const INLINE_TOOLBAR_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} ${INLINE_TOOLBAR_INTERFACE_SELECTOR}`;
+const POPOVER_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-popover`;
+
+/**
+ * Reset the editor holder and destroy any existing instance
+ *
+ * @param page - The Playwright page object
+ */
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ * Create editor with i18n configuration
+ *
+ * @param page - The Playwright page object
+ * @param config - Editor configuration including i18n settings
+ */
+const createEditorWithI18n = async (
+  page: Page,
+  config: {
+    tools?: Record<string, unknown>;
+    i18n?: { messages?: Record<string, unknown> };
+    data?: { blocks?: OutputData['blocks'] };
+  }
+): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(
+    async ({ holderId, editorConfig }) => {
+      const resolveFromWindow = (value: unknown): unknown => {
+        if (typeof value === 'string') {
+          return value.split('.').reduce<unknown>((acc, key) => {
+            if (acc && typeof acc === 'object') {
+              return (acc as Record<string, unknown>)[key];
+            }
+
+            return undefined;
+          }, window as unknown);
+        }
+
+        return value;
+      };
+
+      const resolveClassConfig = (classConfig: string): unknown => {
+        const resolvedClass = resolveFromWindow(classConfig);
+
+        if (resolvedClass === undefined) {
+          throw new Error(`Unable to resolve tool class "${classConfig}" from window.`);
+        }
+
+        return resolvedClass;
+      };
+
+      const normalizeToolConfig = (toolConfig: unknown): unknown => {
+        if (toolConfig === undefined || toolConfig === null) {
+          return toolConfig;
+        }
+
+        if (typeof toolConfig === 'function') {
+          return toolConfig;
+        }
+
+        if (typeof toolConfig === 'string') {
+          const resolvedTool = resolveFromWindow(toolConfig);
+
+          if (resolvedTool === undefined) {
+            throw new Error(`Unable to resolve tool "${toolConfig}" from window.`);
+          }
+
+          return resolvedTool;
+        }
+
+        if (typeof toolConfig === 'object') {
+          const normalizedConfig = { ...(toolConfig as Record<string, unknown>) };
+
+          if ('class' in normalizedConfig && typeof normalizedConfig.class === 'string') {
+            normalizedConfig.class = resolveClassConfig(normalizedConfig.class);
+          }
+
+          return normalizedConfig;
+        }
+
+        return toolConfig;
+      };
+
+      const normalizeTools = (tools: Record<string, unknown> | undefined): Record<string, unknown> | undefined => {
+        if (!tools) {
+          return tools;
+        }
+
+        return Object.entries(tools).reduce<Record<string, unknown>>((acc, [toolName, toolConfig]) => {
+          const normalizedConfig = normalizeToolConfig(toolConfig);
+
+          if (normalizedConfig === undefined) {
+            throw new Error(`Tool "${toolName}" is undefined. Provide a valid constructor or configuration object.`);
+          }
+
+          return {
+            ...acc,
+            [toolName]: normalizedConfig,
+          };
+        }, {});
+      };
+
+      const { tools, ...restConfig } = editorConfig ?? {};
+      const normalizedTools = normalizeTools(tools as Record<string, unknown> | undefined);
+
+      const editor = new window.EditorJS({
+        holder: holderId,
+        ...restConfig,
+        ...(normalizedTools ? { tools: normalizedTools } : {}),
+      });
+
+      window.editorInstance = editor;
+      await editor.isReady;
+
+      await new Promise<void>((resolve) => {
+        if ('requestIdleCallback' in window) {
+          window.requestIdleCallback(() => resolve(), { timeout: 100 });
+
+          return;
+        }
+
+        setTimeout(resolve, 0);
+      });
+    },
+    { holderId: HOLDER_ID,
+      editorConfig: config }
+  );
+};
+
+/**
+ * Select text content within a locator by string match
+ *
+ * @param locator - The Playwright locator for the element containing the text
+ * @param text - The text string to select within the element
+ */
+const selectText = async (locator: Locator, text: string): Promise<void> => {
+  await locator.evaluate((element, targetText) => {
+    const walker = element.ownerDocument.createTreeWalker(element, NodeFilter.SHOW_TEXT);
+    let textNode: Node | null = null;
+    let start = -1;
+
+    while (walker.nextNode()) {
+      const node = walker.currentNode;
+      const content = node.textContent ?? '';
+      const idx = content.indexOf(targetText);
+
+      if (idx !== -1) {
+        textNode = node;
+        start = idx;
+        break;
+      }
+    }
+
+    if (!textNode || start === -1) {
+      throw new Error(`Text "${targetText}" was not found in element`);
+    }
+
+    const range = element.ownerDocument.createRange();
+
+    range.setStart(textNode, start);
+    range.setEnd(textNode, start + targetText.length);
+
+    const selection = element.ownerDocument.getSelection();
+
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+
+    element.ownerDocument.dispatchEvent(new Event('selectionchange'));
+  }, text);
+};
+
+/**
+ * Wait for tooltip to appear and get its text
+ *
+ * @param page - The Playwright page object
+ * @param triggerElement - Element to hover over to trigger tooltip
+ * @returns The tooltip text content
+ */
+const getTooltipText = async (page: Page, triggerElement: Locator): Promise<string> => {
+  await triggerElement.hover();
+
+  const tooltip = page.locator(TOOLTIP_INTERFACE_SELECTOR);
+
+  await expect(tooltip).toBeVisible();
+
+  return (await tooltip.textContent()) ?? '';
+};
+
+/**
+ * Opens the inline toolbar popover and waits until it becomes visible.
+ *
+ * @param page - The Playwright page object
+ * @returns Locator for the inline toolbar popover
+ */
+const openInlineToolbarPopover = async (page: Page): Promise<Locator> => {
+  const inlineToolbar = page.locator(INLINE_TOOLBAR_SELECTOR);
+
+  await expect(inlineToolbar).toHaveCount(1);
+
+  await page.evaluate(() => {
+    window.editorInstance?.inlineToolbar?.open();
+  });
+
+  const inlinePopover = inlineToolbar.locator(':scope > .ce-popover');
+
+  await expect(inlinePopover).toHaveCount(1);
+
+  const inlinePopoverContainer = inlinePopover.locator(':scope > .ce-popover__container');
+
+  await expect(inlinePopoverContainer).toHaveCount(1);
+  await expect(inlinePopoverContainer).toBeVisible();
+
+  return inlinePopover;
+};
+
+test.describe('editor i18n', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test.describe('toolbox', () => {
+    test('should translate tool title in a toolbox', async ({ page }) => {
+      const toolNamesDictionary = {
+        Heading: 'Заголовок',
+      };
+
+      // Create a simple header tool in the browser context
+      await page.evaluate(() => {
+        // @ts-expect-error - Define SimpleHeader in window for editor creation
+        window.SimpleHeader = class {
+          private data: { text: string };
+
+          /**
+           * Creates a `SimpleHeader` instance with initial block data.
+           *
+           * @param root0 - Editor.js constructor arguments containing the block data.
+           */
+          constructor({ data }: { data: { text: string } }) {
+            this.data = data;
+          }
+
+          /**
+           *
+           */
+          public render(): HTMLHeadingElement {
+            const element = document.createElement('h1');
+
+            element.contentEditable = 'true';
+            element.innerHTML = this.data.text;
+
+            return element;
+          }
+
+          /**
+           * Persists the heading content to the Editor.js data format.
+           *
+           * @param element - Heading element that contains the current block content.
+           */
+          public save(element: HTMLHeadingElement): { text: string; level: number } {
+            return {
+              text: element.innerHTML,
+              level: 1,
+            };
+          }
+
+          /**
+           *
+           */
+          public static get toolbox(): { title: string; icon: string } {
+            return {
+              title: 'Heading',
+              icon: '<svg width="17" height="15" viewBox="0 0 336 276" xmlns="http://www.w3.org/2000/svg"><path d="M291 150V79c0-19-15-34-34-34H79c-19 0-34 15-34 34v42l67-44 81 72 56-29 42 30zm0 52l-43-30-56 30-81-67-66 39v23c0 19 15 34 34 34h178c17 0 31-13 34-29zM79 0h178c44 0 79 35 79 79v118c0 44-35 79-79 79H79c-44 0-79-35-79-79V79C0 35 35 0 79 0z"/></svg>',
+            };
+          }
+        };
+      });
+
+      await createEditorWithI18n(page, {
+        tools: {
+          header: 'SimpleHeader',
+        },
+        i18n: {
+          messages: {
+            toolNames: toolNamesDictionary,
+          },
+        },
+      });
+
+      const block = page.locator(BLOCK_SELECTOR);
+
+      await expect(block).toHaveCount(1);
+      await block.click();
+      await page.locator(PLUS_BUTTON_SELECTOR).click();
+
+      const headerItem = page.locator(`${POPOVER_SELECTOR} [data-item-name="header"]`);
+
+      await expect(headerItem).toBeVisible();
+      await expect(headerItem).toContainText(toolNamesDictionary.Heading);
+    });
+
+    test('should translate titles of toolbox entries', async ({ page }) => {
+      const toolNamesDictionary = {
+        Title1: 'Название 1',
+        Title2: 'Название 2',
+      };
+
+      // Create a test tool with multiple toolbox entries
+      await page.evaluate(() => {
+        // @ts-expect-error - Define TestTool in window for editor creation
+        window.TestTool = class {
+          /**
+           *
+           */
+          public static get toolbox(): Array<{ title: string; icon: string }> {
+            return [
+              {
+                title: 'Title1',
+                icon: 'Icon 1',
+              },
+              {
+                title: 'Title2',
+                icon: 'Icon 2',
+              },
+            ];
+          }
+
+          /**
+           *
+           */
+          public render(): HTMLDivElement {
+            const wrapper = document.createElement('div');
+
+            wrapper.contentEditable = 'true';
+            wrapper.innerHTML = 'Test tool content';
+
+            return wrapper;
+          }
+
+          /**
+           *
+           */
+          public save(): Record<string, unknown> {
+            return {};
+          }
+        };
+      });
+
+      await createEditorWithI18n(page, {
+        tools: {
+          testTool: 'TestTool',
+        },
+        i18n: {
+          messages: {
+            toolNames: toolNamesDictionary,
+          },
+        },
+      });
+
+      const block = page.locator(BLOCK_SELECTOR);
+
+      await expect(block).toHaveCount(1);
+      await block.click();
+      await page.locator(PLUS_BUTTON_SELECTOR).click();
+
+      const testToolItems = page.locator(`${POPOVER_SELECTOR} [data-item-name="testTool"]`);
+
+      await expect(testToolItems).toHaveCount(2);
+      await expect(testToolItems).toContainText([
+        toolNamesDictionary.Title1,
+        toolNamesDictionary.Title2,
+      ]);
+    });
+
+    test('should use capitalized tool name as translation key if toolbox title is missing', async ({ page }) => {
+      const toolNamesDictionary = {
+        TestTool: 'ТестТул',
+      };
+
+      // Create a test tool without title
+      await page.evaluate(() => {
+        // @ts-expect-error - Define TestTool in window for editor creation
+        window.TestTool = class {
+          /**
+           *
+           */
+          public static get toolbox(): { title: string; icon: string } {
+            return {
+              title: '',
+              icon: '<svg width="17" height="15" viewBox="0 0 336 276" xmlns="http://www.w3.org/2000/svg"><path d="M291 150V79c0-19-15-34-34-34H79c-19 0-34 15-34 34v42l67-44 81 72 56-29 42 30zm0 52l-43-30-56 30-81-67-66 39v23c0 19 15 34 34 34h178c17 0 31-13 34-29zM79 0h178c44 0 79 35 79 79v118c0 44-35 79-79 79H79c-44 0-79-35-79-79V79C0 35 35 0 79 0z"/></svg>',
+            };
+          }
+
+          /**
+           *
+           */
+          public render(): HTMLDivElement {
+            const wrapper = document.createElement('div');
+
+            wrapper.contentEditable = 'true';
+            wrapper.innerHTML = 'Test tool content';
+
+            return wrapper;
+          }
+
+          /**
+           *
+           */
+          public save(): Record<string, unknown> {
+            return {};
+          }
+        };
+      });
+
+      await createEditorWithI18n(page, {
+        tools: {
+          testTool: 'TestTool',
+        },
+        i18n: {
+          messages: {
+            toolNames: toolNamesDictionary,
+          },
+        },
+      });
+
+      const block = page.locator(BLOCK_SELECTOR);
+
+      await expect(block).toHaveCount(1);
+      await block.click();
+      await page.locator(PLUS_BUTTON_SELECTOR).click();
+
+      const testToolItem = page.locator(`${POPOVER_SELECTOR} [data-item-name="testTool"]`);
+
+      await expect(testToolItem).toBeVisible();
+      await expect(testToolItem).toContainText(toolNamesDictionary.TestTool);
+    });
+  });
+
+  test.describe('block tunes', () => {
+    test('should translate Delete button title', async ({ page }) => {
+      const blockTunesDictionary = {
+        delete: {
+          Delete: 'Удалить',
+        },
+      };
+
+      await createEditorWithI18n(page, {
+        i18n: {
+          messages: {
+            blockTunes: blockTunesDictionary,
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Some text',
+              },
+            },
+          ],
+        },
+      });
+
+      const block = page.locator(BLOCK_SELECTOR);
+
+      await expect(block).toHaveCount(1);
+      await block.click();
+      await page.locator(SETTINGS_BUTTON_SELECTOR).click();
+
+      const deleteButton = page.locator(`${POPOVER_SELECTOR} [data-item-name="delete"]`);
+
+      await expect(deleteButton).toBeVisible();
+      await expect(deleteButton).toContainText(blockTunesDictionary.delete.Delete);
+    });
+
+    test('should translate Move up button title', async ({ page }) => {
+      const blockTunesDictionary = {
+        moveUp: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention -- Dictionary keys must match i18n structure
+          'Move up': 'Переместить вверх',
+        },
+      };
+
+      await createEditorWithI18n(page, {
+        i18n: {
+          messages: {
+            blockTunes: blockTunesDictionary,
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'First block',
+              },
+            },
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Second block',
+              },
+            },
+          ],
+        },
+      });
+
+      const secondBlock = page.locator(BLOCK_SELECTOR).filter({ hasText: 'Second block' });
+
+      await expect(secondBlock).toHaveCount(1);
+      await secondBlock.click();
+      await page.locator(SETTINGS_BUTTON_SELECTOR).click();
+
+      const moveUpButton = page.locator(`${POPOVER_SELECTOR} [data-item-name="move-up"]`);
+
+      await expect(moveUpButton).toBeVisible();
+      await expect(moveUpButton).toContainText(blockTunesDictionary.moveUp['Move up']);
+    });
+
+    test('should translate Move down button title', async ({ page }) => {
+      const blockTunesDictionary = {
+        moveDown: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention -- Dictionary keys must match i18n structure
+          'Move down': 'Переместить вниз',
+        },
+      };
+
+      await createEditorWithI18n(page, {
+        i18n: {
+          messages: {
+            blockTunes: blockTunesDictionary,
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'First block',
+              },
+            },
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Second block',
+              },
+            },
+          ],
+        },
+      });
+
+      const firstBlock = page.locator(BLOCK_SELECTOR).filter({ hasText: 'First block' });
+
+      await expect(firstBlock).toHaveCount(1);
+      await firstBlock.click();
+      await page.locator(SETTINGS_BUTTON_SELECTOR).click();
+
+      const moveDownButton = page.locator(`${POPOVER_SELECTOR} [data-item-name="move-down"]`);
+
+      await expect(moveDownButton).toBeVisible();
+      await expect(moveDownButton).toContainText(blockTunesDictionary.moveDown['Move down']);
+    });
+
+    test('should translate "Click to delete" confirmation message', async ({ page }) => {
+      const blockTunesDictionary = {
+        delete: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention -- Dictionary keys must match i18n structure
+          'Click to delete': 'Нажмите для удаления',
+        },
+      };
+
+      await createEditorWithI18n(page, {
+        i18n: {
+          messages: {
+            blockTunes: blockTunesDictionary,
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Some text',
+              },
+            },
+          ],
+        },
+      });
+
+      const block = page.locator(BLOCK_SELECTOR);
+
+      await expect(block).toHaveCount(1);
+      await block.click();
+      await page.locator(SETTINGS_BUTTON_SELECTOR).click();
+
+      const deleteButton = page.locator(`${POPOVER_SELECTOR} [data-item-name="delete"]`);
+
+      await deleteButton.click();
+
+      // Wait for confirmation popover to appear
+      // eslint-disable-next-line playwright/no-wait-for-timeout -- Waiting for UI animation
+      await page.waitForTimeout(100);
+
+      // Check if confirmation message appears (it might be in a nested popover or notification)
+      const confirmationText = blockTunesDictionary.delete['Click to delete'];
+      const confirmationElement = page.locator(`text=${confirmationText}`);
+
+      // The confirmation might appear in different ways, so we check if it exists
+      const confirmationExists = await confirmationElement.count() > 0;
+
+      expect(confirmationExists).toBeTruthy();
+    });
+
+    test('should translate tool name in Convert To', async ({ page }) => {
+      const toolNamesDictionary = {
+        Heading: 'Заголовок',
+      };
+
+      // Create a simple header tool in the browser context
+      await page.evaluate(() => {
+        // @ts-expect-error - Define SimpleHeader in window for editor creation
+        window.SimpleHeader = class {
+          private data: { text: string };
+
+          /**
+           * Creates a `SimpleHeader` instance with initial block data.
+           *
+           * @param root0 - Editor.js constructor arguments containing the block data.
+           */
+          constructor({ data }: { data: { text: string } }) {
+            this.data = data;
+          }
+
+          /**
+           *
+           */
+          public render(): HTMLHeadingElement {
+            const element = document.createElement('h1');
+
+            element.contentEditable = 'true';
+            element.innerHTML = this.data.text;
+
+            return element;
+          }
+
+          /**
+           * Persists the heading content to the Editor.js data format.
+           *
+           * @param element - Heading element that contains the current block content.
+           */
+          public save(element: HTMLHeadingElement): { text: string; level: number } {
+            return {
+              text: element.innerHTML,
+              level: 1,
+            };
+          }
+
+          /**
+           *
+           */
+          public static get toolbox(): { title: string; icon: string } {
+            return {
+              title: 'Heading',
+              icon: '<svg width="17" height="15" viewBox="0 0 336 276" xmlns="http://www.w3.org/2000/svg"><path d="M291 150V79c0-19-15-34-34-34H79c-19 0-34 15-34 34v42l67-44 81 72 56-29 42 30zm0 52l-43-30-56 30-81-67-66 39v23c0 19 15 34 34 34h178c17 0 31-13 34-29zM79 0h178c44 0 79 35 79 79v118c0 44-35 79-79 79H79c-44 0-79-35-79-79V79C0 35 35 0 79 0z"/></svg>',
+            };
+          }
+
+          /**
+           *
+           */
+          public static get conversionConfig(): { export: string; import: string } {
+            return {
+              export: 'text',
+              import: 'text',
+            };
+          }
+        };
+      });
+
+      await createEditorWithI18n(page, {
+        tools: {
+          header: 'SimpleHeader',
+        },
+        i18n: {
+          messages: {
+            toolNames: toolNamesDictionary,
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Some text',
+              },
+            },
+          ],
+        },
+      });
+
+      const block = page.locator(BLOCK_SELECTOR);
+
+      await expect(block).toHaveCount(1);
+      await block.click();
+      await page.locator(SETTINGS_BUTTON_SELECTOR).click();
+
+      // Open "Convert to" menu
+      const convertToButton = page.locator(`${POPOVER_SELECTOR} [data-item-name="convert-to"]`);
+
+      await expect(convertToButton).toBeVisible();
+      await convertToButton.click();
+
+      // Check item in convert to menu is internationalized
+      const headerItem = page.locator(`${POPOVER_SELECTOR} .ce-popover--nested [data-item-name="header"]`);
+
+      await expect(headerItem).toBeVisible();
+      await expect(headerItem).toContainText(toolNamesDictionary.Heading);
+    });
+  });
+
+  test.describe('ui popover', () => {
+    test('should translate "Filter" search placeholder in toolbox', async ({ page }) => {
+      const uiDictionary = {
+        popover: {
+          Filter: 'Поиск',
+        },
+      };
+
+      await createEditorWithI18n(page, {
+        i18n: {
+          messages: {
+            ui: uiDictionary,
+          },
+        },
+      });
+
+      const block = page.locator(BLOCK_SELECTOR);
+
+      await expect(block).toHaveCount(1);
+      await block.click();
+      await page.locator(PLUS_BUTTON_SELECTOR).click();
+
+      const searchInput = page.locator(`${POPOVER_SELECTOR} input[type="search"], ${POPOVER_SELECTOR} input[placeholder*="Filter"]`);
+
+      await expect(searchInput).toBeVisible();
+
+      const placeholder = await searchInput.getAttribute('placeholder');
+
+      expect(placeholder).toContain(uiDictionary.popover.Filter);
+    });
+
+    test('should translate "Nothing found" message in toolbox', async ({ page }) => {
+      const uiDictionary = {
+        popover: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention -- Dictionary keys must match i18n structure
+          'Nothing found': 'Ничего не найдено',
+        },
+      };
+
+      await createEditorWithI18n(page, {
+        i18n: {
+          messages: {
+            ui: uiDictionary,
+          },
+        },
+      });
+
+      const block = page.locator(BLOCK_SELECTOR);
+
+      await expect(block).toHaveCount(1);
+      await block.click();
+      await page.locator(PLUS_BUTTON_SELECTOR).click();
+
+      const popoverContainer = page
+        .locator(`${POPOVER_SELECTOR} .ce-popover__container:visible`)
+        .filter({ has: page.locator('input[type="search"]') });
+
+      await expect(popoverContainer).toHaveCount(1);
+      await expect(popoverContainer).toBeVisible();
+
+      const searchInput = popoverContainer.locator('input[type="search"]');
+
+      await expect(searchInput).toHaveCount(1);
+      await expect(searchInput).toBeVisible();
+      await searchInput.fill('nonexistenttool12345');
+
+      // Wait for "Nothing found" message to appear
+      // eslint-disable-next-line playwright/no-wait-for-timeout -- Waiting for search results
+      await page.waitForTimeout(300);
+
+      const nothingFoundMessage = popoverContainer.getByText(uiDictionary.popover['Nothing found']);
+
+      await expect(nothingFoundMessage).toBeVisible();
+    });
+
+    test('should translate "Filter" and "Nothing found" in block settings popover', async ({ page }) => {
+      const uiDictionary = {
+        popover: {
+          Filter: 'Поиск',
+          // eslint-disable-next-line @typescript-eslint/naming-convention -- Dictionary keys must match i18n structure
+          'Nothing found': 'Ничего не найдено',
+        },
+      };
+
+      await page.evaluate(() => {
+        // @ts-expect-error - Define SimpleHeader in window for editor creation
+        window.SimpleHeader = class {
+          private data: { text: string };
+
+          /**
+           *
+           * @param root0 - root data
+           */
+          constructor({ data }: { data: { text: string } }) {
+            this.data = data;
+          }
+
+          /**
+           *
+           */
+          public render(): HTMLHeadingElement {
+            const element = document.createElement('h1');
+
+            element.contentEditable = 'true';
+            element.innerHTML = this.data.text;
+
+            return element;
+          }
+
+          /**
+           *
+           * @param element - heading element
+           */
+          public save(element: HTMLHeadingElement): { text: string; level: number } {
+            return {
+              text: element.innerHTML,
+              level: 1,
+            };
+          }
+
+          /**
+           *
+           */
+          public static get toolbox(): { title: string; icon: string } {
+            return {
+              title: 'Heading',
+              icon: '<svg width="17" height="15" viewBox="0 0 336 276" xmlns="http://www.w3.org/2000/svg"><path d="M291 150V79c0-19-15-34-34-34H79c-19 0-34 15-34 34v42l67-44 81 72 56-29 42 30zm0 52l-43-30-56 30-81-67-66 39v23c0 19 15 34 34 34h178c17 0 31-13 34-29zM79 0h178c44 0 79 35 79 79v118c0 44-35 79-79 79H79c-44 0-79-35-79-79V79C0 35 35 0 79 0z"/></svg>',
+            };
+          }
+
+          /**
+           *
+           */
+          public static get conversionConfig(): { export: string; import: string } {
+            return {
+              export: 'text',
+              import: 'text',
+            };
+          }
+        };
+      });
+
+      await createEditorWithI18n(page, {
+        i18n: {
+          messages: {
+            ui: uiDictionary,
+          },
+        },
+        tools: {
+          header: 'SimpleHeader',
+        },
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Some text',
+              },
+            },
+          ],
+        },
+      });
+
+      const block = page.locator(BLOCK_SELECTOR);
+
+      await expect(block).toHaveCount(1);
+      await block.click();
+      await page.locator(SETTINGS_BUTTON_SELECTOR).click();
+
+      const popoverContainer = page
+        .locator(`${POPOVER_SELECTOR} .ce-popover__container:visible`)
+        .filter({ has: page.locator(`input[placeholder*="${uiDictionary.popover.Filter}"]`) });
+
+      await expect(popoverContainer).toHaveCount(1);
+      await expect(popoverContainer).toBeVisible();
+
+      const searchInput = popoverContainer.getByRole('searchbox', { name: uiDictionary.popover.Filter });
+
+      await expect(searchInput).toHaveCount(1);
+      await expect(searchInput).toBeVisible();
+
+      const placeholder = await searchInput.getAttribute('placeholder');
+
+      expect(placeholder).toContain(uiDictionary.popover.Filter);
+
+      await searchInput.fill('nonexistent12345');
+      // eslint-disable-next-line playwright/no-wait-for-timeout -- Waiting for search results
+      await page.waitForTimeout(300);
+
+      const nothingFoundMessage = popoverContainer.getByText(uiDictionary.popover['Nothing found']);
+
+      await expect(nothingFoundMessage).toBeVisible();
+    });
+
+    test('should translate "Filter" and "Nothing found" in inline toolbar popover', async ({ page }) => {
+      const uiDictionary = {
+        popover: {
+          Filter: 'Поиск',
+          // eslint-disable-next-line @typescript-eslint/naming-convention -- Dictionary keys must match i18n structure
+          'Nothing found': 'Ничего не найдено',
+        },
+      };
+
+      await page.evaluate(() => {
+        // @ts-expect-error - Define SimpleHeader in window for editor creation
+        window.SimpleHeader = class {
+          private data: { text: string };
+
+          /**
+           *
+           * @param root0 - root data
+           */
+          constructor({ data }: { data: { text: string } }) {
+            this.data = data;
+          }
+
+          /**
+           *
+           */
+          public render(): HTMLHeadingElement {
+            const element = document.createElement('h1');
+
+            element.contentEditable = 'true';
+            element.innerHTML = this.data.text;
+
+            return element;
+          }
+
+          /**
+           *
+           * @param element - heading element
+           */
+          public save(element: HTMLHeadingElement): { text: string; level: number } {
+            return {
+              text: element.innerHTML,
+              level: 1,
+            };
+          }
+
+          /**
+           *
+           */
+          public static get toolbox(): { title: string; icon: string } {
+            return {
+              title: 'Heading',
+              icon: '<svg width="17" height="15" viewBox="0 0 336 276" xmlns="http://www.w3.org/2000/svg"><path d="M291 150V79c0-19-15-34-34-34H79c-19 0-34 15-34 34v42l67-44 81 72 56-29 42 30zm0 52l-43-30-56 30-81-67-66 39v23c0 19 15 34 34 34h178c17 0 31-13 34-29zM79 0h178c44 0 79 35 79 79v118c0 44-35 79-79 79H79c-44 0-79-35-79-79V79C0 35 35 0 79 0z"/></svg>',
+            };
+          }
+
+          /**
+           *
+           */
+          public static get conversionConfig(): { export: string; import: string } {
+            return {
+              export: 'text',
+              import: 'text',
+            };
+          }
+        };
+      });
+
+      await resetEditor(page);
+      await page.evaluate(
+        async ({ holderId, uiDict }) => {
+          // @ts-expect-error - Get SimpleHeader from window
+          const SimpleHeader = window.SimpleHeader;
+
+          const editor = new window.EditorJS({
+            holder: holderId,
+            tools: {
+              header: SimpleHeader,
+            },
+            i18n: {
+              messages: {
+                ui: uiDict,
+              },
+            },
+            data: {
+              blocks: [
+                {
+                  type: 'paragraph',
+                  data: {
+                    text: 'Some text to select',
+                  },
+                },
+              ],
+            },
+          });
+
+          window.editorInstance = editor;
+          await editor.isReady;
+        },
+        { holderId: HOLDER_ID,
+          uiDict: uiDictionary }
+      );
+
+      const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+      await expect(paragraph).toHaveCount(1);
+
+      await selectText(paragraph, 'Some text');
+
+      // Wait for inline toolbar to appear
+      // eslint-disable-next-line playwright/no-wait-for-timeout -- Waiting for UI animation
+      await page.waitForTimeout(200);
+
+      const inlinePopover = await openInlineToolbarPopover(page);
+      const convertToButton = inlinePopover.locator('[data-item-name="convert-to"]');
+
+      await expect(convertToButton).toBeVisible();
+      await expect(convertToButton).toHaveCount(1);
+      await convertToButton.click();
+
+      const nestedPopover = page.locator(`${INLINE_TOOLBAR_SELECTOR} .ce-popover--nested`);
+
+      await expect(nestedPopover).toHaveCount(1);
+
+      const nestedPopoverContainer = nestedPopover.locator('.ce-popover__container');
+
+      await expect(nestedPopoverContainer).toHaveCount(1);
+      await expect(nestedPopoverContainer).toBeVisible();
+
+      const searchInput = nestedPopover.getByRole('searchbox', { name: uiDictionary.popover.Filter });
+
+      await expect(searchInput).toHaveCount(1);
+      await expect(searchInput).toBeVisible();
+
+      const placeholder = await searchInput.getAttribute('placeholder');
+
+      expect(placeholder).toContain(uiDictionary.popover.Filter);
+
+      await searchInput.fill('nonexistent12345');
+      // eslint-disable-next-line playwright/no-wait-for-timeout -- Waiting for search results
+      await page.waitForTimeout(300);
+
+      const nothingFoundMessage = nestedPopover.getByText(uiDictionary.popover['Nothing found']);
+
+      await expect(nothingFoundMessage).toBeVisible();
+    });
+  });
+
+  test.describe('ui toolbar toolbox', () => {
+    test('should translate "Add" button tooltip', async ({ page }) => {
+      const uiDictionary = {
+        toolbar: {
+          toolbox: {
+            Add: 'Добавить',
+          },
+        },
+      };
+
+      await createEditorWithI18n(page, {
+        i18n: {
+          messages: {
+            ui: uiDictionary,
+          },
+        },
+      });
+
+      const block = page.locator(BLOCK_SELECTOR);
+
+      await expect(block).toHaveCount(1);
+      await block.click();
+
+      const plusButton = page.locator(PLUS_BUTTON_SELECTOR);
+
+      await expect(plusButton).toBeVisible();
+
+      const tooltipText = await getTooltipText(page, plusButton);
+
+      expect(tooltipText).toContain(uiDictionary.toolbar.toolbox.Add);
+    });
+  });
+
+  test.describe('ui block tunes toggler', () => {
+    test('should translate "Click to tune" tooltip', async ({ page }) => {
+      const uiDictionary = {
+        blockTunes: {
+          toggler: {
+            // eslint-disable-next-line @typescript-eslint/naming-convention -- Dictionary keys must match i18n structure
+            'Click to tune': 'Нажмите, чтобы настроить',
+          },
+        },
+      };
+
+      await createEditorWithI18n(page, {
+        i18n: {
+          messages: {
+            ui: uiDictionary,
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Some text',
+              },
+            },
+          ],
+        },
+      });
+
+      const block = page.locator(BLOCK_SELECTOR);
+
+      await expect(block).toHaveCount(1);
+      await block.click();
+
+      const settingsButton = page.locator(SETTINGS_BUTTON_SELECTOR);
+
+      await expect(settingsButton).toBeVisible();
+
+      const tooltipText = await getTooltipText(page, settingsButton);
+
+      expect(tooltipText).toContain(uiDictionary.blockTunes.toggler['Click to tune']);
+    });
+  });
+
+  test.describe('ui inline toolbar converter', () => {
+    test('should translate "Convert to" label in inline toolbar', async ({ page }) => {
+      const uiDictionary = {
+        inlineToolbar: {
+          converter: {
+            // eslint-disable-next-line @typescript-eslint/naming-convention -- Dictionary keys must match i18n structure
+            'Convert to': 'Конвертировать в',
+          },
+        },
+      };
+
+      // Create a simple header tool in the browser context
+      await page.evaluate(() => {
+        // @ts-expect-error - Define SimpleHeader in window for editor creation
+        window.SimpleHeader = class {
+          private data: { text: string };
+
+          /**
+           * Creates a `SimpleHeader` instance with initial block data.
+           *
+           * @param root0 - Editor.js constructor arguments containing the block data.
+           */
+          constructor({ data }: { data: { text: string } }) {
+            this.data = data;
+          }
+
+          /**
+           *
+           */
+          public render(): HTMLHeadingElement {
+            const element = document.createElement('h1');
+
+            element.contentEditable = 'true';
+            element.innerHTML = this.data.text;
+
+            return element;
+          }
+
+          /**
+           * Persists the heading content to the Editor.js data format.
+           *
+           * @param element - Heading element that contains the current block content.
+           */
+          public save(element: HTMLHeadingElement): { text: string; level: number } {
+            return {
+              text: element.innerHTML,
+              level: 1,
+            };
+          }
+
+          /**
+           *
+           */
+          public static get toolbox(): { title: string; icon: string } {
+            return {
+              title: 'Heading',
+              icon: '<svg width="17" height="15" viewBox="0 0 336 276" xmlns="http://www.w3.org/2000/svg"><path d="M291 150V79c0-19-15-34-34-34H79c-19 0-34 15-34 34v42l67-44 81 72 56-29 42 30zm0 52l-43-30-56 30-81-67-66 39v23c0 19 15 34 34 34h178c17 0 31-13 34-29zM79 0h178c44 0 79 35 79 79v118c0 44-35 79-79 79H79c-44 0-79-35-79-79V79C0 35 35 0 79 0z"/></svg>',
+            };
+          }
+
+          /**
+           *
+           */
+          public static get conversionConfig(): { export: string; import: string } {
+            return {
+              export: 'text',
+              import: 'text',
+            };
+          }
+        };
+      });
+
+      // Create editor with header tool
+      await resetEditor(page);
+      await page.evaluate(
+        async ({ holderId, uiDict }) => {
+          // @ts-expect-error - Get SimpleHeader from window
+          const SimpleHeader = window.SimpleHeader;
+
+          const editor = new window.EditorJS({
+            holder: holderId,
+            tools: {
+              header: SimpleHeader,
+            },
+            i18n: {
+              messages: {
+                ui: uiDict,
+              },
+            },
+            data: {
+              blocks: [
+                {
+                  type: 'paragraph',
+                  data: {
+                    text: 'Some text',
+                  },
+                },
+              ],
+            },
+          });
+
+          window.editorInstance = editor;
+          await editor.isReady;
+        },
+        { holderId: HOLDER_ID,
+          uiDict: uiDictionary }
+      );
+
+      const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+      await expect(paragraph).toHaveCount(1);
+
+      await selectText(paragraph, 'Some text');
+
+      // Wait for inline toolbar to appear
+      // eslint-disable-next-line playwright/no-wait-for-timeout -- Waiting for UI animation
+      await page.waitForTimeout(200);
+
+      const inlinePopover = await openInlineToolbarPopover(page);
+
+      // Look for "Convert to" button/item in inline toolbar
+      const convertToButton = inlinePopover.locator('[data-item-name="convert-to"]');
+
+      await expect(convertToButton).toHaveCount(1);
+      const convertToTooltip = await getTooltipText(page, convertToButton);
+
+      expect(convertToTooltip).toContain(uiDictionary.inlineToolbar.converter['Convert to']);
+    });
+  });
+
+  test.describe('tools translations', () => {
+    test('should translate "Add a link" placeholder for link tool', async ({ page }) => {
+      const toolsDictionary = {
+        link: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention -- Dictionary keys must match i18n structure
+          'Add a link': 'Вставьте ссылку',
+        },
+      };
+
+      await createEditorWithI18n(page, {
+        i18n: {
+          messages: {
+            tools: toolsDictionary,
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Some text',
+              },
+            },
+          ],
+        },
+      });
+
+      const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+      await expect(paragraph).toHaveCount(1);
+
+      await selectText(paragraph, 'Some text');
+
+      // Wait for inline toolbar to appear
+      // eslint-disable-next-line playwright/no-wait-for-timeout -- Waiting for UI animation
+      await page.waitForTimeout(200);
+
+      // Trigger link tool (Ctrl+K or Cmd+K)
+      await page.keyboard.press(`${MODIFIER_KEY}+k`);
+
+      // Wait for link input to appear
+      // eslint-disable-next-line playwright/no-wait-for-timeout -- Waiting for UI animation
+      await page.waitForTimeout(200);
+
+      const linkInput = page.locator('input[data-link-tool-input-opened], input[placeholder*="link" i]');
+
+      await expect(linkInput).toBeVisible();
+
+      const placeholder = await linkInput.getAttribute('placeholder');
+
+      expect(placeholder).toContain(toolsDictionary.link['Add a link']);
+    });
+
+    test('should translate stub tool message', async ({ page }) => {
+      const toolsDictionary = {
+        stub: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention -- Dictionary keys must match i18n structure
+          'The block can not be displayed correctly.': 'Блок не может быть отображен корректно.',
+        },
+      };
+
+      await createEditorWithI18n(page, {
+        i18n: {
+          messages: {
+            tools: toolsDictionary,
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'unknown-tool-type',
+              data: {},
+            },
+          ],
+        },
+      });
+
+      // Stub block should be rendered with translated message
+      const stubMessage = page.locator(`text=${toolsDictionary.stub['The block can not be displayed correctly.']}`);
+
+      await expect(stubMessage).toBeVisible();
+    });
+  });
+
+  test.describe('inline toolbar', () => {
+    test('should translate tool name in Convert To', async ({ page }) => {
+      const toolNamesDictionary = {
+        Heading: 'Заголовок',
+      };
+
+      // Create a simple header tool in the browser context
+      await page.evaluate(() => {
+        // @ts-expect-error - Define SimpleHeader in window for editor creation
+        window.SimpleHeader = class {
+          private data: { text: string };
+
+          /**
+           * Creates a `SimpleHeader` instance with initial block data.
+           *
+           * @param root0 - Editor.js constructor arguments containing the block data.
+           */
+          constructor({ data }: { data: { text: string } }) {
+            this.data = data;
+          }
+
+          /**
+           *
+           */
+          public render(): HTMLHeadingElement {
+            const element = document.createElement('h1');
+
+            element.contentEditable = 'true';
+            element.innerHTML = this.data.text;
+
+            return element;
+          }
+
+          /**
+           * Persists the heading content to the Editor.js data format.
+           *
+           * @param element - Heading element that contains the current block content.
+           */
+          public save(element: HTMLHeadingElement): { text: string; level: number } {
+            return {
+              text: element.innerHTML,
+              level: 1,
+            };
+          }
+
+          /**
+           *
+           */
+          public static get toolbox(): { title: string; icon: string } {
+            return {
+              title: 'Heading',
+              icon: '<svg width="17" height="15" viewBox="0 0 336 276" xmlns="http://www.w3.org/2000/svg"><path d="M291 150V79c0-19-15-34-34-34H79c-19 0-34 15-34 34v42l67-44 81 72 56-29 42 30zm0 52l-43-30-56 30-81-67-66 39v23c0 19 15 34 34 34h178c17 0 31-13 34-29zM79 0h178c44 0 79 35 79 79v118c0 44-35 79-79 79H79c-44 0-79-35-79-79V79C0 35 35 0 79 0z"/></svg>',
+            };
+          }
+
+          /**
+           *
+           */
+          public static get conversionConfig(): { export: string; import: string } {
+            return {
+              export: 'text',
+              import: 'text',
+            };
+          }
+        };
+      });
+
+      await createEditorWithI18n(page, {
+        tools: {
+          header: 'SimpleHeader',
+        },
+        i18n: {
+          messages: {
+            toolNames: toolNamesDictionary,
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Some text',
+              },
+            },
+          ],
+        },
+      });
+
+      const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+      await expect(paragraph).toHaveCount(1);
+
+      // Open Inline Toolbar
+      await selectText(paragraph, 'Some text');
+
+      // Wait for inline toolbar to appear
+      // eslint-disable-next-line playwright/no-wait-for-timeout -- Waiting for UI animation
+      await page.waitForTimeout(200);
+
+      const inlinePopover = await openInlineToolbarPopover(page);
+
+      // Open "Convert to" menu
+      const convertToButton = inlinePopover.locator('[data-item-name="convert-to"]');
+
+      await expect(convertToButton).toBeVisible();
+      await convertToButton.click();
+
+      // Check item in convert to menu is internationalized
+      const nestedPopover = page.locator(`${INLINE_TOOLBAR_SELECTOR} .ce-popover--nested`);
+
+      await expect(nestedPopover).toHaveCount(1);
+
+      const headerItem = nestedPopover.locator('[data-item-name="header"]');
+
+      await expect(headerItem).toHaveCount(1);
+      await expect(headerItem).toBeVisible();
+      await expect(headerItem).toContainText(toolNamesDictionary.Heading);
+    });
+  });
+});
+
diff --git a/test/playwright/tests/inline-tools/bold.spec.ts b/test/playwright/tests/inline-tools/bold.spec.ts
new file mode 100644
index 000000000..b13586e2c
--- /dev/null
+++ b/test/playwright/tests/inline-tools/bold.spec.ts
@@ -0,0 +1,609 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type EditorJS from '@/types';
+import type { OutputData } from '@/types';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR, MODIFIER_KEY } from '../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-block-tool="paragraph"]`;
+const INLINE_TOOLBAR_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-cy=inline-toolbar]`;
+
+/**
+ * Reset the editor holder and destroy any existing instance
+ *
+ * @param page - The Playwright page object
+ */
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ * Create editor with provided blocks
+ *
+ * @param page - The Playwright page object
+ * @param blocks - The blocks data to initialize the editor with
+ */
+const createEditorWithBlocks = async (page: Page, blocks: OutputData['blocks']): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, blocks: editorBlocks }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+      data: { blocks: editorBlocks },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID,
+    blocks });
+};
+
+/**
+ * Select text content within a locator by string match
+ *
+ * @param locator - The Playwright locator for the element containing the text
+ * @param text - The text string to select within the element
+ */
+const selectText = async (locator: Locator, text: string): Promise<void> => {
+  await locator.evaluate((element, targetText) => {
+    // Walk text nodes to find the target text within the element
+    const walker = element.ownerDocument.createTreeWalker(element, NodeFilter.SHOW_TEXT);
+    let textNode: Node | null = null;
+    let start = -1;
+
+    while (walker.nextNode()) {
+      const node = walker.currentNode;
+      const content = node.textContent ?? '';
+      const idx = content.indexOf(targetText);
+
+      if (idx !== -1) {
+        textNode = node;
+        start = idx;
+        break;
+      }
+    }
+
+    if (!textNode || start === -1) {
+      throw new Error(`Text "${targetText}" was not found in element`);
+    }
+
+    const range = element.ownerDocument.createRange();
+
+    range.setStart(textNode, start);
+    range.setEnd(textNode, start + targetText.length);
+
+    const selection = element.ownerDocument.getSelection();
+
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+
+    element.ownerDocument.dispatchEvent(new Event('selectionchange'));
+  }, text);
+};
+
+test.describe('inline tool bold', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test('detects bold state across multiple bold words', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: '<strong>first</strong> <strong>second</strong>',
+        },
+      },
+    ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await paragraph.evaluate((el) => {
+      const paragraphEl = el as HTMLElement;
+      const doc = paragraphEl.ownerDocument;
+      const range = doc.createRange();
+      const selection = doc.getSelection();
+
+      if (!selection) {
+        throw new Error('Selection not available');
+      }
+
+      const bolds = paragraphEl.querySelectorAll('strong');
+      const firstBold = bolds[0];
+      const secondBold = bolds[1];
+
+      if (!firstBold || !secondBold) {
+        throw new Error('Bold elements not found');
+      }
+
+      const firstBoldText = firstBold.firstChild;
+      const secondBoldText = secondBold.firstChild;
+
+      if (!firstBoldText || !secondBoldText) {
+        throw new Error('Text nodes not found');
+      }
+
+      range.setStart(firstBoldText, 0);
+      range.setEnd(secondBoldText, secondBoldText.textContent?.length ?? 0);
+
+      selection.removeAllRanges();
+      selection.addRange(range);
+
+      doc.dispatchEvent(new Event('selectionchange'));
+    });
+
+    await expect(page.locator(`${INLINE_TOOLBAR_SELECTOR} [data-popover-opened="true"]`)).toHaveCount(1);
+    await expect(page.locator(`${INLINE_TOOLBAR_SELECTOR} [data-item-name="bold"]`)).toHaveAttribute('data-popover-item-active', 'true');
+  });
+
+  test('detects bold state within a single word', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: '<strong>bold text</strong>',
+        },
+      },
+    ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await selectText(paragraph, 'bold');
+
+    await expect(page.locator(`${INLINE_TOOLBAR_SELECTOR} [data-item-name="bold"]`)).toHaveAttribute('data-popover-item-active', 'true');
+  });
+
+  test('does not detect bold state in normal text', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: 'normal text',
+        },
+      },
+    ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await selectText(paragraph, 'normal');
+
+    await expect(page.locator(`${INLINE_TOOLBAR_SELECTOR} [data-item-name="bold"]`)).not.toHaveAttribute('data-popover-item-active', 'true');
+  });
+
+  test('toggles bold across multiple bold elements', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: '<strong>first</strong> <strong>second</strong>',
+        },
+      },
+    ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    // Select text spanning both bold elements
+    await paragraph.evaluate((el) => {
+      const paragraphEl = el as HTMLElement;
+      const doc = paragraphEl.ownerDocument;
+      const range = doc.createRange();
+      const selection = doc.getSelection();
+
+      if (!selection) {
+        throw new Error('Selection not available');
+      }
+
+      const bolds = paragraphEl.querySelectorAll('strong');
+      const firstBold = bolds[0];
+      const secondBold = bolds[1];
+
+      if (!firstBold || !secondBold) {
+        throw new Error('Bold elements not found');
+      }
+
+      const firstBoldText = firstBold.firstChild;
+      const secondBoldText = secondBold.firstChild;
+
+      if (!firstBoldText || !secondBoldText) {
+        throw new Error('Text nodes not found');
+      }
+
+      range.setStart(firstBoldText, 0);
+      range.setEnd(secondBoldText, secondBoldText.textContent?.length ?? 0);
+
+      selection.removeAllRanges();
+      selection.addRange(range);
+
+      doc.dispatchEvent(new Event('selectionchange'));
+    });
+
+    const boldButton = page.locator(`${INLINE_TOOLBAR_SELECTOR} [data-item-name="bold"]`);
+
+    // Verify bold button is active (since all text is visually bold)
+    await expect(boldButton).toHaveAttribute('data-popover-item-active', 'true');
+
+    // Click bold button - should remove bold on first click (since selection is visually bold)
+    await boldButton.click();
+
+    // Wait for the toolbar state to update (bold button should no longer be active)
+    await expect(boldButton).not.toHaveAttribute('data-popover-item-active', 'true');
+
+    // Verify that bold has been removed
+    const html = await paragraph.innerHTML();
+
+    expect(html).toBe('first second');
+    expect(html).not.toMatch(/<strong>/);
+  });
+
+  test('makes mixed selection (bold and normal text) bold', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: '<strong>bold</strong> normal <strong>bold2</strong>',
+        },
+      },
+    ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    // Select text spanning bold and non-bold
+    await paragraph.evaluate((el) => {
+      const paragraphEl = el as HTMLElement;
+      const doc = paragraphEl.ownerDocument;
+      const range = doc.createRange();
+      const selection = doc.getSelection();
+
+      if (!selection) {
+        throw new Error('Selection not available');
+      }
+
+      const bolds = paragraphEl.querySelectorAll('strong');
+      const firstBold = bolds[0];
+      const secondBold = bolds[1];
+
+      if (!firstBold || !secondBold) {
+        throw new Error('Bold elements not found');
+      }
+
+      const firstBoldText = firstBold.firstChild;
+      const secondBoldText = secondBold.firstChild;
+
+      if (!firstBoldText || !secondBoldText) {
+        throw new Error('Text nodes not found');
+      }
+
+      // Select from first bold through second bold (including the " normal " text)
+      range.setStart(firstBoldText, 0);
+      range.setEnd(secondBoldText, secondBoldText.textContent?.length ?? 0);
+
+      selection.removeAllRanges();
+      selection.addRange(range);
+
+      doc.dispatchEvent(new Event('selectionchange'));
+    });
+
+    // Click bold button (should unwrap existing bold, then wrap everything)
+    await page.locator(`${INLINE_TOOLBAR_SELECTOR} [data-item-name="bold"]`).click();
+
+    // Wait for all selected text to be wrapped in a single <strong> tag
+    await page.waitForFunction(
+      ({ selector }) => {
+        const element = document.querySelector(selector);
+
+        return element && /<strong>bold normal bold2<\/strong>/.test(element.innerHTML);
+      },
+      {
+        selector: PARAGRAPH_SELECTOR,
+      }
+    );
+
+    // Verify that all selected text is now wrapped in a single <strong> tag
+    const html = await paragraph.innerHTML();
+
+    expect(html).toMatch(/<strong>bold normal bold2<\/strong>/);
+  });
+
+  test('removes bold from fully bold selection', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: '<strong>fully bold</strong>',
+        },
+      },
+    ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await selectText(paragraph, 'fully bold');
+
+    const boldButton = page.locator(`${INLINE_TOOLBAR_SELECTOR} [data-item-name="bold"]`);
+
+    await expect(boldButton).toHaveAttribute('data-popover-item-active', 'true');
+
+    await boldButton.click();
+
+    await expect(boldButton).not.toHaveAttribute('data-popover-item-active', 'true');
+
+    const html = await paragraph.innerHTML();
+
+    expect(html).toBe('fully bold');
+  });
+
+  test('toggles bold with keyboard shortcut', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: 'Keyboard shortcut',
+        },
+      },
+    ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await selectText(paragraph, 'Keyboard');
+
+    const boldButton = page.locator(`${INLINE_TOOLBAR_SELECTOR} [data-item-name="bold"]`);
+
+    await page.keyboard.press(`${MODIFIER_KEY}+b`);
+
+    await expect(boldButton).toHaveAttribute('data-popover-item-active', 'true');
+
+    let html = await paragraph.innerHTML();
+
+    expect(html).toMatch(/<strong>Keyboard<\/strong> shortcut/);
+
+    await page.keyboard.press(`${MODIFIER_KEY}+b`);
+
+    await expect(boldButton).not.toHaveAttribute('data-popover-item-active', 'true');
+
+    html = await paragraph.innerHTML();
+
+    expect(html).toBe('Keyboard shortcut');
+  });
+
+  test('applies bold to typed text', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: 'Typing test',
+        },
+      },
+    ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await paragraph.evaluate((element) => {
+      const paragraphEl = element as HTMLElement;
+      const doc = paragraphEl.ownerDocument;
+      const textNode = paragraphEl.childNodes[paragraphEl.childNodes.length - 1];
+
+      if (!textNode || textNode.nodeType !== Node.TEXT_NODE) {
+        throw new Error('Expected trailing text node');
+      }
+
+      const range = doc.createRange();
+      const selection = doc.getSelection();
+
+      range.setStart(textNode, textNode.textContent?.length ?? 0);
+      range.collapse(true);
+
+      selection?.removeAllRanges();
+      selection?.addRange(range);
+    });
+
+    await page.keyboard.press(`${MODIFIER_KEY}+b`);
+    await page.keyboard.type(' Bold');
+    await page.keyboard.press(`${MODIFIER_KEY}+b`);
+    await page.keyboard.type(' normal');
+
+    const html = await paragraph.innerHTML();
+
+    expect(html.replace(/&nbsp;/g, ' ')).toBe('Typing test<strong> Bold</strong> normal');
+  });
+
+  test('persists bold in saved output', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: 'bold text',
+        },
+      },
+    ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await selectText(paragraph, 'bold');
+
+    await page.locator(`${INLINE_TOOLBAR_SELECTOR} [data-item-name="bold"]`).click();
+
+    const savedData = await page.evaluate<OutputData | undefined>(async () => {
+      return window.editorInstance?.save();
+    });
+
+    expect(savedData).toBeDefined();
+
+    const paragraphBlock = savedData?.blocks.find((block) => block.type === 'paragraph');
+
+    expect(paragraphBlock?.data.text).toMatch(/<strong>bold<\/strong> text/);
+  });
+
+  test('removes bold from selection within bold text', async ({ page }) => {
+    // Step 1: Create editor with "Some text"
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: 'Some text',
+        },
+      },
+    ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    // Step 2: Select entire text and make it bold
+    await selectText(paragraph, 'Some text');
+
+    const boldButton = page.locator(`${INLINE_TOOLBAR_SELECTOR} [data-item-name="bold"]`);
+
+    await boldButton.click();
+
+    // Wait for the text to be wrapped in bold tags
+    await page.waitForFunction(
+      ({ selector }) => {
+        const element = document.querySelector(selector);
+
+        return element && /<strong>Some text<\/strong>/.test(element.innerHTML);
+      },
+      {
+        selector: PARAGRAPH_SELECTOR,
+      }
+    );
+
+    // Verify initial bold state
+    let html = await paragraph.innerHTML();
+
+    expect(html).toMatch(/<strong>Some text<\/strong>/);
+
+    // Step 3: Select only "Some" and remove bold formatting
+    await selectText(paragraph, 'Some');
+
+    // Verify bold button is active (since "Some" is bold)
+    await expect(boldButton).toHaveAttribute('data-popover-item-active', 'true');
+
+    // Click to remove bold from "Some"
+    await boldButton.click();
+
+    // Wait for the toolbar state to update (bold button should no longer be active for "Some")
+    await expect(boldButton).not.toHaveAttribute('data-popover-item-active', 'true');
+
+    // Step 4: Verify that "text" is still bold while "Some" is not
+    html = await paragraph.innerHTML();
+
+    // "text" should be wrapped in bold tags (with space before it)
+    expect(html).toMatch(/<strong>\s*text<\/strong>/);
+    // "Some" should not be wrapped in bold tags
+    expect(html).not.toMatch(/<strong>Some<\/strong>/);
+  });
+
+  test('removes bold from separately bolded words', async ({ page }) => {
+    // Step 1: Start with normal text "some text"
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: 'some text',
+        },
+      },
+    ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+    const boldButton = page.locator(`${INLINE_TOOLBAR_SELECTOR} [data-item-name="bold"]`);
+
+    // Step 2: Make "some" bold
+    await selectText(paragraph, 'some');
+    await boldButton.click();
+
+    // Verify "some" is now bold
+    let html = await paragraph.innerHTML();
+
+    expect(html).toMatch(/<strong>some<\/strong> text/);
+
+    // Step 3: Make "text" bold (now we have <strong>some</strong> <strong>text</strong>)
+    await selectText(paragraph, 'text');
+    await boldButton.click();
+
+    // Verify both words are now bold with space between them
+    html = await paragraph.innerHTML();
+
+    expect(html).toMatch(/<strong>some<\/strong> <strong>text<\/strong>/);
+
+    // Step 4: Select the whole phrase including the space
+    await paragraph.evaluate((el) => {
+      const paragraphEl = el as HTMLElement;
+      const doc = paragraphEl.ownerDocument;
+      const range = doc.createRange();
+      const selection = doc.getSelection();
+
+      if (!selection) {
+        throw new Error('Selection not available');
+      }
+
+      const bolds = paragraphEl.querySelectorAll('strong');
+      const firstBold = bolds[0];
+      const secondBold = bolds[1];
+
+      if (!firstBold || !secondBold) {
+        throw new Error('Bold elements not found');
+      }
+
+      const firstBoldText = firstBold.firstChild;
+      const secondBoldText = secondBold.firstChild;
+
+      if (!firstBoldText || !secondBoldText) {
+        throw new Error('Text nodes not found');
+      }
+
+      // Select from start of first bold to end of second bold (including the space)
+      range.setStart(firstBoldText, 0);
+      range.setEnd(secondBoldText, secondBoldText.textContent?.length ?? 0);
+
+      selection.removeAllRanges();
+      selection.addRange(range);
+
+      doc.dispatchEvent(new Event('selectionchange'));
+    });
+
+    // Step 5: Verify the editor indicates the selection is bold (button is active)
+    await expect(boldButton).toHaveAttribute('data-popover-item-active', 'true');
+
+    // Step 6: Click bold button - should remove bold on first click (not wrap again)
+    await boldButton.click();
+
+    // Verify bold button is no longer active
+    await expect(boldButton).not.toHaveAttribute('data-popover-item-active', 'true');
+
+    // Verify that bold has been removed from both words on first click
+    html = await paragraph.innerHTML();
+
+    expect(html).toBe('some text');
+    expect(html).not.toMatch(/<strong>/);
+  });
+});
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+    EditorJS: new (...args: unknown[]) => EditorJS;
+  }
+}
diff --git a/test/playwright/tests/inline-tools/link.spec.ts b/test/playwright/tests/inline-tools/link.spec.ts
new file mode 100644
index 000000000..59651dd46
--- /dev/null
+++ b/test/playwright/tests/inline-tools/link.spec.ts
@@ -0,0 +1,392 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type EditorJS from '@/types';
+import type { OutputData } from '@/types';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+import { INLINE_TOOLBAR_INTERFACE_SELECTOR, MODIFIER_KEY } from '../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const PARAGRAPH_SELECTOR = '[data-block-tool="paragraph"]';
+const INLINE_TOOLBAR_SELECTOR = INLINE_TOOLBAR_INTERFACE_SELECTOR;
+const LINK_BUTTON_SELECTOR = `${INLINE_TOOLBAR_SELECTOR} [data-item-name="link"] button`;
+const LINK_INPUT_SELECTOR = `input[data-link-tool-input-opened]`;
+const NOTIFIER_SELECTOR = '.cdx-notifies';
+
+const getParagraphByText = (page: Page, text: string): Locator => {
+  return page.locator(PARAGRAPH_SELECTOR, { hasText: text });
+};
+
+const selectAll = async (locator: Locator): Promise<void> => {
+  await locator.evaluate((element) => {
+    const el = element as HTMLElement;
+    const doc = el.ownerDocument;
+    const range = doc.createRange();
+    const selection = doc.getSelection();
+
+    if (!selection) {
+      throw new Error('Selection is not available');
+    }
+
+    const walker = doc.createTreeWalker(el, NodeFilter.SHOW_TEXT);
+    const textNodes: Node[] = [];
+
+    while (walker.nextNode()) {
+      textNodes.push(walker.currentNode);
+    }
+
+    if (textNodes.length === 0) {
+      throw new Error('Nothing to select');
+    }
+
+    const startNode = textNodes[0];
+    const endNode = textNodes[textNodes.length - 1];
+    const endOffset = endNode.textContent?.length ?? 0;
+
+    range.setStart(startNode, 0);
+    range.setEnd(endNode, endOffset);
+
+    selection.removeAllRanges();
+    selection.addRange(range);
+    doc.dispatchEvent(new Event('selectionchange'));
+  });
+};
+
+/**
+ * Reset the editor holder and destroy any existing instance
+ *
+ * @param page - The Playwright page object
+ */
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ * Create editor with provided blocks
+ *
+ * @param page - The Playwright page object
+ * @param blocks - The blocks data to initialize the editor with
+ */
+const createEditorWithBlocks = async (page: Page, blocks: OutputData['blocks']): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, blocks: editorBlocks }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+      data: { blocks: editorBlocks },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, {
+    holderId: HOLDER_ID,
+    blocks,
+  });
+};
+
+/**
+ * Select text content within a locator by string match using Playwright's built-in methods
+ *
+ * @param locator - The Playwright locator for the element containing the text
+ * @param text - The text string to select within the element
+ */
+const selectText = async (locator: Locator, text: string): Promise<void> => {
+  // Get the full text content to find the position
+  const fullText = await locator.textContent();
+
+  if (!fullText || !fullText.includes(text)) {
+    throw new Error(`Text "${text}" was not found in element`);
+  }
+
+  const startIndex = fullText.indexOf(text);
+  const endIndex = startIndex + text.length;
+
+  // Click on the element to focus it
+  await locator.click();
+
+  // Get the page from the locator to use keyboard API
+  const page = locator.page();
+
+  // Move cursor to the start of the element
+  await page.keyboard.press('Home');
+
+  // Navigate to the start position of the target text
+  for (let i = 0; i < startIndex; i++) {
+    await page.keyboard.press('ArrowRight');
+  }
+
+  // Select the target text by holding Shift and moving right
+  await page.keyboard.down('Shift');
+  for (let i = startIndex; i < endIndex; i++) {
+    await page.keyboard.press('ArrowRight');
+  }
+  await page.keyboard.up('Shift');
+};
+
+/**
+ * Submit a URL via the inline link input
+ *
+ * @param page - The Playwright page object
+ * @param url - URL to submit
+ */
+const submitLink = async (page: Page, url: string): Promise<void> => {
+  const linkInput = page.locator(LINK_INPUT_SELECTOR);
+
+  await expect(linkInput).toBeVisible();
+  await linkInput.fill(url);
+  await linkInput.press('Enter');
+};
+
+test.describe('inline tool link', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test('should create a link via Enter key', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: 'First block text',
+        },
+      },
+    ]);
+
+    const paragraph = getParagraphByText(page, 'First block text');
+
+    await selectText(paragraph, 'First block text');
+    await page.keyboard.press(`${MODIFIER_KEY}+k`);
+
+    await submitLink(page, 'https://codex.so');
+
+    await expect(paragraph.locator('a')).toHaveAttribute('href', 'https://codex.so');
+  });
+
+  test('should create a link via toolbar button', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: 'Link me please',
+        },
+      },
+    ]);
+
+    const paragraph = getParagraphByText(page, 'Link me please');
+
+    await selectText(paragraph, 'Link me');
+
+    const linkButton = page.locator(LINK_BUTTON_SELECTOR);
+
+    await expect(linkButton).toBeVisible();
+    await linkButton.click();
+
+    await submitLink(page, 'example.com');
+
+    const anchor = paragraph.locator('a');
+
+    await expect(anchor).toHaveAttribute('href', 'http://example.com');
+    await expect(anchor).toHaveText('Link me');
+  });
+
+  test('should show validation error for invalid URL', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: 'Invalid URL test',
+        },
+      },
+    ]);
+
+    const paragraph = getParagraphByText(page, 'Invalid URL test');
+
+    await selectText(paragraph, 'Invalid URL test');
+    await page.keyboard.press(`${MODIFIER_KEY}+k`);
+
+    const linkInput = page.locator(LINK_INPUT_SELECTOR);
+
+    await linkInput.fill('https://example .com');
+    await linkInput.press('Enter');
+
+    await expect(linkInput).toBeVisible();
+    await expect(linkInput).toHaveValue('https://example .com');
+    await expect(paragraph.locator('a')).toHaveCount(0);
+
+    await page.waitForFunction(({ notifierSelector }) => {
+      const notifier = document.querySelector(notifierSelector);
+
+      return Boolean(notifier && notifier.textContent && notifier.textContent.includes('Pasted link is not valid.'));
+    }, { notifierSelector: NOTIFIER_SELECTOR });
+  });
+
+  test('should fill in and update existing link', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: '<a href="https://codex.so">First block text</a>',
+        },
+      },
+    ]);
+
+    const paragraph = getParagraphByText(page, 'First block text');
+
+    await selectAll(paragraph);
+    // Use keyboard shortcut to trigger the link tool (this will open the toolbar and input)
+    await page.keyboard.press(`${MODIFIER_KEY}+k`);
+
+    const linkInput = page.locator(LINK_INPUT_SELECTOR);
+
+    // Wait for the input to appear (it should open automatically when a link is detected)
+    await expect(linkInput).toBeVisible();
+    await expect(linkInput).toHaveValue('https://codex.so');
+
+    // Verify button state - find button by data attributes directly
+    const linkButton = page.locator('button[data-link-tool-unlink="true"][data-link-tool-active="true"]');
+
+    await expect(linkButton).toBeVisible();
+
+    await submitLink(page, 'example.org');
+
+    await expect(paragraph.locator('a')).toHaveAttribute('href', 'http://example.org');
+  });
+
+  test('should remove link when toggled', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: '<a href="https://codex.so">Link to remove</a>',
+        },
+      },
+    ]);
+
+    const paragraph = getParagraphByText(page, 'Link to remove');
+
+    await selectAll(paragraph);
+    // Use keyboard shortcut to trigger the link tool
+    await page.keyboard.press(`${MODIFIER_KEY}+k`);
+
+    // Find the unlink button by its data attributes
+    const linkButton = page.locator('button[data-link-tool-unlink="true"]');
+
+    await expect(linkButton).toBeVisible();
+    await linkButton.click();
+
+    await expect(paragraph.locator('a')).toHaveCount(0);
+  });
+
+  test('should persist link in saved output', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: 'Persist me',
+        },
+      },
+    ]);
+
+    const paragraph = getParagraphByText(page, 'Persist me');
+
+    await selectText(paragraph, 'Persist me');
+    await page.keyboard.press(`${MODIFIER_KEY}+k`);
+    await submitLink(page, 'https://codex.so');
+
+    const savedData = await page.evaluate<OutputData | undefined>(async () => {
+      return window.editorInstance?.save();
+    });
+
+    expect(savedData).toBeDefined();
+
+    const paragraphBlock = savedData?.blocks.find((block) => block.type === 'paragraph');
+
+    expect(paragraphBlock?.data.text).toContain('<a href="https://codex.so">Persist me</a>');
+  });
+
+  test('should work in read-only mode', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        type: 'paragraph',
+        data: {
+          text: 'Clickable link',
+        },
+      },
+    ]);
+
+    const paragraph = getParagraphByText(page, 'Clickable link');
+
+    // Create a link
+    await selectText(paragraph, 'Clickable link');
+    await page.keyboard.press(`${MODIFIER_KEY}+k`);
+    await submitLink(page, 'https://example.com');
+
+    // Verify link was created
+    const anchor = paragraph.locator('a');
+
+    await expect(anchor).toHaveAttribute('href', 'https://example.com');
+    await expect(anchor).toHaveText('Clickable link');
+
+    // Enable read-only mode
+    await page.evaluate(async () => {
+      if (window.editorInstance) {
+        await window.editorInstance.readOnly.toggle(true);
+      }
+    });
+
+    // Verify read-only mode is enabled
+    const isReadOnly = await page.evaluate(() => {
+      return window.editorInstance?.readOnly.isEnabled ?? false;
+    });
+
+    expect(isReadOnly).toBe(true);
+
+    // Verify link still exists and has correct href
+    await expect(anchor).toHaveAttribute('href', 'https://example.com');
+    await expect(anchor).toHaveText('Clickable link');
+
+    // Verify link is clickable by checking it's not disabled and has proper href
+    const href = anchor;
+
+    await expect(href).toHaveAttribute('href', 'https://example.com');
+
+    // Verify link element is visible and interactive
+    await expect(anchor).toBeVisible();
+    const isDisabled = await anchor.evaluate((el) => {
+      return el.hasAttribute('disabled') || el.getAttribute('aria-disabled') === 'true';
+    });
+
+    expect(isDisabled).toBe(false);
+  });
+});
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+    EditorJS: new (...args: unknown[]) => EditorJS;
+  }
+}
diff --git a/test/playwright/tests/modules/BlockEvents/ArrowLeft.spec.ts b/test/playwright/tests/modules/BlockEvents/ArrowLeft.spec.ts
new file mode 100644
index 000000000..82238f149
--- /dev/null
+++ b/test/playwright/tests/modules/BlockEvents/ArrowLeft.spec.ts
@@ -0,0 +1,318 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type EditorJS from '../../../../../types';
+import type { OutputData } from '../../../../../types';
+import { ensureEditorBundleBuilt } from '../../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../../fixtures/test.html')
+).href;
+const HOLDER_ID = 'editorjs';
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-block-tool="paragraph"]`;
+
+const getParagraphByIndex = (page: Page, index: number): Locator => {
+  return page.locator(`:nth-match(${PARAGRAPH_SELECTOR}, ${index + 1})`);
+};
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditorWithBlocks = async (page: Page, blocks: OutputData['blocks']): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, blocks: editorBlocks }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+      data: { blocks: editorBlocks },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID,
+    blocks });
+};
+
+const createParagraphEditor = async (page: Page, textBlocks: string[]): Promise<void> => {
+  const blocks: OutputData['blocks'] = textBlocks.map((text) => ({
+    type: 'paragraph',
+    data: { text },
+  }));
+
+  await createEditorWithBlocks(page, blocks);
+};
+
+const createEditorWithDelimiter = async (page: Page): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId }) => {
+    /**
+     *
+     */
+    class ContentlessToolMock {
+      /**
+       *
+       */
+      public static get contentless(): boolean {
+        return true;
+      }
+
+      /**
+       *
+       */
+      public render(): HTMLElement {
+        const wrapper = document.createElement('div');
+
+        wrapper.dataset.cyType = 'contentless-tool';
+        wrapper.textContent = '***';
+
+        return wrapper;
+      }
+
+      /**
+       *
+       */
+      public save(): Record<string, never> {
+        return {};
+      }
+    }
+
+    const editor = new window.EditorJS({
+      holder: holderId,
+      tools: {
+        delimiter: ContentlessToolMock,
+      },
+      data: {
+        blocks: [
+          {
+            id: 'block1',
+            type: 'paragraph',
+            data: {
+              text: '1',
+            },
+          },
+          {
+            id: 'block2',
+            type: 'delimiter',
+            data: {},
+          },
+          {
+            id: 'block3',
+            type: 'paragraph',
+            data: {
+              text: '2',
+            },
+          },
+        ],
+      },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID });
+};
+
+const getCaretInfo = (locator: Locator, options: { normalize?: boolean } = {}): Promise<{ inside: boolean; offset: number; textLength: number } | null> => {
+  return locator.evaluate((element, { normalize }) => {
+    const selection = element.ownerDocument.getSelection();
+
+    if (!selection || selection.rangeCount === 0) {
+      return null;
+    }
+
+    const range = selection.getRangeAt(0);
+
+    if (normalize) {
+      range.startContainer.normalize();
+    }
+
+    return {
+      inside: element.contains(range.startContainer),
+      offset: range.startOffset,
+      textLength: element.textContent?.length ?? 0,
+    };
+  }, { normalize: options.normalize ?? false });
+};
+
+const ensureCaretInfo = async (locator: Locator, options?: { normalize?: boolean }): Promise<{ inside: boolean; offset: number; textLength: number }> => {
+  const caretInfo = await getCaretInfo(locator, options);
+
+  if (!caretInfo) {
+    throw new Error('Caret information is not available.');
+  }
+
+  return caretInfo;
+};
+
+const getDelimiterBlock = (page: Page): Locator => {
+  return page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-block:has([data-cy-type="contentless-tool"])`);
+};
+
+test.describe('arrowLeft keydown', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test.describe('starting whitespaces handling', () => {
+    test('should move caret over visible non-breaking space before navigating to previous block', async ({ page }) => {
+      await createParagraphEditor(page, ['1', '&nbsp;2']);
+
+      const lastParagraph = getParagraphByIndex(page, 1);
+
+      await lastParagraph.click();
+      await page.keyboard.press('ArrowLeft');
+      await page.keyboard.press('ArrowLeft');
+      await page.keyboard.press('ArrowLeft');
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      const caretInfo = await ensureCaretInfo(firstParagraph);
+
+      expect(caretInfo.inside).toBe(true);
+      expect(caretInfo.offset).toBe(1);
+    });
+
+    test('should ignore invisible spaces before caret when moving to previous block', async ({ page }) => {
+      await createParagraphEditor(page, ['1', ' 2']);
+
+      const lastParagraph = getParagraphByIndex(page, 1);
+
+      await lastParagraph.click();
+      await page.keyboard.press('ArrowLeft');
+      await page.keyboard.press('ArrowLeft');
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      const caretInfo = await ensureCaretInfo(firstParagraph);
+
+      expect(caretInfo.inside).toBe(true);
+      expect(caretInfo.offset).toBe(1);
+    });
+
+    test('should ignore empty tags before caret when moving to previous block', async ({ page }) => {
+      await createParagraphEditor(page, ['1', '<b></b>2']);
+
+      const lastParagraph = getParagraphByIndex(page, 1);
+
+      await lastParagraph.click();
+      await page.keyboard.press('ArrowLeft');
+      await page.keyboard.press('ArrowLeft');
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      const caretInfo = await ensureCaretInfo(firstParagraph);
+
+      expect(caretInfo.inside).toBe(true);
+      expect(caretInfo.offset).toBe(1);
+    });
+
+    test('should move caret over non-breaking space that follows empty tag before navigating to previous block', async ({ page }) => {
+      await createParagraphEditor(page, ['1', '<b></b>&nbsp;2']);
+
+      const lastParagraph = getParagraphByIndex(page, 1);
+
+      await lastParagraph.click();
+      await page.keyboard.press('ArrowLeft');
+      await page.keyboard.press('ArrowLeft');
+      await page.keyboard.press('ArrowLeft');
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      const caretInfo = await ensureCaretInfo(firstParagraph);
+
+      expect(caretInfo.inside).toBe(true);
+      expect(caretInfo.offset).toBe(1);
+    });
+
+    test('should handle non-breaking space placed before empty tag when moving to previous block', async ({ page }) => {
+      await createParagraphEditor(page, ['1', '<b></b>&nbsp;2']);
+
+      const lastParagraph = getParagraphByIndex(page, 1);
+
+      await lastParagraph.click();
+      await page.keyboard.press('ArrowLeft');
+      await page.keyboard.press('ArrowLeft');
+      await page.keyboard.press('ArrowLeft');
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      const caretInfo = await ensureCaretInfo(firstParagraph);
+
+      expect(caretInfo.inside).toBe(true);
+      expect(caretInfo.offset).toBe(1);
+    });
+
+    test('should move caret over non-breaking and regular spaces before navigating to previous block', async ({ page }) => {
+      await createParagraphEditor(page, ['1', ' &nbsp;2']);
+
+      const lastParagraph = getParagraphByIndex(page, 1);
+
+      await lastParagraph.click();
+      await page.keyboard.press('ArrowLeft');
+      await page.keyboard.press('ArrowLeft');
+      await page.keyboard.press('ArrowLeft');
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      const caretInfo = await ensureCaretInfo(firstParagraph);
+
+      expect(caretInfo.inside).toBe(true);
+      expect(caretInfo.offset).toBe(1);
+    });
+  });
+
+  test('should move caret to previous block when focused block is contentless', async ({ page }) => {
+    await createEditorWithDelimiter(page);
+
+    const secondParagraph = getParagraphByIndex(page, 1);
+
+    await secondParagraph.click();
+    await page.keyboard.press('Home');
+    await page.keyboard.press('ArrowLeft');
+
+    const delimiterBlock = getDelimiterBlock(page);
+
+    await expect(delimiterBlock).toHaveClass(/ce-block--selected/);
+
+    await page.keyboard.press('ArrowLeft');
+
+    await expect(delimiterBlock).not.toHaveClass(/ce-block--selected/);
+
+    const firstParagraph = getParagraphByIndex(page, 0);
+
+    const caretInfo = await ensureCaretInfo(firstParagraph);
+
+    expect(caretInfo.inside).toBe(true);
+    expect(caretInfo.offset).toBe(1);
+  });
+});
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+    EditorJS: new (...args: unknown[]) => EditorJS;
+  }
+}
+
+
diff --git a/test/playwright/tests/modules/BlockEvents/ArrowRight.spec.ts b/test/playwright/tests/modules/BlockEvents/ArrowRight.spec.ts
new file mode 100644
index 000000000..256521da8
--- /dev/null
+++ b/test/playwright/tests/modules/BlockEvents/ArrowRight.spec.ts
@@ -0,0 +1,332 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type EditorJS from '../../../../../types';
+import type { OutputData } from '../../../../../types';
+import { ensureEditorBundleBuilt } from '../../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../../fixtures/test.html')
+).href;
+const HOLDER_ID = 'editorjs';
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} div.ce-block`;
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-block-tool="paragraph"]`;
+const CONTENTLESS_TOOL_SELECTOR = '[data-cy-type="contentless-tool"]';
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditorWithBlocks = async (page: Page, blocks: OutputData['blocks']): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, blocks: editorBlocks }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+      data: { blocks: editorBlocks },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID,
+    blocks });
+};
+
+const createParagraphEditor = async (page: Page, textBlocks: string[]): Promise<void> => {
+  const blocks: OutputData['blocks'] = textBlocks.map((text) => ({
+    type: 'paragraph',
+    data: { text },
+  }));
+
+  await createEditorWithBlocks(page, blocks);
+};
+
+const createEditorWithContentlessBlock = async (page: Page): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId }) => {
+    /**
+     *
+     */
+    class ContentlessToolMock {
+      /**
+       *
+       */
+      public static get contentless(): boolean {
+        return true;
+      }
+
+      /**
+       *
+       */
+      public render(): HTMLElement {
+        const wrapper = document.createElement('div');
+
+        wrapper.dataset.cy = 'contentless-tool';
+        wrapper.dataset.cyType = 'contentless-tool';
+        wrapper.textContent = '***';
+
+        return wrapper;
+      }
+
+      /**
+       *
+       */
+      public save(): Record<string, never> {
+        return {};
+      }
+    }
+
+    const editor = new window.EditorJS({
+      holder: holderId,
+      tools: {
+        delimiter: ContentlessToolMock,
+      },
+      data: {
+        blocks: [
+          {
+            id: 'block1',
+            type: 'paragraph',
+            data: {
+              text: '1',
+            },
+          },
+          {
+            id: 'block2',
+            type: 'delimiter',
+            data: {},
+          },
+          {
+            id: 'block3',
+            type: 'paragraph',
+            data: {
+              text: '2',
+            },
+          },
+        ],
+      },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID });
+};
+
+const getParagraphByIndex = (page: Page, index: number): Locator => {
+  return page.locator(`:nth-match(${PARAGRAPH_SELECTOR}, ${index + 1})`);
+};
+
+const getCaretInfo = (locator: Locator, options: { normalize?: boolean } = {}): Promise<{ inside: boolean; offset: number; textLength: number } | null> => {
+  return locator.evaluate((element, { normalize }) => {
+    const selection = element.ownerDocument.getSelection();
+
+    if (!selection || selection.rangeCount === 0) {
+      return null;
+    }
+
+    const range = selection.getRangeAt(0);
+
+    if (normalize) {
+      range.startContainer.normalize();
+    }
+
+    return {
+      inside: element.contains(range.startContainer),
+      offset: range.startOffset,
+      textLength: element.textContent?.length ?? 0,
+    };
+  }, { normalize: options.normalize ?? false });
+};
+
+const getCaretInfoOrThrow = async (
+  locator: Locator,
+  options: { normalize?: boolean } = {}
+): Promise<{ inside: boolean; offset: number; textLength: number }> => {
+  const caretInfo = await getCaretInfo(locator, options);
+
+  if (caretInfo === null) {
+    throw new Error('Failed to retrieve caret information.');
+  }
+
+  return caretInfo;
+};
+
+test.describe('arrow right keydown', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test.describe('starting whitespaces handling', () => {
+    test('should move caret over visible non-breaking space then to next block', async ({ page }) => {
+      await createParagraphEditor(page, ['1&nbsp;', '2']);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+      const secondParagraph = getParagraphByIndex(page, 1);
+
+      await firstParagraph.click();
+      await firstParagraph.press('Home');
+      await page.keyboard.press('ArrowRight');
+      await page.keyboard.press('ArrowRight');
+      await page.keyboard.press('ArrowRight');
+
+      const caretInfo = await getCaretInfoOrThrow(secondParagraph);
+
+      expect(caretInfo).toMatchObject({
+        inside: true,
+        offset: 0,
+      });
+    });
+
+    test('should ignore invisible space after caret and move to next block', async ({ page }) => {
+      await createParagraphEditor(page, ['1 ', '2']);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+      const secondParagraph = getParagraphByIndex(page, 1);
+
+      await firstParagraph.click();
+      await firstParagraph.press('Home');
+      await page.keyboard.press('ArrowRight');
+      await page.keyboard.press('ArrowRight');
+
+      const caretInfo = await getCaretInfoOrThrow(secondParagraph);
+
+      expect(caretInfo).toMatchObject({
+        inside: true,
+        offset: 0,
+      });
+    });
+
+    test('should ignore empty tags after caret and move to next block', async ({ page }) => {
+      await createParagraphEditor(page, ['1<b></b>', '2']);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+      const secondParagraph = getParagraphByIndex(page, 1);
+
+      await firstParagraph.click();
+      await firstParagraph.press('Home');
+      await page.keyboard.press('ArrowRight');
+      await page.keyboard.press('ArrowRight');
+
+      const caretInfo = await getCaretInfoOrThrow(secondParagraph);
+
+      expect(caretInfo).toMatchObject({
+        inside: true,
+        offset: 0,
+      });
+    });
+
+    test('should move caret over visible space and then to next block when empty tag follows', async ({ page }) => {
+      await createParagraphEditor(page, ['1&nbsp;<b></b>', '2']);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+      const secondParagraph = getParagraphByIndex(page, 1);
+
+      await firstParagraph.click();
+      await firstParagraph.press('Home');
+      await page.keyboard.press('ArrowRight');
+      await page.keyboard.press('ArrowRight');
+      await page.keyboard.press('ArrowRight');
+
+      const caretInfo = await getCaretInfoOrThrow(secondParagraph);
+
+      expect(caretInfo).toMatchObject({
+        inside: true,
+        offset: 0,
+      });
+    });
+
+    test('should ignore empty tag and move caret over visible space before moving to next block', async ({ page }) => {
+      await createParagraphEditor(page, ['1<b></b>&nbsp;', '2']);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+      const secondParagraph = getParagraphByIndex(page, 1);
+
+      await firstParagraph.click();
+      await firstParagraph.press('Home');
+      await page.keyboard.press('ArrowRight');
+      await page.keyboard.press('ArrowRight');
+      await page.keyboard.press('ArrowRight');
+
+      const caretInfo = await getCaretInfoOrThrow(secondParagraph);
+
+      expect(caretInfo).toMatchObject({
+        inside: true,
+        offset: 0,
+      });
+    });
+
+    test('should move caret over visible space and ignore trailing space before moving to next block', async ({ page }) => {
+      await createParagraphEditor(page, ['1&nbsp; ', '2']);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+      const secondParagraph = getParagraphByIndex(page, 1);
+
+      await firstParagraph.click();
+      await firstParagraph.press('Home');
+      await page.keyboard.press('ArrowRight');
+      await page.keyboard.press('ArrowRight');
+      await page.keyboard.press('ArrowRight');
+
+      const caretInfo = await getCaretInfoOrThrow(secondParagraph);
+
+      expect(caretInfo).toMatchObject({
+        inside: true,
+        offset: 0,
+      });
+    });
+  });
+
+  test('should move caret to next block if currently focused block is contentless', async ({ page }) => {
+    await createEditorWithContentlessBlock(page);
+
+    const firstParagraph = getParagraphByIndex(page, 0);
+    const contentlessBlock = page.locator(BLOCK_SELECTOR, {
+      has: page.locator(CONTENTLESS_TOOL_SELECTOR),
+    });
+    const lastParagraph = getParagraphByIndex(page, 1);
+
+    await firstParagraph.click();
+    await firstParagraph.press('End');
+    await page.keyboard.press('ArrowRight');
+
+    await expect(contentlessBlock).toHaveClass(/ce-block--selected/);
+
+    await page.keyboard.press('ArrowRight');
+
+    await expect(contentlessBlock).not.toHaveClass(/ce-block--selected/);
+    const caretInfo = await getCaretInfoOrThrow(lastParagraph);
+
+    expect(caretInfo).toMatchObject({
+      inside: true,
+      offset: 0,
+    });
+  });
+});
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+    EditorJS: new (...args: unknown[]) => EditorJS;
+  }
+}
+
diff --git a/test/playwright/tests/modules/BlockEvents/Backspace.spec.ts b/test/playwright/tests/modules/BlockEvents/Backspace.spec.ts
new file mode 100644
index 000000000..33401f6c9
--- /dev/null
+++ b/test/playwright/tests/modules/BlockEvents/Backspace.spec.ts
@@ -0,0 +1,787 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type EditorJS from '../../../../../types';
+import type { OutputData } from '../../../../../types';
+import { ensureEditorBundleBuilt } from '../../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../../fixtures/test.html')
+).href;
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} div.ce-block`;
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-block-tool="paragraph"]`;
+const TOOLBAR_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar`;
+const HOLDER_ID = 'editorjs';
+
+const getPositionalLocator = async (page: Page, selector: string, position: 'first' | 'last'): Promise<Locator> => {
+  const locators = await page.locator(selector).all();
+
+  if (locators.length === 0) {
+    throw new Error(`No elements found for selector: ${selector}`);
+  }
+
+  return position === 'first' ? locators[0] : locators[locators.length - 1];
+};
+
+const getParagraphLocator = async (page: Page, position: 'first' | 'last'): Promise<Locator> => {
+  return getPositionalLocator(page, PARAGRAPH_SELECTOR, position);
+};
+
+const getBlockLocator = async (page: Page, position: 'first' | 'last'): Promise<Locator> => {
+  return getPositionalLocator(page, BLOCK_SELECTOR, position);
+};
+
+const getQuoteInputLocator = async (page: Page, position: 'first' | 'last'): Promise<Locator> => {
+  const quoteInputSelector = `${EDITOR_INTERFACE_SELECTOR} [data-cy=quote-tool] div[contenteditable]`;
+
+  return getPositionalLocator(page, quoteInputSelector, position);
+};
+
+const getBlockWrapperLocator = async (page: Page, position: 'first' | 'last'): Promise<Locator> => {
+  const blockWrapperSelector = `${EDITOR_INTERFACE_SELECTOR} [data-cy=block-wrapper]`;
+
+  return getPositionalLocator(page, blockWrapperSelector, position);
+};
+
+/**
+ * Resets the editor instance by destroying any existing instance and clearing the holder.
+ *
+ * @param page - The Playwright Page object to interact with the browser.
+ */
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ *
+ * @param page - Playwright Page instance
+ * @param blocks - Array of block data to initialize the editor with
+ */
+const createEditorWithBlocks = async (page: Page, blocks: OutputData['blocks']): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, blocks: editorBlocks }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+      data: { blocks: editorBlocks },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID,
+    blocks });
+};
+
+/**
+ *
+ * @param page - The Playwright page object
+ * @param textBlocks - Array of text strings to create paragraph blocks from
+ */
+const createParagraphEditor = async (page: Page, textBlocks: string[]): Promise<void> => {
+  const blocks: OutputData['blocks'] = textBlocks.map((text) => ({
+    type: 'paragraph',
+    data: { text },
+  }));
+
+  await createEditorWithBlocks(page, blocks);
+};
+
+
+/**
+ *
+ * @param page - Playwright Page instance
+ * @param blocks - Array of block data to initialize the editor with
+ */
+const createEditorWithSimpleHeader = async (page: Page, blocks: OutputData['blocks']): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, blocks: editorBlocks }) => {
+    /**
+     *
+     */
+    class SimpleHeader {
+      private data: { text: string };
+      private element: HTMLHeadingElement | null = null;
+
+      /**
+       *
+       * @param root0 - Constructor parameter object
+       * @param root0.data - Initial data for the header
+       */
+      constructor({ data }: { data: { text: string } }) {
+        this.data = data;
+      }
+
+      /**
+       *
+       */
+      public render(): HTMLHeadingElement {
+        this.element = document.createElement('h1');
+        this.element.contentEditable = 'true';
+        this.element.innerHTML = this.data.text;
+
+        return this.element;
+      }
+
+      /**
+       *
+       * @param data - Data object containing text to merge
+       */
+      public merge(data: { text: string }): void {
+        this.element?.insertAdjacentHTML('beforeend', data.text);
+      }
+
+      /**
+       *
+       * @param element - The HTML heading element to save
+       */
+      public save(element: HTMLHeadingElement): { text: string; level: number } {
+        return {
+          text: element.innerHTML,
+          level: 1,
+        };
+      }
+
+      /**
+       *
+       */
+      public static get conversionConfig(): { export: string; import: string } {
+        return {
+          export: 'text',
+          import: 'text',
+        };
+      }
+    }
+
+    const editor = new window.EditorJS({
+      holder: holderId,
+      tools: {
+        header: SimpleHeader,
+      },
+      data: { blocks: editorBlocks },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID,
+    blocks });
+};
+
+/**
+ *
+ * @param page - Playwright Page instance
+ */
+const createMultiInputToolEditor = async (page: Page): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId }) => {
+    /**
+     *
+     */
+    class ExampleOfToolWithSeveralInputs {
+      /**
+       *
+       */
+      public render(): HTMLElement {
+        const container = document.createElement('div');
+        const input = document.createElement('div');
+        const input2 = document.createElement('div');
+
+        container.dataset.cy = 'quote-tool';
+
+        input.contentEditable = 'true';
+        input2.contentEditable = 'true';
+
+        container.append(input, input2);
+
+        return container;
+      }
+
+      /**
+       *
+       */
+      public save(): Record<string, never> {
+        return {};
+      }
+    }
+
+    const editor = new window.EditorJS({
+      holder: holderId,
+      tools: {
+        quote: ExampleOfToolWithSeveralInputs,
+      },
+      data: {
+        blocks: [
+          {
+            type: 'quote',
+            data: {},
+          },
+        ],
+      },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ *
+ * @param page - Playwright Page instance
+ * @param options - Configuration options
+ * @param options.hasConversionConfig - Whether the tool has a conversion config
+ */
+const createUnmergeableToolEditor = async (page: Page, options: { hasConversionConfig: boolean }): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, hasConversionConfig }) => {
+    /**
+     *
+     */
+    class UnmergeableTool {
+      /**
+       *
+       */
+      public render(): HTMLElement {
+        const container = document.createElement('div');
+
+        container.dataset.cy = 'unmergeable-tool';
+        container.contentEditable = 'true';
+        container.innerHTML = 'Unmergeable not empty tool';
+
+        return container;
+      }
+
+      /**
+       *
+       */
+      public save(): Record<string, string> {
+        return hasConversionConfig ? { key: 'value' } : {};
+      }
+
+      /**
+       *
+       */
+      public static get conversionConfig(): { export: string; import: string } | undefined {
+        if (!hasConversionConfig) {
+          return undefined;
+        }
+
+        return {
+          export: 'key',
+          import: 'key',
+        };
+      }
+    }
+
+    const editor = new window.EditorJS({
+      holder: holderId,
+      tools: {
+        code: UnmergeableTool,
+      },
+      data: {
+        blocks: [
+          {
+            type: 'code',
+            data: {},
+          },
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Second block',
+            },
+          },
+        ],
+      },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID,
+    hasConversionConfig: options.hasConversionConfig });
+};
+
+/**
+ *
+ * @param page - Playwright Page instance
+ */
+const saveEditor = async (page: Page): Promise<OutputData> => {
+  return page.evaluate(async () => {
+    if (!window.editorInstance) {
+      throw new Error('Editor instance is not initialized');
+    }
+
+    return window.editorInstance.save();
+  });
+};
+
+/**
+ *
+ * @param locator - Playwright Locator for the element
+ * @param text - Text to select within the element
+ */
+const selectText = async (locator: Locator, text: string): Promise<void> => {
+  await locator.evaluate((element, targetText) => {
+    const textNode = element.firstChild;
+
+    if (!textNode || textNode.nodeType !== Node.TEXT_NODE) {
+      throw new Error('Element does not contain a text node');
+    }
+
+    const content = textNode.textContent ?? '';
+    const start = content.indexOf(targetText);
+
+    if (start === -1) {
+      throw new Error(`Text "${targetText}" was not found`);
+    }
+
+    const range = element.ownerDocument.createRange();
+
+    range.setStart(textNode, start);
+    range.setEnd(textNode, start + targetText.length);
+
+    const selection = element.ownerDocument.getSelection();
+
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+  }, text);
+};
+
+/**
+ *
+ * @param locator - Playwright Locator for the element
+ * @param options - Options for caret info retrieval
+ * @param options.normalize - Whether to normalize the range before getting caret info
+ */
+const getCaretInfo = (locator: Locator, options: { normalize?: boolean } = {}): Promise<{ inside: boolean; offset: number; textLength: number } | null> => {
+  return locator.evaluate((element, { normalize }) => {
+    const selection = element.ownerDocument.getSelection();
+
+    if (!selection || selection.rangeCount === 0) {
+      return null;
+    }
+
+    const range = selection.getRangeAt(0);
+
+    if (normalize) {
+      range.startContainer.normalize();
+    }
+
+    return {
+      inside: element.contains(range.startContainer),
+      offset: range.startOffset,
+      textLength: element.textContent?.length ?? 0,
+    };
+  }, { normalize: options.normalize ?? false });
+};
+
+/**
+ *
+ * @param locator - Playwright Locator for the element
+ */
+const expectCaretAtEnd = async (locator: Locator): Promise<void> => {
+  const caretInfo = await getCaretInfo(locator);
+
+  expect(caretInfo?.inside).toBeTruthy();
+  expect(caretInfo?.offset).toBe(caretInfo?.textLength);
+};
+
+/**
+ *
+ * @param locator - Playwright Locator for the element
+ * @param expectedOffset - Expected caret offset position
+ * @param options - Options for caret offset check
+ * @param options.normalize - Whether to normalize the range before checking offset
+ */
+const expectCaretOffset = async (locator: Locator, expectedOffset: number, options?: { normalize?: boolean }): Promise<void> => {
+  const caretInfo = await getCaretInfo(locator, options);
+
+  expect(caretInfo?.inside).toBeTruthy();
+  expect(caretInfo?.offset).toBe(expectedOffset);
+};
+
+/**
+ *
+ * @param page - Playwright Page instance
+ */
+const expectToolbarClosed = async (page: Page): Promise<void> => {
+  const toolbar = page.locator(TOOLBAR_SELECTOR);
+
+  await expect(toolbar).not.toHaveClass(/ce-toolbar--opened/);
+};
+
+test.describe('backspace keydown', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test.describe('starting whitespaces handling', () => {
+    test('should delete non-breaking space at block start', async ({ page }) => {
+      await createParagraphEditor(page, ['1', '&nbsp;2']);
+
+      const lastParagraph = await getParagraphLocator(page, 'last');
+
+      await lastParagraph.click();
+      await lastParagraph.press('ArrowLeft');
+      await lastParagraph.press('Backspace');
+
+      const lastBlock = await getBlockLocator(page, 'last');
+
+      await expect(lastBlock).toHaveText('2');
+    });
+
+    test('should merge blocks when invisible space precedes caret at block start', async ({ page }) => {
+      await createParagraphEditor(page, ['1', ' 2']);
+
+      const lastParagraph = await getParagraphLocator(page, 'last');
+
+      await lastParagraph.click();
+      await lastParagraph.press('ArrowLeft');
+      await lastParagraph.press('Backspace');
+
+      const lastBlock = await getBlockLocator(page, 'last');
+
+      await expect(lastBlock).toHaveText('12');
+    });
+
+    test('should merge blocks when empty tags precede caret at block start', async ({ page }) => {
+      await createParagraphEditor(page, ['1', '<b></b>2']);
+
+      const lastParagraph = await getParagraphLocator(page, 'last');
+
+      await lastParagraph.click();
+      await lastParagraph.press('ArrowLeft');
+      await lastParagraph.press('Backspace');
+
+      const lastBlock = await getBlockLocator(page, 'last');
+
+      await expect(lastBlock).toHaveText('12');
+    });
+
+    test('should remove non-breaking space and ignore empty tags at block start', async ({ page }) => {
+      await createParagraphEditor(page, ['1', '<b></b>&nbsp;2']);
+
+      const lastParagraph = await getParagraphLocator(page, 'last');
+
+      await lastParagraph.click();
+      await lastParagraph.press('ArrowLeft');
+      await lastParagraph.press('Backspace');
+      await lastParagraph.press('Backspace');
+
+      const lastBlock = await getBlockLocator(page, 'last');
+
+      await expect(lastBlock).toHaveText('12');
+    });
+
+    test('should remove non-breaking space before empty tags at block start', async ({ page }) => {
+      await createParagraphEditor(page, ['1', '<b></b>&nbsp;2']);
+
+      const lastParagraph = await getParagraphLocator(page, 'last');
+
+      await lastParagraph.click();
+      await lastParagraph.press('ArrowLeft');
+      await lastParagraph.press('Backspace');
+      await lastParagraph.press('Backspace');
+
+      const lastBlock = await getBlockLocator(page, 'last');
+
+      await expect(lastBlock).toHaveText('12');
+    });
+
+    test('should remove non-breaking space and regular space at block start', async ({ page }) => {
+      await createParagraphEditor(page, ['1', ' &nbsp;2']);
+
+      const lastParagraph = await getParagraphLocator(page, 'last');
+
+      await lastParagraph.click();
+      await lastParagraph.press('ArrowLeft');
+      await lastParagraph.press('Backspace');
+      await lastParagraph.press('Backspace');
+
+      const lastBlock = await getBlockLocator(page, 'last');
+
+      await expect(lastBlock).toHaveText('12');
+    });
+
+    test('should delete all whitespaces when block contains only whitespace characters', async ({ page }) => {
+      await createParagraphEditor(page, ['1', '&nbsp; &nbsp;']);
+
+      const lastParagraph = await getParagraphLocator(page, 'last');
+
+      await lastParagraph.click();
+      await lastParagraph.press('ArrowDown');
+      for (const _ of Array(4)) {
+        await page.keyboard.press('Backspace');
+      }
+
+      const lastBlock = await getBlockLocator(page, 'last');
+
+      await expect(lastBlock).toHaveText('1');
+    });
+  });
+
+  test('should delete selected text using native behavior', async ({ page }) => {
+    await createParagraphEditor(page, ['The first block', 'The second block']);
+
+    const lastParagraph = await getParagraphLocator(page, 'last');
+
+    await lastParagraph.click();
+    await selectText(lastParagraph, 'The ');
+    await page.keyboard.press('Backspace');
+
+    const lastBlock = await getBlockLocator(page, 'last');
+
+    await expect(lastBlock).toHaveText('second block');
+  });
+
+  test('should delete character using native behavior when caret is not at block start', async ({ page }) => {
+    await createParagraphEditor(page, ['The first block', 'The second block']);
+
+    const lastParagraph = await getParagraphLocator(page, 'last');
+
+    await lastParagraph.click();
+    await lastParagraph.press('Backspace');
+
+    const lastBlock = await getBlockLocator(page, 'last');
+
+    await expect(lastBlock).toHaveText('The second bloc');
+  });
+
+  test('should navigate to previous input when caret is not at first input', async ({ page }) => {
+    await createMultiInputToolEditor(page);
+
+    const lastInput = await getQuoteInputLocator(page, 'last');
+    const firstInput = await getQuoteInputLocator(page, 'first');
+
+    await lastInput.click();
+    await lastInput.press('Backspace');
+
+    const caretInfo = await getCaretInfo(firstInput);
+
+    expect(caretInfo?.inside).toBeTruthy();
+  });
+
+  test('should remove previous empty block and close toolbar when caret is at block start', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        id: 'block1',
+        type: 'paragraph',
+        data: { text: '' },
+      },
+      {
+        id: 'block2',
+        type: 'paragraph',
+        data: { text: 'Not empty block' },
+      },
+    ]);
+
+    const lastParagraph = await getParagraphLocator(page, 'last');
+
+    await lastParagraph.click();
+    await lastParagraph.press('Home');
+    await lastParagraph.press('Backspace');
+
+    const { blocks } = await saveEditor(page);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].id).toBe('block2');
+  });
+
+  test('should remove current empty block and place caret at end of previous block', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        id: 'block1',
+        type: 'paragraph',
+        data: { text: 'Not empty block' },
+      },
+      {
+        id: 'block2',
+        type: 'paragraph',
+        data: { text: '' },
+      },
+    ]);
+
+    const lastParagraph = await getParagraphLocator(page, 'last');
+
+    await lastParagraph.click();
+    await lastParagraph.press('Backspace');
+
+    const { blocks } = await saveEditor(page);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].id).toBe('block1');
+
+    const firstParagraph = await getParagraphLocator(page, 'first');
+
+    await expectCaretAtEnd(firstParagraph);
+    await expectToolbarClosed(page);
+  });
+
+  test('should merge mergeable blocks and place caret at merge point when caret is at block start', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        id: 'block1',
+        type: 'paragraph',
+        data: { text: 'First block' },
+      },
+      {
+        id: 'block2',
+        type: 'paragraph',
+        data: { text: 'Second block' },
+      },
+    ]);
+
+    const lastParagraph = await getParagraphLocator(page, 'last');
+
+    await lastParagraph.click();
+    await lastParagraph.press('Home');
+    await lastParagraph.press('Backspace');
+
+    const { blocks } = await saveEditor(page);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].id).toBe('block1');
+    expect((blocks[0].data as { text: string }).text).toBe('First blockSecond block');
+
+    const firstParagraph = await getParagraphLocator(page, 'first');
+
+    await expectCaretOffset(firstParagraph, 'First block'.length, { normalize: true });
+    await expectToolbarClosed(page);
+  });
+
+  test('should merge paragraph into header when conversion config is valid', async ({ page }) => {
+    await createEditorWithSimpleHeader(page, [
+      {
+        id: 'block1',
+        type: 'header',
+        data: { text: 'First block heading' },
+      },
+      {
+        id: 'block2',
+        type: 'paragraph',
+        data: { text: 'Second block paragraph' },
+      },
+    ]);
+
+    const lastParagraph = await getParagraphLocator(page, 'last');
+
+    await lastParagraph.click();
+    await lastParagraph.press('Home');
+    await lastParagraph.press('Backspace');
+
+    const { blocks } = await saveEditor(page);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].id).toBe('block1');
+    expect((blocks[0].data as { text: string }).text).toBe('First block headingSecond block paragraph');
+
+    const firstBlockWrapper = await getBlockWrapperLocator(page, 'first');
+
+    await expectCaretOffset(firstBlockWrapper, 'First block heading'.length, { normalize: true });
+    await expectToolbarClosed(page);
+  });
+
+  test('should merge header into paragraph when conversion config is valid', async ({ page }) => {
+    await createEditorWithSimpleHeader(page, [
+      {
+        id: 'block1',
+        type: 'paragraph',
+        data: { text: 'First block paragraph' },
+      },
+      {
+        id: 'block2',
+        type: 'header',
+        data: { text: 'Second block heading' },
+      },
+    ]);
+
+    const targetBlock = page.locator(`${EDITOR_INTERFACE_SELECTOR} [data-cy="block-wrapper"][data-id="block2"]`);
+
+    await targetBlock.click();
+    await targetBlock.press('Home');
+    await targetBlock.press('Backspace');
+
+    const { blocks } = await saveEditor(page);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].id).toBe('block1');
+    expect((blocks[0].data as { text: string }).text).toBe('First block paragraphSecond block heading');
+
+    const firstBlockWrapper = await getBlockWrapperLocator(page, 'first');
+
+    await expectCaretOffset(firstBlockWrapper, 'First block paragraph'.length, { normalize: true });
+    await expectToolbarClosed(page);
+  });
+
+  test('should move caret to end of previous block when blocks are not mergeable without merge method', async ({ page }) => {
+    await createUnmergeableToolEditor(page, { hasConversionConfig: false });
+
+    const lastParagraph = await getParagraphLocator(page, 'last');
+
+    await lastParagraph.click();
+    await lastParagraph.press('Home');
+    await lastParagraph.press('Backspace');
+
+    const { blocks } = await saveEditor(page);
+
+    expect(blocks).toHaveLength(2);
+    await expectCaretAtEnd(page.locator(`${EDITOR_INTERFACE_SELECTOR} [data-cy=unmergeable-tool]`));
+    await expectToolbarClosed(page);
+  });
+
+  test('should move caret to end of previous block when blocks are not mergeable despite conversion config', async ({ page }) => {
+    await createUnmergeableToolEditor(page, { hasConversionConfig: true });
+
+    const lastParagraph = await getParagraphLocator(page, 'last');
+
+    await lastParagraph.click();
+    await lastParagraph.press('Home');
+    await lastParagraph.press('Backspace');
+
+    const { blocks } = await saveEditor(page);
+
+    expect(blocks).toHaveLength(2);
+    await expectCaretAtEnd(page.locator(`${EDITOR_INTERFACE_SELECTOR} [data-cy=unmergeable-tool]`));
+    await expectToolbarClosed(page);
+  });
+
+  test.describe('at the start of the first block', () => {
+    test('should do nothing when block is not empty', async ({ page }) => {
+      await createParagraphEditor(page, [ 'The only block. Not empty' ]);
+
+      const onlyParagraph = await getParagraphLocator(page, 'first');
+
+      await onlyParagraph.click();
+      await onlyParagraph.press('Home');
+      await onlyParagraph.press('Backspace');
+
+      await expect(page.locator(PARAGRAPH_SELECTOR)).toHaveCount(1);
+      await expect(onlyParagraph).toHaveText('The only block. Not empty');
+    });
+  });
+});
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+    EditorJS: new (...args: unknown[]) => EditorJS;
+  }
+}
diff --git a/test/playwright/tests/modules/BlockEvents/Delete.spec.ts b/test/playwright/tests/modules/BlockEvents/Delete.spec.ts
new file mode 100644
index 000000000..3fb6964db
--- /dev/null
+++ b/test/playwright/tests/modules/BlockEvents/Delete.spec.ts
@@ -0,0 +1,558 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type EditorJS from '../../../../../types';
+import type { OutputData } from '../../../../../types';
+import { ensureEditorBundleBuilt } from '../../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../../fixtures/test.html')
+).href;
+const HOLDER_ID = 'editorjs';
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} div.ce-block`;
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-block-tool="paragraph"]`;
+const TOOLBAR_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar`;
+const QUOTE_TOOL_INPUT_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-cy="quote-tool"] div[contenteditable]`;
+
+const getBlockByIndex = (page: Page, index: number): Locator => {
+  return page.locator(`:nth-match(${BLOCK_SELECTOR}, ${index + 1})`);
+};
+
+const getLastBlock = async (page: Page): Promise<Locator> => {
+  const blockCount = await page.locator(BLOCK_SELECTOR).count();
+
+  if (blockCount === 0) {
+    throw new Error('No blocks found for selector: div.ce-block');
+  }
+
+  return page.locator(`:nth-match(${BLOCK_SELECTOR}, ${blockCount})`);
+};
+
+const getParagraphByIndex = (page: Page, index: number): Locator => {
+  return page.locator(`:nth-match(${PARAGRAPH_SELECTOR}, ${index + 1})`);
+};
+
+const getQuoteToolInputByIndex = (page: Page, index: number): Locator => {
+  return page.locator(`:nth-match(${QUOTE_TOOL_INPUT_SELECTOR}, ${index + 1})`);
+};
+
+const getLastQuoteToolInput = async (page: Page): Promise<Locator> => {
+  const inputCount = await page.locator(QUOTE_TOOL_INPUT_SELECTOR).count();
+
+  if (inputCount === 0) {
+    throw new Error('No quote tool inputs found');
+  }
+
+  return page.locator(`:nth-match(${QUOTE_TOOL_INPUT_SELECTOR}, ${inputCount})`);
+};
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditorWithBlocks = async (page: Page, blocks: OutputData['blocks']): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, blocks: editorBlocks }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+      data: { blocks: editorBlocks },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID,
+    blocks });
+};
+
+const createParagraphEditor = async (page: Page, textBlocks: string[]): Promise<void> => {
+  const blocks: OutputData['blocks'] = textBlocks.map((text) => ({
+    type: 'paragraph',
+    data: { text },
+  }));
+
+  await createEditorWithBlocks(page, blocks);
+};
+
+const createMultiInputToolEditor = async (page: Page): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId }) => {
+    /**
+     *
+     */
+    class ExampleOfToolWithSeveralInputs {
+      /**
+       *
+       */
+      public render(): HTMLElement {
+        const container = document.createElement('div');
+        const input = document.createElement('div');
+        const input2 = document.createElement('div');
+
+        container.dataset.cy = 'quote-tool';
+
+        input.contentEditable = 'true';
+        input2.contentEditable = 'true';
+
+        container.append(input, input2);
+
+        return container;
+      }
+
+      /**
+       *
+       */
+      public save(): Record<string, never> {
+        return {};
+      }
+    }
+
+    const editor = new window.EditorJS({
+      holder: holderId,
+      tools: {
+        quote: ExampleOfToolWithSeveralInputs,
+      },
+      data: {
+        blocks: [
+          {
+            type: 'quote',
+            data: {},
+          },
+        ],
+      },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditorWithUnmergeableTool = async (page: Page): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId }) => {
+    /**
+     *
+     */
+    class ExampleOfUnmergeableTool {
+      /**
+       *
+       */
+      public render(): HTMLElement {
+        const container = document.createElement('div');
+
+        container.dataset.cy = 'unmergeable-tool';
+        container.contentEditable = 'true';
+        container.innerHTML = 'Unmergeable not empty tool';
+
+        return container;
+      }
+
+      /**
+       *
+       */
+      public save(): Record<string, never> {
+        return {};
+      }
+    }
+
+    const editor = new window.EditorJS({
+      holder: holderId,
+      tools: {
+        code: ExampleOfUnmergeableTool,
+      },
+      data: {
+        blocks: [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Second block',
+            },
+          },
+          {
+            type: 'code',
+            data: {},
+          },
+        ],
+      },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID });
+};
+
+const saveEditor = async (page: Page): Promise<OutputData> => {
+  return page.evaluate(async () => {
+    if (!window.editorInstance) {
+      throw new Error('Editor instance is not initialized');
+    }
+
+    return window.editorInstance.save();
+  });
+};
+
+const selectText = async (locator: Locator, text: string): Promise<void> => {
+  await locator.evaluate((element, targetText) => {
+    const textNode = element.firstChild;
+
+    if (!textNode || textNode.nodeType !== Node.TEXT_NODE) {
+      throw new Error('Element does not contain a text node');
+    }
+
+    const content = textNode.textContent ?? '';
+    const start = content.indexOf(targetText);
+
+    if (start === -1) {
+      throw new Error(`Text "${targetText}" was not found`);
+    }
+
+    const range = element.ownerDocument.createRange();
+
+    range.setStart(textNode, start);
+    range.setEnd(textNode, start + targetText.length);
+
+    const selection = element.ownerDocument.getSelection();
+
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+  }, text);
+};
+
+const getCaretInfo = (locator: Locator, options: { normalize?: boolean } = {}): Promise<{ inside: boolean; offset: number; textLength: number } | null> => {
+  return locator.evaluate((element, { normalize }) => {
+    const selection = element.ownerDocument.getSelection();
+
+    if (!selection || selection.rangeCount === 0) {
+      return null;
+    }
+
+    const range = selection.getRangeAt(0);
+
+    if (normalize) {
+      range.startContainer.normalize();
+    }
+
+    return {
+      inside: element.contains(range.startContainer),
+      offset: range.startOffset,
+      textLength: element.textContent?.length ?? 0,
+    };
+  }, { normalize: options.normalize ?? false });
+};
+
+const expectCaretAtStart = async (locator: Locator): Promise<void> => {
+  const caretInfo = await getCaretInfo(locator);
+
+  expect(caretInfo?.inside).toBeTruthy();
+  expect(caretInfo?.offset).toBe(0);
+};
+
+const expectCaretOffset = async (locator: Locator, expectedOffset: number, options?: { normalize?: boolean }): Promise<void> => {
+  const caretInfo = await getCaretInfo(locator, options);
+
+  expect(caretInfo?.inside).toBeTruthy();
+  expect(caretInfo?.offset).toBe(expectedOffset);
+};
+
+const expectToolbarClosed = async (page: Page): Promise<void> => {
+  const toolbar = page.locator(TOOLBAR_SELECTOR);
+
+  await expect(toolbar).not.toHaveClass(/ce-toolbar--opened/);
+};
+
+test.describe('delete keydown', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test.describe('ending whitespaces handling', () => {
+    test('should delete visible non-breaking space', async ({ page }) => {
+      await createParagraphEditor(page, ['1&nbsp;', '2']);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      await firstParagraph.click();
+      await firstParagraph.press('Home');
+      await firstParagraph.press('ArrowRight');
+      await firstParagraph.press('Delete');
+      await firstParagraph.press('Delete');
+
+      await expect(getBlockByIndex(page, 0)).toHaveText('12');
+    });
+
+    test('should merge blocks when invisible space follows caret', async ({ page }) => {
+      await createParagraphEditor(page, ['1 ', '2']);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      await firstParagraph.click();
+      await firstParagraph.press('Home');
+      await firstParagraph.press('ArrowRight');
+      await firstParagraph.press('Delete');
+
+      const lastBlock = await getLastBlock(page);
+
+      await expect(lastBlock).toHaveText('1 2');
+    });
+
+    test('should ignore empty tags after caret when merging', async ({ page }) => {
+      await createParagraphEditor(page, ['1<b></b>', '2']);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      await firstParagraph.click();
+      await firstParagraph.press('Home');
+      await firstParagraph.press('ArrowRight');
+      await firstParagraph.press('Delete');
+
+      const lastBlock = await getLastBlock(page);
+
+      await expect(lastBlock).toHaveText('12');
+    });
+
+    test('should remove non-breaking space and ignore empty tag', async ({ page }) => {
+      await createParagraphEditor(page, ['1&nbsp;<b></b>', '2']);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      await firstParagraph.click();
+      await firstParagraph.press('Home');
+      await firstParagraph.press('ArrowRight');
+      await firstParagraph.press('Delete');
+      await firstParagraph.press('Delete');
+
+      const lastBlock = await getLastBlock(page);
+
+      await expect(lastBlock).toHaveText('12');
+    });
+
+    test('should remove non-breaking space placed after empty tag', async ({ page }) => {
+      await createParagraphEditor(page, ['1<b></b>&nbsp;', '2']);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      await firstParagraph.click();
+      await firstParagraph.press('Home');
+      await firstParagraph.press('ArrowRight');
+      await firstParagraph.press('Delete');
+      await firstParagraph.press('Delete');
+
+      const lastBlock = await getLastBlock(page);
+
+      await expect(lastBlock).toHaveText('12');
+    });
+
+    test('should remove non-breaking space and ignore regular space', async ({ page }) => {
+      await createParagraphEditor(page, ['1&nbsp; ', '2']);
+
+      const firstParagraph = getParagraphByIndex(page, 0);
+
+      await firstParagraph.click();
+      await firstParagraph.press('Home');
+      await firstParagraph.press('ArrowRight');
+      await firstParagraph.press('Delete');
+      await firstParagraph.press('Delete');
+
+      const lastBlock = await getLastBlock(page);
+
+      await expect(lastBlock).toHaveText(/^(12|1 2)$/);
+    });
+  });
+
+  test('should delete selected fragment using native behaviour', async ({ page }) => {
+    await createParagraphEditor(page, ['The first block', 'The second block']);
+
+    const firstParagraph = getParagraphByIndex(page, 0);
+
+    await firstParagraph.click();
+    await selectText(firstParagraph, 'The ');
+    await page.keyboard.press('Delete');
+
+    await expect(getBlockByIndex(page, 0)).toHaveText('first block');
+  });
+
+  test('should delete character using native behaviour when caret is not at block end', async ({ page }) => {
+    await createParagraphEditor(page, ['The first block', 'The second block']);
+
+    const firstParagraph = getParagraphByIndex(page, 0);
+
+    await firstParagraph.click();
+    await firstParagraph.press('ArrowLeft');
+    await firstParagraph.press('Delete');
+
+    await expect(getBlockByIndex(page, 0)).toHaveText('The first bloc');
+  });
+
+  test('should focus next input when caret is not in the last input', async ({ page }) => {
+    await createMultiInputToolEditor(page);
+
+    const firstInput = getQuoteToolInputByIndex(page, 0);
+
+    await firstInput.click();
+    await firstInput.press('Delete');
+
+    const lastQuoteToolInput = await getLastQuoteToolInput(page);
+    const caretInfo = await getCaretInfo(lastQuoteToolInput);
+
+    expect(caretInfo?.inside).toBeTruthy();
+  });
+
+  test('should remove next empty block and close toolbox when caret at block end', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        id: 'block1',
+        type: 'paragraph',
+        data: {
+          text: 'Not empty block',
+        },
+      },
+      {
+        id: 'block2',
+        type: 'paragraph',
+        data: {
+          text: '',
+        },
+      },
+    ]);
+
+    const firstParagraph = getParagraphByIndex(page, 0);
+
+    await firstParagraph.click();
+    await firstParagraph.press('End');
+    await firstParagraph.press('Delete');
+
+    const { blocks } = await saveEditor(page);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].id).toBe('block1');
+
+    await expectToolbarClosed(page);
+  });
+
+  test('should remove current empty block and place caret at next block start', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        id: 'block1',
+        type: 'paragraph',
+        data: {
+          text: '1',
+        },
+      },
+      {
+        id: 'block2',
+        type: 'paragraph',
+        data: {
+          text: 'Not empty block',
+        },
+      },
+    ]);
+
+    const firstParagraph = getParagraphByIndex(page, 0);
+
+    await firstParagraph.click();
+    await firstParagraph.press('Backspace');
+    await firstParagraph.press('Delete');
+
+    const { blocks } = await saveEditor(page);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].id).toBe('block2');
+
+    await expectCaretAtStart(getParagraphByIndex(page, 0));
+    await expectToolbarClosed(page);
+  });
+
+  test('should merge blocks when both are mergeable and caret at block end', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        id: 'block1',
+        type: 'paragraph',
+        data: {
+          text: 'First block',
+        },
+      },
+      {
+        id: 'block2',
+        type: 'paragraph',
+        data: {
+          text: 'Second block',
+        },
+      },
+    ]);
+
+    const firstParagraph = getParagraphByIndex(page, 0);
+
+    await firstParagraph.click();
+    await firstParagraph.press('End');
+    await firstParagraph.press('Delete');
+
+    const { blocks } = await saveEditor(page);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].id).toBe('block1');
+    expect((blocks[0].data as { text: string }).text).toBe('First blockSecond block');
+
+    await expectCaretOffset(getParagraphByIndex(page, 0), 'First block'.length, { normalize: true });
+    await expectToolbarClosed(page);
+  });
+
+  test('should place caret at start of next unmergeable block', async ({ page }) => {
+    await createEditorWithUnmergeableTool(page);
+
+    const firstParagraph = getParagraphByIndex(page, 0);
+
+    await firstParagraph.click();
+    await firstParagraph.press('End');
+    await firstParagraph.press('Delete');
+
+    const caretInfo = await getCaretInfo(page.locator(`${EDITOR_INTERFACE_SELECTOR} [data-cy=unmergeable-tool]`));
+
+    expect(caretInfo?.inside).toBeTruthy();
+    await expectToolbarClosed(page);
+  });
+
+  test.describe('at the end of the last block', () => {
+    test('should do nothing for non-empty block', async ({ page }) => {
+      await createParagraphEditor(page, [ 'The only block. Not empty' ]);
+
+      const onlyParagraph = getParagraphByIndex(page, 0);
+
+      await onlyParagraph.click();
+      await onlyParagraph.press('End');
+      await onlyParagraph.press('Delete');
+
+      await expect(page.locator(PARAGRAPH_SELECTOR)).toHaveCount(1);
+      await expect(onlyParagraph).toHaveText('The only block. Not empty');
+    });
+  });
+});
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+    EditorJS: new (...args: unknown[]) => EditorJS;
+  }
+}
+
+
diff --git a/test/playwright/tests/modules/BlockEvents/Enter.spec.ts b/test/playwright/tests/modules/BlockEvents/Enter.spec.ts
new file mode 100644
index 000000000..f3985ae95
--- /dev/null
+++ b/test/playwright/tests/modules/BlockEvents/Enter.spec.ts
@@ -0,0 +1,166 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type EditorJS from '../../../../../types';
+import type { OutputData } from '../../../../../types';
+import { ensureEditorBundleBuilt } from '../../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../../fixtures/test.html')
+).href;
+const HOLDER_ID = 'editorjs';
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} div.ce-block`;
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-block-tool="paragraph"]`;
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createParagraphEditor = async (page: Page, paragraphs: string[]): Promise<void> => {
+  const blocks: OutputData['blocks'] = paragraphs.map((text) => ({
+    type: 'paragraph',
+    data: { text },
+  }));
+
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, blocks: editorBlocks }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+      data: { blocks: editorBlocks },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID,
+    blocks });
+};
+
+const selectText = async (locator: Locator, text: string): Promise<void> => {
+  await locator.evaluate((element, targetText) => {
+    const textNode = element.firstChild;
+
+    if (!textNode || textNode.nodeType !== Node.TEXT_NODE) {
+      throw new Error('Element does not contain a text node');
+    }
+
+    const content = textNode.textContent ?? '';
+    const start = content.indexOf(targetText);
+
+    if (start === -1) {
+      throw new Error(`Text "${targetText}" was not found`);
+    }
+
+    const range = element.ownerDocument.createRange();
+
+    range.setStart(textNode, start);
+    range.setEnd(textNode, start + targetText.length);
+
+    const selection = element.ownerDocument.getSelection();
+
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+  }, text);
+};
+
+const saveEditor = async (page: Page): Promise<OutputData> => {
+  return page.evaluate(async () => {
+    if (!window.editorInstance) {
+      throw new Error('Editor instance is not initialized');
+    }
+
+    return window.editorInstance.save();
+  });
+};
+
+const getLastItem = <T>(items: T[]): T => {
+  const lastItem = items.at(-1);
+
+  if (!lastItem) {
+    throw new Error('Expected to receive at least one item');
+  }
+
+  return lastItem;
+};
+
+test.describe('enter keydown', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test('should split block and remove selected fragment when part of text is selected', async ({ page }) => {
+    await createParagraphEditor(page, [ 'The block with some text' ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await paragraph.click();
+    await selectText(paragraph, 'with so');
+    await page.keyboard.press('Enter');
+
+    const { blocks } = await saveEditor(page);
+
+    expect(blocks).toHaveLength(2);
+    expect((blocks[0].data as { text: string }).text).toBe('The block ');
+    expect((blocks[1].data as { text: string }).text).toBe('me text');
+  });
+
+  test('should place caret into new block when Enter pressed at block end', async ({ page }) => {
+    await createParagraphEditor(page, [ 'The block with some text' ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await paragraph.click();
+    await paragraph.press('End');
+    await paragraph.press('Enter');
+
+    const blockCount = page.locator(BLOCK_SELECTOR);
+
+    await expect(blockCount).toHaveCount(2);
+
+    const blockHandles = await page.locator(BLOCK_SELECTOR).elementHandles();
+    const lastBlockHandle = getLastItem(blockHandles);
+
+    const caretInsideLastBlock = await lastBlockHandle.evaluate((element) => {
+      const selection = element.ownerDocument?.getSelection();
+
+      if (!selection || selection.rangeCount === 0) {
+        return false;
+      }
+
+      const range = selection.getRangeAt(0);
+
+      return element.contains(range.startContainer);
+    });
+
+    expect(caretInsideLastBlock).toBeTruthy();
+  });
+});
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+    EditorJS: new (...args: unknown[]) => EditorJS;
+  }
+}
+
diff --git a/test/playwright/tests/modules/BlockEvents/Slash.spec.ts b/test/playwright/tests/modules/BlockEvents/Slash.spec.ts
new file mode 100644
index 000000000..d9f07fc08
--- /dev/null
+++ b/test/playwright/tests/modules/BlockEvents/Slash.spec.ts
@@ -0,0 +1,204 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type EditorJS from '../../../../../types';
+import type { OutputData } from '../../../../../types';
+import { ensureEditorBundleBuilt } from '../../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../../fixtures/test.html')
+).href;
+const HOLDER_ID = 'editorjs';
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-block-tool="paragraph"]`;
+const TOOLBOX_CONTAINER_SELECTOR = '[data-cy="toolbox"] .ce-popover__container';
+const TOOLBOX_ITEM_SELECTOR = (itemName: string): string =>
+  `${EDITOR_INTERFACE_SELECTOR} .ce-popover-item[data-item-name=${itemName}]`;
+const BLOCK_TUNES_SELECTOR = '[data-cy="block-tunes"] .ce-popover__container';
+const PLUS_BUTTON_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__plus`;
+
+const modifierKeyVariants: Array<{ description: string; key: 'Control' | 'Meta' }> = [
+  { description: 'Ctrl',
+    key: 'Control' },
+  { description: 'Cmd',
+    key: 'Meta' },
+];
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createParagraphEditor = async (page: Page, paragraphs: string[]): Promise<void> => {
+  const blocks: OutputData['blocks'] = paragraphs.map((text) => ({
+    type: 'paragraph',
+    data: { text },
+  }));
+
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, blocks: editorBlocks }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+      data: { blocks: editorBlocks },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID,
+    blocks });
+};
+
+const getTextContent = async (locator: Locator): Promise<string> => {
+  return locator.evaluate((element) => element.textContent ?? '');
+};
+
+test.describe('slash keydown', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test('should add "/" in empty block and open Toolbox', async ({ page }) => {
+    await createParagraphEditor(page, [ '' ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await paragraph.click();
+    await paragraph.type('/');
+
+    await expect(page.locator(TOOLBOX_CONTAINER_SELECTOR)).toBeVisible();
+
+    const textContent = await getTextContent(paragraph);
+
+    expect(textContent).toBe('/');
+  });
+
+  for (const { description, key } of modifierKeyVariants) {
+    test(`should not open Toolbox if Slash pressed with ${description}`, async ({ page }) => {
+      await createParagraphEditor(page, [ '' ]);
+
+      const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+      await paragraph.click();
+      await page.keyboard.down(key);
+      await page.keyboard.press('Slash');
+      await page.keyboard.up(key);
+
+      await expect(page.locator(TOOLBOX_CONTAINER_SELECTOR)).toBeHidden();
+      const textContent = await getTextContent(paragraph);
+
+      expect(textContent).toBe('');
+    });
+  }
+
+  test('should not open Toolbox in non-empty block and append slash character', async ({ page }) => {
+    await createParagraphEditor(page, [ 'Hello' ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await paragraph.click();
+    await paragraph.type('/');
+
+    await expect(page.locator(TOOLBOX_CONTAINER_SELECTOR)).toBeHidden();
+
+    const textContent = await getTextContent(paragraph);
+
+    expect(textContent).toBe('Hello/');
+  });
+
+  test('should not modify text outside editor when slash pressed', async ({ page }) => {
+    await createParagraphEditor(page, [ '' ]);
+
+    await page.evaluate(() => {
+      const title = document.querySelector('h1');
+
+      if (title) {
+        title.setAttribute('data-cy', 'page-title');
+      }
+    });
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await paragraph.click();
+
+    const plusButton = page.locator(PLUS_BUTTON_SELECTOR);
+
+    await plusButton.click();
+
+    const toolbox = page.locator(TOOLBOX_CONTAINER_SELECTOR);
+
+    await expect(toolbox).toBeVisible();
+
+    const textToolOption = page.locator(TOOLBOX_ITEM_SELECTOR('paragraph'));
+
+    await textToolOption.click();
+
+    const pageTitle = page.locator('[data-cy="page-title"]');
+
+    await pageTitle.evaluate((element) => {
+      element.setAttribute('contenteditable', 'true');
+      element.focus();
+
+      const selection = element.ownerDocument.getSelection();
+      const range = element.ownerDocument.createRange();
+
+      range.selectNodeContents(element);
+      selection?.removeAllRanges();
+      selection?.addRange(range);
+    });
+
+    await pageTitle.evaluate((element) => {
+      element.removeAttribute('contenteditable');
+      element.dispatchEvent(
+        new KeyboardEvent('keydown', {
+          key: '/',
+          code: 'Slash',
+          which: 191,
+          bubbles: true,
+        })
+      );
+    });
+
+    await expect(pageTitle).toHaveText('Editor.js test page');
+  });
+
+  test('should open Block Tunes when cmd+slash pressed', async ({ page }) => {
+    await createParagraphEditor(page, [ '' ]);
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await paragraph.click();
+    await page.keyboard.down('Meta');
+    await page.keyboard.press('Slash');
+    await page.keyboard.up('Meta');
+
+    await expect(page.locator(BLOCK_TUNES_SELECTOR)).toBeVisible();
+  });
+});
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+    EditorJS: new (...args: unknown[]) => EditorJS;
+  }
+}
+
diff --git a/test/playwright/tests/modules/BlockEvents/Tab.spec.ts b/test/playwright/tests/modules/BlockEvents/Tab.spec.ts
new file mode 100644
index 000000000..2e2b73acd
--- /dev/null
+++ b/test/playwright/tests/modules/BlockEvents/Tab.spec.ts
@@ -0,0 +1,383 @@
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type EditorJS from '../../../../../types';
+import type { OutputData } from '../../../../../types';
+import { ensureEditorBundleBuilt } from '../../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../../fixtures/test.html')
+).href;
+const HOLDER_ID = 'editorjs';
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-block-tool="paragraph"]`;
+const TOOL_WITH_TWO_INPUTS_PRIMARY_SELECTOR = '[data-cy=tool-with-two-inputs-primary]';
+const TOOL_WITH_TWO_INPUTS_SECONDARY_SELECTOR = '[data-cy=tool-with-two-inputs-secondary]';
+const CONTENTLESS_TOOL_SELECTOR = '[data-cy=contentless-tool]';
+const REGULAR_INPUT_SELECTOR = '[data-cy=regular-input]';
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createParagraphEditor = async (page: Page, paragraphs: string[]): Promise<void> => {
+  const blocks: OutputData['blocks'] = paragraphs.map((text) => ({
+    type: 'paragraph',
+    data: { text },
+  }));
+
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, blocks: editorBlocks }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+      data: { blocks: editorBlocks },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID,
+    blocks });
+};
+
+const createDefaultEditor = async (page: Page): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+      data: {
+        blocks: [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'default paragraph',
+            },
+          },
+        ],
+      },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditorWithTwoInputTool = async (page: Page): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId }) => {
+    /**
+     *
+     */
+    class ToolWithTwoInputs {
+      /**
+       *
+       */
+      public render(): HTMLElement {
+        const wrapper = document.createElement('div');
+        const input1 = document.createElement('div');
+        const input2 = document.createElement('div');
+
+        wrapper.dataset.cy = 'tool-with-two-inputs';
+
+        input1.contentEditable = 'true';
+        input2.contentEditable = 'true';
+        input1.dataset.cy = 'tool-with-two-inputs-primary';
+        input2.dataset.cy = 'tool-with-two-inputs-secondary';
+
+        wrapper.append(input1, input2);
+
+        return wrapper;
+      }
+
+      /**
+       *
+       */
+      public save(): Record<string, never> {
+        return {};
+      }
+    }
+
+    const editor = new window.EditorJS({
+      holder: holderId,
+      tools: {
+        toolWithTwoInputs: ToolWithTwoInputs,
+      },
+      data: {
+        blocks: [
+          {
+            type: 'toolWithTwoInputs',
+            data: {},
+          },
+          {
+            type: 'paragraph',
+            data: {
+              text: 'second paragraph',
+            },
+          },
+        ],
+      },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditorWithContentlessTool = async (page: Page): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId }) => {
+    /**
+     *
+     */
+    class ContentlessTool {
+      public static contentless = true;
+
+      /**
+       *
+       */
+      public render(): HTMLElement {
+        const wrapper = document.createElement('div');
+
+        wrapper.dataset.cy = 'contentless-tool';
+        wrapper.textContent = '***';
+
+        return wrapper;
+      }
+
+      /**
+       *
+       */
+      public save(): Record<string, never> {
+        return {};
+      }
+    }
+
+    const editor = new window.EditorJS({
+      holder: holderId,
+      tools: {
+        contentlessTool: ContentlessTool,
+      },
+      data: {
+        blocks: [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'second paragraph',
+            },
+          },
+          {
+            type: 'contentlessTool',
+            data: {},
+          },
+          {
+            type: 'paragraph',
+            data: {
+              text: 'third paragraph',
+            },
+          },
+        ],
+      },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID });
+};
+
+const addRegularInput = async (page: Page, position: 'before' | 'after'): Promise<void> => {
+  await page.evaluate(({ placement, holderId }) => {
+    const input = document.createElement('input');
+    const holder = document.getElementById(holderId);
+
+    if (!holder || !holder.parentNode) {
+      throw new Error('Editor holder is not available');
+    }
+
+    input.dataset.cy = 'regular-input';
+
+    if (placement === 'before') {
+      holder.parentNode.insertBefore(input, holder);
+    } else if (holder.nextSibling) {
+      holder.parentNode.insertBefore(input, holder.nextSibling);
+    } else {
+      holder.parentNode.appendChild(input);
+    }
+  }, { placement: position,
+    holderId: HOLDER_ID });
+};
+
+test.describe('tab keydown', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test('should focus next block when current block has single input', async ({ page }) => {
+    await createParagraphEditor(page, ['first paragraph', 'second paragraph']);
+
+    const firstParagraph = page.locator(PARAGRAPH_SELECTOR).filter({ hasText: 'first paragraph' });
+    const secondParagraph = page.locator(PARAGRAPH_SELECTOR).filter({ hasText: 'second paragraph' });
+
+    await firstParagraph.click();
+    await firstParagraph.press('Tab');
+
+    await expect(secondParagraph).toBeFocused();
+  });
+
+  test('should focus next input within same block when block has multiple inputs', async ({ page }) => {
+    await createEditorWithTwoInputTool(page);
+
+    const firstInput = page.locator(TOOL_WITH_TWO_INPUTS_PRIMARY_SELECTOR);
+    const secondInput = page.locator(TOOL_WITH_TWO_INPUTS_SECONDARY_SELECTOR);
+
+    await firstInput.click();
+    await firstInput.press('Tab');
+
+    await expect(secondInput).toBeFocused();
+  });
+
+  test('should highlight next block when it is contentless (has no inputs)', async ({ page }) => {
+    await createEditorWithContentlessTool(page);
+
+    const firstParagraph = page.locator(PARAGRAPH_SELECTOR).filter({ hasText: 'second paragraph' });
+
+    await firstParagraph.click();
+    await firstParagraph.press('Tab');
+
+    await page.waitForFunction(
+      ({ selector }) => {
+        const element = document.querySelector(selector);
+
+        return element?.closest('.ce-block')?.classList.contains('ce-block--selected') ?? false;
+      },
+      { selector: CONTENTLESS_TOOL_SELECTOR }
+    );
+
+    const contentlessTool = page.locator(CONTENTLESS_TOOL_SELECTOR);
+
+    const isSelected = await contentlessTool.evaluate((element) => {
+      return element.closest('.ce-block')?.classList.contains('ce-block--selected') ?? false;
+    });
+
+    expect(isSelected).toBeTruthy();
+  });
+
+  test('should focus input outside editor when Tab pressed in last block', async ({ page }) => {
+    await createDefaultEditor(page);
+    await addRegularInput(page, 'after');
+    await page.evaluate(() => {
+      /**
+       * Hide block tune popovers to keep the tab order identical to the previous e2e plugin,
+       * which skips hidden elements when emulating native Tab navigation.
+       */
+      const elements = Array.from(document.querySelectorAll('.ce-popover__items'));
+
+      for (const element of elements) {
+        (element as HTMLElement).style.display = 'none';
+      }
+    });
+
+    const lastParagraph = page.locator(PARAGRAPH_SELECTOR).filter({ hasText: 'default paragraph' });
+    const regularInput = page.locator(REGULAR_INPUT_SELECTOR);
+
+    await lastParagraph.click();
+    await lastParagraph.press('Tab');
+
+    await expect(regularInput).toBeFocused();
+  });
+});
+
+test.describe('shift+Tab keydown', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test('should focus previous block when current block has single input', async ({ page }) => {
+    await createParagraphEditor(page, ['first paragraph', 'second paragraph']);
+
+    const lastParagraph = page.locator(PARAGRAPH_SELECTOR).filter({ hasText: 'second paragraph' });
+    const firstParagraph = page.locator(PARAGRAPH_SELECTOR).filter({ hasText: 'first paragraph' });
+
+    await lastParagraph.click();
+    await lastParagraph.press('Shift+Tab');
+
+    await expect(firstParagraph).toBeFocused();
+  });
+
+  test('should focus previous input within same block when block has multiple inputs', async ({ page }) => {
+    await createEditorWithTwoInputTool(page);
+
+    const firstInput = page.locator(TOOL_WITH_TWO_INPUTS_PRIMARY_SELECTOR);
+    const secondInput = page.locator(TOOL_WITH_TWO_INPUTS_SECONDARY_SELECTOR);
+
+    await secondInput.click();
+    await secondInput.press('Shift+Tab');
+
+    await expect(firstInput).toBeFocused();
+  });
+
+  test('should highlight previous block when it is contentless (has no inputs)', async ({ page }) => {
+    await createEditorWithContentlessTool(page);
+
+    const lastParagraph = page.locator(PARAGRAPH_SELECTOR).filter({ hasText: 'third paragraph' });
+
+    await lastParagraph.click();
+    await lastParagraph.press('Shift+Tab');
+
+    await page.waitForFunction(
+      ({ selector }) => {
+        const element = document.querySelector(selector);
+
+        return element?.closest('.ce-block')?.classList.contains('ce-block--selected') ?? false;
+      },
+      { selector: CONTENTLESS_TOOL_SELECTOR }
+    );
+
+    const contentlessTool = page.locator(CONTENTLESS_TOOL_SELECTOR);
+    const isSelected = await contentlessTool.evaluate((element) => {
+      return element.closest('.ce-block')?.classList.contains('ce-block--selected') ?? false;
+    });
+
+    expect(isSelected).toBeTruthy();
+  });
+
+  test('should focus input outside editor when Shift+Tab pressed in first block', async ({ page }) => {
+    await createDefaultEditor(page);
+    await addRegularInput(page, 'before');
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR).filter({ hasText: 'default paragraph' });
+    const regularInput = page.locator(REGULAR_INPUT_SELECTOR);
+
+    await paragraph.click();
+    await paragraph.press('Shift+Tab');
+
+    await expect(regularInput).toBeFocused();
+  });
+});
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+    EditorJS: new (...args: unknown[]) => EditorJS;
+  }
+}
diff --git a/test/playwright/tests/modules/BlockIds.spec.ts b/test/playwright/tests/modules/BlockIds.spec.ts
new file mode 100644
index 000000000..5c02c3bcb
--- /dev/null
+++ b/test/playwright/tests/modules/BlockIds.spec.ts
@@ -0,0 +1,377 @@
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { nanoid } from 'nanoid';
+
+import type EditorJS from '@/types';
+import type { OutputData } from '@/types';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HEADER_TOOL_UMD_PATH = path.resolve(
+  __dirname,
+  '../../../../node_modules/@editorjs/header/dist/header.umd.js'
+);
+
+const HOLDER_ID = 'editorjs';
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-block`;
+const PLUS_BUTTON_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__plus`;
+const TOOLBOX_ITEM_SELECTOR = (itemName: string): string =>
+  `${EDITOR_INTERFACE_SELECTOR} .ce-popover-item[data-item-name=${itemName}]`;
+
+type SerializableToolConfig = {
+  className?: string;
+  classCode?: string;
+  config?: Record<string, unknown>;
+};
+
+type CreateEditorOptions = {
+  data?: OutputData;
+  tools?: Record<string, SerializableToolConfig>;
+};
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+  }
+}
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditor = async (page: Page, options: CreateEditorOptions = {}): Promise<void> => {
+  const { data = null, tools = {} } = options;
+
+  await resetEditor(page);
+  await page.waitForFunction(() => typeof window.EditorJS === 'function');
+
+  const serializedTools = Object.entries(tools).map(([name, tool]) => {
+    return {
+      name,
+      className: tool.className ?? null,
+      classCode: tool.classCode ?? null,
+      config: tool.config ?? {},
+    };
+  });
+
+  await page.evaluate(
+    async ({ holderId, data: initialData, serializedTools: toolsConfig }) => {
+      const editorConfig: Record<string, unknown> = {
+        holder: holderId,
+      };
+
+      if (initialData) {
+        editorConfig.data = initialData;
+      }
+
+      if (toolsConfig.length > 0) {
+        const resolvedTools = toolsConfig.reduce<Record<string, { class: unknown } & Record<string, unknown>>>(
+          (accumulator, { name, className, classCode, config }) => {
+            let toolClass: unknown = null;
+
+            if (className) {
+              toolClass = (window as unknown as Record<string, unknown>)[className] ?? null;
+            }
+
+            if (!toolClass && classCode) {
+              // eslint-disable-next-line no-new-func -- evaluated in browser context to reconstruct tool class
+              toolClass = new Function(`return (${classCode});`)();
+            }
+
+            if (!toolClass) {
+              throw new Error(`Tool "${name}" is not available globally`);
+            }
+
+            return {
+              ...accumulator,
+              [name]: {
+                class: toolClass,
+                ...config,
+              },
+            };
+          },
+          {}
+        );
+
+        editorConfig.tools = resolvedTools;
+      }
+
+      const editor = new window.EditorJS(editorConfig);
+
+      window.editorInstance = editor;
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      data,
+      serializedTools,
+    }
+  );
+};
+
+const saveEditor = async (page: Page): Promise<OutputData> => {
+  return await page.evaluate(async () => {
+    if (!window.editorInstance) {
+      throw new Error('Editor instance not found');
+    }
+
+    return await window.editorInstance.save();
+  });
+};
+
+/**
+ * Ensures that the provided value is a string.
+ *
+ * @param value - Value to validate.
+ * @param errorMessage - Message for the thrown error when validation fails.
+ */
+const assertIsString: (value: unknown, errorMessage: string) => asserts value is string = (
+  value,
+  errorMessage
+) => {
+  if (typeof value !== 'string') {
+    throw new Error(errorMessage);
+  }
+};
+
+const getBlockIdByIndex = async (page: Page, blockIndex: number): Promise<string> => {
+  return await page.evaluate((index) => {
+    const editor = window.editorInstance;
+
+    if (!editor) {
+      throw new Error('Editor instance not found');
+    }
+
+    const block = editor.blocks.getBlockByIndex(index);
+
+    if (!block) {
+      throw new Error(`Block at index ${index} was not found`);
+    }
+
+    const { id } = block;
+
+    if (typeof id !== 'string') {
+      throw new Error(`Block id at index ${index} is not a string`);
+    }
+
+    return id;
+  }, blockIndex);
+};
+
+const getLastBlockId = async (page: Page): Promise<string> => {
+  const blocksCount = await page.evaluate(() => {
+    const editor = window.editorInstance;
+
+    if (!editor) {
+      throw new Error('Editor instance not found');
+    }
+
+    return editor.blocks.getBlocksCount();
+  });
+
+  if (blocksCount <= 0) {
+    throw new Error('Editor does not contain any blocks');
+  }
+
+  return await getBlockIdByIndex(page, blocksCount - 1);
+};
+
+test.describe('block ids', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+  });
+
+  test('generates unique ids for new blocks', async ({ page }) => {
+    await page.addScriptTag({ path: HEADER_TOOL_UMD_PATH });
+
+    await createEditor(page, {
+      tools: {
+        header: {
+          className: 'Header',
+        },
+      },
+    });
+
+    const firstParagraphId = await getBlockIdByIndex(page, 0);
+    const firstParagraph = page.locator(
+      `${EDITOR_INTERFACE_SELECTOR} [data-id="${firstParagraphId}"] [data-block-tool="paragraph"]`
+    );
+
+    await firstParagraph.click();
+    await page.keyboard.type('First block ');
+    await page.keyboard.press('Enter');
+    await page.keyboard.type('Second block ');
+    await page.keyboard.press('Enter');
+
+    const plusButton = page.locator(PLUS_BUTTON_SELECTOR);
+
+    await plusButton.click();
+    await page.locator(TOOLBOX_ITEM_SELECTOR('header')).click();
+
+    const headerBlockId = await getLastBlockId(page);
+    const headerBlock = page.locator(
+      `${EDITOR_INTERFACE_SELECTOR} [data-id="${headerBlockId}"] [data-block-tool="header"]`
+    );
+
+    await headerBlock.click();
+    await page.keyboard.type('Header');
+
+    const { blocks } = await saveEditor(page);
+    const blockIds = blocks.map((block) => block.id);
+
+    expect(blocks).not.toHaveLength(0);
+    for (const block of blocks) {
+      expect(typeof block.id).toBe('string');
+    }
+    expect(new Set(blockIds).size).toBe(blockIds.length);
+  });
+
+  test('preserves provided block ids', async ({ page }) => {
+    const blocks: OutputData['blocks'] = [
+      {
+        id: nanoid(),
+        type: 'paragraph',
+        data: {
+          text: 'First block',
+        },
+      },
+      {
+        id: nanoid(),
+        type: 'paragraph',
+        data: {
+          text: 'Second block',
+        },
+      },
+    ];
+
+    await createEditor(page, {
+      data: {
+        blocks,
+      },
+    });
+
+    const { blocks: savedBlocks } = await saveEditor(page);
+
+    expect(savedBlocks).toHaveLength(blocks.length);
+    savedBlocks.forEach((block, index) => {
+      expect(block.id).toBe(blocks[index]?.id);
+    });
+  });
+
+  test('preserves provided ids when new block is added', async ({ page }) => {
+    const blocks: OutputData['blocks'] = [
+      {
+        id: nanoid(),
+        type: 'paragraph',
+        data: {
+          text: 'First block',
+        },
+      },
+      {
+        id: nanoid(),
+        type: 'paragraph',
+        data: {
+          text: 'Second block',
+        },
+      },
+    ];
+
+    await createEditor(page, {
+      data: {
+        blocks,
+      },
+    });
+
+    const firstParagraphId = blocks[0]?.id;
+
+    assertIsString(firstParagraphId, 'First block id was not provided');
+
+    const firstParagraph = page.locator(
+      `${EDITOR_INTERFACE_SELECTOR} [data-id="${firstParagraphId}"] [data-block-tool="paragraph"]`
+    );
+
+    await firstParagraph.click();
+    await page.keyboard.press('Enter');
+    await page.keyboard.type('Middle block');
+
+    const { blocks: savedBlocks } = await saveEditor(page);
+
+    expect(savedBlocks).toHaveLength(3);
+    expect(savedBlocks[0]?.id).toBe(blocks[0]?.id);
+    expect(savedBlocks[2]?.id).toBe(blocks[1]?.id);
+  });
+
+  test('exposes block id on wrapper via data-id attribute', async ({ page }) => {
+    const blocks: OutputData['blocks'] = [
+      {
+        id: nanoid(),
+        type: 'paragraph',
+        data: {
+          text: 'First block',
+        },
+      },
+      {
+        id: nanoid(),
+        type: 'paragraph',
+        data: {
+          text: 'Second block',
+        },
+      },
+    ];
+
+    await createEditor(page, {
+      data: {
+        blocks,
+      },
+    });
+
+    const blockWrappers = page.locator(BLOCK_SELECTOR);
+
+    await expect(blockWrappers).toHaveCount(blocks.length);
+
+    const blockHandles = await blockWrappers.elementHandles();
+
+    await Promise.all(
+      blockHandles.map((handle, index) => {
+        return handle.evaluate((element, expectedId) => {
+          if (!(element instanceof HTMLElement)) {
+            throw new Error('Block wrapper is not an HTMLElement');
+          }
+
+          const dataId = element.getAttribute('data-id');
+
+          if (dataId !== expectedId) {
+            throw new Error(`Expected block data-id to equal "${expectedId}", but received "${dataId}"`);
+          }
+        }, blocks[index]?.id);
+      })
+    );
+  });
+});
+
+
diff --git a/test/playwright/tests/modules/Saver.spec.ts b/test/playwright/tests/modules/Saver.spec.ts
new file mode 100644
index 000000000..fd03a1d85
--- /dev/null
+++ b/test/playwright/tests/modules/Saver.spec.ts
@@ -0,0 +1,236 @@
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import type EditorJS from '@/types';
+import type { OutputData } from '@/types';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HEADER_TOOL_UMD_PATH = path.resolve(
+  __dirname,
+  '../../../../node_modules/@editorjs/header/dist/header.umd.js'
+);
+
+const HOLDER_ID = 'editorjs';
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-block`;
+const BLOCK_CONTENT_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-block__content`;
+const SETTINGS_BUTTON_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__settings-btn`;
+const SETTINGS_ITEM_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-settings .ce-popover-item`;
+const BLOCK_TEXT = 'The block with some text';
+
+type SerializableToolConfig = {
+  className?: string;
+  classCode?: string;
+  config?: Record<string, unknown>;
+};
+
+type CreateEditorOptions = {
+  data?: OutputData;
+  tools?: Record<string, SerializableToolConfig>;
+};
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+  }
+}
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditor = async (page: Page, options: CreateEditorOptions = {}): Promise<void> => {
+  const { data = null, tools = {} } = options;
+
+  await resetEditor(page);
+  await page.waitForFunction(() => typeof window.EditorJS === 'function');
+
+  const serializedTools = Object.entries(tools).map(([name, tool]) => {
+    return {
+      name,
+      className: tool.className ?? null,
+      classCode: tool.classCode ?? null,
+      config: tool.config ?? {},
+    };
+  });
+
+  await page.evaluate(
+    async ({ holderId, data: initialData, serializedTools: toolsConfig }) => {
+      const editorConfig: Record<string, unknown> = {
+        holder: holderId,
+      };
+
+      if (initialData) {
+        editorConfig.data = initialData;
+      }
+
+      if (toolsConfig.length > 0) {
+        const resolvedTools = toolsConfig.reduce<Record<string, { class: unknown } & Record<string, unknown>>>(
+          (accumulator, { name, className, classCode, config }) => {
+            let toolClass: unknown = null;
+
+            if (className) {
+              toolClass = (window as unknown as Record<string, unknown>)[className] ?? null;
+            }
+
+            if (!toolClass && classCode) {
+              // eslint-disable-next-line no-new-func -- evaluated in browser context to reconstruct tool class
+              toolClass = new Function(`return (${classCode});`)();
+            }
+
+            if (!toolClass) {
+              throw new Error(`Tool "${name}" is not available globally`);
+            }
+
+            return {
+              ...accumulator,
+              [name]: {
+                class: toolClass,
+                ...config,
+              },
+            };
+          },
+          {}
+        );
+
+        editorConfig.tools = resolvedTools;
+      }
+
+      const editor = new window.EditorJS(editorConfig);
+
+      window.editorInstance = editor;
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      data,
+      serializedTools,
+    }
+  );
+};
+
+const saveEditor = async (page: Page): Promise<OutputData> => {
+  return await page.evaluate(async () => {
+    if (!window.editorInstance) {
+      throw new Error('Editor instance not found');
+    }
+
+    return await window.editorInstance.save();
+  });
+};
+
+test.describe('saver module', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+  });
+
+  test('saves block data when extraneous DOM nodes are present', async ({ page }) => {
+    await createEditor(page, {
+      data: {
+        blocks: [
+          {
+            type: 'paragraph',
+            data: {
+              text: BLOCK_TEXT,
+            },
+          },
+        ],
+      },
+    });
+
+    const blockContent = page.locator(BLOCK_CONTENT_SELECTOR).filter({ hasText: BLOCK_TEXT });
+
+    await blockContent.evaluate((element) => {
+      const extensionNode = element.ownerDocument.createElement('extension-node');
+
+      element.append(extensionNode);
+    });
+
+    const savedData = await saveEditor(page);
+
+    expect(savedData.blocks).toHaveLength(1);
+    expect(savedData.blocks[0]?.type).toBe('paragraph');
+    expect(savedData.blocks[0]?.data).toMatchObject({
+      text: BLOCK_TEXT,
+    });
+  });
+
+  test('saves header block data after container element changes', async ({ page }) => {
+    await page.addScriptTag({ path: HEADER_TOOL_UMD_PATH });
+
+    await createEditor(page, {
+      data: {
+        blocks: [
+          {
+            type: 'header',
+            data: {
+              text: BLOCK_TEXT,
+              level: 1,
+            },
+          },
+        ],
+      },
+      tools: {
+        header: {
+          className: 'Header',
+        },
+      },
+    });
+
+    await page.locator(BLOCK_SELECTOR).filter({ hasText: BLOCK_TEXT })
+      .click();
+
+    const settingsButton = page.locator(SETTINGS_BUTTON_SELECTOR);
+
+    await expect(settingsButton).toBeVisible();
+    await settingsButton.click();
+
+    const headerLevelOption = page.locator(SETTINGS_ITEM_SELECTOR).filter({ hasText: /^Heading 3$/ });
+
+    await headerLevelOption.waitFor({ state: 'visible' });
+    await headerLevelOption.click();
+
+    await page.waitForFunction(
+      ({ editorSelector }) => {
+        const headerElement = document.querySelector(`${editorSelector} .ce-header`);
+
+        return headerElement?.tagName === 'H3';
+      },
+      { editorSelector: EDITOR_INTERFACE_SELECTOR }
+    );
+
+    const savedData = await saveEditor(page);
+
+    expect(savedData.blocks[0]?.type).toBe('header');
+    expect(savedData.blocks[0]?.data).toMatchObject({
+      text: BLOCK_TEXT,
+      level: 3,
+    });
+  });
+});
+
diff --git a/test/playwright/tests/onchange.spec.ts b/test/playwright/tests/onchange.spec.ts
new file mode 100644
index 000000000..42773ff53
--- /dev/null
+++ b/test/playwright/tests/onchange.spec.ts
@@ -0,0 +1,1235 @@
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import type EditorJS from '@/types';
+import type { EditorConfig, OutputData } from '@/types';
+import { modificationsObserverBatchTimeout, EDITOR_INTERFACE_SELECTOR } from '../../../src/components/constants';
+import { ensureEditorBundleBuilt } from './helpers/ensure-build';
+import { BlockAddedMutationType } from '../../../types/events/block/BlockAdded';
+import { BlockChangedMutationType } from '../../../types/events/block/BlockChanged';
+import { BlockMovedMutationType } from '../../../types/events/block/BlockMoved';
+import { BlockRemovedMutationType } from '../../../types/events/block/BlockRemoved';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} div.ce-block`;
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-paragraph`;
+const TOOLBAR_PLUS_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__plus`;
+const SETTINGS_BUTTON_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__settings-btn`;
+const WAIT_FOR_BATCH = modificationsObserverBatchTimeout + 100;
+
+const HEADER_TOOL_UMD_PATH = path.resolve(
+  __dirname,
+  '../../../node_modules/@editorjs/header/dist/header.umd.js'
+);
+const CODE_TOOL_UMD_PATH = path.resolve(
+  __dirname,
+  '../../../node_modules/@editorjs/code/dist/code.umd.js'
+);
+const DELIMITER_TOOL_UMD_PATH = path.resolve(
+  __dirname,
+  '../../../node_modules/@editorjs/delimiter/dist/delimiter.umd.js'
+);
+
+type SerializableToolConfig = {
+  name: string;
+  className?: string;
+  classCode?: string;
+  config?: Record<string, unknown>;
+};
+
+type SerializedBlockMutationEvent = {
+  type: string;
+  detail?: Record<string, unknown>;
+};
+
+type SerializedOnChangeCall = SerializedBlockMutationEvent | SerializedBlockMutationEvent[];
+
+const ensureSerializedBlockMutationEvent = (
+  value: SerializedOnChangeCall
+): SerializedBlockMutationEvent => {
+  if (Array.isArray(value)) {
+    throw new Error('Expected a single serialized block mutation event');
+  }
+
+  return value;
+};
+
+const ensureSerializedBlockMutationEvents = (
+  value: SerializedOnChangeCall
+): SerializedBlockMutationEvent[] => {
+  if (!Array.isArray(value)) {
+    throw new Error('Expected an array of serialized block mutation events');
+  }
+
+  return value;
+};
+
+type CreateEditorOptions = {
+  blocks?: OutputData['blocks'];
+  readOnly?: boolean;
+  tools?: SerializableToolConfig[];
+  callSaveInsideOnChange?: boolean;
+  config?: Record<string, unknown>;
+};
+
+type WindowTestState = Partial<Record<'__onChangeCalls', SerializedOnChangeCall[]>> &
+  Partial<Record<'__testToolWrapper', HTMLElement>> &
+  Partial<Record<'__testToolChild', HTMLElement>>;
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+  }
+}
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditor = async (page: Page, options: CreateEditorOptions = {}): Promise<void> => {
+  const {
+    blocks,
+    readOnly,
+    tools = [],
+    callSaveInsideOnChange = false,
+    config = {},
+  } = options;
+
+  await resetEditor(page);
+  await page.waitForFunction(() => typeof window.EditorJS === 'function');
+
+  await page.evaluate(
+    async ({
+      holderId,
+      blocks: initialBlocks,
+      readOnly: readOnlyOption,
+      tools: serializedTools,
+      callSaveInsideOnChange: shouldCallSave,
+      config: editorConfigOptions,
+    }) => {
+      const windowObj = window as unknown as Window & WindowTestState;
+
+      windowObj.__onChangeCalls = [];
+
+      const reviveTools = serializedTools.reduce<Record<string, Record<string, unknown>>>((accumulator, tool) => {
+        let toolClass: unknown = null;
+
+        if (tool.className) {
+          toolClass = (window as unknown as Record<string, unknown>)[tool.className] ?? null;
+        }
+
+        if (!toolClass && tool.classCode) {
+          // eslint-disable-next-line no-new-func -- evaluated in browser context to reconstruct tool class
+          toolClass = new Function(`return (${tool.classCode});`)();
+        }
+
+        if (!toolClass) {
+          throw new Error(`Tool "${tool.name}" is not available globally`);
+        }
+
+        return {
+          ...accumulator,
+          [tool.name]: {
+            class: toolClass,
+            ...(tool.config ?? {}),
+          },
+        };
+      }, {});
+
+      const editorConfig: Record<string, unknown> = {
+        holder: holderId,
+        ...editorConfigOptions,
+      };
+
+      if (typeof readOnlyOption === 'boolean') {
+        editorConfig.readOnly = readOnlyOption;
+      }
+
+      if (initialBlocks) {
+        editorConfig.data = {
+          blocks: initialBlocks,
+        };
+      }
+
+      if (Object.keys(reviveTools).length > 0) {
+        editorConfig.tools = reviveTools;
+      }
+
+      const cloneDetail = <T>(value: T): T => {
+        const structuredCloneFn = typeof globalThis.structuredClone === 'function'
+          ? globalThis.structuredClone
+          : null;
+
+        if (structuredCloneFn) {
+          return structuredCloneFn(value);
+        }
+
+        try {
+          return JSON.parse(JSON.stringify(value));
+        } catch (error) {
+          return value;
+        }
+      };
+
+      const serializeEvent = (event: CustomEvent | CustomEvent[]): SerializedOnChangeCall => {
+        const serializeSingle = (singleEvent: CustomEvent): SerializedBlockMutationEvent => {
+          const { type, detail } = singleEvent;
+
+          return {
+            type,
+            detail: detail ? cloneDetail(detail) : undefined,
+          };
+        };
+
+        return Array.isArray(event)
+          ? event.map(serializeSingle)
+          : serializeSingle(event);
+      };
+
+      editorConfig.onChange = (api: unknown, event: CustomEvent | CustomEvent[]) => {
+        windowObj.__onChangeCalls = windowObj.__onChangeCalls ?? [];
+
+        windowObj.__onChangeCalls.push(serializeEvent(event));
+
+        if (shouldCallSave && typeof (api as { saver?: { save: () => Promise<unknown> } }).saver?.save === 'function') {
+          const saveResult = (api as { saver?: { save: () => Promise<unknown> } }).saver?.save();
+
+          if (saveResult && typeof (saveResult as Promise<unknown>).catch === 'function') {
+            void (saveResult as Promise<unknown>).catch(() => {
+              // Swallow errors to match the previous e2e behaviour where Promise rejections were ignored.
+            });
+          }
+        }
+      };
+
+      const editor = new window.EditorJS(editorConfig as EditorConfig);
+
+      windowObj.editorInstance = editor;
+
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      blocks: blocks ?? null,
+      readOnly,
+      tools,
+      callSaveInsideOnChange,
+      config,
+    }
+  );
+};
+
+const waitForOnChangeCallCount = async (page: Page, expectedCount: number): Promise<void> => {
+  await page.waitForFunction(
+    ({ expected }) => {
+      const calls = (window as unknown as Window & WindowTestState).__onChangeCalls ?? [];
+
+      return calls.length >= expected;
+    },
+    { expected: expectedCount },
+    { timeout: WAIT_FOR_BATCH + 1000 }
+  );
+};
+
+const getOnChangeCalls = async (page: Page): Promise<SerializedOnChangeCall[]> => {
+  return await page.evaluate(() => {
+    const calls = (window as unknown as Window & WindowTestState).__onChangeCalls ?? [];
+
+    return calls.slice();
+  });
+};
+
+const waitForDelay = async (page: Page, delayMs: number): Promise<void> => {
+  await page.evaluate(
+    async (timeout) => {
+      await new Promise<void>((resolve) => {
+        window.setTimeout(resolve, timeout);
+      });
+    },
+    delayMs
+  );
+};
+
+const waitForBatchProcessing = async (page: Page): Promise<void> => {
+  await waitForDelay(page, WAIT_FOR_BATCH);
+};
+
+const openBlockSettings = async (page: Page, index: number = 0): Promise<void> => {
+  const block = page.locator(`${BLOCK_SELECTOR}:nth-of-type(${index + 1})`);
+
+  await block.scrollIntoViewIfNeeded();
+  await block.click();
+  await block.hover();
+
+  const settingsButton = page.locator(SETTINGS_BUTTON_SELECTOR);
+
+  await settingsButton.waitFor({ state: 'visible' });
+  await settingsButton.click();
+};
+
+test.describe('onChange callback', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test('should batch events when several changes happened at once', async ({ page }) => {
+    await createEditor(page, {
+      blocks: [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'The first paragraph',
+          },
+        },
+      ],
+    });
+
+    const paragraph = page.locator(`${PARAGRAPH_SELECTOR}:first-of-type`);
+
+    await paragraph.click();
+    await paragraph.type('change');
+    await page.keyboard.press('Enter');
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ firstCall ] = await getOnChangeCalls(page);
+    const events = ensureSerializedBlockMutationEvents(firstCall);
+
+    expect(events).toStrictEqual([
+      expect.objectContaining({
+        type: BlockChangedMutationType,
+        detail: expect.objectContaining({
+          index: 0,
+        }),
+      }),
+      expect.objectContaining({
+        type: BlockAddedMutationType,
+        detail: expect.objectContaining({
+          index: 1,
+        }),
+      }),
+    ]);
+  });
+
+  test('should filter out similar events on batching', async ({ page }) => {
+    await createEditor(page, {
+      blocks: [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'The first paragraph',
+          },
+        },
+      ],
+    });
+
+    const paragraph = page.locator(`${PARAGRAPH_SELECTOR}:first-of-type`);
+
+    await paragraph.click();
+    await paragraph.type('first change');
+    await waitForDelay(page, 100);
+    await paragraph.type('second change');
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ event ] = await getOnChangeCalls(page);
+    const singleEvent = ensureSerializedBlockMutationEvent(event);
+
+    expect(singleEvent).toStrictEqual(expect.objectContaining({
+      type: BlockChangedMutationType,
+      detail: expect.objectContaining({
+        index: 0,
+        target: expect.objectContaining({
+          name: 'paragraph',
+        }),
+      }),
+    }));
+  });
+
+  test('should be fired with correct index on block insertion above the current block', async ({ page }) => {
+    await createEditor(page);
+
+    const firstBlock = page.locator(`${BLOCK_SELECTOR}:first-of-type`);
+
+    await firstBlock.click();
+    await page.keyboard.press('Enter');
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ event ] = await getOnChangeCalls(page);
+    const singleEvent = ensureSerializedBlockMutationEvent(event);
+
+    expect(singleEvent).toStrictEqual(expect.objectContaining({
+      type: BlockAddedMutationType,
+      detail: expect.objectContaining({
+        index: 0,
+        target: expect.objectContaining({
+          name: 'paragraph',
+        }),
+      }),
+    }));
+  });
+
+  test('should be fired with only single "block-added" event by pressing Enter at the end of a block', async ({ page }) => {
+    await createEditor(page, {
+      blocks: [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'some text',
+          },
+        },
+      ],
+    });
+
+    const block = page.locator(`${BLOCK_SELECTOR}:first-of-type`);
+
+    await block.click();
+    await page.keyboard.press('Enter');
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ event ] = await getOnChangeCalls(page);
+    const singleEvent = ensureSerializedBlockMutationEvent(event);
+
+    expect(singleEvent).toStrictEqual(expect.objectContaining({
+      type: BlockAddedMutationType,
+      detail: expect.objectContaining({
+        target: expect.objectContaining({
+          name: 'paragraph',
+        }),
+      }),
+    }));
+  });
+
+  test('should be fired with correct index on block insertion after the current block', async ({ page }) => {
+    await createEditor(page, {
+      blocks: [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'some text',
+          },
+        },
+      ],
+    });
+
+    const block = page.locator(`${BLOCK_SELECTOR}:first-of-type`);
+
+    await block.click();
+    await page.keyboard.press('End');
+    await page.keyboard.press('Enter');
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ event ] = await getOnChangeCalls(page);
+    const singleEvent = ensureSerializedBlockMutationEvent(event);
+
+    expect(singleEvent).toStrictEqual(expect.objectContaining({
+      type: BlockAddedMutationType,
+      detail: expect.objectContaining({
+        index: 1,
+      }),
+    }));
+  });
+
+  test('should be fired on typing into block', async ({ page }) => {
+    await createEditor(page);
+
+    const paragraph = page.locator(`${PARAGRAPH_SELECTOR}:first-of-type`);
+
+    await paragraph.click();
+    await paragraph.type('some text');
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ event ] = await getOnChangeCalls(page);
+    const singleEvent = ensureSerializedBlockMutationEvent(event);
+
+    expect(singleEvent).toStrictEqual(expect.objectContaining({
+      type: BlockChangedMutationType,
+      detail: expect.objectContaining({
+        index: 0,
+      }),
+    }));
+  });
+
+  test('should be fired on block insertion with save inside onChange', async ({ page }) => {
+    await page.addScriptTag({ path: HEADER_TOOL_UMD_PATH });
+    await page.addScriptTag({ path: CODE_TOOL_UMD_PATH });
+    await page.addScriptTag({ path: DELIMITER_TOOL_UMD_PATH });
+
+    await createEditor(page, {
+      callSaveInsideOnChange: true,
+      tools: [
+        {
+          name: 'header',
+          className: 'Header',
+        },
+        {
+          name: 'code',
+          className: 'CodeTool',
+        },
+        {
+          name: 'delimiter',
+          className: 'Delimiter',
+        },
+      ],
+    });
+
+    const block = page.locator(`${BLOCK_SELECTOR}:first-of-type`);
+
+    await block.click();
+
+    const plusButton = page.locator(TOOLBAR_PLUS_SELECTOR);
+
+    await plusButton.click();
+
+    const delimiterOption = page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover-item[data-item-name=delimiter]`);
+
+    await delimiterOption.click();
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ events ] = await getOnChangeCalls(page);
+    const eventsBatch = ensureSerializedBlockMutationEvents(events);
+
+    expect(eventsBatch).toStrictEqual([
+      expect.objectContaining({
+        type: BlockRemovedMutationType,
+        detail: expect.objectContaining({
+          index: 0,
+          target: expect.objectContaining({
+            name: 'paragraph',
+          }),
+        }),
+      }),
+      expect.objectContaining({
+        type: BlockAddedMutationType,
+        detail: expect.objectContaining({
+          index: 0,
+          target: expect.objectContaining({
+            name: 'delimiter',
+          }),
+        }),
+      }),
+      expect.objectContaining({
+        type: BlockAddedMutationType,
+        detail: expect.objectContaining({
+          index: 1,
+          target: expect.objectContaining({
+            name: 'paragraph',
+          }),
+        }),
+      }),
+    ]);
+  });
+
+  test('should be fired on block replacement for both blocks', async ({ page }) => {
+    await page.addScriptTag({ path: HEADER_TOOL_UMD_PATH });
+
+    await createEditor(page, {
+      tools: [
+        {
+          name: 'header',
+          className: 'Header',
+        },
+      ],
+    });
+
+    const block = page.locator(`${BLOCK_SELECTOR}:first-of-type`);
+
+    await block.click();
+
+    const plusButton = page.locator(TOOLBAR_PLUS_SELECTOR);
+
+    await plusButton.click();
+
+    const headerOption = page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover-item[data-item-name=header]`);
+
+    await headerOption.click();
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ events ] = await getOnChangeCalls(page);
+    const eventsBatch = ensureSerializedBlockMutationEvents(events);
+
+    expect(eventsBatch).toStrictEqual([
+      expect.objectContaining({
+        type: BlockRemovedMutationType,
+        detail: expect.objectContaining({
+          index: 0,
+          target: expect.objectContaining({
+            name: 'paragraph',
+          }),
+        }),
+      }),
+      expect.objectContaining({
+        type: BlockAddedMutationType,
+        detail: expect.objectContaining({
+          index: 0,
+          target: expect.objectContaining({
+            name: 'header',
+          }),
+        }),
+      }),
+    ]);
+  });
+
+  test('should be fired on tune modifying', async ({ page }) => {
+    await page.addScriptTag({ path: HEADER_TOOL_UMD_PATH });
+
+    await createEditor(page, {
+      tools: [
+        {
+          name: 'header',
+          className: 'Header',
+        },
+      ],
+      blocks: [
+        {
+          type: 'header',
+          data: {
+            text: 'Header block',
+          },
+        },
+      ],
+    });
+
+    await openBlockSettings(page, 0);
+
+    const tuneOption = page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-settings .ce-popover-item:nth-of-type(4)`);
+
+    await tuneOption.click();
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ event ] = await getOnChangeCalls(page);
+    const singleEvent = ensureSerializedBlockMutationEvent(event);
+
+    expect(singleEvent).toStrictEqual(expect.objectContaining({
+      type: BlockChangedMutationType,
+      detail: expect.objectContaining({
+        index: 0,
+        target: expect.objectContaining({
+          name: 'header',
+        }),
+      }),
+    }));
+  });
+
+  test('should be fired when block is removed', async ({ page }) => {
+    await createEditor(page, {
+      blocks: [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'some text',
+          },
+        },
+      ],
+    });
+
+    await openBlockSettings(page, 0);
+
+    const deleteOption = page.locator(`${EDITOR_INTERFACE_SELECTOR} [data-item-name=delete]:visible`);
+
+    await deleteOption.click();
+    await deleteOption.click();
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ events ] = await getOnChangeCalls(page);
+    const eventsBatch = ensureSerializedBlockMutationEvents(events);
+
+    expect(eventsBatch).toStrictEqual([
+      expect.objectContaining({
+        type: BlockRemovedMutationType,
+        detail: expect.objectContaining({
+          index: 0,
+        }),
+      }),
+      expect.objectContaining({
+        type: BlockAddedMutationType,
+        detail: expect.objectContaining({
+          index: 0,
+        }),
+      }),
+    ]);
+  });
+
+  test('should be fired when block is moved', async ({ page }) => {
+    await createEditor(page, {
+      blocks: [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'first block',
+          },
+        },
+        {
+          type: 'paragraph',
+          data: {
+            text: 'second block',
+          },
+        },
+      ],
+    });
+
+    await openBlockSettings(page, 1);
+
+    const moveUpOption = page.locator(`${EDITOR_INTERFACE_SELECTOR} [data-item-name=move-up]`);
+
+    await moveUpOption.click();
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ event ] = await getOnChangeCalls(page);
+    const singleEvent = ensureSerializedBlockMutationEvent(event);
+
+    expect(singleEvent).toStrictEqual(expect.objectContaining({
+      type: BlockMovedMutationType,
+      detail: expect.objectContaining({
+        fromIndex: 1,
+        toIndex: 0,
+      }),
+    }));
+  });
+
+  test('should be fired if something changed inside native input', async ({ page }) => {
+    await page.addScriptTag({ path: CODE_TOOL_UMD_PATH });
+
+    await createEditor(page, {
+      tools: [
+        {
+          name: 'code',
+          className: 'CodeTool',
+        },
+      ],
+      blocks: [
+        {
+          type: 'code',
+          data: {
+            code: '',
+          },
+        },
+      ],
+    });
+
+    const textarea = page.locator(`${EDITOR_INTERFACE_SELECTOR} textarea`);
+
+    await textarea.click();
+    await textarea.type('Some input to the textarea');
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ event ] = await getOnChangeCalls(page);
+    const singleEvent = ensureSerializedBlockMutationEvent(event);
+
+    expect(singleEvent).toStrictEqual(expect.objectContaining({
+      type: BlockChangedMutationType,
+      detail: expect.objectContaining({
+        index: 0,
+      }),
+    }));
+  });
+
+  test('should not be fired on fake cursor adding and removing', async ({ page }) => {
+    await createEditor(page, {
+      blocks: [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'some text',
+          },
+        },
+      ],
+    });
+
+    const block = page.locator(`${BLOCK_SELECTOR}:first-of-type`);
+
+    await block.click();
+
+    await openBlockSettings(page, 0);
+
+    await block.click();
+
+    await waitForBatchProcessing(page);
+
+    const calls = await getOnChangeCalls(page);
+
+    expect(calls).toHaveLength(0);
+  });
+
+  test('should be fired when the whole text inside block is removed', async ({ page }) => {
+    await createEditor(page, {
+      blocks: [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'a',
+          },
+        },
+      ],
+    });
+
+    const block = page.locator(`${BLOCK_SELECTOR}:first-of-type`);
+
+    await block.click();
+    await page.keyboard.press('Backspace');
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ event ] = await getOnChangeCalls(page);
+    const singleEvent = ensureSerializedBlockMutationEvent(event);
+
+    expect(singleEvent).toStrictEqual(expect.objectContaining({
+      type: BlockChangedMutationType,
+      detail: expect.objectContaining({
+        index: 0,
+      }),
+    }));
+  });
+
+  test('should not be fired when element with the "data-mutation-free" mark changes some attribute', async ({ page }) => {
+    await page.evaluate(() => {
+      const toolWrapper = document.createElement('div');
+
+      toolWrapper.dataset.mutationFree = 'true';
+
+      const windowTestState = window as unknown as Window & WindowTestState;
+
+      windowTestState.__testToolWrapper = toolWrapper;
+    });
+
+    const toolClassCode = `
+      (() => {
+        return class ToolWithMutationFreeAttribute {
+          render() {
+            return window.__testToolWrapper;
+          }
+          save() {
+            return {};
+          }
+        };
+      })()
+    `;
+
+    await createEditor(page, {
+      tools: [
+        {
+          name: 'testTool',
+          classCode: toolClassCode,
+        },
+      ],
+      blocks: [
+        {
+          type: 'testTool',
+          data: {},
+        },
+      ],
+    });
+
+    await waitForDelay(page, 100);
+
+    await page.evaluate(() => {
+      const windowTestState = window as unknown as Window & WindowTestState;
+
+      windowTestState.__testToolWrapper?.setAttribute('some-changed-attr', 'some-new-value');
+    });
+
+    await waitForBatchProcessing(page);
+
+    const calls = await getOnChangeCalls(page);
+
+    expect(calls).toHaveLength(0);
+  });
+
+  test('should not be fired when mutation happened in a child of element with the "data-mutation-free" mark', async ({ page }) => {
+    await page.evaluate(() => {
+      const toolWrapper = document.createElement('div');
+      const child = document.createElement('div');
+
+      toolWrapper.dataset.mutationFree = 'true';
+      toolWrapper.appendChild(child);
+
+      const windowTestState = window as unknown as Window & WindowTestState;
+
+      windowTestState.__testToolWrapper = toolWrapper;
+      windowTestState.__testToolChild = child;
+    });
+
+    const toolClassCode = `
+      (() => {
+        return class ToolWithMutationFreeAttribute {
+          render() {
+            return window.__testToolWrapper;
+          }
+          save() {
+            return {};
+          }
+        };
+      })()
+    `;
+
+    await createEditor(page, {
+      tools: [
+        {
+          name: 'testTool',
+          classCode: toolClassCode,
+        },
+      ],
+      blocks: [
+        {
+          type: 'testTool',
+          data: {},
+        },
+      ],
+    });
+
+    await waitForDelay(page, 100);
+
+    await page.evaluate(() => {
+      const windowTestState = window as unknown as Window & WindowTestState;
+
+      windowTestState.__testToolChild?.setAttribute('some-changed-attr', 'some-new-value');
+    });
+
+    await waitForBatchProcessing(page);
+
+    const calls = await getOnChangeCalls(page);
+
+    expect(calls).toHaveLength(0);
+  });
+
+  test('should not be fired when "characterData" mutation happened in a child of element with the "data-mutation-free" mark', async ({ page }) => {
+    await page.evaluate(() => {
+      const toolWrapper = document.createElement('div');
+      const child = document.createElement('div');
+
+      child.setAttribute('data-cy', 'tool-child');
+      child.setAttribute('contenteditable', 'true');
+      child.textContent = '';
+
+      toolWrapper.dataset.mutationFree = 'true';
+      toolWrapper.appendChild(child);
+
+      const windowTestState = window as unknown as Window & WindowTestState;
+
+      windowTestState.__testToolWrapper = toolWrapper;
+      windowTestState.__testToolChild = child;
+    });
+
+    const toolClassCode = `
+      (() => {
+        return class ToolWithMutationFreeAttribute {
+          render() {
+            return window.__testToolWrapper;
+          }
+          save() {
+            return {};
+          }
+        };
+      })()
+    `;
+
+    await createEditor(page, {
+      tools: [
+        {
+          name: 'testTool',
+          classCode: toolClassCode,
+        },
+      ],
+      blocks: [
+        {
+          type: 'testTool',
+          data: {},
+        },
+      ],
+    });
+
+    const child = page.locator('[data-cy=tool-child]');
+
+    await child.click();
+    await child.type('some text');
+
+    await waitForBatchProcessing(page);
+
+    const calls = await getOnChangeCalls(page);
+
+    expect(calls).toHaveLength(0);
+  });
+
+  test('should be called on blocks.clear() with removed and added blocks', async ({ page }) => {
+    await createEditor(page, {
+      blocks: [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'The first paragraph',
+          },
+        },
+        {
+          type: 'paragraph',
+          data: {
+            text: 'The second paragraph',
+          },
+        },
+      ],
+    });
+
+    await page.evaluate(async () => {
+      if (!window.editorInstance) {
+        throw new Error('Editor instance not found');
+      }
+
+      await window.editorInstance.blocks.clear();
+    });
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ events ] = await getOnChangeCalls(page);
+    const eventsBatch = ensureSerializedBlockMutationEvents(events);
+
+    expect(eventsBatch).toStrictEqual([
+      expect.objectContaining({
+        type: BlockRemovedMutationType,
+      }),
+      expect.objectContaining({
+        type: BlockRemovedMutationType,
+      }),
+      expect.objectContaining({
+        type: BlockAddedMutationType,
+      }),
+    ]);
+  });
+
+  test('should not be called on blocks.render() on non-empty editor', async ({ page }) => {
+    await createEditor(page, {
+      blocks: [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'The first paragraph',
+          },
+        },
+        {
+          type: 'paragraph',
+          data: {
+            text: 'The second paragraph',
+          },
+        },
+      ],
+    });
+
+    await page.evaluate(async () => {
+      if (!window.editorInstance) {
+        throw new Error('Editor instance not found');
+      }
+
+      await window.editorInstance.blocks.render({
+        blocks: [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'The new paragraph',
+            },
+          },
+        ],
+      });
+    });
+
+    await waitForBatchProcessing(page);
+
+    const calls = await getOnChangeCalls(page);
+
+    expect(calls).toHaveLength(0);
+  });
+
+  test('should be called on blocks.update() with "block-changed" event', async ({ page }) => {
+    const block = {
+      id: 'bwnFX5LoX7',
+      type: 'paragraph',
+      data: {
+        text: 'The first block mock.',
+      },
+    };
+
+    await createEditor(page, {
+      blocks: [
+        block,
+      ],
+    });
+
+    await page.evaluate(async ({ blockId }) => {
+      if (!window.editorInstance) {
+        throw new Error('Editor instance not found');
+      }
+
+      await window.editorInstance.blocks.update(blockId, {
+        text: 'Updated text',
+      });
+    }, { blockId: block.id });
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ event ] = await getOnChangeCalls(page);
+    const singleEvent = ensureSerializedBlockMutationEvent(event);
+
+    expect(singleEvent).toStrictEqual(expect.objectContaining({
+      type: BlockChangedMutationType,
+      detail: expect.objectContaining({
+        index: 0,
+        target: expect.objectContaining({
+          id: block.id,
+        }),
+      }),
+    }));
+  });
+
+  test('should be fired when the whole text inside some descendant of the block is removed', async ({ page }) => {
+    const toolClassCode = `
+      (() => {
+        return class ToolWithContentEditableDescendant {
+          render() {
+            const contenteditable = document.createElement('div');
+
+            contenteditable.contentEditable = 'true';
+            contenteditable.innerText = 'a';
+            contenteditable.setAttribute('data-cy', 'nested-contenteditable');
+
+            const wrapper = document.createElement('div');
+
+            wrapper.appendChild(contenteditable);
+
+            return wrapper;
+          }
+          save() {
+            return {};
+          }
+        };
+      })()
+    `;
+
+    await createEditor(page, {
+      tools: [
+        {
+          name: 'testTool',
+          classCode: toolClassCode,
+        },
+      ],
+      blocks: [
+        {
+          type: 'testTool',
+          data: {},
+        },
+      ],
+    });
+
+    const nestedContentEditable = page.locator('[data-cy=nested-contenteditable]');
+
+    await nestedContentEditable.click();
+    await nestedContentEditable.clear();
+
+    await waitForOnChangeCallCount(page, 1);
+
+    const [ event ] = await getOnChangeCalls(page);
+    const singleEvent = ensureSerializedBlockMutationEvent(event);
+
+    expect(singleEvent).toStrictEqual(expect.objectContaining({
+      type: BlockChangedMutationType,
+      detail: expect.objectContaining({
+        index: 0,
+      }),
+    }));
+  });
+
+  test('should not be called when editor is initialized with readOnly mode', async ({ page }) => {
+    await createEditor(page, {
+      readOnly: true,
+      blocks: [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'The first paragraph',
+          },
+        },
+      ],
+    });
+
+    await waitForBatchProcessing(page);
+
+    const calls = await getOnChangeCalls(page);
+
+    expect(calls).toHaveLength(0);
+  });
+
+  test('should not be called when editor is switched to and from readOnly mode', async ({ page }) => {
+    await createEditor(page, {
+      blocks: [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'The first paragraph',
+          },
+        },
+      ],
+    });
+
+    await page.evaluate(async () => {
+      if (!window.editorInstance) {
+        throw new Error('Editor instance not found');
+      }
+
+      await window.editorInstance.readOnly.toggle(true);
+    });
+
+    await waitForBatchProcessing(page);
+
+    let calls = await getOnChangeCalls(page);
+
+    expect(calls).toHaveLength(0);
+
+    await page.evaluate(async () => {
+      if (!window.editorInstance) {
+        throw new Error('Editor instance not found');
+      }
+
+      await window.editorInstance.readOnly.toggle(false);
+    });
+
+    await waitForBatchProcessing(page);
+
+    calls = await getOnChangeCalls(page);
+
+    expect(calls).toHaveLength(0);
+  });
+});
+
+
diff --git a/test/playwright/tests/sanitisation.spec.ts b/test/playwright/tests/sanitisation.spec.ts
new file mode 100644
index 000000000..30b6b8d8b
--- /dev/null
+++ b/test/playwright/tests/sanitisation.spec.ts
@@ -0,0 +1,1202 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { OutputData } from '@/types';
+import { ensureEditorBundleBuilt } from './helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const INITIAL_BLOCK_ID = 'sanitisation-initial-block';
+
+const getBlockById = (page: Page, blockId: string): Locator => {
+  return page.locator(`${EDITOR_INTERFACE_SELECTOR} [data-id="${blockId}"]`);
+};
+
+const getParagraphByBlockId = (page: Page, blockId: string): Locator => {
+  return getBlockById(page, blockId).locator('.ce-paragraph');
+};
+
+/**
+ * Reset the editor holder and destroy any existing instance
+ *
+ * @param page - The Playwright page object
+ */
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ * Create editor with provided blocks
+ *
+ * @param page - The Playwright page object
+ * @param blocks - The blocks data to initialize the editor with
+ */
+const createEditorWithBlocks = async (page: Page, blocks: OutputData['blocks']): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, blocks: editorBlocks }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+      data: { blocks: editorBlocks },
+      tools: {
+        paragraph: {
+          config: {
+            preserveBlank: true,
+          },
+        },
+      },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID,
+    blocks });
+};
+
+/**
+ * Create editor with empty config
+ *
+ * @param page - The Playwright page object
+ */
+const createEditor = async (page: Page): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, initialBlockId }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+      data: {
+        blocks: [
+          {
+            id: initialBlockId,
+            type: 'paragraph',
+            data: {
+              text: '',
+            },
+          },
+        ],
+      },
+      tools: {
+        paragraph: {
+          config: {
+            preserveBlank: true,
+          },
+        },
+      },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID,
+    initialBlockId: INITIAL_BLOCK_ID });
+};
+
+/**
+ * Save editor data
+ *
+ * @param page - The Playwright page object
+ * @returns The saved output data
+ */
+const saveEditor = async (page: Page): Promise<OutputData> => {
+  return await page.evaluate<OutputData>(async () => {
+    if (!window.editorInstance) {
+      throw new Error('Editor instance not found');
+    }
+
+    return await window.editorInstance.save();
+  });
+};
+
+/**
+ * Simulate paste event with clipboard data
+ *
+ * @param page - The Playwright page object
+ * @param locator - The locator for the element to paste into
+ * @param data - Map with MIME type as key and data as value
+ */
+const paste = async (page: Page, locator: Locator, data: Record<string, string>): Promise<void> => {
+  await locator.evaluate((element: HTMLElement, pasteData: Record<string, string>) => {
+    const pasteEvent = Object.assign(new Event('paste', {
+      bubbles: true,
+      cancelable: true,
+    }), {
+      clipboardData: {
+        getData: (type: string): string => pasteData[type] ?? '',
+        types: Object.keys(pasteData),
+      },
+    });
+
+    element.dispatchEvent(pasteEvent);
+  }, data);
+
+  // Wait for paste processing to complete
+  // Some tools (paragraph) could have async hydration
+  // The editor is already ready, so we just wait a brief moment for processing
+  await page.evaluate(() => new Promise((resolve) => {
+    setTimeout(resolve, 200);
+  }));
+};
+
+/**
+ * Select all text in a block
+ *
+ * @param locator - The locator for the block element
+ */
+const selectAllText = async (locator: Locator): Promise<void> => {
+  await locator.evaluate((element) => {
+    const el = element as HTMLElement;
+    const doc = el.ownerDocument;
+    const range = doc.createRange();
+    const selection = doc.getSelection();
+
+    if (!selection) {
+      throw new Error('Selection not available');
+    }
+
+    const walker = doc.createTreeWalker(el, NodeFilter.SHOW_TEXT);
+    const textNodes: Node[] = [];
+
+    while (walker.nextNode()) {
+      textNodes.push(walker.currentNode);
+    }
+
+    if (textNodes.length === 0) {
+      throw new Error('Nothing to select');
+    }
+
+    const startNode = textNodes[0];
+    const endNode = textNodes[textNodes.length - 1];
+    const endOffset = endNode.textContent?.length ?? 0;
+
+    range.setStart(startNode, 0);
+    range.setEnd(endNode, endOffset);
+
+    selection.removeAllRanges();
+    selection.addRange(range);
+    doc.dispatchEvent(new Event('selectionchange'));
+  });
+};
+
+/**
+ * Create editor with custom sanitizer config
+ *
+ * @param page - The Playwright page object
+ * @param sanitizerConfig - Custom sanitizer configuration
+ */
+const createEditorWithSanitizer = async (page: Page, sanitizerConfig: Record<string, unknown>): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(async ({ holderId, sanitizer }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+      sanitizer,
+      tools: {
+        paragraph: {
+          config: {
+            preserveBlank: true,
+          },
+        },
+      },
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID,
+    sanitizer: sanitizerConfig });
+};
+
+test.describe('sanitizing', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test.describe('output should save inline formatting', () => {
+    test('should save initial formatting for paragraph', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<strong>Bold text</strong>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+
+      expect(output.blocks[0].data.text).toBe('<strong>Bold text</strong>');
+    });
+
+    test('should save formatting for paragraph', async ({ page }) => {
+      await createEditor(page);
+
+      const block = getBlockById(page, INITIAL_BLOCK_ID);
+
+      await block.click();
+      await block.type('This text should be bold.');
+
+      // Select all text
+      await selectAllText(block);
+
+      // Click bold button
+      const boldButton = page.locator(`${EDITOR_INTERFACE_SELECTOR} [data-item-name="bold"]`);
+
+      await boldButton.click();
+
+      // Click block to deselect
+      await block.click();
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toMatch(/<strong>This text should be bold\.(<br>)?<\/strong>/);
+    });
+
+    test('should save formatting for paragraph on paste', async ({ page }) => {
+      await createEditor(page);
+
+      const block = getBlockById(page, INITIAL_BLOCK_ID);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<p>Text</p><p><strong>Bold text</strong></p>',
+      });
+
+      const output = await saveEditor(page);
+
+      expect(output.blocks[1].data.text).toBe('<strong>Bold text</strong>');
+    });
+  });
+
+  test('should sanitize unwanted html on blocks merging', async ({ page }) => {
+    await createEditorWithBlocks(page, [
+      {
+        id: 'block1',
+        type: 'paragraph',
+        data: {
+          text: 'First block',
+        },
+      },
+      {
+        id: 'paragraph',
+        type: 'paragraph',
+        data: {
+          /**
+           * Tool does not support spans in its sanitization config
+           */
+          text: 'Second <span id="taint-html">XSS<span> block',
+        },
+      },
+    ]);
+
+    const lastParagraph = getParagraphByBlockId(page, 'paragraph');
+
+    await lastParagraph.click();
+    await page.keyboard.press('Home');
+    await page.keyboard.press('Backspace');
+
+    const { blocks } = await saveEditor(page);
+
+    // text has been merged, span has been removed
+    expect(blocks[0].data.text).toBe('First blockSecond XSS block');
+  });
+
+  test.describe('other inline tools', () => {
+    test('should save italic formatting', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<i>Italic text</i>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+
+      expect(output.blocks[0].data.text).toBe('<i>Italic text</i>');
+    });
+
+    test('should save italic formatting applied via toolbar', async ({ page }) => {
+      await createEditor(page);
+
+      const block = getBlockById(page, INITIAL_BLOCK_ID);
+
+      await block.click();
+      await block.type('This text should be italic.');
+
+      await selectAllText(block);
+
+      const italicButton = page.locator(`${EDITOR_INTERFACE_SELECTOR} [data-item-name="italic"]`);
+
+      await italicButton.click();
+      await block.click();
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toMatch(/<i>This text should be italic\.(<br>)?<\/i>/);
+    });
+
+    test('should save link formatting with href attribute', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<a href="https://example.com">Link text</a>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+
+      expect(output.blocks[0].data.text).toContain('<a href="https://example.com">');
+      expect(output.blocks[0].data.text).toContain('Link text');
+    });
+
+    test('should save link formatting applied via toolbar', async ({ page }) => {
+      await createEditor(page);
+
+      const block = getBlockById(page, INITIAL_BLOCK_ID);
+
+      await block.click();
+      await block.type('Link text');
+
+      await selectAllText(block);
+
+      const linkButton = page.locator(`${EDITOR_INTERFACE_SELECTOR} [data-item-name="link"]`);
+
+      await linkButton.click();
+
+      const linkInput = page.locator('input[data-link-tool-input-opened]');
+
+      await linkInput.fill('https://example.com');
+      await linkInput.press('Enter');
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toMatch(/<a href="https:\/\/example\.com"[^>]*>Link text<\/a>/);
+    });
+  });
+
+  test.describe('attribute sanitization', () => {
+    test('should strip unwanted attributes from links', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<a href="https://example.com" onclick="alert(1)" style="color:red" id="malicious">Link</a>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toContain('href="https://example.com"');
+      expect(text).not.toContain('onclick');
+      expect(text).not.toContain('style');
+      expect(text).not.toContain('id="malicious"');
+    });
+
+    test('should preserve allowed link attributes', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<a href="https://example.com" target="_blank" rel="nofollow">Link</a>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toContain('href="https://example.com"');
+      expect(text).toContain('target="_blank"');
+      expect(text).toContain('rel="nofollow"');
+    });
+
+    test('should strip attributes while keeping tags when rule is false', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<strong style="color:red" onclick="alert(1)">Bold</strong>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toContain('<strong>');
+      expect(text).toContain('Bold');
+      expect(text).not.toContain('style');
+      expect(text).not.toContain('onclick');
+    });
+  });
+
+  test.describe('xSS prevention', () => {
+    test('should remove script tags', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: 'Text<script>alert("XSS")</script>More text' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+
+      expect(output.blocks[0].data.text).not.toContain('<script>');
+      expect(output.blocks[0].data.text).not.toContain('alert');
+      expect(output.blocks[0].data.text).toBe('TextMore text');
+    });
+
+    test('should remove event handlers', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<strong onclick="alert(1)" onerror="alert(2)" onload="alert(3)">Bold</strong>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).not.toContain('onclick');
+      expect(text).not.toContain('onerror');
+      expect(text).not.toContain('onload');
+      expect(text).toContain('<strong>');
+    });
+
+    test('should remove javascript: URLs', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<a href="javascript:alert(1)">Link</a>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      // The link should be removed or href should be sanitized
+      expect(text).not.toContain('javascript:');
+    });
+
+    test('should remove data: URLs with scripts', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<img src="data:text/html,<script>alert(1)</script>" />' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).not.toContain('data:text/html');
+      expect(text).not.toContain('<script>');
+    });
+
+    test('should remove style attributes with expressions', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<span style="expression(alert(1))">Text</span>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).not.toContain('style');
+      expect(text).not.toContain('expression');
+    });
+
+    test('should remove malicious attributes', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<strong onmouseover="alert(1)" onfocus="alert(2)">Bold</strong>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).not.toContain('onmouseover');
+      expect(text).not.toContain('onfocus');
+    });
+  });
+
+  test.describe('nested HTML structures', () => {
+    test('should save nested formatting (bold inside italic)', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<i>Italic <strong>and bold</strong> text</i>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+
+      expect(output.blocks[0].data.text).toContain('<i>');
+      expect(output.blocks[0].data.text).toContain('<strong>');
+      expect(output.blocks[0].data.text).toContain('and bold');
+    });
+
+    test('should save multiple levels of nesting', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<strong>Bold <i>italic <a href="https://example.com">link</a></i></strong>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toContain('<strong>');
+      expect(text).toContain('<i>');
+      expect(text).toContain('<a href="https://example.com">');
+      expect(text).toContain('link');
+    });
+
+    test('should sanitize nested unwanted tags', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<strong>Bold <span id="bad">bad</span> text</strong>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toContain('<strong>');
+      expect(text).not.toContain('<span>');
+      expect(text).toContain('bad');
+    });
+  });
+
+  test.describe('edge cases', () => {
+    test('should handle empty sanitization config', async ({ page }) => {
+      await createEditorWithSanitizer(page, {});
+
+      await page.evaluate(async () => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        window.editorInstance.blocks.insert('paragraph', {
+          text: '<strong>Bold</strong> <i>italic</i>',
+        });
+
+        // Wait for block to be rendered
+        await new Promise((resolve) => {
+          setTimeout(resolve, 100);
+        });
+      });
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      // With empty config, all HTML should be preserved
+      expect(text).toContain('<strong>Bold</strong> <i>italic</i>');
+    });
+
+    test('should handle empty string', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+
+      expect(output.blocks[0].data.text).toBe('');
+    });
+
+    test('should handle whitespace-only content', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '   \n\t  ' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+
+      expect(output.blocks[0].data.text).toBeTruthy();
+    });
+
+    test('should handle HTML entities', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          type: 'paragraph',
+          data: { text: '<strong>&lt;script&gt;</strong>' },
+        },
+      ]);
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toContain('<strong>');
+      // Entities should be preserved or decoded appropriately
+      expect(text).toContain('script');
+    });
+  });
+
+  test.describe('editor-level sanitizer config', () => {
+    test('should apply custom sanitizer config', async ({ page }) => {
+      await createEditorWithSanitizer(page, {
+        b: true,
+        i: true,
+        // No 'strong' or 'a' tags allowed
+      });
+
+      await page.evaluate(async () => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        window.editorInstance.blocks.insert('paragraph', {
+          text: '<b>Bold</b> <i>italic</i> <strong>strong</strong> <a href="#">link</a>',
+        });
+
+        // Wait for block to be rendered
+        await new Promise((resolve) => {
+          setTimeout(resolve, 100);
+        });
+      });
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toContain('<b>');
+      expect(text).toContain('<i>');
+      expect(text).not.toContain('<strong>');
+      expect(text).not.toContain('<a>');
+    });
+
+    test('should override tool-level sanitization', async ({ page }) => {
+      await createEditorWithSanitizer(page, {
+        span: true,
+        div: true,
+      });
+
+      await page.evaluate(async () => {
+        if (!window.editorInstance) {
+          throw new Error('Editor instance not found');
+        }
+
+        window.editorInstance.blocks.insert('paragraph', {
+          text: '<span>Span</span> <div>Div</div>',
+        });
+
+        // Wait for block to be rendered
+        await new Promise((resolve) => {
+          setTimeout(resolve, 100);
+        });
+      });
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      // Custom config should allow span and div
+      expect(text).toContain('<span>');
+      expect(text).toContain('<div>');
+    });
+  });
+
+  test.describe('block merging edge cases', () => {
+    test('should sanitize when merging blocks with different configs', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          id: 'block1',
+          type: 'paragraph',
+          data: {
+            text: 'First block',
+          },
+        },
+        {
+          id: 'block2',
+          type: 'paragraph',
+          data: {
+            text: 'Second <span id="taint">block</span>',
+          },
+        },
+      ]);
+
+      const lastParagraph = getParagraphByBlockId(page, 'block2');
+
+      await lastParagraph.click();
+      await page.keyboard.press('Home');
+      await page.keyboard.press('Backspace');
+
+      const { blocks } = await saveEditor(page);
+
+      expect(blocks[0].data.text).toBe('First blockSecond block');
+      expect(blocks[0].data.text).not.toContain('<span>');
+    });
+
+    test('should sanitize nested structures when merging', async ({ page }) => {
+      await createEditorWithBlocks(page, [
+        {
+          id: 'block1',
+          type: 'paragraph',
+          data: {
+            text: '<strong>First</strong>',
+          },
+        },
+        {
+          id: 'block2',
+          type: 'paragraph',
+          data: {
+            text: '<strong>Second <span>bad</span></strong>',
+          },
+        },
+      ]);
+
+      const lastParagraph = getParagraphByBlockId(page, 'block2');
+
+      await lastParagraph.click();
+      await page.keyboard.press('Home');
+      await page.keyboard.press('Backspace');
+
+      const { blocks } = await saveEditor(page);
+      const text = blocks[0].data.text;
+
+      expect(text).toContain('<strong>');
+      expect(text).not.toContain('<span>');
+      expect(text).toContain('bad');
+    });
+  });
+
+  test.describe('paste sanitization', () => {
+    test('should sanitize malicious content on paste', async ({ page }) => {
+      await createEditor(page);
+
+      const block = getBlockById(page, INITIAL_BLOCK_ID);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<p>Text<script>alert("XSS")</script></p>',
+      });
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).not.toContain('<script>');
+      expect(text).not.toContain('alert');
+    });
+
+    test('should sanitize mixed allowed/disallowed tags on paste', async ({ page }) => {
+      await createEditor(page);
+
+      const block = getBlockById(page, INITIAL_BLOCK_ID);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<p><strong>Bold</strong> <span id="bad">bad</span> <i>italic</i></p>',
+      });
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toContain('<strong>');
+      expect(text).toContain('<i>');
+      expect(text).not.toContain('<span>');
+      expect(text).toContain('bad');
+    });
+
+    test('should sanitize nested structures on paste', async ({ page }) => {
+      await createEditor(page);
+
+      const block = getBlockById(page, INITIAL_BLOCK_ID);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<p><strong>Bold <span>nested</span></strong></p>',
+      });
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toContain('<strong>');
+      expect(text).not.toContain('<span>');
+      expect(text).toContain('nested');
+    });
+
+    test('should sanitize event handlers on paste', async ({ page }) => {
+      await createEditor(page);
+
+      const block = getBlockById(page, INITIAL_BLOCK_ID);
+
+      await block.click();
+      await paste(page, block, {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        'text/html': '<p><strong onclick="alert(1)">Bold</strong></p>',
+      });
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toContain('<strong>');
+      expect(text).not.toContain('onclick');
+    });
+  });
+
+  test.describe('deep sanitization', () => {
+    test('should sanitize nested objects with HTML strings', async ({ page }) => {
+      await resetEditor(page);
+
+      await page.evaluate(async ({ holderId }) => {
+        /**
+         * Custom tool with nested data structure
+         */
+        class CustomTool {
+          public static toolbox = {
+            icon: 'C',
+            title: 'Custom',
+          };
+
+          public static sanitize = {
+            text: {
+              strong: {},
+            },
+            items: {
+              strong: {},
+            },
+          };
+
+          private data: { text: string; items: Array<{ content: string }> };
+
+          /**
+           * @param data - tool data
+           */
+          constructor({ data }: { data: { text: string; items: Array<{ content: string }> } }) {
+            this.data = data;
+          }
+
+          /**
+           * Render tool content
+           */
+          public render(): HTMLElement {
+            const wrapper = document.createElement('div');
+
+            wrapper.innerHTML = this.data.text;
+
+            return wrapper;
+          }
+
+          /**
+           * Save tool data
+           */
+          public save(): { text: string; items: Array<{ content: string }> } {
+            return this.data;
+          }
+        }
+
+        const editor = new window.EditorJS({
+          holder: holderId,
+          tools: {
+            custom: CustomTool,
+          },
+          data: {
+            blocks: [
+              {
+                type: 'custom',
+                data: {
+                  text: '<strong>Bold</strong> <span>bad</span>',
+                  items: [
+                    { content: '<strong>Item</strong> <span>bad</span>' },
+                  ],
+                },
+              },
+            ],
+          },
+        });
+
+        window.editorInstance = editor;
+        await editor.isReady;
+      }, { holderId: HOLDER_ID });
+
+      const output = await saveEditor(page);
+      const blockData = output.blocks[0].data;
+
+      expect(blockData.text).toContain('<strong>');
+      expect(blockData.text).not.toContain('<span>');
+      expect(blockData.items[0].content).toContain('<strong>');
+      expect(blockData.items[0].content).not.toContain('<span>');
+    });
+
+    test('should sanitize arrays containing HTML strings', async ({ page }) => {
+      await resetEditor(page);
+
+      await page.evaluate(async ({ holderId }) => {
+        /**
+         * Custom tool with array data structure
+         */
+        class CustomTool {
+          public static toolbox = {
+            icon: 'C',
+            title: 'Custom',
+          };
+
+          public static sanitize = {
+            items: {
+              strong: {},
+            },
+          };
+
+          private data: { items: string[] };
+
+          /**
+           * @param data - tool data
+           */
+          constructor({ data }: { data: { items: string[] } }) {
+            this.data = data;
+          }
+
+          /**
+           * Render tool content
+           */
+          public render(): HTMLElement {
+            const wrapper = document.createElement('div');
+
+            wrapper.innerHTML = this.data.items.join('');
+
+            return wrapper;
+          }
+
+          /**
+           * Save tool data
+           */
+          public save(): { items: string[] } {
+            return this.data;
+          }
+        }
+
+        const editor = new window.EditorJS({
+          holder: holderId,
+          tools: {
+            custom: CustomTool,
+          },
+          data: {
+            blocks: [
+              {
+                type: 'custom',
+                data: {
+                  items: [
+                    '<strong>Bold</strong>',
+                    '<span>bad</span>',
+                    '<i>italic</i>',
+                  ],
+                },
+              },
+            ],
+          },
+        });
+
+        window.editorInstance = editor;
+        await editor.isReady;
+      }, { holderId: HOLDER_ID });
+
+      const output = await saveEditor(page);
+      const blockData = output.blocks[0].data;
+
+      expect(blockData.items[0]).toContain('<strong>');
+      expect(blockData.items[1]).not.toContain('<span>');
+      expect(blockData.items[2]).not.toContain('<i>'); // Not in sanitize config
+    });
+  });
+
+  test.describe('function-based sanitization rules', () => {
+    test('should apply function-based sanitization rules', async ({ page }) => {
+      await resetEditor(page);
+
+      await page.evaluate(async ({ holderId }) => {
+        /**
+         * Custom tool with function-based sanitization
+         */
+        class CustomTool {
+          public static toolbox = {
+            icon: 'C',
+            title: 'Custom',
+          };
+
+          public static sanitize = {
+            text: {
+              a: (el: Element) => {
+                const href = el.getAttribute('href');
+
+                if (href && href.startsWith('http')) {
+                  return {
+                    href: true,
+                    target: '_blank',
+                  };
+                }
+
+                return {
+                  href: true,
+                };
+              },
+            },
+          };
+
+          private data: { text: string };
+
+          /**
+           * @param data - tool data
+           */
+          constructor({ data }: { data: { text: string } }) {
+            this.data = data;
+          }
+
+          /**
+           * Render tool content
+           */
+          public render(): HTMLElement {
+            const wrapper = document.createElement('div');
+
+            wrapper.innerHTML = this.data.text;
+
+            return wrapper;
+          }
+
+          /**
+           * Save tool data
+           */
+          public save(): { text: string } {
+            return this.data;
+          }
+        }
+
+        const editor = new window.EditorJS({
+          holder: holderId,
+          tools: {
+            custom: CustomTool,
+          },
+          data: {
+            blocks: [
+              {
+                type: 'custom',
+                data: {
+                  text: '<a href="https://example.com">HTTP link</a> <a href="javascript:alert(1)">JS link</a>',
+                },
+              },
+            ],
+          },
+        });
+
+        window.editorInstance = editor;
+        await editor.isReady;
+      }, { holderId: HOLDER_ID });
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toContain('href="https://example.com"');
+      expect(text).toContain('target="_blank"');
+      // javascript: links should be handled by sanitizer
+      expect(text).not.toContain('javascript:');
+    });
+
+    test('should apply conditional sanitization based on content', async ({ page }) => {
+      await resetEditor(page);
+
+      await page.evaluate(async ({ holderId }) => {
+        /**
+         * Custom tool with conditional sanitization
+         */
+        class CustomTool {
+          public static toolbox = {
+            icon: 'C',
+            title: 'Custom',
+          };
+
+          public static sanitize = {
+            text: {
+              strong: (el: Element) => {
+                // Only allow strong tags that are not empty
+                return el.textContent !== '';
+              },
+            },
+          };
+
+          private data: { text: string };
+
+          /**
+           * @param data - tool data
+           */
+          constructor({ data }: { data: { text: string } }) {
+            this.data = data;
+          }
+
+          /**
+           * Render tool content
+           */
+          public render(): HTMLElement {
+            const wrapper = document.createElement('div');
+
+            wrapper.innerHTML = this.data.text;
+
+            return wrapper;
+          }
+
+          /**
+           * Save tool data
+           */
+          public save(): { text: string } {
+            return this.data;
+          }
+        }
+
+        const editor = new window.EditorJS({
+          holder: holderId,
+          tools: {
+            custom: CustomTool,
+          },
+          data: {
+            blocks: [
+              {
+                type: 'custom',
+                data: {
+                  text: '<strong>Valid</strong> <strong></strong>',
+                },
+              },
+            ],
+          },
+        });
+
+        window.editorInstance = editor;
+        await editor.isReady;
+      }, { holderId: HOLDER_ID });
+
+      const output = await saveEditor(page);
+      const text = output.blocks[0].data.text;
+
+      expect(text).toContain('<strong>Valid</strong>');
+      // Empty strong should be removed
+      expect(text).not.toContain('<strong></strong>');
+    });
+  });
+});
+
diff --git a/test/playwright/tests/tools/block-tool.spec.ts b/test/playwright/tests/tools/block-tool.spec.ts
new file mode 100644
index 000000000..7f7166d64
--- /dev/null
+++ b/test/playwright/tests/tools/block-tool.spec.ts
@@ -0,0 +1,957 @@
+import { expect, test } from '@playwright/test';
+import type {
+  API,
+  BlockToolConstructable,
+  BlockToolConstructorOptions,
+  BlockToolData,
+  InlineToolConstructable,
+  SanitizerConfig,
+  ToolboxConfigEntry
+} from '../../../../types';
+import { ToolType } from '../../../../types/tools/adapters/tool-type';
+import BlockToolAdapter from '../../../../src/components/tools/block';
+import InlineToolAdapter from '../../../../src/components/tools/inline';
+import ToolsCollection from '../../../../src/components/tools/collection';
+
+type BlockToolAdapterOptions = ConstructorParameters<typeof BlockToolAdapter>[0];
+type InlineToolAdapterOptions = ConstructorParameters<typeof InlineToolAdapter>[0];
+
+type ToolUserConfig = {
+  option1?: string;
+  option2?: string;
+  placeholder?: string;
+  [key: string]: unknown;
+};
+
+type BlockToolOptionsOverride = Partial<Omit<BlockToolAdapterOptions, 'config'>> & {
+  config?: Partial<BlockToolAdapterOptions['config']> & {
+    config?: ToolUserConfig;
+  };
+};
+
+type InlineToolOptionsOverride = Partial<Omit<InlineToolAdapterOptions, 'config'>> & {
+  config?: Partial<InlineToolAdapterOptions['config']>;
+};
+
+type BlockToolCtorOptions = BlockToolConstructorOptions<{ text: string }, ToolUserConfig>;
+
+type Mock<Args extends unknown[] = [], Result = void> = {
+  fn: (...args: Args) => Result;
+  calls: Args[];
+};
+
+type BlockToolStubInstance = {
+  data: BlockToolData<{ text: string }>;
+  block: BlockToolCtorOptions['block'];
+  ['readonly']: boolean;
+  api: API;
+  config: ToolUserConfig;
+};
+
+type BlockToolConstructableWithOptionalDisabling = BlockToolConstructable & {
+  toolbox?: ToolboxConfigEntry | ToolboxConfigEntry[] | false;
+  pasteConfig?: BlockToolConstructable['pasteConfig'] | false;
+};
+
+/**
+ * Determines whether provided constructable exposes Block Tool capabilities.
+ *
+ * @param constructable - Tool constructable candidate.
+ */
+const isBlockToolConstructable = (
+  constructable: BlockToolAdapterOptions['constructable']
+): constructable is BlockToolConstructableWithOptionalDisabling => (
+  typeof constructable === 'function' && typeof constructable.prototype?.render === 'function'
+);
+
+/**
+ * Ensures constructable implements the Block Tool interface or throws.
+ *
+ * @param constructable - Tool constructable candidate.
+ */
+const ensureBlockToolConstructable = (
+  constructable: BlockToolAdapterOptions['constructable']
+): BlockToolConstructableWithOptionalDisabling => {
+  if (!isBlockToolConstructable(constructable)) {
+    throw new Error('Expected block tool constructable for this test scenario');
+  }
+
+  return constructable;
+};
+
+/**
+ * Determines whether the supplied instance matches the block tool stub shape.
+ *
+ * @param instance - Value to test.
+ */
+const isBlockToolStubInstance = (instance: unknown): instance is BlockToolStubInstance => {
+  if (!instance || typeof instance !== 'object') {
+    return false;
+  }
+
+  const candidate = instance as Partial<BlockToolStubInstance>;
+
+  return !(
+    candidate.data === undefined ||
+    candidate.block === undefined ||
+    candidate.api === undefined ||
+    candidate.config === undefined ||
+    candidate['readonly'] === undefined
+  );
+};
+
+/**
+ * Coerces a value to a block tool stub instance or throws.
+ *
+ * @param instance - Value to assert.
+ */
+const ensureBlockToolStubInstance = (instance: unknown): BlockToolStubInstance => {
+  if (!isBlockToolStubInstance(instance)) {
+    throw new Error('Received value is not a block tool stub instance');
+  }
+
+  return instance;
+};
+
+/**
+ * Creates a simple mock function that records every call.
+ *
+ * @param implementation - Optional implementation executed on each invocation.
+ */
+const createMock = <Args extends unknown[] = [], Result = void>(
+  implementation?: (...args: Args) => Result
+): Mock<Args, Result> => {
+  const calls: Args[] = [];
+  const fn = (...args: Args): Result => {
+    calls.push(args);
+
+    if (implementation) {
+      return implementation(...args);
+    }
+
+    return undefined as Result;
+  };
+
+  return {
+    fn,
+    calls,
+  };
+};
+
+/**
+ * Creates a typed stub for the Editor.js API.
+ */
+const createApiStub = (): API => ({
+  blocks: {} as API['blocks'],
+  caret: {} as API['caret'],
+  tools: {} as API['tools'],
+  events: {} as API['events'],
+  listeners: {} as API['listeners'],
+  notifier: {} as API['notifier'],
+  sanitizer: {} as API['sanitizer'],
+  saver: {} as API['saver'],
+  selection: {} as API['selection'],
+  styles: {} as API['styles'],
+  toolbar: {} as API['toolbar'],
+  inlineToolbar: {} as API['inlineToolbar'],
+  tooltip: {} as API['tooltip'],
+  i18n: {} as API['i18n'],
+  readOnly: {} as API['readOnly'],
+  ui: {} as API['ui'],
+});
+
+/**
+ * Provides a constructable block tool stub with predefined static metadata.
+ */
+const createBlockToolConstructable = (): BlockToolConstructable => {
+  /**
+   * Minimal block tool stub used for adapter tests.
+   */
+  class BlockTool {
+    public static sanitize: SanitizerConfig = {
+      rule1: {
+        div: true,
+      },
+    };
+
+    public static toolbox: ToolboxConfigEntry = {
+      icon: 'Tool icon',
+      title: 'Tool title',
+    };
+
+    public static enableLineBreaks = true;
+
+    public static pasteConfig = {
+      tags: [ 'div' ],
+    };
+
+    public static conversionConfig = {
+      import: 'import',
+      export: 'export',
+    };
+
+    public static isReadOnlySupported = true;
+
+    public static reset?: () => void | Promise<void>;
+
+    public static prepare?: (data: { toolName: string; config: ToolUserConfig }) => void | Promise<void>;
+
+    public static shortcut = 'CTRL+N';
+
+    public data: BlockToolData<{ text: string }>;
+
+    public block: BlockToolCtorOptions['block'];
+
+    public ['readonly']: boolean;
+
+    public api: API;
+
+    public config: ToolUserConfig;
+
+    /**
+     * @param options - Block tool constructor options supplied by the adapter.
+     */
+    constructor(options: BlockToolCtorOptions) {
+      const { data, block, readOnly, api, config } = options;
+
+      this.data = data;
+      this.block = block;
+      this.readonly = readOnly;
+      this.api = api;
+      this.config = config ?? {};
+    }
+
+    /**
+     * Returns a placeholder element for compliance with the block tool interface.
+     */
+    public render(): HTMLElement {
+      return {} as HTMLElement;
+    }
+  }
+
+  return BlockTool as unknown as BlockToolConstructable;
+};
+
+/**
+ * Provides a constructable inline tool stub with supplied sanitize config.
+ *
+ * @param sanitize - Sanitize configuration exposed by the inline tool.
+ */
+const createInlineToolConstructable = (
+  sanitize: SanitizerConfig = {}
+): InlineToolConstructable => {
+  /**
+   * Minimal inline tool stub used for adapter tests.
+   */
+  class InlineTool {
+    public static isInline = true;
+
+    public static sanitize: SanitizerConfig = sanitize;
+
+    /**
+     * Returns a placeholder element for compliance with the inline tool interface.
+     */
+    public render(): HTMLElement {
+      return {} as HTMLElement;
+    }
+  }
+
+  return InlineTool as unknown as InlineToolConstructable;
+};
+
+/**
+ * Creates options for instantiating a block tool adapter.
+ *
+ * @param override - Optional overrides applied to the default block tool options.
+ */
+const createBlockToolOptions = (override: BlockToolOptionsOverride = {}): BlockToolAdapterOptions => {
+  const baseUserConfig: ToolUserConfig = {
+    option1: 'option1',
+    option2: 'option2',
+  };
+
+  const overrideConfig = override.config ?? {};
+
+  const mergedConfig = {
+    inlineToolbar: ['link', 'bold'] as BlockToolAdapterOptions['config'] extends { inlineToolbar?: infer T } ? T : string[] | boolean,
+    tunes: ['anchor', 'favorites'] as BlockToolAdapterOptions['config'] extends { tunes?: infer T } ? T : string[] | boolean,
+    shortcut: 'CMD+SHIFT+B',
+    toolbox: {
+      title: 'User Block Tool',
+      icon: 'User icon',
+    } as ToolboxConfigEntry,
+    ...overrideConfig,
+    config: {
+      ...baseUserConfig,
+      ...overrideConfig.config,
+    },
+  } satisfies BlockToolAdapterOptions['config'];
+
+  return {
+    name: override.name ?? 'blockTool',
+    constructable: override.constructable ?? createBlockToolConstructable(),
+    config: mergedConfig,
+    api: override.api ?? createApiStub(),
+    isDefault: override.isDefault ?? false,
+    isInternal: override.isInternal ?? false,
+    defaultPlaceholder: override.defaultPlaceholder ?? 'Default placeholder',
+  };
+};
+
+/**
+ * Creates options for instantiating an inline tool adapter.
+ *
+ * @param override - Optional overrides applied to the default inline tool options.
+ */
+const createInlineToolOptions = (override: InlineToolOptionsOverride = {}): InlineToolAdapterOptions => ({
+  name: override.name ?? 'inlineTool',
+  constructable: override.constructable ?? createInlineToolConstructable(),
+  config: {
+    ...override.config,
+  },
+  api: override.api ?? createApiStub(),
+  isDefault: override.isDefault ?? false,
+  isInternal: override.isInternal ?? false,
+  defaultPlaceholder: override.defaultPlaceholder,
+});
+
+/**
+ * Creates an inline tool adapter with a specific sanitize configuration.
+ *
+ * @param sanitize - Sanitize configuration exposed by the inline tool.
+ * @param name - Tool name used when registering the inline tool.
+ */
+const createInlineToolAdapter = (
+  sanitize: SanitizerConfig,
+  name: string
+): InlineToolAdapter => new InlineToolAdapter(createInlineToolOptions({
+  name,
+  constructable: createInlineToolConstructable(sanitize),
+}));
+
+test.describe('blockToolAdapter', () => {
+  test('.type returns ToolType.Block', () => {
+    const tool = new BlockToolAdapter(createBlockToolOptions());
+
+    expect(tool.type).toBe(ToolType.Block);
+  });
+
+  test('.name returns provided value', () => {
+    const options = createBlockToolOptions();
+    const tool = new BlockToolAdapter(options);
+
+    expect(tool.name).toBe(options.name);
+  });
+
+  test('.isDefault reflects provided flag', () => {
+    const defaultTool = new BlockToolAdapter(createBlockToolOptions());
+    const overriddenTool = new BlockToolAdapter(createBlockToolOptions({ isDefault: true }));
+
+    expect(defaultTool.isDefault).toBe(false);
+    expect(overriddenTool.isDefault).toBe(true);
+  });
+
+  test('.isInternal reflects provided flag', () => {
+    const externalTool = new BlockToolAdapter(createBlockToolOptions());
+    const internalTool = new BlockToolAdapter(createBlockToolOptions({ isInternal: true }));
+
+    expect(externalTool.isInternal).toBe(false);
+    expect(internalTool.isInternal).toBe(true);
+  });
+
+  test.describe('settings', () => {
+    test('returns user configuration', () => {
+      const options = createBlockToolOptions();
+      const tool = new BlockToolAdapter(options);
+
+      expect(tool.settings).toStrictEqual(options.config?.config);
+    });
+
+    test('includes default placeholder when tool is default', () => {
+      const options = createBlockToolOptions({ isDefault: true });
+      const tool = new BlockToolAdapter(options);
+
+      expect(tool.settings).toMatchObject({
+        placeholder: options.defaultPlaceholder,
+      });
+    });
+  });
+
+  test.describe('sanitizeConfig', () => {
+    test('returns constructable sanitize config', () => {
+      const options = createBlockToolOptions();
+      const tool = new BlockToolAdapter(options);
+
+      expect(tool.sanitizeConfig).toStrictEqual(options.constructable.sanitize);
+    });
+
+    test('merges inline tool sanitize config when available', () => {
+      const options = createBlockToolOptions();
+      const tool = new BlockToolAdapter(options);
+
+      const inlineSanitize: SanitizerConfig = {
+        b: true,
+      };
+
+      const inlineTool = createInlineToolAdapter(inlineSanitize, 'inlineTool');
+
+      tool.inlineTools = new ToolsCollection<InlineToolAdapter>([
+        ['inlineTool', inlineTool],
+      ]);
+
+      const expected = Object.fromEntries(
+        Object
+          .entries(options.constructable.sanitize ?? {})
+          .map(([field, rules]) => {
+            if (typeof rules === 'object' && rules !== null) {
+              return [
+                field,
+                {
+                  ...tool.baseSanitizeConfig,
+                  ...rules,
+                },
+              ];
+            }
+
+            return [field, rules];
+          })
+      );
+
+      expect(tool.sanitizeConfig).toStrictEqual(expected);
+    });
+
+    test('returns inline tools config when constructable does not provide sanitize config', () => {
+      const baseOptions = createBlockToolOptions();
+
+      /**
+       * Block tool without sanitize settings for verifying fallback behaviour.
+       */
+      class WithoutSanitize extends (baseOptions.constructable as BlockToolConstructable) {
+        public static override sanitize?: SanitizerConfig;
+      }
+
+      const options = createBlockToolOptions({
+        constructable: WithoutSanitize,
+      });
+
+      const tool = new BlockToolAdapter(options);
+
+      const inlineTool1 = createInlineToolAdapter({
+        b: true,
+      }, 'inlineTool1');
+      const inlineTool2 = createInlineToolAdapter({
+        a: true,
+      }, 'inlineTool2');
+
+      tool.inlineTools = new ToolsCollection<InlineToolAdapter>([
+        ['inlineTool1', inlineTool1],
+        ['inlineTool2', inlineTool2],
+      ]);
+
+      const expected = {
+        ...inlineTool1.sanitizeConfig,
+        ...inlineTool2.sanitizeConfig,
+      };
+
+      expect(tool.sanitizeConfig).toStrictEqual(expected);
+    });
+
+    test('returns empty object when no sanitize config provided', () => {
+      /**
+       * Block tool without sanitize logic to ensure defaults resolve to an empty object.
+       */
+      class RenderOnlyBlockTool {
+        /**
+         * Returns a placeholder element for tests.
+         */
+        public render(): HTMLElement {
+          return {} as HTMLElement;
+        }
+      }
+
+      const options = createBlockToolOptions({
+        constructable: RenderOnlyBlockTool as unknown as BlockToolConstructable,
+      });
+
+      const tool = new BlockToolAdapter(options);
+
+      expect(tool.sanitizeConfig).toStrictEqual({});
+    });
+  });
+
+  test('.isBlock returns true', () => {
+    const tool = new BlockToolAdapter(createBlockToolOptions());
+
+    expect(tool.isBlock()).toBe(true);
+  });
+
+  test('.isInline returns false', () => {
+    const tool = new BlockToolAdapter(createBlockToolOptions());
+
+    expect(tool.isInline()).toBe(false);
+  });
+
+  test('.isTune returns false', () => {
+    const tool = new BlockToolAdapter(createBlockToolOptions());
+
+    expect(tool.isTune()).toBe(false);
+  });
+
+  test('.isReadOnlySupported reflects constructable setting', () => {
+    const options = createBlockToolOptions();
+    const tool = new BlockToolAdapter(options);
+
+    expect(tool.isReadOnlySupported).toBe(true);
+  });
+
+  test('.isLineBreaksEnabled reflects constructable setting', () => {
+    const options = createBlockToolOptions();
+    const tool = new BlockToolAdapter(options);
+
+    expect(tool.isLineBreaksEnabled).toBe(true);
+  });
+
+  test('.conversionConfig returns constructable value', () => {
+    const options = createBlockToolOptions();
+    const tool = new BlockToolAdapter(options);
+    const constructable = ensureBlockToolConstructable(options.constructable);
+
+    expect(tool.conversionConfig).toStrictEqual(constructable.conversionConfig);
+  });
+
+  test.describe('pasteConfig', () => {
+    test('returns constructable paste config', () => {
+      const options = createBlockToolOptions();
+      const tool = new BlockToolAdapter(options);
+      const constructable = ensureBlockToolConstructable(options.constructable);
+
+      expect(tool.pasteConfig).toStrictEqual(constructable.pasteConfig);
+    });
+
+    test('returns false when constructable provides false', () => {
+      const baseOptions = createBlockToolOptions();
+      const baseConstructable = ensureBlockToolConstructable(baseOptions.constructable);
+
+      /**
+       * Block tool stub that explicitly disables paste configuration.
+       */
+      class WithoutPasteConfig extends baseConstructable {
+        public static override pasteConfig: BlockToolConstructableWithOptionalDisabling['pasteConfig'] = false;
+      }
+
+      const tool = new BlockToolAdapter(createBlockToolOptions({
+        constructable: WithoutPasteConfig,
+      }));
+
+      expect(tool.pasteConfig).toBe(false);
+    });
+
+    test('returns empty object when paste config is not provided', () => {
+      const baseOptions = createBlockToolOptions();
+      const baseConstructable = ensureBlockToolConstructable(baseOptions.constructable);
+
+      /**
+       * Block tool stub without any paste configuration.
+       */
+      class UndefinedPasteConfig extends baseConstructable {
+        public static override pasteConfig: BlockToolConstructableWithOptionalDisabling['pasteConfig'] = undefined;
+      }
+
+      const tool = new BlockToolAdapter(createBlockToolOptions({
+        constructable: UndefinedPasteConfig,
+      }));
+
+      expect(tool.pasteConfig).toStrictEqual({});
+    });
+  });
+
+  test.describe('enabledInlineTools', () => {
+    test('returns inline toolbar configuration', () => {
+      const options = createBlockToolOptions();
+      const tool = new BlockToolAdapter(options);
+
+      expect(tool.enabledInlineTools).toStrictEqual(options.config?.inlineToolbar);
+    });
+
+    test('returns false when inline toolbar is not configured', () => {
+      const options = createBlockToolOptions({
+        config: {
+          inlineToolbar: undefined,
+        },
+      });
+      const tool = new BlockToolAdapter(options);
+
+      expect(tool.enabledInlineTools).toBe(false);
+    });
+  });
+
+  test('.enabledBlockTunes returns user configuration', () => {
+    const options = createBlockToolOptions();
+    const tool = new BlockToolAdapter(options);
+
+    expect(tool.enabledBlockTunes).toStrictEqual(options.config?.tunes);
+  });
+
+  test.describe('prepare', () => {
+    test('calls constructable prepare method', async () => {
+      const options = createBlockToolOptions();
+      const constructable = options.constructable as typeof options.constructable & {
+        prepare?: (data: { toolName: string; config: ToolUserConfig }) => void;
+      };
+      const prepareMock = createMock<[ { toolName: string; config: ToolUserConfig } ]>();
+
+      constructable.prepare = prepareMock.fn;
+
+      const tool = new BlockToolAdapter(options);
+
+      await tool.prepare();
+
+      expect(prepareMock.calls).toHaveLength(1);
+      expect(prepareMock.calls[0]?.[0]).toMatchObject({
+        toolName: tool.name,
+        config: tool.settings,
+      });
+    });
+
+    test('does not throw when prepare is not defined', async () => {
+      /**
+       * Block tool stub without prepare/reset hooks.
+       */
+      class MinimalBlockTool {
+        /**
+         * Returns a placeholder element for tests.
+         */
+        public render(): HTMLElement {
+          return {} as HTMLElement;
+        }
+      }
+
+      const tool = new BlockToolAdapter(createBlockToolOptions({
+        constructable: MinimalBlockTool as unknown as BlockToolConstructable,
+      }));
+
+      await expect(Promise.resolve(tool.prepare())).resolves.toBeUndefined();
+    });
+  });
+
+  test.describe('reset', () => {
+    test('calls constructable reset method', async () => {
+      const options = createBlockToolOptions();
+      const constructable = options.constructable as typeof options.constructable & {
+        reset?: () => void;
+      };
+      const resetMock = createMock<[]>();
+
+      constructable.reset = resetMock.fn;
+
+      const tool = new BlockToolAdapter(options);
+
+      await tool.reset();
+
+      expect(resetMock.calls).toHaveLength(1);
+    });
+
+    test('does not throw when reset is not defined', async () => {
+      /**
+       * Block tool stub without reset hook.
+       */
+      class MinimalBlockToolWithoutReset {
+        /**
+         * Returns a placeholder element for tests.
+         */
+        public render(): HTMLElement {
+          return {} as HTMLElement;
+        }
+      }
+
+      const tool = new BlockToolAdapter(createBlockToolOptions({
+        constructable: MinimalBlockToolWithoutReset as unknown as BlockToolConstructable,
+      }));
+
+      await expect(Promise.resolve(tool.reset())).resolves.toBeUndefined();
+    });
+  });
+
+  test.describe('shortcut', () => {
+    test('prefers user shortcut', () => {
+      const options = createBlockToolOptions();
+      const tool = new BlockToolAdapter(options);
+
+      expect(tool.shortcut).toBe(options.config?.shortcut);
+    });
+
+    test('falls back to constructable shortcut', () => {
+      const baseOptions = createBlockToolOptions();
+
+      /**
+       * Block tool stub without a shortcut configured.
+       */
+      class WithoutShortcut extends (baseOptions.constructable as BlockToolConstructable) {
+        public static override shortcut = undefined;
+      }
+
+      const userlessOptions = createBlockToolOptions({
+        constructable: WithoutShortcut,
+        config: {
+          shortcut: undefined,
+        },
+      });
+
+      const tool = new BlockToolAdapter({
+        ...userlessOptions,
+        constructable: baseOptions.constructable,
+      });
+
+      expect(tool.shortcut).toBe(baseOptions.constructable.shortcut);
+    });
+  });
+
+  test.describe('toolbox', () => {
+    test('wraps user toolbox config in array', () => {
+      const options = createBlockToolOptions();
+      const tool = new BlockToolAdapter(options);
+
+      expect(tool.toolbox).toStrictEqual([ options.config?.toolbox ]);
+    });
+
+    test('wraps constructable toolbox config when user config is not provided', () => {
+      const options = createBlockToolOptions({
+        config: {
+          toolbox: undefined,
+        },
+      });
+      const tool = new BlockToolAdapter(options);
+      const constructable = ensureBlockToolConstructable(options.constructable);
+
+      expect(tool.toolbox).toStrictEqual([ constructable.toolbox ]);
+    });
+
+    test('merges constructable toolbox config with user config when both are objects', () => {
+      const optionsWithTitleOnly = createBlockToolOptions({
+        config: {
+          toolbox: {
+            title: 'Custom title',
+          },
+        },
+      });
+      const optionsWithIconOnly = createBlockToolOptions({
+        config: {
+          toolbox: {
+            icon: 'Custom icon',
+          },
+        },
+      });
+
+      const toolWithTitle = new BlockToolAdapter(optionsWithTitleOnly);
+      const toolWithIcon = new BlockToolAdapter(optionsWithIconOnly);
+      const constructableWithTitle = ensureBlockToolConstructable(optionsWithTitleOnly.constructable);
+      const constructableWithIcon = ensureBlockToolConstructable(optionsWithIconOnly.constructable);
+
+      expect(toolWithTitle.toolbox).toStrictEqual([
+        {
+          ...constructableWithTitle.toolbox,
+          title: 'Custom title',
+        },
+      ]);
+
+      expect(toolWithIcon.toolbox).toStrictEqual([
+        {
+          ...constructableWithIcon.toolbox,
+          icon: 'Custom icon',
+        },
+      ]);
+    });
+
+    test('replaces constructable toolbox array with user object config', () => {
+      const baseOptions = createBlockToolOptions();
+      const baseConstructable = ensureBlockToolConstructable(baseOptions.constructable);
+
+      /**
+       * Block tool stub with an array-based toolbox configuration.
+       */
+      class ConstructableWithArray extends baseConstructable {
+        public static override toolbox: ToolboxConfigEntry[] = [
+          { title: 'Toolbox entry 1' },
+          { title: 'Toolbox entry 2' },
+        ];
+      }
+
+      const userToolbox = {
+        icon: 'User icon',
+        title: 'User title',
+      };
+
+      const tool = new BlockToolAdapter(createBlockToolOptions({
+        constructable: ConstructableWithArray,
+        config: {
+          toolbox: userToolbox,
+        },
+      }));
+
+      expect(tool.toolbox).toStrictEqual([ userToolbox ]);
+    });
+
+    test('replaces constructable toolbox object with user array config', () => {
+      const userToolbox = [
+        { title: 'Toolbox entry 1' },
+        { title: 'Toolbox entry 2' },
+      ];
+
+      const tool = new BlockToolAdapter(createBlockToolOptions({
+        config: {
+          toolbox: userToolbox,
+        },
+      }));
+
+      expect(tool.toolbox).toStrictEqual(userToolbox);
+    });
+
+    test('merges constructable and user arrays preserving user length', () => {
+      const baseOptions = createBlockToolOptions();
+      const baseConstructable = ensureBlockToolConstructable(baseOptions.constructable);
+
+      /**
+       * Block tool stub with limited array-based toolbox configuration.
+       */
+      class ConstructableWithShortArray extends baseConstructable {
+        public static override toolbox: ToolboxConfigEntry[] = [
+          { title: 'Toolbox entry 1' },
+        ];
+      }
+
+      const userToolbox = [
+        { icon: 'Icon 1' },
+        {
+          icon: 'Icon 2',
+          title: 'Toolbox entry 2',
+        },
+      ];
+
+      const tool = new BlockToolAdapter(createBlockToolOptions({
+        constructable: ConstructableWithShortArray,
+        config: {
+          toolbox: userToolbox,
+        },
+      }));
+
+      const expected = userToolbox.map((entry, index) => {
+        const toolEntry = ConstructableWithShortArray.toolbox[index];
+
+        if (toolEntry) {
+          return {
+            ...toolEntry,
+            ...entry,
+          };
+        }
+
+        return entry;
+      });
+
+      expect(tool.toolbox).toStrictEqual(expected);
+    });
+
+    test('returns undefined when user explicitly disables toolbox', () => {
+      const tool = new BlockToolAdapter(createBlockToolOptions({
+        config: {
+          toolbox: false,
+        },
+      }));
+
+      expect(tool.toolbox).toBeUndefined();
+    });
+
+    test('returns undefined when constructable disables toolbox', () => {
+      const baseOptions = createBlockToolOptions();
+      const baseConstructable = ensureBlockToolConstructable(baseOptions.constructable);
+
+      /**
+       * Block tool stub that programmatically disables toolbox visibility.
+       */
+      class ToolboxDisabledConstructable extends baseConstructable {
+        public static override toolbox: BlockToolConstructableWithOptionalDisabling['toolbox'] = false;
+      }
+
+      const tool = new BlockToolAdapter(createBlockToolOptions({
+        constructable: ToolboxDisabledConstructable,
+      }));
+
+      expect(tool.toolbox).toBeUndefined();
+    });
+
+    test('returns undefined when constructable toolbox config is empty', () => {
+      const baseOptions = createBlockToolOptions();
+      const baseConstructable = ensureBlockToolConstructable(baseOptions.constructable);
+
+      /**
+       * Block tool stub with an empty toolbox configuration.
+       */
+      class ToolboxEmptyConstructable extends baseConstructable {
+        public static override toolbox: ToolboxConfigEntry = {};
+      }
+
+      const tool = new BlockToolAdapter(createBlockToolOptions({
+        constructable: ToolboxEmptyConstructable,
+      }));
+
+      expect(tool.toolbox).toBeUndefined();
+    });
+  });
+
+  test.describe('create', () => {
+    const data: BlockToolData<{ text: string }> = { text: 'text' };
+    const blockApi = {} as BlockToolCtorOptions['block'];
+
+    test('returns tool instance of constructable', () => {
+      const options = createBlockToolOptions();
+      const tool = new BlockToolAdapter(options);
+
+      const instance = tool.create(data, blockApi, false);
+
+      expect(instance).toBeInstanceOf(options.constructable);
+    });
+
+    test('passes provided data to tool instance', () => {
+      const options = createBlockToolOptions();
+      const tool = new BlockToolAdapter(options);
+      const instance = ensureBlockToolStubInstance(tool.create(data, blockApi, false));
+
+      expect(instance.data).toStrictEqual(data);
+    });
+
+    test('passes provided BlockAPI to tool instance', () => {
+      const options = createBlockToolOptions();
+      const tool = new BlockToolAdapter(options);
+      const instance = ensureBlockToolStubInstance(tool.create(data, blockApi, false));
+
+      expect(instance.block).toBe(blockApi);
+    });
+
+    test('passes readOnly flag to tool instance', () => {
+      const options = createBlockToolOptions();
+      const tool = new BlockToolAdapter(options);
+      const writableInstance = ensureBlockToolStubInstance(tool.create(data, blockApi, false));
+      const readonlyInstance = ensureBlockToolStubInstance(tool.create(data, blockApi, true));
+
+      expect(writableInstance.readonly).toBe(false);
+      expect(readonlyInstance.readonly).toBe(true);
+    });
+
+    test('passes API object to tool instance', () => {
+      const options = createBlockToolOptions();
+      const tool = new BlockToolAdapter(options);
+      const instance = ensureBlockToolStubInstance(tool.create(data, blockApi, false));
+
+      expect(instance.api).toBe(options.api);
+    });
+
+    test('passes tool settings to tool instance', () => {
+      const options = createBlockToolOptions();
+      const tool = new BlockToolAdapter(options);
+      const instance = ensureBlockToolStubInstance(tool.create(data, blockApi, false));
+
+      expect(instance.config).toStrictEqual(options.config?.config);
+    });
+  });
+});
+
+
diff --git a/test/playwright/tests/tools/block-tune.spec.ts b/test/playwright/tests/tools/block-tune.spec.ts
new file mode 100644
index 000000000..28a22bc37
--- /dev/null
+++ b/test/playwright/tests/tools/block-tune.spec.ts
@@ -0,0 +1,248 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, jsdoc/require-jsdoc */
+import { expect, test } from '@playwright/test';
+import BlockTuneAdapter from '../../../../src/components/tools/tune';
+import { ToolType } from '../../../../types/tools/adapters/tool-type';
+import type { ToolSettings } from '../../../../types';
+import type { BlockTuneData } from '../../../../types/block-tunes/block-tune-data';
+
+const createBlockTuneOptions = (): any => {
+  class Constructable {
+    public static reset?: () => void | Promise<void>;
+    public static prepare?: (
+      data: { toolName: string; config: ToolSettings }
+    ) => void | Promise<void>;
+
+    public api: object;
+    public config: ToolSettings;
+    public data: BlockTuneData;
+    public block: object;
+
+    constructor({
+      api,
+      config,
+      block,
+      data,
+    }: {
+      api: object;
+      config: ToolSettings;
+      block: object;
+      data: BlockTuneData;
+    }) {
+      this.api = api;
+      this.config = config;
+      this.block = block;
+      this.data = data;
+    }
+  }
+
+  return {
+    name: 'blockTune',
+    constructable: Constructable,
+    config: {
+      config: {
+        option1: 'option1',
+        option2: 'option2',
+      },
+      shortcut: 'CMD+SHIFT+B',
+    },
+    api: {
+      prop1: 'prop1',
+      prop2: 'prop2',
+    },
+    isDefault: false,
+    isInternal: false,
+    defaultPlaceholder: 'Default placeholder',
+  };
+};
+
+test.describe('blockTuneAdapter', () => {
+  test('.type returns ToolType.Tune', () => {
+    const options = createBlockTuneOptions();
+    const tool = new BlockTuneAdapter(options as any);
+
+    expect(tool.type).toBe(ToolType.Tune);
+  });
+
+  test('.name returns correct value', () => {
+    const options = createBlockTuneOptions();
+    const tool = new BlockTuneAdapter(options as any);
+
+    expect(tool.name).toBe(options.name);
+  });
+
+  test('.isInternal returns correct value', () => {
+    const options = createBlockTuneOptions();
+
+    const tool1 = new BlockTuneAdapter(options as any);
+    const tool2 = new BlockTuneAdapter({
+      ...options,
+      isInternal: true,
+    } as any);
+
+    expect(tool1.isInternal).toBe(false);
+    expect(tool2.isInternal).toBe(true);
+  });
+
+  test('.settings returns correct value', () => {
+    const options = createBlockTuneOptions();
+    const tool = new BlockTuneAdapter(options as any);
+
+    expect(tool.settings).toStrictEqual(options.config.config);
+  });
+
+  test('.isBlock() returns false', () => {
+    const options = createBlockTuneOptions();
+    const tool = new BlockTuneAdapter(options as any);
+
+    expect(tool.isBlock()).toBe(false);
+  });
+
+  test('.isInline() returns false', () => {
+    const options = createBlockTuneOptions();
+    const tool = new BlockTuneAdapter(options as any);
+
+    expect(tool.isInline()).toBe(false);
+  });
+
+  test('.isTune() returns true', () => {
+    const options = createBlockTuneOptions();
+    const tool = new BlockTuneAdapter(options as any);
+
+    expect(tool.isTune()).toBe(true);
+  });
+
+  test.describe('.prepare()', () => {
+    test('calls Tool prepare method', async () => {
+      const options = createBlockTuneOptions();
+      const calls: Array<{ toolName: string; config: ToolSettings }> = [];
+
+      options.constructable.prepare = (data: {
+        toolName: string;
+        config: ToolSettings;
+      }) => {
+        calls.push(data);
+      };
+
+      const tool = new BlockTuneAdapter(options as any);
+
+      await tool.prepare();
+
+      expect(calls).toStrictEqual([
+        {
+          toolName: tool.name,
+          config: tool.settings,
+        },
+      ]);
+    });
+
+    test('does not fail if Tool prepare method does not exist', async () => {
+      const options = createBlockTuneOptions();
+      const tool = new BlockTuneAdapter({
+        ...options,
+        constructable: {},
+      } as any);
+
+      const result = await tool.prepare();
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  test.describe('.reset()', () => {
+    test('calls Tool reset method', async () => {
+      const options = createBlockTuneOptions();
+      let callCount = 0;
+
+      options.constructable.reset = () => {
+        callCount += 1;
+      };
+
+      const tool = new BlockTuneAdapter(options as any);
+
+      await tool.reset();
+
+      expect(callCount).toBe(1);
+    });
+
+    test('does not fail if Tool reset method does not exist', async () => {
+      const options = createBlockTuneOptions();
+      const tool = new BlockTuneAdapter({
+        ...options,
+        constructable: {},
+      } as any);
+
+      const result = await tool.reset();
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  test.describe('.create()', () => {
+    test('returns Tool instance', () => {
+      const options = createBlockTuneOptions();
+      const tool = new BlockTuneAdapter(options as any);
+      const data: BlockTuneData = { text: 'text' };
+      const blockApi = {
+        method(): void {},
+      };
+
+      expect(tool.create(data, blockApi as any)).toBeInstanceOf(
+        options.constructable
+      );
+    });
+
+    test('returns Tool instance with passed data', () => {
+      const options = createBlockTuneOptions();
+      const tool = new BlockTuneAdapter(options as any);
+      const data: BlockTuneData = { text: 'text' };
+      const blockApi = {
+        method(): void {},
+      };
+
+      const instance = tool.create(data, blockApi as any) as any;
+
+      expect(instance.data).toStrictEqual(data);
+    });
+
+    test('returns Tool instance with passed BlockAPI object', () => {
+      const options = createBlockTuneOptions();
+      const tool = new BlockTuneAdapter(options as any);
+      const data: BlockTuneData = { text: 'text' };
+      const blockApi = {
+        method(): void {},
+      };
+
+      const instance = tool.create(data, blockApi as any) as any;
+
+      expect(instance.block).toStrictEqual(blockApi);
+    });
+
+    test('returns Tool instance with passed API object', () => {
+      const options = createBlockTuneOptions();
+      const tool = new BlockTuneAdapter(options as any);
+      const data: BlockTuneData = { text: 'text' };
+      const blockApi = {
+        method(): void {},
+      };
+
+      const instance = tool.create(data, blockApi as any) as any;
+
+      expect(instance.api).toStrictEqual(options.api);
+    });
+
+    test('returns Tool instance with passed settings', () => {
+      const options = createBlockTuneOptions();
+      const tool = new BlockTuneAdapter(options as any);
+      const data: BlockTuneData = { text: 'text' };
+      const blockApi = {
+        method(): void {},
+      };
+
+      const instance = tool.create(data, blockApi as any) as any;
+
+      expect(instance.config).toStrictEqual(options.config.config);
+    });
+  });
+});
+
+
diff --git a/test/playwright/tests/tools/inline-tool.spec.ts b/test/playwright/tests/tools/inline-tool.spec.ts
new file mode 100644
index 000000000..7cb482fe0
--- /dev/null
+++ b/test/playwright/tests/tools/inline-tool.spec.ts
@@ -0,0 +1,298 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, jsdoc/require-jsdoc */
+import { expect, test } from '@playwright/test';
+import InlineToolAdapter from '../../../../src/components/tools/inline';
+import { ToolType } from '../../../../types/tools/adapters/tool-type';
+import type { ToolConfig, ToolSettings } from '../../../../types';
+
+const createInlineToolOptions = (): any => {
+  class Constructable {
+    public static sanitize = {
+      rule1: 'rule1',
+    };
+
+    public static title = 'Title';
+
+    public static reset?: () => void | Promise<void>;
+    public static prepare?: (data: { toolName: string; config: ToolConfig }) => void | Promise<void>;
+
+    public static shortcut = 'CTRL+N';
+    public static isReadOnlySupported = true;
+
+    public api: object;
+    public config: ToolSettings;
+
+    constructor({ api, config }: { api: object; config: ToolSettings }) {
+      this.api = api;
+      this.config = config;
+    }
+  }
+
+  return {
+    name: 'inlineTool',
+    constructable: Constructable,
+    config: {
+      config: {
+        option1: 'option1',
+        option2: 'option2',
+      },
+      shortcut: 'CMD+SHIFT+B',
+    },
+    api: {
+      prop1: 'prop1',
+      prop2: 'prop2',
+    },
+    isDefault: false,
+    isInternal: false,
+    defaultPlaceholder: 'Default placeholder',
+  };
+};
+
+test.describe('inlineToolAdapter', () => {
+  test('.type returns ToolType.Inline', () => {
+    const options = createInlineToolOptions();
+    const tool = new InlineToolAdapter(options as any);
+
+    expect(tool.type).toBe(ToolType.Inline);
+  });
+
+  test('.name returns correct value', () => {
+    const options = createInlineToolOptions();
+    const tool = new InlineToolAdapter(options as any);
+
+    expect(tool.name).toBe(options.name);
+  });
+
+  test('.title returns correct title', () => {
+    const options = createInlineToolOptions();
+    const tool = new InlineToolAdapter(options as any);
+
+    expect(tool.title).toBe(options.constructable.title);
+  });
+
+  test('.isInternal returns correct value', () => {
+    const options = createInlineToolOptions();
+
+    const tool1 = new InlineToolAdapter(options as any);
+    const tool2 = new InlineToolAdapter({
+      ...options,
+      isInternal: true,
+    } as any);
+
+    expect(tool1.isInternal).toBe(false);
+    expect(tool2.isInternal).toBe(true);
+  });
+
+  test('.settings returns correct value', () => {
+    const options = createInlineToolOptions();
+    const tool = new InlineToolAdapter(options as any);
+
+    expect(tool.settings).toStrictEqual(options.config.config);
+  });
+
+  test('.sanitizeConfig returns correct value', () => {
+    const options = createInlineToolOptions();
+    const tool = new InlineToolAdapter(options as any);
+
+    expect(tool.sanitizeConfig).toStrictEqual(options.constructable.sanitize);
+  });
+
+  test('.isBlock() returns false', () => {
+    const options = createInlineToolOptions();
+    const tool = new InlineToolAdapter(options as any);
+
+    expect(tool.isBlock()).toBe(false);
+  });
+
+  test('.isInline() returns true', () => {
+    const options = createInlineToolOptions();
+    const tool = new InlineToolAdapter(options as any);
+
+    expect(tool.isInline()).toBe(true);
+  });
+
+  test('.isTune() returns false', () => {
+    const options = createInlineToolOptions();
+    const tool = new InlineToolAdapter(options as any);
+
+    expect(tool.isTune()).toBe(false);
+  });
+
+  test.describe('.prepare()', () => {
+    test('calls Tool prepare method', async () => {
+      const options = createInlineToolOptions();
+      const calls: Array<{ toolName: string; config: ToolConfig }> = [];
+
+      options.constructable.prepare = (data: { toolName: string; config: ToolConfig }) => {
+        calls.push(data);
+      };
+
+      const tool = new InlineToolAdapter(options as any);
+
+      await tool.prepare();
+
+      expect(calls).toStrictEqual([
+        {
+          toolName: tool.name,
+          config: tool.settings,
+        },
+      ]);
+    });
+
+    test('does not fail if Tool prepare method does not exist', async () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter({
+        ...options,
+        constructable: {},
+      } as any);
+
+      const result = await tool.prepare();
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  test.describe('.reset()', () => {
+    test('calls Tool reset method', async () => {
+      const options = createInlineToolOptions();
+      let callCount = 0;
+
+      options.constructable.reset = () => {
+        callCount += 1;
+      };
+
+      const tool = new InlineToolAdapter(options as any);
+
+      await tool.reset();
+
+      expect(callCount).toBe(1);
+    });
+
+    test('does not fail if Tool reset method does not exist', async () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter({
+        ...options,
+        constructable: {},
+      } as any);
+
+      const result = await tool.reset();
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  test.describe('.getMissingMethods()', () => {
+    test('returns all required methods when constructable prototype is missing', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter({
+        ...options,
+        constructable: {} as typeof options.constructable,
+      } as any);
+      const requiredMethods = ['render', 'surround'];
+
+      expect(tool.getMissingMethods(requiredMethods)).toStrictEqual(requiredMethods);
+    });
+
+    test('returns only methods that are not implemented on the prototype', () => {
+      const options = createInlineToolOptions();
+
+      class ConstructableWithRender extends options.constructable {
+        public render(): void {}
+      }
+
+      const tool = new InlineToolAdapter({
+        ...options,
+        constructable: ConstructableWithRender,
+      } as any);
+      const requiredMethods = ['render', 'surround'];
+
+      expect(tool.getMissingMethods(requiredMethods)).toStrictEqual([ 'surround' ]);
+    });
+
+    test('returns an empty array when all required methods are implemented', () => {
+      const options = createInlineToolOptions();
+
+      class ConstructableWithAllMethods extends options.constructable {
+        public render(): void {}
+        public surround(): void {}
+      }
+
+      const tool = new InlineToolAdapter({
+        ...options,
+        constructable: ConstructableWithAllMethods,
+      } as any);
+      const requiredMethods = ['render', 'surround'];
+
+      expect(tool.getMissingMethods(requiredMethods)).toStrictEqual([]);
+    });
+  });
+
+  test.describe('.shortcut', () => {
+    test('returns user provided shortcut', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter(options as any);
+
+      expect(tool.shortcut).toBe(options.config.shortcut);
+    });
+
+    test('falls back to Tool provided shortcut when user shortcut is not specified', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter({
+        ...options,
+        config: {
+          ...options.config,
+          shortcut: undefined,
+        },
+      } as any);
+
+      expect(tool.shortcut).toBe(options.constructable.shortcut);
+    });
+  });
+
+  test.describe('.create()', () => {
+    test('returns Tool instance', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter(options as any);
+
+      expect(tool.create()).toBeInstanceOf(options.constructable);
+    });
+
+    test('returns Tool instance with passed API object', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter(options as any);
+
+      const instance = tool.create() as any;
+
+      expect(instance.api).toStrictEqual(options.api);
+    });
+
+    test('returns Tool instance with passed config', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter(options as any);
+
+      const instance = tool.create() as any;
+
+      expect(instance.config).toStrictEqual(options.config.config);
+    });
+  });
+
+  test.describe('.isReadOnlySupported', () => {
+    test('returns Tool provided value', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter(options as any);
+
+      expect(tool.isReadOnlySupported).toBe(options.constructable.isReadOnlySupported);
+    });
+
+    test('returns false if Tool provided value does not exist', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter({
+        ...options,
+        constructable: {},
+      } as any);
+
+      expect(tool.isReadOnlySupported).toBe(false);
+    });
+  });
+});
+
+
diff --git a/test/playwright/tests/tools/tools-collection.spec.ts b/test/playwright/tests/tools/tools-collection.spec.ts
new file mode 100644
index 000000000..152d04a4e
--- /dev/null
+++ b/test/playwright/tests/tools/tools-collection.spec.ts
@@ -0,0 +1,139 @@
+import { expect, test } from '@playwright/test';
+import type { ToolClass } from '../../../../src/components/tools/collection';
+import ToolsCollection from '../../../../src/components/tools/collection';
+import type BlockToolAdapter from '../../../../src/components/tools/block';
+import type InlineToolAdapter from '../../../../src/components/tools/inline';
+import type BlockTuneAdapter from '../../../../src/components/tools/tune';
+
+type ToolStubOptions = {
+  block?: boolean;
+  inline?: boolean;
+  tune?: boolean;
+  internal?: boolean;
+};
+
+const createToolStub = <T extends ToolClass>({
+  block = false,
+  inline = false,
+  tune = false,
+  internal = false,
+}: ToolStubOptions = {}): T => ({
+    isBlock: () => block,
+    isInline: () => inline,
+    isTune: () => tune,
+    isInternal: internal,
+  } as unknown as T);
+
+const blockTool = createToolStub<BlockToolAdapter>({ block: true });
+const inlineTool = createToolStub<InlineToolAdapter>({ inline: true });
+const blockTune = createToolStub<BlockTuneAdapter>({ tune: true });
+const internalBlockTool = createToolStub<BlockToolAdapter>({ block: true,
+  internal: true });
+const internalInlineTool = createToolStub<InlineToolAdapter>({ inline: true,
+  internal: true });
+const internalBlockTune = createToolStub<BlockTuneAdapter>({ tune: true,
+  internal: true });
+
+const fakeTools: Array<[string, ToolClass]> = [
+  ['block1', blockTool],
+  ['inline1', inlineTool],
+  ['block2', internalBlockTool],
+  ['tune1', blockTune],
+  ['block3', blockTool],
+  ['inline2', internalInlineTool],
+  ['tune2', blockTune],
+  ['tune3', internalBlockTune],
+  ['block3', inlineTool],
+  ['block4', blockTool],
+];
+
+test.describe('toolsCollection', () => {
+  let collection: ToolsCollection;
+
+  test.beforeEach(() => {
+    collection = new ToolsCollection(fakeTools);
+  });
+
+  test('should be instance of Map', () => {
+    expect(collection).toBeInstanceOf(Map);
+  });
+
+  test.describe('.blockTools', () => {
+    test('should return new instance of ToolsCollection', () => {
+      expect(collection.blockTools).toBeInstanceOf(ToolsCollection);
+    });
+
+    test('result should contain only block tools', () => {
+      const values = Array.from(collection.blockTools.values());
+
+      expect(values.every((tool: BlockToolAdapter) => tool.isBlock())).toBe(true);
+    });
+  });
+
+  test.describe('.inlineTools', () => {
+    test('should return new instance of ToolsCollection', () => {
+      expect(collection.inlineTools).toBeInstanceOf(ToolsCollection);
+    });
+
+    test('result should contain only inline tools', () => {
+      const values = Array.from(collection.inlineTools.values());
+
+      expect(values.every((tool: InlineToolAdapter) => tool.isInline())).toBe(true);
+    });
+  });
+
+  test.describe('.blockTunes', () => {
+    test('should return new instance of ToolsCollection', () => {
+      expect(collection.blockTunes).toBeInstanceOf(ToolsCollection);
+    });
+
+    test('result should contain only block tunes', () => {
+      const values = Array.from(collection.blockTunes.values());
+
+      expect(values.every((tool: BlockTuneAdapter) => tool.isTune())).toBe(true);
+    });
+  });
+
+  test.describe('.internalTools', () => {
+    test('should return new instance of ToolsCollection', () => {
+      expect(collection.internalTools).toBeInstanceOf(ToolsCollection);
+    });
+
+    test('result should contain only internal tools', () => {
+      const values = Array.from(collection.internalTools.values());
+
+      expect(values.every((tool) => tool.isInternal)).toBe(true);
+    });
+  });
+
+  test.describe('.externalTools', () => {
+    test('should return new instance of ToolsCollection', () => {
+      expect(collection.externalTools).toBeInstanceOf(ToolsCollection);
+    });
+
+    test('result should contain only external tools', () => {
+      const values = Array.from(collection.externalTools.values());
+
+      expect(values.every((tool) => !tool.isInternal)).toBe(true);
+    });
+  });
+
+  test.describe('mixed access', () => {
+    test.describe('.blockTunes.internalTools', () => {
+      test('should return only internal tunes', () => {
+        const values = Array.from(collection.blockTunes.internalTools.values());
+
+        expect(values.every((tool: BlockTuneAdapter) => tool.isTune() && tool.isInternal)).toBe(true);
+      });
+    });
+
+    test.describe('.externalTools.blockTools', () => {
+      test('should return only external block tools', () => {
+        const values = Array.from(collection.externalTools.blockTools.values());
+
+        expect(values.every((tool: BlockToolAdapter) => tool.isBlock() && !tool.isInternal)).toBe(true);
+      });
+    });
+  });
+});
+
diff --git a/test/playwright/tests/tools/tools-factory.spec.ts b/test/playwright/tests/tools/tools-factory.spec.ts
new file mode 100644
index 000000000..2be046cb2
--- /dev/null
+++ b/test/playwright/tests/tools/tools-factory.spec.ts
@@ -0,0 +1,99 @@
+import { expect, test } from '@playwright/test';
+import Paragraph from '@editorjs/paragraph';
+import LinkInlineTool from '../../../../src/components/inline-tools/inline-tool-link';
+import MoveUpTune from '../../../../src/components/block-tunes/block-tune-move-up';
+import ToolsFactory from '../../../../src/components/tools/factory';
+import InlineToolAdapter from '../../../../src/components/tools/inline';
+import BlockToolAdapter from '../../../../src/components/tools/block';
+import BlockTuneAdapter from '../../../../src/components/tools/tune';
+import type ApiModule from '../../../../src/components/modules/api';
+import type {
+  BlockToolConstructable,
+  ToolConstructable,
+  ToolSettings
+} from '../../../../types';
+import type { EditorConfig } from '../../../../types/configs/editor-config';
+
+const paragraphClass = Paragraph as unknown as BlockToolConstructable;
+
+const toolsConfig = {
+  paragraph: {
+    class: paragraphClass,
+  },
+  link: {
+    class: LinkInlineTool,
+  },
+  moveUp: {
+    class: MoveUpTune,
+  },
+} as Record<string, ToolSettings & { class: ToolConstructable; isInternal?: boolean }>;
+
+const editorConfig: EditorConfig = {
+  placeholder: 'Placeholder',
+  defaultBlock: 'paragraph',
+};
+
+type ToolApiMethods = ReturnType<ApiModule['getMethodsForTool']>;
+
+const apiMethodsStub: ToolApiMethods = {
+  blocks: {} as ToolApiMethods['blocks'],
+  caret: {} as ToolApiMethods['caret'],
+  tools: {} as ToolApiMethods['tools'],
+  events: {} as ToolApiMethods['events'],
+  listeners: {} as ToolApiMethods['listeners'],
+  notifier: {} as ToolApiMethods['notifier'],
+  sanitizer: {} as ToolApiMethods['sanitizer'],
+  saver: {} as ToolApiMethods['saver'],
+  selection: {} as ToolApiMethods['selection'],
+  styles: {} as ToolApiMethods['styles'],
+  toolbar: {} as ToolApiMethods['toolbar'],
+  inlineToolbar: {} as ToolApiMethods['inlineToolbar'],
+  tooltip: {} as ToolApiMethods['tooltip'],
+  i18n: {} as ToolApiMethods['i18n'],
+  readOnly: {} as ToolApiMethods['readOnly'],
+  ui: {} as ToolApiMethods['ui'],
+};
+
+const apiMock: Pick<ApiModule, 'getMethodsForTool'> = {
+  getMethodsForTool() {
+    return apiMethodsStub;
+  },
+};
+
+test.describe('toolsFactory', () => {
+  let factory: ToolsFactory;
+
+  test.beforeEach(() => {
+    factory = new ToolsFactory(
+      toolsConfig,
+      editorConfig,
+      apiMock as unknown as ApiModule
+    );
+  });
+
+  test('.get returns appropriate tool object', () => {
+    const tool = factory.get('link');
+
+    expect(tool.name).toBe('link');
+  });
+
+  test('.get returns InlineTool object for inline tool', () => {
+    const tool = factory.get('link');
+
+    expect(tool).toBeInstanceOf(InlineToolAdapter);
+  });
+
+  test('.get returns BlockTool object for block tool', () => {
+    const tool = factory.get('paragraph');
+
+    expect(tool).toBeInstanceOf(BlockToolAdapter);
+  });
+
+  test('.get returns BlockTune object for tune', () => {
+    const tool = factory.get('moveUp');
+
+    expect(tool).toBeInstanceOf(BlockTuneAdapter);
+  });
+});
+
+
diff --git a/test/playwright/tests/ui/block-tunes.spec.ts b/test/playwright/tests/ui/block-tunes.spec.ts
new file mode 100644
index 000000000..d1f1b7984
--- /dev/null
+++ b/test/playwright/tests/ui/block-tunes.spec.ts
@@ -0,0 +1,586 @@
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import type EditorJS from '@/types';
+import type { OutputData } from '@/types';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+import {
+  EDITOR_INTERFACE_SELECTOR,
+  MODIFIER_KEY,
+  selectionChangeDebounceTimeout
+} from '../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HEADER_TOOL_UMD_PATH = path.resolve(
+  __dirname,
+  '../../../../node_modules/@editorjs/header/dist/header.umd.js'
+);
+
+const HOLDER_ID = 'editorjs';
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-block`;
+const SETTINGS_BUTTON_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__settings-btn`;
+const CONVERT_TO_OPTION_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-popover-item[data-item-name="convert-to"]`;
+const NESTED_POPOVER_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-popover--nested`;
+const POPOVER_CONTAINER_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-popover.ce-popover--opened > .ce-popover__container`;
+const SEARCH_INPUT_SELECTOR = `${POPOVER_CONTAINER_SELECTOR} .cdx-search-field__input`;
+const DEFAULT_WAIT_TIMEOUT = 5_000;
+const BLOCK_TUNES_WAIT_BUFFER = 500;
+
+type SerializableToolConfig = {
+  className?: string;
+  classCode?: string;
+  config?: Record<string, unknown>;
+};
+
+type CreateEditorOptions = {
+  data?: OutputData;
+  tools?: Record<string, SerializableToolConfig>;
+};
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+  }
+}
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditor = async (page: Page, options: CreateEditorOptions = {}): Promise<void> => {
+  const { data = null, tools = {} } = options;
+
+  await resetEditor(page);
+  await page.waitForFunction(() => typeof window.EditorJS === 'function');
+
+  const serializedTools = Object.entries(tools).map(([name, tool]) => ({
+    name,
+    className: tool.className ?? null,
+    classCode: tool.classCode ?? null,
+    config: tool.config ?? {},
+  }));
+
+  await page.evaluate(
+    async ({ holderId, data: initialData, serializedTools: toolsConfig }) => {
+      const editorConfig: Record<string, unknown> = {
+        holder: holderId,
+      };
+
+      if (initialData) {
+        editorConfig.data = initialData;
+      }
+
+      if (toolsConfig.length > 0) {
+        const resolvedTools = toolsConfig.reduce<
+          Record<string, { class: unknown } & Record<string, unknown>>
+        >((accumulator, { name, className, classCode, config }) => {
+          let toolClass: unknown = null;
+
+          if (className) {
+            toolClass = (window as unknown as Record<string, unknown>)[className] ?? null;
+          }
+
+          if (!toolClass && classCode) {
+            // eslint-disable-next-line no-new-func -- executed in browser context to recreate tool class
+            toolClass = new Function(`return (${classCode});`)();
+          }
+
+          if (!toolClass) {
+            throw new Error(`Tool "${name}" is not available globally`);
+          }
+
+          return {
+            ...accumulator,
+            [name]: {
+              class: toolClass,
+              ...config,
+            },
+          };
+        }, {});
+
+        editorConfig.tools = resolvedTools;
+      }
+
+      const editor = new window.EditorJS(editorConfig);
+
+      window.editorInstance = editor;
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      data,
+      serializedTools,
+    }
+  );
+};
+
+const waitForBlockTunesPopover = async (
+  page: Page,
+  timeout = DEFAULT_WAIT_TIMEOUT
+): Promise<void> => {
+  const popover = page.locator(POPOVER_CONTAINER_SELECTOR);
+
+  await expect(popover).toHaveCount(1);
+  await popover.waitFor({
+    state: 'visible',
+    timeout,
+  });
+};
+
+const focusFirstBlock = async (page: Page): Promise<void> => {
+  const block = page.locator(BLOCK_SELECTOR);
+
+  await expect(block).toHaveCount(1);
+  await expect(block).toBeVisible();
+  await block.click();
+};
+
+const openBlockTunesViaToolbar = async (page: Page): Promise<void> => {
+  await focusFirstBlock(page);
+
+  const settingsButton = page.locator(SETTINGS_BUTTON_SELECTOR);
+
+  await expect(settingsButton).toBeVisible();
+  await settingsButton.click();
+  await waitForBlockTunesPopover(page);
+};
+
+const openBlockTunesViaShortcut = async (page: Page): Promise<void> => {
+  await focusFirstBlock(page);
+  await page.keyboard.press(`${MODIFIER_KEY}+/`);
+  await waitForBlockTunesPopover(
+    page,
+    selectionChangeDebounceTimeout + BLOCK_TUNES_WAIT_BUFFER
+  );
+};
+
+const toolWithoutConversionExportClass = (): string => `
+(() => {
+  return class ToolWithoutConversionExport {
+    constructor({ data }) {
+      this.data = data ?? { text: 'Some text' };
+    }
+
+    static get conversionConfig() {
+      return {
+        import: 'text',
+      };
+    }
+
+    render() {
+      const element = document.createElement('div');
+
+      element.contentEditable = 'true';
+      element.textContent = this.data?.text ?? '';
+
+      return element;
+    }
+
+    save(element) {
+      return {
+        text: element.innerHTML,
+      };
+    }
+  };
+})()
+`;
+
+const toolWithToolboxVariantsClass = (): string => `
+(() => {
+  return class TestTool {
+    constructor({ data }) {
+      this.data = data ?? { text: 'Some text', level: 1 };
+    }
+
+    static get conversionConfig() {
+      return {
+        import: 'text',
+        export: 'text',
+      };
+    }
+
+    static get toolbox() {
+      return [
+        {
+          title: 'Title 1',
+          icon: 'Icon1',
+          data: {
+            level: 1,
+          },
+        },
+        {
+          title: 'Title 2',
+          icon: 'Icon2',
+          data: {
+            level: 2,
+          },
+        },
+      ];
+    }
+
+    render() {
+      const element = document.createElement('div');
+
+      element.textContent = this.data?.text ?? 'Some text';
+
+      return element;
+    }
+
+    save() {
+      return {
+        text: this.data?.text ?? 'Some text',
+        level: this.data?.level ?? 1,
+      };
+    }
+  };
+})()
+`;
+
+const toolWithCustomTuneClass = (): string => `
+(() => {
+  return class TestTool {
+    constructor({ data }) {
+      this.data = data ?? { text: 'Some text', level: 1 };
+    }
+
+    static get toolbox() {
+      return [
+        {
+          title: 'Title 1',
+          icon: 'Icon1',
+          data: {
+            level: 1,
+          },
+        },
+      ];
+    }
+
+    render() {
+      const element = document.createElement('div');
+
+      element.textContent = this.data?.text ?? 'Some text';
+
+      return element;
+    }
+
+    save() {
+      return {
+        text: this.data?.text ?? 'Some text',
+        level: this.data?.level ?? 1,
+      };
+    }
+
+    renderSettings() {
+      return {
+        icon: 'Icon',
+        title: 'Tune',
+        onActivate: () => {},
+      };
+    }
+  };
+})()
+`;
+
+const isSelectionInsideBlock = async (page: Page, selector: string): Promise<boolean> => {
+  return await page.evaluate(({ blockSelector }) => {
+    const block = document.querySelector(blockSelector);
+    const selection = window.getSelection();
+
+    if (!block || !selection || selection.rangeCount === 0) {
+      return false;
+    }
+
+    const range = selection.getRangeAt(0);
+
+    return block.contains(range.startContainer);
+  }, { blockSelector: selector });
+};
+
+test.describe('ui.block-tunes', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test.describe('keyboard interactions', () => {
+    test('keeps block content when pressing Enter inside search input', async ({ page }) => {
+      await createEditor(page, {
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Some text',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockTunesViaShortcut(page);
+
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+
+      await expect(searchInput).toHaveCount(1);
+      await searchInput.waitFor({ state: 'visible' });
+      await page.keyboard.press('Enter');
+
+      const paragraph = page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-paragraph`);
+
+      await expect(paragraph).toHaveCount(1);
+      await expect(paragraph).toHaveText('Some text');
+    });
+
+    test('keeps block selection when pressing Enter on a block tune', async ({ page }) => {
+      await createEditor(page, {
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Some text',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockTunesViaShortcut(page);
+
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+
+      await expect(searchInput).toHaveCount(1);
+      await searchInput.waitFor({ state: 'visible' });
+      await page.keyboard.press('Enter');
+
+      const block = page.locator(BLOCK_SELECTOR);
+
+      await expect(block).toHaveCount(1);
+      await expect(block).toHaveClass(/ce-block--selected/);
+    });
+  });
+
+  test.describe('convert to', () => {
+    test('shows available tools when conversion is possible', async ({ page }) => {
+      await page.addScriptTag({ path: HEADER_TOOL_UMD_PATH });
+      await createEditor(page, {
+        tools: {
+          header: {
+            className: 'Header',
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Some text',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockTunesViaToolbar(page);
+
+      const convertToOption = page
+        .locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover-item`)
+        .filter({ hasText: 'Convert to' });
+
+      await expect(convertToOption).toBeVisible();
+      await convertToOption.click();
+
+      await expect(
+        page.locator(`${NESTED_POPOVER_SELECTOR} [data-item-name="header"]`)
+      ).toBeVisible();
+    });
+
+    test('hides convert option when there is nothing to convert to', async ({ page }) => {
+      await createEditor(page, {
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Some text',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockTunesViaToolbar(page);
+
+      await expect(page.locator(CONVERT_TO_OPTION_SELECTOR)).toHaveCount(0);
+    });
+
+    test('hides convert option when export is not configured', async ({ page }) => {
+      await createEditor(page, {
+        tools: {
+          testTool: {
+            classCode: toolWithoutConversionExportClass(),
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'testTool',
+              data: {
+                text: 'Some text',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockTunesViaToolbar(page);
+
+      await expect(page.locator(CONVERT_TO_OPTION_SELECTOR)).toHaveCount(0);
+    });
+
+    test('filters out options with identical data', async ({ page }) => {
+      await createEditor(page, {
+        tools: {
+          testTool: {
+            classCode: toolWithToolboxVariantsClass(),
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'testTool',
+              data: {
+                text: 'Some text',
+                level: 1,
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockTunesViaToolbar(page);
+
+      const convertToOption = page
+        .locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover-item`)
+        .filter({ hasText: 'Convert to' });
+
+      await convertToOption.click();
+
+      await expect(
+        page
+          .locator(`${NESTED_POPOVER_SELECTOR} [data-item-name="testTool"]`)
+          .filter({ hasText: 'Title 1' })
+      ).toHaveCount(0);
+
+      await expect(
+        page
+          .locator(`${NESTED_POPOVER_SELECTOR} [data-item-name="testTool"]`)
+          .filter({ hasText: 'Title 2' })
+      ).toBeVisible();
+    });
+
+    test('converts block and keeps caret inside the new block', async ({ page }) => {
+      await page.addScriptTag({ path: HEADER_TOOL_UMD_PATH });
+      await createEditor(page, {
+        tools: {
+          header: {
+            className: 'Header',
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'Some text',
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockTunesViaToolbar(page);
+
+      const convertToOption = page
+        .locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover-item`)
+        .filter({ hasText: 'Convert to' });
+
+      await convertToOption.click();
+      await page
+        .locator(`${NESTED_POPOVER_SELECTOR} [data-item-name="header"]`)
+        .click();
+
+      const headerBlock = page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-header`);
+
+      await expect(headerBlock).toHaveText('Some text');
+      expect(
+        await isSelectionInsideBlock(
+          page,
+          `${EDITOR_INTERFACE_SELECTOR} .ce-header`
+        )
+      ).toBe(true);
+    });
+  });
+
+  test.describe('tunes order', () => {
+    test('renders block-specific tunes before common tunes', async ({ page }) => {
+      await createEditor(page, {
+        tools: {
+          testTool: {
+            classCode: toolWithCustomTuneClass(),
+          },
+        },
+        data: {
+          blocks: [
+            {
+              type: 'testTool',
+              data: {
+                text: 'Some text',
+                level: 1,
+              },
+            },
+          ],
+        },
+      });
+
+      await openBlockTunesViaToolbar(page);
+
+      const popoverContainer = page.locator(POPOVER_CONTAINER_SELECTOR);
+
+      await expect(popoverContainer).toHaveCount(1);
+
+      const popoverItems = popoverContainer.locator('.ce-popover-item:not(.ce-popover-item--hidden)');
+      const itemsCount = await popoverItems.count();
+
+      expect(itemsCount).toBeGreaterThan(1);
+      const firstPopoverItem = popoverContainer.locator('.ce-popover-item:not(.ce-popover-item--hidden):first-of-type');
+
+      await expect(firstPopoverItem).toContainText('Tune');
+    });
+  });
+});
+
diff --git a/test/playwright/tests/ui/data-empty.spec.ts b/test/playwright/tests/ui/data-empty.spec.ts
new file mode 100644
index 000000000..ff118a267
--- /dev/null
+++ b/test/playwright/tests/ui/data-empty.spec.ts
@@ -0,0 +1,167 @@
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import type EditorJS from '@/types';
+import type { OutputData } from '@/types';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-paragraph`;
+const PARAGRAPH_INDEX_ATTRIBUTE = 'data-cy-paragraph-index';
+const SELECT_ALL_SHORTCUT = process.platform === 'darwin' ? 'Meta+A' : 'Control+A';
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+  }
+}
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditorWithTextBlocks = async (page: Page, textBlocks: string[]): Promise<void> => {
+  const blocks: OutputData['blocks'] = textBlocks.map((text, index) => ({
+    id: `paragraph-${index + 1}`,
+    type: 'paragraph',
+    data: {
+      text,
+    },
+  }));
+
+  await resetEditor(page);
+  await page.waitForFunction(() => typeof window.EditorJS === 'function');
+
+  await page.evaluate(
+    async ({ holderId, blocksData }) => {
+      const editor = new window.EditorJS({
+        holder: holderId,
+        data: {
+          blocks: blocksData,
+        },
+      });
+
+      window.editorInstance = editor;
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      blocksData: blocks,
+    }
+  );
+};
+
+const assignParagraphIndexes = async (page: Page): Promise<void> => {
+  await page.evaluate(
+    ({ selector, attribute }) => {
+      const elements = Array.from(document.querySelectorAll<HTMLElement>(selector));
+
+      elements.forEach((element, index) => {
+        element.setAttribute(attribute, String(index));
+      });
+    },
+    {
+      selector: PARAGRAPH_SELECTOR,
+      attribute: PARAGRAPH_INDEX_ATTRIBUTE,
+    }
+  );
+};
+
+test.describe('data-empty attribute', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+  });
+
+  test('reflects initial block content', async ({ page }) => {
+    await createEditorWithTextBlocks(page, ['First', '']);
+    await assignParagraphIndexes(page);
+
+    const paragraphs = page.locator(PARAGRAPH_SELECTOR);
+    const firstParagraph = page.locator(
+      `${PARAGRAPH_SELECTOR}[${PARAGRAPH_INDEX_ATTRIBUTE}="0"]`
+    );
+    const secondParagraph = page.locator(
+      `${PARAGRAPH_SELECTOR}[${PARAGRAPH_INDEX_ATTRIBUTE}="1"]`
+    );
+
+    await expect(paragraphs).toHaveCount(2);
+    await expect(firstParagraph).toHaveAttribute('data-empty', 'false');
+    await expect(secondParagraph).toHaveAttribute('data-empty', 'true');
+  });
+
+  test('updates to "false" after typing', async ({ page }) => {
+    await createEditorWithTextBlocks(page, ['First', '']);
+    await assignParagraphIndexes(page);
+
+    const lastParagraph = page.locator(
+      `${PARAGRAPH_SELECTOR}[${PARAGRAPH_INDEX_ATTRIBUTE}="1"]`
+    );
+
+    await lastParagraph.click();
+    await lastParagraph.type('Some text');
+    await expect(lastParagraph).toHaveAttribute('data-empty', 'false');
+  });
+
+  test('updates to "true" after removing content', async ({ page }) => {
+    await createEditorWithTextBlocks(page, ['', 'Some text']);
+    await assignParagraphIndexes(page);
+
+    const lastParagraph = page.locator(
+      `${PARAGRAPH_SELECTOR}[${PARAGRAPH_INDEX_ATTRIBUTE}="1"]`
+    );
+
+    await lastParagraph.click();
+    await page.keyboard.press(SELECT_ALL_SHORTCUT);
+    await page.keyboard.press('Backspace');
+    await expect(lastParagraph).toHaveAttribute('data-empty', 'true');
+  });
+
+  test('applies to newly created blocks', async ({ page }) => {
+    await createEditorWithTextBlocks(page, ['First', '']);
+    await assignParagraphIndexes(page);
+
+    const paragraphs = page.locator(PARAGRAPH_SELECTOR);
+    const secondParagraph = page.locator(
+      `${PARAGRAPH_SELECTOR}[${PARAGRAPH_INDEX_ATTRIBUTE}="1"]`
+    );
+
+    await secondParagraph.click();
+    await page.keyboard.press('Enter');
+
+    await assignParagraphIndexes(page);
+
+    await expect(paragraphs).toHaveCount(3);
+    const newestParagraph = page.locator(
+      `${PARAGRAPH_SELECTOR}[${PARAGRAPH_INDEX_ATTRIBUTE}="2"]`
+    );
+
+    await expect(newestParagraph).toHaveAttribute('data-empty', 'true');
+  });
+});
+
diff --git a/test/playwright/tests/ui/initialization.spec.ts b/test/playwright/tests/ui/initialization.spec.ts
new file mode 100644
index 000000000..5396008d9
--- /dev/null
+++ b/test/playwright/tests/ui/initialization.spec.ts
@@ -0,0 +1,155 @@
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import type EditorJS from '@/types';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const EDITOR_ROOT_SELECTOR = EDITOR_INTERFACE_SELECTOR;
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-paragraph`;
+const STYLE_TAG_SELECTOR = '#editor-js-styles';
+
+type InitializationOptions = {
+  readOnly?: boolean;
+  style?: {
+    nonce?: string;
+  };
+};
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+  }
+}
+
+const waitForEditorConstructor = async (page: Page): Promise<void> => {
+  await page.waitForFunction(() => {
+    const candidate = (window as unknown as { EditorJS?: unknown }).EditorJS;
+
+    if (typeof candidate === 'function') {
+      return true;
+    }
+
+    if (candidate && typeof candidate === 'object') {
+      const defaultExport = (candidate as { default?: unknown }).default;
+
+      return typeof defaultExport === 'function';
+    }
+
+    return false;
+  });
+};
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const normalizeEditorConstructor = async (page: Page): Promise<void> => {
+  await page.evaluate(() => {
+    const candidate = (window as unknown as { EditorJS?: unknown }).EditorJS;
+
+    if (!candidate) {
+      throw new Error('EditorJS constructor is not available on window');
+    }
+
+    if (typeof candidate === 'object') {
+      const defaultExport = (candidate as { default?: unknown }).default;
+
+      if (typeof defaultExport === 'function') {
+        (window as unknown as { EditorJS: unknown }).EditorJS = defaultExport;
+      }
+    }
+  });
+};
+
+const createEditor = async (page: Page, options: InitializationOptions = {}): Promise<void> => {
+  await resetEditor(page);
+  await waitForEditorConstructor(page);
+  await normalizeEditorConstructor(page);
+
+  await page.evaluate(async ({ serializedOptions }) => {
+    if (typeof window.EditorJS !== 'function') {
+      throw new Error('EditorJS constructor is not available on window');
+    }
+
+    const editorConfig: Record<string, unknown> = {};
+
+    if (serializedOptions.readOnly !== undefined) {
+      editorConfig.readOnly = serializedOptions.readOnly;
+    }
+
+    if (serializedOptions.style) {
+      editorConfig.style = serializedOptions.style;
+    }
+
+    const editor = new window.EditorJS(editorConfig);
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { serializedOptions: options });
+};
+
+test.describe('editor basic initialization', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+  });
+
+  test.describe('zero-config initialization', () => {
+    test('creates a visible UI', async ({ page }) => {
+      await createEditor(page);
+
+      await expect(page.locator(EDITOR_ROOT_SELECTOR)).toBeVisible();
+    });
+  });
+
+  test.describe('configuration', () => {
+    test.describe('readOnly', () => {
+      test('creates editor without editing ability when true passed', async ({ page }) => {
+        await createEditor(page, {
+          readOnly: true,
+        });
+
+        const readOnlyParagraph = page.locator(`${PARAGRAPH_SELECTOR}[contenteditable="false"]`);
+
+        await expect(readOnlyParagraph).toBeVisible();
+      });
+    });
+
+    test('adds passed nonce attribute to editor styles when nonce provided', async ({ page }) => {
+      await createEditor(page, {
+        style: {
+          nonce: 'test-nonce',
+        },
+      });
+
+      await expect(page.locator(STYLE_TAG_SELECTOR)).toHaveAttribute('nonce', 'test-nonce');
+    });
+  });
+});
+
+
diff --git a/test/playwright/tests/ui/inline-toolbar.spec.ts b/test/playwright/tests/ui/inline-toolbar.spec.ts
new file mode 100644
index 000000000..3a54c6192
--- /dev/null
+++ b/test/playwright/tests/ui/inline-toolbar.spec.ts
@@ -0,0 +1,832 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type EditorJS from '@/types';
+import type { EditorConfig, OutputData } from '@/types';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+import {
+  EDITOR_INTERFACE_SELECTOR,
+  INLINE_TOOLBAR_INTERFACE_SELECTOR
+} from '../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HEADER_TOOL_UMD_PATH = path.resolve(
+  __dirname,
+  '../../../../node_modules/@editorjs/header/dist/header.umd.js'
+);
+
+const HOLDER_ID = 'editorjs';
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-paragraph`;
+const HEADER_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-header`;
+const INLINE_TOOLBAR_ITEMS_SELECTOR = `${INLINE_TOOLBAR_INTERFACE_SELECTOR} .ce-popover__items > *`;
+const INLINE_TOOLBAR_CONTAINER_SELECTOR = `${INLINE_TOOLBAR_INTERFACE_SELECTOR} .ce-popover__container`;
+const INLINE_TOOL_SELECTOR = `${INLINE_TOOLBAR_INTERFACE_SELECTOR} .ce-popover-item`;
+const NESTED_EDITOR_ID = 'nested-editor';
+
+type SerializableToolConfig = {
+  className?: string;
+  classCode?: string;
+  config?: Record<string, unknown>;
+};
+
+type CreateEditorOptions = Pick<EditorConfig, 'readOnly' | 'placeholder'> & {
+  data?: OutputData;
+  tools?: Record<string, SerializableToolConfig>;
+};
+
+const TEST_INLINE_TOOL_SOURCE = `
+class TestTool {
+  static isInline = true;
+
+  constructor() {}
+
+  render() {
+    return {
+      icon: 'n',
+      title: 'Test Tool',
+      name: 'test-tool',
+      children: {
+        items: [
+          {
+            icon: 'm',
+            title: 'Test Tool Item',
+            onActivate: () => {},
+          },
+        ],
+      },
+    };
+  }
+}
+`;
+
+const READ_ONLY_INLINE_TOOL_SOURCE = `
+class ReadOnlyInlineTool {
+  static isInline = true;
+  static isReadOnlySupported = true;
+
+  render() {
+    return {
+      title: 'Test Tool',
+      name: 'test-tool',
+      onActivate: () => {},
+    };
+  }
+}
+`;
+
+const NESTED_EDITOR_TOOL_SOURCE = `
+class NestedEditorTool {
+  constructor({ data }) {
+    this.data = data || {};
+    this.nestedEditor = null;
+  }
+
+  render() {
+    const wrapper = document.createElement('div');
+    const holder = document.createElement('div');
+    const holderId = '${NESTED_EDITOR_ID}-holder-' + Math.random().toString(16).slice(2);
+
+    wrapper.dataset.cy = '${NESTED_EDITOR_ID}';
+    holder.id = holderId;
+    holder.dataset.cy = '${NESTED_EDITOR_ID}-holder';
+
+    wrapper.appendChild(holder);
+
+    this.nestedEditor = new window.EditorJS({
+      holder: holderId,
+      data: {
+        blocks: [
+          {
+            type: 'paragraph',
+            data: {
+              text: this.data?.text || '',
+            },
+          },
+        ],
+      },
+      inlineToolbar: true,
+    });
+
+    return wrapper;
+  }
+
+  async destroy() {
+    if (this.nestedEditor && typeof this.nestedEditor.destroy === 'function') {
+      await this.nestedEditor.destroy();
+    }
+  }
+
+  save() {
+    return this.data?.text || '';
+  }
+}
+`;
+
+/**
+ * Reset the editor holder and destroy any existing instance
+ *
+ * @param page - The Playwright page object
+ */
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ * Initialize the editor with the provided configuration
+ *
+ * @param page - The Playwright page object
+ * @param options - Editor configuration options
+ */
+const createEditor = async (page: Page, options: CreateEditorOptions = {}): Promise<void> => {
+  await resetEditor(page);
+
+  const { tools = {}, data, ...restOptions } = options;
+
+  const serializedTools = Object.entries(tools).map(([name, toolConfig]) => {
+    return {
+      name,
+      className: toolConfig.className ?? null,
+      classCode: toolConfig.classCode ?? null,
+      config: toolConfig.config ?? {},
+    };
+  });
+
+  await page.evaluate(
+    async ({ holderId, editorOptions, editorData, editorTools }) => {
+      const editorConfig: Record<string, unknown> = {
+        holder: holderId,
+        ...editorOptions,
+      };
+
+      if (editorData) {
+        editorConfig.data = editorData;
+      }
+
+      if (editorTools.length > 0) {
+        const toolsConfig = editorTools.reduce<Record<string, { class: unknown } & Record<string, unknown>>>(
+          (accumulator, { name, className, classCode, config }) => {
+            let toolClass: unknown;
+
+            if (className) {
+              toolClass = (window as unknown as Record<string, unknown>)[className];
+            }
+
+            if (!toolClass && classCode) {
+              // eslint-disable-next-line no-new-func -- constructing helper class inside page context
+              toolClass = new Function(`return (${classCode});`)();
+            }
+
+            if (!toolClass) {
+              throw new Error(`Tool class for "${name}" is not available`);
+            }
+
+            return {
+              ...accumulator,
+              [name]: {
+                class: toolClass,
+                ...config,
+              },
+            };
+          },
+          {}
+        );
+
+        editorConfig.tools = toolsConfig;
+      }
+
+      const editor = new window.EditorJS(editorConfig);
+
+      window.editorInstance = editor;
+
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      editorOptions: restOptions,
+      editorData: data ?? null,
+      editorTools: serializedTools,
+    }
+  );
+};
+
+/**
+ * Programmatically set selection range within an element.
+ *
+ * @param locator - Locator that wraps the element containing selectable text
+ * @param start - Selection start offset (inclusive)
+ * @param end - Selection end offset (exclusive)
+ */
+const setSelectionRange = async (locator: Locator, start: number, end: number): Promise<void> => {
+  if (start < 0 || end < start) {
+    throw new Error(`Invalid selection offsets: start (${start}) must be >= 0 and end (${end}) must be >= start.`);
+  }
+
+  await locator.scrollIntoViewIfNeeded();
+  await locator.focus();
+
+  await locator.evaluate(
+    (element, { start: selectionStart, end: selectionEnd }) => {
+      const ownerDocument = element.ownerDocument;
+
+      if (!ownerDocument) {
+        return;
+      }
+
+      const selection = ownerDocument.getSelection();
+
+      if (!selection) {
+        return;
+      }
+
+      const textNodes: Text[] = [];
+      const walker = ownerDocument.createTreeWalker(element, NodeFilter.SHOW_TEXT);
+
+      let currentNode = walker.nextNode();
+
+      while (currentNode) {
+        textNodes.push(currentNode as Text);
+        currentNode = walker.nextNode();
+      }
+
+      if (textNodes.length === 0) {
+        return;
+      }
+
+      const findPosition = (offset: number): { node: Text; nodeOffset: number } | null => {
+        let accumulated = 0;
+
+        for (const node of textNodes) {
+          const length = node.textContent?.length ?? 0;
+          const nodeStart = accumulated;
+          const nodeEnd = accumulated + length;
+
+          if (offset >= nodeStart && offset <= nodeEnd) {
+            return {
+              node,
+              nodeOffset: Math.min(length, offset - nodeStart),
+            };
+          }
+
+          accumulated = nodeEnd;
+        }
+
+        if (offset === 0) {
+          const firstNode = textNodes[0];
+
+          return {
+            node: firstNode,
+            nodeOffset: 0,
+          };
+        }
+
+        return null;
+      };
+
+      const startPosition = findPosition(selectionStart);
+      const endPosition = findPosition(selectionEnd);
+
+      if (!startPosition || !endPosition) {
+        return;
+      }
+
+      const range = ownerDocument.createRange();
+
+      range.setStart(startPosition.node, startPosition.nodeOffset);
+      range.setEnd(endPosition.node, endPosition.nodeOffset);
+
+      selection.removeAllRanges();
+      selection.addRange(range);
+    },
+    { start,
+      end }
+  );
+};
+
+/**
+ * Select text content within a locator by string match
+ *
+ * @param locator - The Playwright locator for the element containing the text
+ * @param text - The text string to select within the element
+ */
+const selectText = async (locator: Locator, text: string): Promise<void> => {
+  const fullText = await locator.textContent();
+
+  if (!fullText || !fullText.includes(text)) {
+    throw new Error(`Text "${text}" was not found in element`);
+  }
+
+  const startIndex = fullText.indexOf(text);
+  const endIndex = startIndex + text.length;
+
+  await setSelectionRange(locator, startIndex, endIndex);
+};
+
+/**
+ * Select text content within a locator by character offsets
+ *
+ * @param locator - The Playwright locator for the element containing the text
+ * @param start - The start offset (inclusive)
+ * @param end - The end offset (exclusive)
+ */
+const selectTextByOffset = async (locator: Locator, start: number, end: number): Promise<void> => {
+  await setSelectionRange(locator, start, end);
+};
+
+/**
+ * Calculate line wrap positions for the provided locator
+ *
+ * @param locator - The Playwright locator for the element containing the text
+ */
+const getLineWrapPositions = async (locator: Locator): Promise<number[]> => {
+  return locator.evaluate((element) => {
+    const lineWraps: number[] = [];
+    const firstChild = element.firstChild;
+
+    if (!firstChild || firstChild.nodeType !== Node.TEXT_NODE) {
+      return lineWraps;
+    }
+
+    const document = element.ownerDocument;
+
+    if (!document) {
+      return lineWraps;
+    }
+
+    const textContent = firstChild.textContent ?? '';
+    let currentLineTop: number | undefined;
+
+    for (let index = 0; index < textContent.length; index++) {
+      const range = document.createRange();
+
+      range.setStart(firstChild, index);
+      range.setEnd(firstChild, index);
+
+      const rect = range.getBoundingClientRect();
+
+      if (index === 0) {
+        currentLineTop = rect.top;
+        continue;
+      }
+
+      if (typeof currentLineTop === 'number' && rect.top > currentLineTop) {
+        lineWraps.push(index);
+        currentLineTop = rect.top;
+      }
+    }
+
+    return lineWraps;
+  });
+};
+
+type ToolbarItemSnapshot = {
+  name: string | null;
+  hasSeparator: boolean;
+};
+
+/**
+ * Collect inline toolbar items meta information for assertions that depend on ordering
+ *
+ * @param page - The Playwright page object
+ */
+const getInlineToolbarSnapshot = async (page: Page): Promise<ToolbarItemSnapshot[]> => {
+  // eslint-disable-next-line playwright/no-wait-for-selector
+  await page.waitForSelector(INLINE_TOOLBAR_ITEMS_SELECTOR, {
+    state: 'visible',
+  });
+
+  return page.evaluate((selector) => {
+    const elements = Array.from(document.querySelectorAll(selector));
+
+    return elements.map((element) => {
+      return {
+        name: element.getAttribute('data-item-name'),
+        hasSeparator: element.classList.contains('ce-popover-item-separator'),
+      };
+    });
+  }, INLINE_TOOLBAR_ITEMS_SELECTOR);
+};
+
+test.describe('inline toolbar', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test('should align with the left coordinate of the selection range', async ({ page }) => {
+    await createEditor(page, {
+      data: {
+        blocks: [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'First block text',
+            },
+          },
+        ],
+      },
+    });
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await expect(paragraph).toHaveCount(1);
+
+    await selectText(paragraph, 'block');
+
+    const toolbar = page.locator(INLINE_TOOLBAR_CONTAINER_SELECTOR);
+
+    await expect(toolbar).toBeVisible();
+
+    const toolbarBox = await toolbar.boundingBox();
+
+    expect(toolbarBox).not.toBeNull();
+
+    const selectionRect = await page.evaluate(() => {
+      const selection = window.getSelection();
+
+      if (!selection || selection.rangeCount === 0) {
+        throw new Error('No selection available');
+      }
+
+      const rect = selection.getRangeAt(0).getBoundingClientRect();
+
+      return {
+        left: rect.left,
+      };
+    });
+
+    const toolbarLeft = toolbarBox!.x;
+
+    expect(Math.abs(toolbarLeft - selectionRect.left)).toBeLessThanOrEqual(1);
+  });
+
+  test('should align with the right edge when toolbar width exceeds available space', async ({ page }) => {
+    await createEditor(page, {
+      data: {
+        blocks: [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Writing is a powerful tool for communication and expression. When crafting content, it is important to consider your audience and the message you want to convey. Good writing requires careful thought, clear structure, and attention to detail. The process of editing helps refine your ideas and improve clarity.',
+            },
+          },
+        ],
+      },
+    });
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await expect(paragraph).toHaveCount(1);
+    const [ firstLineWrapIndex ] = await getLineWrapPositions(paragraph);
+
+    expect(firstLineWrapIndex).toBeGreaterThan(4);
+
+    await selectTextByOffset(paragraph, firstLineWrapIndex - 5, firstLineWrapIndex);
+
+    const toolbar = page.locator(INLINE_TOOLBAR_CONTAINER_SELECTOR);
+
+    await expect(toolbar).toBeVisible();
+
+    const toolbarBox = await toolbar.boundingBox();
+    const paragraphBox = await paragraph.boundingBox();
+
+    expect(toolbarBox).not.toBeNull();
+    expect(paragraphBox).not.toBeNull();
+
+    const toolbarRight = toolbarBox!.x + toolbarBox!.width;
+    const paragraphRight = paragraphBox!.x + paragraphBox!.width;
+
+    expect(Math.abs(toolbarRight - paragraphRight)).toBeLessThanOrEqual(10);
+  });
+
+  test('should display inline toolbar in read-only mode when tool supports it', async ({ page }) => {
+    await page.addScriptTag({ path: HEADER_TOOL_UMD_PATH });
+
+    await createEditor(page, {
+      readOnly: true,
+      data: {
+        blocks: [
+          {
+            type: 'header',
+            data: {
+              text: 'First block text',
+            },
+          },
+        ],
+      },
+      tools: {
+        header: {
+          className: 'Header',
+          config: {
+            inlineToolbar: ['bold', 'testTool'],
+          },
+        },
+        testTool: {
+          classCode: READ_ONLY_INLINE_TOOL_SOURCE,
+        },
+      },
+    });
+
+    const headerBlock = page.locator(HEADER_SELECTOR);
+
+    await expect(headerBlock).toHaveCount(1);
+
+    await selectText(headerBlock, 'block');
+
+    const toolbarItems = page.locator(INLINE_TOOL_SELECTOR);
+
+    await expect(toolbarItems).toHaveCount(1);
+    await expect(toolbarItems).toHaveAttribute('data-item-name', 'test-tool');
+  });
+
+  test('should not submit surrounding form when inline tool is activated', async ({ page }) => {
+    await createEditor(page, {
+      data: {
+        blocks: [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Some text',
+            },
+          },
+        ],
+      },
+    });
+
+    await page.evaluate(({ holderId }) => {
+      const form = document.createElement('form');
+
+      form.id = 'inline-toolbar-form';
+      form.addEventListener('submit', (event) => {
+        event.preventDefault();
+        window.inlineToolbarFormSubmitCount = (window.inlineToolbarFormSubmitCount ?? 0) + 1;
+      });
+
+      document.body.appendChild(form);
+
+      const editorElement = document.getElementById(holderId);
+
+      if (!editorElement) {
+        throw new Error('Editor element not found');
+      }
+
+      form.appendChild(editorElement);
+
+      window.inlineToolbarFormSubmitCount = 0;
+    }, { holderId: HOLDER_ID });
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await expect(paragraph).toHaveCount(1);
+
+    await selectText(paragraph, 'Some text');
+
+    await page.locator('[data-item-name="bold"]').click();
+
+    const submitCount = await page.evaluate(() => window.inlineToolbarFormSubmitCount ?? 0);
+
+    expect(submitCount).toBe(0);
+  });
+
+  test('should restore caret after converting a block', async ({ page }) => {
+    await page.addScriptTag({ path: HEADER_TOOL_UMD_PATH });
+
+    await createEditor(page, {
+      tools: {
+        header: {
+          className: 'Header',
+        },
+      },
+      data: {
+        blocks: [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Some text',
+            },
+          },
+        ],
+      },
+    });
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await expect(paragraph).toHaveCount(1);
+
+    await selectText(paragraph, 'Some text');
+
+    await page.locator('[data-item-name="convert-to"]').click();
+    await page.locator(`${INLINE_TOOLBAR_INTERFACE_SELECTOR} .ce-popover-item[data-item-name="header"]`).click();
+
+    await expect(page.locator(HEADER_SELECTOR)).toHaveText('Some text');
+
+    const selectionState = await page.evaluate((selector) => {
+      const selection = window.getSelection();
+
+      if (!selection || selection.rangeCount === 0) {
+        return {
+          rangeCount: 0,
+          isInsideHeader: false,
+        };
+      }
+
+      const range = selection.getRangeAt(0);
+      const headerElement = document.querySelector(selector);
+
+      return {
+        rangeCount: selection.rangeCount,
+        isInsideHeader: !!headerElement && headerElement.contains(range.startContainer),
+      };
+    }, HEADER_SELECTOR);
+
+    expect(selectionState.rangeCount).toBe(1);
+    expect(selectionState.isInsideHeader).toBe(true);
+  });
+
+  test('should keep nested inline toolbar open while interacting with nested editor', async ({ page }) => {
+    await createEditor(page, {
+      tools: {
+        nestedEditor: {
+          classCode: NESTED_EDITOR_TOOL_SOURCE,
+        },
+      },
+      data: {
+        blocks: [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Document editing requires precision and attention to detail. Every word matters when crafting clear and effective content.',
+            },
+          },
+          {
+            type: 'nestedEditor',
+            data: {
+              text: 'The nested editor allows for complex document structures and hierarchical content organization',
+            },
+          },
+        ],
+      },
+    });
+
+    const nestedParagraph = page.locator(`[data-cy="${NESTED_EDITOR_ID}"] ${PARAGRAPH_SELECTOR}`);
+
+    await expect(nestedParagraph).toHaveCount(1);
+
+    await expect(nestedParagraph).toBeVisible();
+
+    await selectText(nestedParagraph, 'document structures');
+
+    await page.locator(`[data-cy="${NESTED_EDITOR_ID}"] [data-item-name="link"]`).click();
+
+    const input = page.locator(`[data-cy="${NESTED_EDITOR_ID}"] .ce-inline-tool-input`);
+
+    await input.click();
+    await input.type('https://editorjs.io', { delay: 20 });
+
+    const nestedToolbar = page.locator(
+      `[data-cy="${NESTED_EDITOR_ID}"] [data-interface="inline-toolbar"] > .ce-popover > .ce-popover__container`
+    );
+
+    await expect(nestedToolbar).toBeVisible();
+  });
+
+  test('should have a separator after the first item if it has children', async ({ page }) => {
+    await createEditor(page, {
+      data: {
+        blocks: [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'First block text',
+            },
+          },
+        ],
+      },
+    });
+
+    const paragraph = page.locator(PARAGRAPH_SELECTOR);
+
+    await expect(paragraph).toHaveCount(1);
+
+    await selectText(paragraph, 'block');
+
+    const toolbarSnapshot = await getInlineToolbarSnapshot(page);
+
+    expect(toolbarSnapshot[0]?.name).toBe('convert-to');
+    expect(toolbarSnapshot[1]?.hasSeparator).toBe(true);
+  });
+
+  test('should have separators from both sides of item if it is in the middle and has children', async ({ page }) => {
+    await page.addScriptTag({ path: HEADER_TOOL_UMD_PATH });
+
+    await createEditor(page, {
+      data: {
+        blocks: [
+          {
+            type: 'header',
+            data: {
+              text: 'First block text',
+            },
+          },
+        ],
+      },
+      tools: {
+        header: {
+          className: 'Header',
+          config: {
+            inlineToolbar: ['bold', 'testTool', 'link'],
+          },
+        },
+        testTool: {
+          classCode: TEST_INLINE_TOOL_SOURCE,
+        },
+      },
+    });
+
+    const headerBlock = page.locator(HEADER_SELECTOR);
+
+    await expect(headerBlock).toHaveCount(1);
+
+    await selectText(headerBlock, 'block');
+
+    const toolbarSnapshot = await getInlineToolbarSnapshot(page);
+    const testToolIndex = toolbarSnapshot.findIndex((item) => item.name === 'test-tool');
+
+    expect(testToolIndex).toBeGreaterThan(0);
+    expect(toolbarSnapshot[testToolIndex - 1]?.hasSeparator).toBe(true);
+    expect(toolbarSnapshot[testToolIndex + 1]?.hasSeparator).toBe(true);
+  });
+
+  test('should have separator before the item with children if it is the last of all items', async ({ page }) => {
+    await page.addScriptTag({ path: HEADER_TOOL_UMD_PATH });
+
+    await createEditor(page, {
+      data: {
+        blocks: [
+          {
+            type: 'header',
+            data: {
+              text: 'First block text',
+            },
+          },
+        ],
+      },
+      tools: {
+        header: {
+          className: 'Header',
+          config: {
+            inlineToolbar: ['bold', 'testTool'],
+          },
+        },
+        testTool: {
+          classCode: TEST_INLINE_TOOL_SOURCE,
+        },
+      },
+    });
+
+    const headerBlock = page.locator(HEADER_SELECTOR);
+
+    await expect(headerBlock).toHaveCount(1);
+
+    await selectText(headerBlock, 'block');
+
+    const toolbarSnapshot = await getInlineToolbarSnapshot(page);
+    const testToolIndex = toolbarSnapshot.findIndex((item) => item.name === 'test-tool');
+
+    expect(testToolIndex).toBeGreaterThan(0);
+    expect(testToolIndex).toBe(toolbarSnapshot.length - 1);
+    expect(toolbarSnapshot[testToolIndex - 1]?.hasSeparator).toBe(true);
+  });
+});
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+    EditorJS: new (...args: unknown[]) => EditorJS;
+    toolSurround?: () => void;
+    inlineToolbarFormSubmitCount?: number;
+  }
+}
+
diff --git a/test/playwright/tests/ui/placeholders.spec.ts b/test/playwright/tests/ui/placeholders.spec.ts
new file mode 100644
index 000000000..d4d02cae1
--- /dev/null
+++ b/test/playwright/tests/ui/placeholders.spec.ts
@@ -0,0 +1,201 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import type EditorJS from '@/types';
+import type { EditorConfig } from '@/types';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-paragraph`;
+const PLACEHOLDER_TEXT = 'Write something or press / to select a tool';
+const SELECT_ALL_SHORTCUT = process.platform === 'darwin' ? 'Meta+A' : 'Control+A';
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+  }
+}
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+type CreateEditorOptions = Pick<EditorConfig, 'placeholder' | 'autofocus'>;
+
+const createEditor = async (page: Page, options: CreateEditorOptions = {}): Promise<void> => {
+  const { placeholder = null, autofocus = null } = options;
+
+  await resetEditor(page);
+  await page.waitForFunction(() => typeof window.EditorJS === 'function');
+
+  await page.evaluate(
+    async ({ holderId, editorOptions }) => {
+      const config: Record<string, unknown> = {
+        holder: holderId,
+      };
+
+      if (editorOptions.placeholder !== null) {
+        config.placeholder = editorOptions.placeholder;
+      }
+
+      if (editorOptions.autofocus !== null) {
+        config.autofocus = editorOptions.autofocus;
+      }
+
+      const editor = new window.EditorJS(config);
+
+      window.editorInstance = editor;
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      editorOptions: {
+        placeholder,
+        autofocus,
+      },
+    }
+  );
+};
+
+const escapeAttributeValue = (value: string): string => {
+  return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+};
+
+const getParagraphWithPlaceholder = (page: Page, placeholder: string): Locator => {
+  const escapedPlaceholder = escapeAttributeValue(placeholder);
+
+  const selectors = [
+    `${PARAGRAPH_SELECTOR}[data-placeholder='${escapedPlaceholder}']`,
+    `${PARAGRAPH_SELECTOR}[data-placeholder-active='${escapedPlaceholder}']`,
+  ].join(', ');
+
+  return page.locator(selectors);
+};
+
+const getPseudoElementContent = async (
+  locator: Locator,
+  pseudoElement: '::before' | '::after'
+): Promise<string> => {
+  return await locator.evaluate((element, pseudo) => {
+    const view = element.ownerDocument.defaultView;
+
+    if (!view) {
+      throw new Error('Element is not attached to a window');
+    }
+
+    const content = view.getComputedStyle(element, pseudo).getPropertyValue('content');
+
+    return content.replace(/['"]/g, '');
+  }, pseudoElement);
+};
+
+const expectPlaceholderContent = async (locator: Locator, expected: string): Promise<void> => {
+  await expect.poll(async () => {
+    return await getPseudoElementContent(locator, '::before');
+  }).toBe(expected);
+};
+
+test.describe('placeholders', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+  });
+
+  test('shows placeholder when provided in config', async ({ page }) => {
+    await createEditor(page, { placeholder: PLACEHOLDER_TEXT });
+
+    const paragraph = getParagraphWithPlaceholder(page, PLACEHOLDER_TEXT);
+
+    await expect(paragraph).toBeVisible();
+    await expectPlaceholderContent(paragraph, PLACEHOLDER_TEXT);
+  });
+
+  test('shows placeholder when editor is autofocusable', async ({ page }) => {
+    await createEditor(page, {
+      placeholder: PLACEHOLDER_TEXT,
+      autofocus: true,
+    });
+
+    const paragraph = getParagraphWithPlaceholder(page, PLACEHOLDER_TEXT);
+
+    await expect(paragraph).toBeVisible();
+    await expectPlaceholderContent(paragraph, PLACEHOLDER_TEXT);
+  });
+
+  test('keeps placeholder visible when block receives focus', async ({ page }) => {
+    await createEditor(page, { placeholder: PLACEHOLDER_TEXT });
+
+    const paragraph = getParagraphWithPlaceholder(page, PLACEHOLDER_TEXT);
+
+    await expect(paragraph).toBeVisible();
+    await paragraph.click();
+    await expectPlaceholderContent(paragraph, PLACEHOLDER_TEXT);
+  });
+
+  test('restores placeholder after clearing typed content', async ({ page }) => {
+    await createEditor(page, { placeholder: PLACEHOLDER_TEXT });
+
+    const paragraph = getParagraphWithPlaceholder(page, PLACEHOLDER_TEXT);
+
+    await expect(paragraph).toBeVisible();
+    await paragraph.click();
+    await paragraph.type('aaa');
+    await page.keyboard.press(SELECT_ALL_SHORTCUT);
+    await page.keyboard.press('Backspace');
+
+    await expectPlaceholderContent(paragraph, PLACEHOLDER_TEXT);
+  });
+
+  test('hides placeholder after typing characters', async ({ page }) => {
+    await createEditor(page, { placeholder: PLACEHOLDER_TEXT });
+
+    const paragraph = getParagraphWithPlaceholder(page, PLACEHOLDER_TEXT);
+
+    await expect(paragraph).toBeVisible();
+    await expectPlaceholderContent(paragraph, PLACEHOLDER_TEXT);
+
+    await paragraph.type('a');
+
+    await expectPlaceholderContent(paragraph, 'none');
+  });
+
+  test('hides placeholder after typing whitespace', async ({ page }) => {
+    await createEditor(page, { placeholder: PLACEHOLDER_TEXT });
+
+    const paragraph = getParagraphWithPlaceholder(page, PLACEHOLDER_TEXT);
+
+    await expect(paragraph).toBeVisible();
+    await expectPlaceholderContent(paragraph, PLACEHOLDER_TEXT);
+
+    await paragraph.type('   ');
+
+    await expectPlaceholderContent(paragraph, 'none');
+  });
+});
+
+
diff --git a/test/playwright/tests/ui/toolbox.spec.ts b/test/playwright/tests/ui/toolbox.spec.ts
new file mode 100644
index 000000000..9b8d1065e
--- /dev/null
+++ b/test/playwright/tests/ui/toolbox.spec.ts
@@ -0,0 +1,619 @@
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type EditorJS from '@/types';
+import type { ConversionConfig, ToolboxConfig, OutputData } from '@/types';
+import type { BlockToolConstructable } from '@/types/tools';
+import { EDITOR_INTERFACE_SELECTOR, MODIFIER_KEY } from '../../../../src/components/constants';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-block-tool="paragraph"]`;
+const POPOVER_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-popover`;
+const POPOVER_ITEM_SELECTOR = `${POPOVER_SELECTOR} .ce-popover-item`;
+const SECONDARY_TITLE_SELECTOR = '.ce-popover-item__secondary-title';
+
+/**
+ * Reset the editor holder and destroy any existing instance
+ *
+ * @param page - The Playwright page object
+ */
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ * Create editor with custom tools
+ *
+ * @param page - The Playwright page object
+ * @param tools - Tools configuration
+ * @param data - Optional initial editor data
+ */
+type SerializedToolConfig = {
+  name: string;
+  classSource: string;
+  config: Record<string, unknown>;
+};
+
+const registerToolClasses = async (page: Page, tools: SerializedToolConfig[]): Promise<void> => {
+  if (tools.length === 0) {
+    return;
+  }
+
+  const scriptContent = tools
+    .map(({ name, classSource }) => {
+      return `
+(function registerTool(){
+  window.__playwrightToolRegistry = window.__playwrightToolRegistry || {};
+  window.__playwrightToolRegistry[${JSON.stringify(name)}] = (${classSource});
+}());
+`;
+    })
+    .join('\n');
+
+  await page.addScriptTag({ content: scriptContent });
+};
+
+const serializeTools = (
+  tools: Record<string, { class: BlockToolConstructable; shortcut?: string }>
+): SerializedToolConfig[] => {
+  return Object.entries(tools).map(([name, toolConfig]) => {
+    const { class: toolClass, ...config } = toolConfig;
+
+    return {
+      name,
+      classSource: toolClass.toString(),
+      config,
+    };
+  });
+};
+
+const createEditorWithTools = async (
+  page: Page,
+  tools: Record<string, { class: BlockToolConstructable; shortcut?: string }>,
+  data?: OutputData
+): Promise<void> => {
+  await resetEditor(page);
+
+  const serializedTools = serializeTools(tools);
+
+  await registerToolClasses(page, serializedTools);
+
+  const registeredToolNames = await page.evaluate(
+    async ({ holderId, editorTools, editorData }) => {
+      const registry = window.__playwrightToolRegistry ?? {};
+
+      const toolsMap = editorTools.reduce<
+      Record<string, { class: BlockToolConstructable } & Record<string, unknown>>
+      >((accumulator, { name, config }) => {
+        const toolClass = registry[name];
+
+        if (!toolClass) {
+          throw new Error(`Tool class "${name}" was not registered in the page context.`);
+        }
+
+        return {
+          ...accumulator,
+          [name]: {
+            class: toolClass as BlockToolConstructable,
+            ...config,
+          },
+        };
+      }, {});
+
+      const editor = new window.EditorJS({
+        holder: holderId,
+        tools: toolsMap,
+        ...(editorData ? { data: editorData } : {}),
+      });
+
+      window.editorInstance = editor;
+      await editor.isReady;
+
+      return Object.keys(toolsMap);
+    },
+    {
+      holderId: HOLDER_ID,
+      editorTools: serializedTools.map(({ name, config }) => ({
+        name,
+        config,
+      })),
+      editorData: data ?? null,
+    }
+  );
+
+  const missingTools = Object.keys(tools).filter((toolName) => !registeredToolNames.includes(toolName));
+
+  if (missingTools.length > 0) {
+    throw new Error(`Failed to register tools: ${missingTools.join(', ')}`);
+  }
+};
+
+/**
+ * Save editor data
+ *
+ * @param page - The Playwright page object
+ * @returns The saved output data
+ */
+const saveEditor = async (page: Page): Promise<OutputData> => {
+  return await page.evaluate(async () => {
+    if (!window.editorInstance) {
+      throw new Error('Editor instance not found');
+    }
+
+    return await window.editorInstance.save();
+  });
+};
+
+const runShortcutBehaviour = async (page: Page, toolName: string): Promise<void> => {
+  await page.evaluate(
+    async ({ toolName: shortcutTool }) => {
+      const editor =
+        window.editorInstance ??
+        (() => {
+          throw new Error('Editor instance not found');
+        })();
+
+      const { blocks, caret } = editor;
+      const currentBlockIndex = blocks.getCurrentBlockIndex();
+      const currentBlock =
+        blocks.getBlockByIndex(currentBlockIndex) ??
+        (() => {
+          throw new Error('Current block not found');
+        })();
+
+      try {
+        const newBlock = await blocks.convert(currentBlock.id, shortcutTool);
+
+        const newBlockId = newBlock?.id ?? currentBlock.id;
+
+        caret.setToBlock(newBlockId, 'end');
+      } catch (error) {
+        const insertionIndex = currentBlockIndex + Number(!currentBlock.isEmpty);
+
+        blocks.insert(shortcutTool, undefined, undefined, insertionIndex, undefined, currentBlock.isEmpty);
+      }
+    },
+    { toolName }
+  );
+};
+
+/**
+ * Check if caret is within a block element
+ *
+ * @param page - The Playwright page object
+ * @param blockId - Block ID to check
+ * @returns True if caret is within the block
+ */
+const isCaretInBlock = async (page: Page, blockId: string): Promise<boolean> => {
+  return await page.evaluate(({ blockId: id }) => {
+    const selection = window.getSelection();
+
+    if (!selection || selection.rangeCount === 0) {
+      return false;
+    }
+
+    const range = selection.getRangeAt(0);
+    const blockElement = document.querySelector(`.ce-block[data-id="${id}"]`);
+
+    if (!blockElement) {
+      return false;
+    }
+
+    return blockElement.contains(range.startContainer);
+  }, { blockId });
+};
+
+test.describe('toolbox', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+  });
+
+  test.describe('shortcuts', () => {
+    test('should convert current Block to the Shortcuts\'s Block if both tools provides a "conversionConfig". Caret should be restored after conversion.', async ({ page }) => {
+      /**
+       * Mock of Tool with conversionConfig
+       */
+      const ConvertableTool = class {
+        /**
+         * Specify how to import string data to this Tool
+         */
+        public static get conversionConfig(): ConversionConfig {
+          return {
+            import: 'text',
+          };
+        }
+
+        /**
+         * Specify how to display Tool in a Toolbox
+         */
+        public static get toolbox(): ToolboxConfig {
+          return {
+            icon: '',
+            title: 'Convertable tool',
+          };
+        }
+
+        private data: { text: string };
+
+        /**
+         * Constructor
+         *
+         * @param data - Tool data
+         */
+        constructor({ data }: { data: { text: string } }) {
+          this.data = data;
+        }
+
+        /**
+         * Render tool element
+         *
+         * @returns Rendered HTML element
+         */
+        public render(): HTMLElement {
+          const contenteditable = document.createElement('div');
+
+          contenteditable.contentEditable = 'true';
+          contenteditable.textContent = this.data.text;
+
+          return contenteditable;
+        }
+
+        /**
+         * Save tool data
+         *
+         * @param el - HTML element to save from
+         * @returns Saved data
+         */
+        public save(el: HTMLElement): { text: string } {
+          return {
+            // eslint-disable-next-line playwright/no-conditional-in-test
+            text: el.textContent ?? '',
+          };
+        }
+      };
+
+      await createEditorWithTools(page, {
+        convertableTool: {
+          class: ConvertableTool as unknown as BlockToolConstructable,
+          shortcut: 'CMD+SHIFT+H',
+        },
+      });
+
+      const paragraphBlock = page.locator(PARAGRAPH_SELECTOR);
+
+      await expect(paragraphBlock).toHaveCount(1);
+
+      await paragraphBlock.click();
+      await paragraphBlock.type('Some text');
+
+      await runShortcutBehaviour(page, 'convertableTool');
+
+      /**
+       * Check that block was converted
+       */
+      const editorData = await saveEditor(page);
+
+      expect(editorData.blocks).toHaveLength(1);
+      expect(editorData.blocks[0].type).toBe('convertableTool');
+      expect(editorData.blocks[0].data.text).toBe('Some text');
+
+      /**
+       * Check that caret belongs to the new block after conversion
+       */
+      const blockId = editorData.blocks[0]?.id;
+
+      expect(blockId).toBeDefined();
+
+      const caretInBlock = await isCaretInBlock(page, blockId!);
+
+      expect(caretInBlock).toBe(true);
+    });
+
+    test('should insert a Shortcuts\'s Block below the current if some (original or target) tool does not provide a "conversionConfig"', async ({ page }) => {
+      /**
+       * Mock of Tool without conversionConfig
+       */
+      const ToolWithoutConversionConfig = class {
+        /**
+         * Specify how to display Tool in a Toolbox
+         */
+        public static get toolbox(): ToolboxConfig {
+          return {
+            icon: '',
+            title: 'Convertable tool',
+          };
+        }
+
+        private data: { text: string };
+
+        /**
+         * Constructor
+         *
+         * @param data - Tool data
+         */
+        constructor({ data }: { data: { text: string } }) {
+          this.data = data;
+        }
+
+        /**
+         * Render tool element
+         *
+         * @returns Rendered HTML element
+         */
+        public render(): HTMLElement {
+          const contenteditable = document.createElement('div');
+
+          contenteditable.contentEditable = 'true';
+          contenteditable.textContent = this.data.text;
+
+          return contenteditable;
+        }
+
+        /**
+         * Save tool data
+         *
+         * @param el - HTML element to save from
+         * @returns Saved data
+         */
+        public save(el: HTMLElement): { text: string } {
+          return {
+            // eslint-disable-next-line playwright/no-conditional-in-test
+            text: el.textContent ?? '',
+          };
+        }
+      };
+
+      await createEditorWithTools(page, {
+        nonConvertableTool: {
+          class: ToolWithoutConversionConfig as unknown as BlockToolConstructable,
+          shortcut: 'CMD+SHIFT+H',
+        },
+      });
+
+      const paragraphBlock = page.locator(PARAGRAPH_SELECTOR);
+
+      await expect(paragraphBlock).toHaveCount(1);
+
+      await paragraphBlock.click();
+      await paragraphBlock.type('Some text');
+
+      await runShortcutBehaviour(page, 'nonConvertableTool');
+
+      /**
+       * Check that the new block was appended
+       */
+      const editorData = await saveEditor(page);
+
+      expect(editorData.blocks).toHaveLength(2);
+      expect(editorData.blocks[1].type).toBe('nonConvertableTool');
+    });
+
+    test('should display shortcut only for the first toolbox item if tool exports toolbox with several items', async ({ page }) => {
+      /**
+       * Mock of Tool with several toolbox items
+       */
+      const ToolWithSeveralToolboxItems = class {
+        /**
+         * Specify toolbox with several items related to one tool
+         */
+        public static get toolbox(): ToolboxConfig {
+          return [
+            {
+              icon: '',
+              title: 'first tool',
+            },
+            {
+              icon: '',
+              title: 'second tool',
+            },
+          ];
+        }
+
+        private data: { text: string };
+
+        /**
+         * Constructor
+         *
+         * @param data - Tool data
+         */
+        constructor({ data }: { data: { text: string } }) {
+          this.data = data;
+        }
+
+        /**
+         * Render tool element
+         *
+         * @returns Rendered HTML element
+         */
+        public render(): HTMLElement {
+          const contenteditable = document.createElement('div');
+
+          contenteditable.contentEditable = 'true';
+          contenteditable.textContent = this.data.text;
+
+          return contenteditable;
+        }
+
+        /**
+         * Save tool data
+         *
+         * @param el - HTML element to save from
+         * @returns Saved data
+         */
+        public save(el: HTMLElement): { text: string } {
+          return {
+            // eslint-disable-next-line playwright/no-conditional-in-test
+            text: el.textContent ?? '',
+          };
+        }
+      };
+
+      await createEditorWithTools(page, {
+        severalToolboxItemsTool: {
+          class: ToolWithSeveralToolboxItems as unknown as BlockToolConstructable,
+          shortcut: 'CMD+SHIFT+L',
+        },
+      });
+
+      const paragraphBlock = page.locator(PARAGRAPH_SELECTOR);
+
+      await expect(paragraphBlock).toHaveCount(1);
+
+      await paragraphBlock.click();
+      await paragraphBlock.type('Some text');
+      await page.keyboard.press(`${MODIFIER_KEY}+A`);
+      await page.keyboard.press('Backspace');
+
+      // Open toolbox with "/" shortcut
+      await page.keyboard.type('/');
+
+      const popover = page.locator(POPOVER_SELECTOR);
+
+      await popover.waitFor({ state: 'attached' });
+      await expect(popover).toHaveAttribute('data-popover-opened', 'true');
+
+      /**
+       * Secondary title (shortcut) should exist for first toolbox item of the tool
+       */
+      const severalToolboxItems = page.locator(
+        `${POPOVER_ITEM_SELECTOR}[data-item-name="severalToolboxItemsTool"]`
+      );
+      const firstItem = severalToolboxItems.filter({ hasText: 'first tool' });
+      const firstSecondaryTitle = firstItem.locator(SECONDARY_TITLE_SELECTOR);
+
+      await expect(firstSecondaryTitle).toBeVisible();
+
+      /**
+       * Secondary title (shortcut) should not exist for second toolbox item of the same tool
+       */
+      const secondItem = severalToolboxItems.filter({ hasText: 'second tool' });
+      const secondSecondaryTitle = secondItem.locator(SECONDARY_TITLE_SELECTOR);
+
+      await expect(secondSecondaryTitle).toBeHidden();
+    });
+
+    test('should display shortcut for the item if tool exports toolbox as an one item object', async ({ page }) => {
+      /**
+       * Mock of Tool with one toolbox item
+       */
+      const ToolWithOneToolboxItems = class {
+        /**
+         * Specify toolbox with one item
+         */
+        public static get toolbox(): ToolboxConfig {
+          return {
+            icon: '',
+            title: 'tool',
+          };
+        }
+
+        private data: { text: string };
+
+        /**
+         * Constructor
+         *
+         * @param data - Tool data
+         */
+        constructor({ data }: { data: { text: string } }) {
+          this.data = data;
+        }
+
+        /**
+         * Render tool element
+         *
+         * @returns Rendered HTML element
+         */
+        public render(): HTMLElement {
+          const contenteditable = document.createElement('div');
+
+          contenteditable.contentEditable = 'true';
+          contenteditable.textContent = this.data.text;
+
+          return contenteditable;
+        }
+
+        /**
+         * Save tool data
+         *
+         * @param el - HTML element to save from
+         * @returns Saved data
+         */
+        public save(el: HTMLElement): { text: string } {
+          return {
+            // eslint-disable-next-line playwright/no-conditional-in-test
+            text: el.textContent ?? '',
+          };
+        }
+      };
+
+      await createEditorWithTools(page, {
+        oneToolboxItemTool: {
+          class: ToolWithOneToolboxItems as unknown as BlockToolConstructable,
+          shortcut: 'CMD+SHIFT+L',
+        },
+      });
+
+      const paragraphBlock = page.locator(PARAGRAPH_SELECTOR);
+
+      await expect(paragraphBlock).toHaveCount(1);
+
+      await paragraphBlock.click();
+      await paragraphBlock.type('Some text');
+      await page.keyboard.press(`${MODIFIER_KEY}+A`);
+      await page.keyboard.press('Backspace');
+
+      // Open toolbox with "/" shortcut
+      await page.keyboard.type('/');
+
+      const popover = page.locator(POPOVER_SELECTOR);
+
+      await popover.waitFor({ state: 'attached' });
+      await expect(popover).toHaveAttribute('data-popover-opened', 'true');
+
+      /**
+       * Secondary title (shortcut) should exist for toolbox item of the tool
+       */
+      const item = page.locator(`${POPOVER_ITEM_SELECTOR}[data-item-name="oneToolboxItemTool"]`);
+
+      await expect(item).toHaveCount(1);
+      const secondaryTitle = item.locator(SECONDARY_TITLE_SELECTOR);
+
+      await expect(secondaryTitle).toBeVisible();
+    });
+  });
+});
+
+declare global {
+  interface Window {
+    // eslint-disable-next-line @typescript-eslint/naming-convention -- test-specific property
+    __playwrightToolRegistry?: Record<string, BlockToolConstructable>;
+    editorInstance?: EditorJS;
+    EditorJS: new (...args: unknown[]) => EditorJS;
+  }
+}
+
diff --git a/test/playwright/tests/ui/ui-module.spec.ts b/test/playwright/tests/ui/ui-module.spec.ts
new file mode 100644
index 000000000..6511ef5bd
--- /dev/null
+++ b/test/playwright/tests/ui/ui-module.spec.ts
@@ -0,0 +1,352 @@
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import type EditorJS from '@/types';
+import type { OutputData } from '@/types';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const PARAGRAPH_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-paragraph`;
+const REDACTOR_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .codex-editor__redactor`;
+
+type CreateEditorOptions = {
+  data?: OutputData;
+  readOnly?: boolean;
+};
+
+declare global {
+  interface Window {
+    editorInstance?: EditorJS;
+  }
+}
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditor = async (page: Page, options: CreateEditorOptions = {}): Promise<void> => {
+  const { data, readOnly } = options;
+
+  await resetEditor(page);
+  await page.waitForFunction(() => typeof window.EditorJS === 'function');
+
+  await page.evaluate(
+    async ({ holderId, editorData, readOnlyMode }) => {
+      const editorConfig: Record<string, unknown> = {
+        holder: holderId,
+      };
+
+      if (editorData !== null) {
+        editorConfig.data = editorData;
+      }
+
+      if (readOnlyMode !== null) {
+        editorConfig.readOnly = readOnlyMode;
+      }
+
+      const editor = new window.EditorJS(editorConfig);
+
+      window.editorInstance = editor;
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      editorData: data ?? null,
+      readOnlyMode: typeof readOnly === 'boolean' ? readOnly : null,
+    }
+  );
+};
+
+const ensureBottomPadding = async (page: Page): Promise<void> => {
+  await page.evaluate(({ selector }) => {
+    const redactor = document.querySelector(selector);
+
+    if (!redactor) {
+      throw new Error('Redactor element not found');
+    }
+
+    (redactor as HTMLElement).style.paddingBottom = '200px';
+  }, { selector: REDACTOR_SELECTOR });
+};
+
+const clickBottomZone = async (page: Page): Promise<void> => {
+  const clickPoint = await page.evaluate(({ selector }) => {
+    const redactor = document.querySelector(selector);
+
+    if (!redactor) {
+      throw new Error('Redactor element not found');
+    }
+
+    const rect = redactor.getBoundingClientRect();
+    const clientX = rect.left + rect.width / 2;
+    const clientY = Math.min(rect.bottom - 4, rect.top + rect.height - 4);
+
+    return {
+      x: clientX,
+      y: clientY,
+    };
+  }, { selector: REDACTOR_SELECTOR });
+
+  await page.mouse.click(clickPoint.x, clickPoint.y);
+};
+
+test.describe('ui module', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+  });
+
+  test.describe('documentKeydown', () => {
+    const initialData: OutputData = {
+      blocks: [
+        {
+          id: 'block1',
+          type: 'paragraph',
+          data: {
+            text: 'The first block',
+          },
+        },
+        {
+          id: 'block2',
+          type: 'paragraph',
+          data: {
+            text: 'The second block',
+          },
+        },
+      ],
+    };
+
+    const selectBlocks = async (page: Page): Promise<void> => {
+      const firstParagraph = page.locator(PARAGRAPH_SELECTOR).filter({
+        hasText: 'The first block',
+      });
+
+      await firstParagraph.click();
+      await page.keyboard.press('Shift+ArrowDown');
+    };
+
+    const getSavedBlocksCount = async (page: Page): Promise<number> => {
+      return await page.evaluate(async () => {
+        const editor = window.editorInstance;
+
+        if (!editor) {
+          throw new Error('Editor instance not found');
+        }
+
+        const savedData = await editor.save();
+
+        return savedData.blocks.length;
+      });
+    };
+
+    test('removes selected blocks with Backspace', async ({ page }) => {
+      await createEditor(page, { data: initialData });
+      await selectBlocks(page);
+
+      await page.keyboard.press('Backspace');
+      await page.waitForFunction(() => {
+        const editor = window.editorInstance;
+
+        if (!editor) {
+          return false;
+        }
+
+        return editor.blocks.getBlocksCount() === 1;
+      });
+
+      const savedBlocksCount = await getSavedBlocksCount(page);
+
+      expect(savedBlocksCount).toBe(0);
+    });
+
+    test('removes selected blocks with Delete', async ({ page }) => {
+      await createEditor(page, { data: initialData });
+      await selectBlocks(page);
+
+      await page.keyboard.press('Delete');
+      await page.waitForFunction(() => {
+        const editor = window.editorInstance;
+
+        if (!editor) {
+          return false;
+        }
+
+        return editor.blocks.getBlocksCount() === 1;
+      });
+
+      const savedBlocksCount = await getSavedBlocksCount(page);
+
+      expect(savedBlocksCount).toBe(0);
+    });
+  });
+
+  test.describe('mousedown', () => {
+    const textBlocks: OutputData = {
+      blocks: [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'first block',
+          },
+        },
+        {
+          type: 'paragraph',
+          data: {
+            text: 'second block',
+          },
+        },
+        {
+          type: 'paragraph',
+          data: {
+            text: 'third block',
+          },
+        },
+      ],
+    };
+
+    test('updates current block on click', async ({ page }) => {
+      await createEditor(page, { data: textBlocks });
+
+      const secondParagraph = page.locator(PARAGRAPH_SELECTOR).filter({
+        hasText: 'second block',
+      });
+
+      await secondParagraph.click();
+      const currentIndex = await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (!editor) {
+          throw new Error('Editor instance not found');
+        }
+
+        return editor.blocks.getCurrentBlockIndex();
+      });
+
+      expect(currentIndex).toBe(1);
+    });
+
+    test('updates current block on click in read-only mode', async ({ page }) => {
+      await createEditor(page, {
+        data: textBlocks,
+        readOnly: true,
+      });
+
+      const secondParagraph = page.locator(PARAGRAPH_SELECTOR).filter({
+        hasText: 'second block',
+      });
+
+      await secondParagraph.click();
+      const currentIndex = await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (!editor) {
+          throw new Error('Editor instance not found');
+        }
+
+        return editor.blocks.getCurrentBlockIndex();
+      });
+
+      expect(currentIndex).toBe(1);
+    });
+  });
+
+  test.describe('bottom zone interactions', () => {
+    test('keeps single empty default block when clicking bottom zone', async ({ page }) => {
+      await createEditor(page);
+      await ensureBottomPadding(page);
+
+      await clickBottomZone(page);
+
+      const result = await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (!editor) {
+          throw new Error('Editor instance not found');
+        }
+
+        return {
+          blocksCount: editor.blocks.getBlocksCount(),
+          currentIndex: editor.blocks.getCurrentBlockIndex(),
+        };
+      });
+
+      expect(result.blocksCount).toBe(1);
+      expect(result.currentIndex).toBe(0);
+    });
+
+    test('inserts new default block when clicking bottom zone with non-empty block', async ({ page }) => {
+      await createEditor(page, {
+        data: {
+          blocks: [
+            {
+              type: 'paragraph',
+              data: {
+                text: 'The only block',
+              },
+            },
+          ],
+        },
+      });
+      await ensureBottomPadding(page);
+
+      await clickBottomZone(page);
+      await page.waitForFunction(() => {
+        const editor = window.editorInstance;
+
+        if (!editor) {
+          return false;
+        }
+
+        return editor.blocks.getBlocksCount() === 2;
+      });
+
+      const result = await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (!editor) {
+          throw new Error('Editor instance not found');
+        }
+
+        const blocksCount = editor.blocks.getBlocksCount();
+        const currentIndex = editor.blocks.getCurrentBlockIndex();
+        const lastBlock = editor.blocks.getBlockByIndex(blocksCount - 1);
+
+        return {
+          blocksCount,
+          currentIndex,
+          lastBlockIsEmpty: lastBlock?.isEmpty ?? false,
+        };
+      });
+
+      expect(result.blocksCount).toBe(2);
+      expect(result.currentIndex).toBe(1);
+      expect(result.lastBlockIsEmpty).toBe(true);
+    });
+  });
+});
+
diff --git a/test/playwright/tests/utils/flipper.spec.ts b/test/playwright/tests/utils/flipper.spec.ts
new file mode 100644
index 000000000..67817ef01
--- /dev/null
+++ b/test/playwright/tests/utils/flipper.spec.ts
@@ -0,0 +1,1491 @@
+/* global globalThis */
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const BLOCK_TUNES_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-cy=block-tunes]`;
+const SETTINGS_BUTTON_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__settings-btn`;
+const POPOVER_CONTAINER_SELECTOR = `${BLOCK_TUNES_SELECTOR} .ce-popover__container`;
+const POPOVER_ITEM_SELECTOR = `${POPOVER_CONTAINER_SELECTOR} .ce-popover-item`;
+const PLUGIN_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .cdx-some-plugin`;
+const INLINE_TOOLBAR_SELECTOR = '[data-cy="inline-toolbar"] .ce-popover--opened';
+
+const KEY_CODES = {
+  TAB: 9,
+  ENTER: 13,
+  ESC: 27,
+  ARROW_LEFT: 37,
+  ARROW_UP: 38,
+  ARROW_DOWN: 40,
+  SLASH: 191,
+} as const;
+
+type KeydownOptions = {
+  ctrlKey?: boolean;
+  metaKey?: boolean;
+  shiftKey?: boolean;
+  code?: string;
+  key?: string;
+};
+
+/**
+ *
+ */
+class SomePlugin {
+  /**
+   *
+   * @param event - The keyboard event to handle
+   */
+  public static pluginInternalKeydownHandler(event: KeyboardEvent): void {
+    const trackedKeyCodes = new Set([9, 13, 37, 38, 40]);
+
+    if (!trackedKeyCodes.has(event.keyCode)) {
+      return;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+    const context = globalThis as typeof globalThis & { __pluginHandlerCallCount?: number };
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+    context.__pluginHandlerCallCount = (context.__pluginHandlerCallCount ?? 0) + 1;
+  }
+
+  /**
+   *
+   */
+  public render(): HTMLElement {
+    const wrapper = document.createElement('div');
+
+    wrapper.classList.add('cdx-some-plugin');
+    wrapper.contentEditable = 'true';
+    wrapper.addEventListener('keydown', SomePlugin.pluginInternalKeydownHandler);
+
+    return wrapper;
+  }
+
+  /**
+   *
+   */
+  public static get toolbox(): { icon: string; title: string; onActivate: () => void } {
+    return {
+      icon: '₷',
+      title: 'Some tool',
+      onActivate: (): void => {},
+    };
+  }
+
+  /**
+   *
+   */
+  public save(): { data: string } {
+    return {
+      data: '123',
+    };
+  }
+}
+
+const SOME_PLUGIN_SOURCE = SomePlugin.toString();
+
+type ToolDefinition = {
+  name: string;
+  classSource: string;
+  config?: Record<string, unknown>;
+};
+
+type EditorSetupOptions = {
+  data?: Record<string, unknown>;
+  config?: Record<string, unknown>;
+  tools?: ToolDefinition[];
+};
+
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+const createEditor = async (page: Page, options: EditorSetupOptions = {}): Promise<void> => {
+  const { data, config, tools = [] } = options;
+
+  await resetEditor(page);
+  await page.waitForFunction(() => typeof window.EditorJS === 'function');
+
+  await page.evaluate(
+    async ({ holderId, rawData, rawConfig, serializedTools }) => {
+      const reviveToolClass = (classSource: string): unknown => {
+        return new Function(`return (${classSource});`)();
+      };
+
+      const revivedTools = serializedTools.reduce<Record<string, unknown>>((accumulator, toolConfig) => {
+        const revivedClass = reviveToolClass(toolConfig.classSource);
+
+        return {
+          ...accumulator,
+          [toolConfig.name]: toolConfig.config
+            ? {
+              ...toolConfig.config,
+              class: revivedClass,
+            }
+            : revivedClass,
+        };
+      }, {});
+
+      const editorConfig = {
+        holder: holderId,
+        ...rawConfig,
+        ...(serializedTools.length > 0 ? { tools: revivedTools } : {}),
+        ...(rawData ? { data: rawData } : {}),
+      };
+
+      const editor = new window.EditorJS(editorConfig);
+
+      window.editorInstance = editor;
+      await editor.isReady;
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      (globalThis as typeof globalThis & { __pluginHandlerCallCount?: number }).__pluginHandlerCallCount = 0;
+    },
+    {
+      holderId: HOLDER_ID,
+      rawData: data ?? null,
+      rawConfig: config ?? {},
+      serializedTools: tools,
+    }
+  );
+};
+
+const createEditorWithPlugin = async (page: Page, data?: Record<string, unknown>): Promise<void> => {
+  await createEditor(page, {
+    data,
+    tools: [
+      {
+        name: 'sometool',
+        classSource: SOME_PLUGIN_SOURCE,
+      },
+    ],
+  });
+};
+
+const waitForBlockTunesPopover = async (page: Page, timeout = 5_000): Promise<void> => {
+  await page.locator(`${BLOCK_TUNES_SELECTOR} .ce-popover`).waitFor({
+    state: 'attached',
+    timeout,
+  });
+  await expect(page.locator(POPOVER_CONTAINER_SELECTOR)).toBeVisible({ timeout });
+};
+
+const triggerKey = async (locator: Locator, keyCode: number, options: KeydownOptions = {}): Promise<void> => {
+  await locator.evaluate(
+    (element, { code, key, ctrlKey, metaKey, shiftKey, keyCode: keyCodeValue }) => {
+      const event = new KeyboardEvent('keydown', {
+        bubbles: true,
+        cancelable: true,
+        code,
+        key,
+        ctrlKey: Boolean(ctrlKey),
+        metaKey: Boolean(metaKey),
+        shiftKey: Boolean(shiftKey),
+      });
+
+      Object.defineProperty(event, 'keyCode', {
+        get: () => keyCodeValue,
+      });
+      Object.defineProperty(event, 'which', {
+        get: () => keyCodeValue,
+      });
+
+      element.dispatchEvent(event);
+    },
+    {
+      code: options.code,
+      key: options.key,
+      ctrlKey: options.ctrlKey ?? false,
+      metaKey: options.metaKey ?? false,
+      shiftKey: options.shiftKey ?? false,
+      keyCode,
+    }
+  );
+};
+
+const openBlockTunesWithShortcut = async (page: Page, plugin: Locator): Promise<void> => {
+  await triggerKey(plugin, KEY_CODES.SLASH, {
+    ctrlKey: true,
+    metaKey: true,
+    code: 'Slash',
+    key: '/',
+  });
+  await waitForBlockTunesPopover(page);
+};
+
+const openBlockTunesViaToolbar = async (page: Page, block: Locator): Promise<void> => {
+  await expect(block).toBeVisible();
+  await block.hover();
+  await block.click();
+  await expect(page.locator(SETTINGS_BUTTON_SELECTOR)).toBeVisible();
+  await page.locator(SETTINGS_BUTTON_SELECTOR).click();
+  await waitForBlockTunesPopover(page);
+};
+
+const selectTextByOffset = async (locator: Locator, start: number, end: number): Promise<void> => {
+  await locator.evaluate(
+    (element, { start: startOffset, end: endOffset }) => {
+      const textNode = element.firstChild;
+
+      if (!textNode || textNode.nodeType !== Node.TEXT_NODE) {
+        throw new Error('Unable to find text node for selection.');
+      }
+
+      const range = element.ownerDocument.createRange();
+
+      range.setStart(textNode, startOffset);
+      range.setEnd(textNode, endOffset);
+
+      const selection = element.ownerDocument.getSelection();
+
+      selection?.removeAllRanges();
+      selection?.addRange(range);
+      element.ownerDocument.dispatchEvent(new Event('selectionchange'));
+    },
+    { start,
+      end }
+  );
+};
+
+const resetPluginHandlerCallCount = async (page: Page): Promise<void> => {
+  await page.evaluate(() => {
+    // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+    (globalThis as typeof globalThis & { __pluginHandlerCallCount?: number }).__pluginHandlerCallCount = 0;
+  });
+};
+
+const getPluginHandlerCallCount = async (page: Page): Promise<number> => {
+  return await page.evaluate(() => {
+    // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+    const context = globalThis as typeof globalThis & { __pluginHandlerCallCount?: number };
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+    return context.__pluginHandlerCallCount ?? 0;
+  });
+};
+
+const getFocusedPopoverIndex = async (page: Page): Promise<number> => {
+  const focusedIndex = await page.locator(POPOVER_ITEM_SELECTOR).evaluateAll(elements => {
+    return elements.findIndex(element => element.classList.contains('ce-popover-item--focused'));
+  });
+
+  if (focusedIndex === -1) {
+    throw new Error('Unable to determine focused popover item');
+  }
+
+  return focusedIndex;
+};
+
+const closeBlockTunes = async (page: Page): Promise<void> => {
+  await page.keyboard.press('Escape');
+  await expect(page.locator(POPOVER_CONTAINER_SELECTOR)).toBeHidden();
+};
+
+test.describe('flipper', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+  });
+  test('prevents plugin keydown handler during keyboard navigation', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await expect(plugin).toBeVisible();
+    await plugin.click();
+    await resetPluginHandlerCallCount(page);
+
+    const sampleText = 'sample text';
+
+    await page.keyboard.type(sampleText);
+
+    await openBlockTunesWithShortcut(page, plugin);
+
+    await triggerKey(plugin, KEY_CODES.ARROW_DOWN, { key: 'ArrowDown' });
+
+    await expect(page.locator('[data-item-name="delete"]')).toHaveClass(/ce-popover-item--focused/);
+
+    await triggerKey(plugin, KEY_CODES.ENTER, { key: 'Enter' });
+    await triggerKey(plugin, KEY_CODES.ENTER, { key: 'Enter' });
+
+    expect(await getPluginHandlerCallCount(page)).toBe(0);
+  });
+
+  test('does not flip items when Shift is held', async ({ page }) => {
+    await createEditor(page, {
+      data: {
+        blocks: [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Workspace in classic editors is made of a single contenteditable element, used to create different HTML markups. Editor.js workspace consists of separate Blocks: paragraphs, headings, images, lists, quotes, etc. Each of them is an independent contenteditable element (or more complex structure) provided by Plugin and united by Editor\'s Core.',
+            },
+          },
+        ],
+      },
+      config: {
+        autofocus: true,
+      },
+    });
+
+    const paragraph = page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-paragraph`, {
+      hasText: /^Workspace in classic editors/,
+    });
+
+    await expect(paragraph).toBeVisible();
+    await selectTextByOffset(paragraph, 0, 10);
+
+    await triggerKey(paragraph, KEY_CODES.ARROW_DOWN, {
+      key: 'ArrowDown',
+      shiftKey: true,
+    });
+
+    await expect(page.locator(INLINE_TOOLBAR_SELECTOR)).toBeVisible();
+    await expect(page.locator(`${INLINE_TOOLBAR_SELECTOR} .ce-popover-item--focused`)).toHaveCount(0);
+  });
+
+  test('cycles focus with Tab and Shift+Tab', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+
+    await openBlockTunesWithShortcut(page, plugin);
+
+    const initialIndex = await getFocusedPopoverIndex(page);
+    const itemCount = await page.locator(POPOVER_ITEM_SELECTOR).count();
+
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+    });
+
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+    });
+
+    const nextIndex = await getFocusedPopoverIndex(page);
+
+    expect(nextIndex).toBe((initialIndex + 1) % itemCount);
+
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+      shiftKey: true,
+    });
+
+    const returnedIndex = await getFocusedPopoverIndex(page);
+
+    expect(returnedIndex).toBe(initialIndex);
+  });
+
+  test('pressing Enter activates the focused item', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    await triggerKey(plugin, KEY_CODES.ARROW_DOWN, { key: 'ArrowDown' });
+
+    await expect(page.locator('[data-item-name="delete"]')).toHaveClass(/ce-popover-item--focused/);
+
+    await page.evaluate(() => {
+      const deleteItem = document.querySelector('[data-item-name="delete"]');
+
+      if (!deleteItem) {
+        throw new Error('Delete item not found');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __deleteItemClicks?: number };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      context.__deleteItemClicks = 0;
+
+      deleteItem.addEventListener('click', () => {
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        context.__deleteItemClicks = (context.__deleteItemClicks ?? 0) + 1;
+      });
+    });
+
+    await triggerKey(plugin, KEY_CODES.ENTER, { key: 'Enter' });
+
+    const deleteItemClickCount = await page.evaluate(() => {
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __deleteItemClicks?: number };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      return context.__deleteItemClicks ?? 0;
+    });
+
+    expect(deleteItemClickCount).toBe(1);
+  });
+
+  test('ignores navigation for keys outside allowed list', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    await resetPluginHandlerCallCount(page);
+    await triggerKey(plugin, KEY_CODES.ARROW_LEFT, { key: 'ArrowLeft' });
+
+    expect(await getPluginHandlerCallCount(page)).toBe(1);
+  });
+
+  test('removes capturing listener on deactivate', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    await resetPluginHandlerCallCount(page);
+
+    await triggerKey(plugin, KEY_CODES.ARROW_DOWN, { key: 'ArrowDown' });
+
+    expect(await getPluginHandlerCallCount(page)).toBe(0);
+
+    await closeBlockTunes(page);
+    await resetPluginHandlerCallCount(page);
+    await plugin.evaluate((element) => element.focus());
+
+    await triggerKey(plugin, KEY_CODES.ARROW_DOWN, { key: 'ArrowDown' });
+
+    expect(await getPluginHandlerCallCount(page)).toBe(1);
+  });
+
+  test('falls back to toolbar button when shortcut is unavailable', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+
+    expect(async () => {
+      await openBlockTunesWithShortcut(page, plugin);
+    }).not.toThrow();
+
+    await closeBlockTunes(page);
+
+    await openBlockTunesViaToolbar(page, plugin);
+
+    await expect(page.locator(POPOVER_CONTAINER_SELECTOR)).toBeVisible();
+  });
+
+  test('isActivated getter returns correct state', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+
+    const isActivatedBefore = await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        return null;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        return null;
+      }
+
+      return blockSettings.flipper.isActivated;
+    });
+
+    expect(isActivatedBefore).toBe(false);
+
+    await openBlockTunesWithShortcut(page, plugin);
+
+    const isActivatedAfter = await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        return null;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        return null;
+      }
+
+      return blockSettings.flipper.isActivated;
+    });
+
+    expect(isActivatedAfter).toBe(true);
+
+    await closeBlockTunes(page);
+
+    const isActivatedAfterClose = await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        return null;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        return null;
+      }
+
+      return blockSettings.flipper.isActivated;
+    });
+
+    expect(isActivatedAfterClose).toBe(false);
+  });
+
+  test('hasFocus returns correct state', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    const hasFocusBefore = await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        return null;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        return null;
+      }
+
+      return blockSettings.flipper.hasFocus();
+    });
+
+    expect(hasFocusBefore).toBe(true);
+
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+    });
+
+    const hasFocusAfter = await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        return null;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        return null;
+      }
+
+      return blockSettings.flipper.hasFocus();
+    });
+
+    expect(hasFocusAfter).toBe(true);
+  });
+
+  test('focusFirst focuses the first item', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        throw new Error('Editor not found');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        throw new Error('Flipper not found');
+      }
+
+      blockSettings.flipper.focusFirst();
+    });
+
+    const isFirstItemFocused = await page.locator(POPOVER_ITEM_SELECTOR).evaluateAll(elements => {
+      const [ firstElement ] = elements;
+
+      if (!firstElement) {
+        throw new Error('No popover items found');
+      }
+
+      return firstElement.classList.contains('ce-popover-item--focused');
+    });
+
+    expect(isFirstItemFocused).toBe(true);
+  });
+
+  test('onFlip callback is executed on navigation', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    const flipCallbackCount = await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        return null;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        return null;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __flipCallbackCount?: number };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      context.__flipCallbackCount = 0;
+
+      const callback = (): void => {
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        context.__flipCallbackCount = (context.__flipCallbackCount ?? 0) + 1;
+      };
+
+      blockSettings.flipper.onFlip(callback);
+
+      return {
+        flipper: blockSettings.flipper,
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        getCount: (): number => context.__flipCallbackCount ?? 0,
+      };
+    });
+
+    expect(flipCallbackCount).not.toBeNull();
+
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+    });
+
+    const countAfterInitialTab = await page.evaluate(() => {
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __flipCallbackCount?: number };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      return context.__flipCallbackCount ?? 0;
+    });
+
+    expect(countAfterInitialTab).toBe(0);
+
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+    });
+
+    const countAfterFirstFlip = await page.evaluate(() => {
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __flipCallbackCount?: number };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      return context.__flipCallbackCount ?? 0;
+    });
+
+    expect(countAfterFirstFlip).toBe(1);
+
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+    });
+
+    const countAfterSecondFlip = await page.evaluate(() => {
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __flipCallbackCount?: number };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      return context.__flipCallbackCount ?? 0;
+    });
+
+    expect(countAfterSecondFlip).toBe(2);
+  });
+
+  test('removeOnFlip removes callback correctly', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        throw new Error('Editor not found');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        throw new Error('Flipper not found');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __flipCallbackCount?: number };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      context.__flipCallbackCount = 0;
+
+      const callback = (): void => {
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        context.__flipCallbackCount = (context.__flipCallbackCount ?? 0) + 1;
+      };
+
+      blockSettings.flipper.onFlip(callback);
+
+      // Store callback reference for removal
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      (globalThis as typeof globalThis & { __flipCallback?: () => void }).__flipCallback = callback;
+    });
+
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+    });
+
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+    });
+
+    const countBeforeRemoval = await page.evaluate(() => {
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __flipCallbackCount?: number };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      return context.__flipCallbackCount ?? 0;
+    });
+
+    expect(countBeforeRemoval).toBe(1);
+
+    await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        throw new Error('Editor not found');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        throw new Error('Flipper not found');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __flipCallback?: () => void };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      if (context.__flipCallback) {
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        blockSettings.flipper.removeOnFlip(context.__flipCallback);
+      }
+    });
+
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+    });
+
+    const countAfterRemoval = await page.evaluate(() => {
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __flipCallbackCount?: number };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      return context.__flipCallbackCount ?? 0;
+    });
+
+    expect(countAfterRemoval).toBe(1);
+  });
+
+  test('activate with cursorPosition parameter', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    const itemCount = await page.locator(POPOVER_ITEM_SELECTOR).count();
+    const targetIndex = Math.min(2, itemCount - 1);
+
+    await page.evaluate(
+      ({ targetIndex: activeIndex, selector }) => {
+        const editor = window.editorInstance;
+
+        if (!editor) {
+          throw new Error('Editor not found');
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+        const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+        if (!blockSettings || !blockSettings.flipper) {
+          throw new Error('Flipper not found');
+        }
+
+        const items = Array.from(
+          document.querySelectorAll(selector)
+        ) as HTMLElement[];
+
+        blockSettings.flipper.deactivate();
+        blockSettings.flipper.activate(items, activeIndex);
+
+        return {
+          targetIndex: activeIndex,
+          itemNames: items.map(item => item.dataset.itemName),
+          focusedItemName: blockSettings.flipper['iterator']?.currentItem?.dataset?.itemName ?? null,
+          focusedItemClasses: blockSettings.flipper['iterator']?.currentItem ? Array.from(blockSettings.flipper['iterator'].currentItem.classList) : null,
+        };
+      },
+      {
+        targetIndex,
+        selector: `${BLOCK_TUNES_SELECTOR} .ce-popover-item`,
+      }
+    );
+
+    const isTargetFocused = await page.locator(POPOVER_ITEM_SELECTOR).evaluateAll(
+      (elements, index) => {
+        const target = elements[index];
+
+        if (!target) {
+          throw new Error(`No popover item found at index ${index}`);
+        }
+
+        return target.classList.contains('ce-popover-item--focused');
+      },
+      targetIndex
+    );
+
+    expect(isTargetFocused).toBe(true);
+  });
+
+  test('activate with items parameter updates items dynamically', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        throw new Error('Editor not found');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        throw new Error('Flipper not found');
+      }
+
+      const originalItems = Array.from(
+        document.querySelectorAll('.ce-popover-item')
+      ) as HTMLElement[];
+
+      // Create new items
+      const newItem1 = document.createElement('div');
+
+      newItem1.className = 'ce-popover-item';
+      newItem1.textContent = 'New Item 1';
+
+      const newItem2 = document.createElement('div');
+
+      newItem2.className = 'ce-popover-item';
+      newItem2.textContent = 'New Item 2';
+
+      const container = document.querySelector('.ce-popover__container');
+
+      if (container) {
+        container.appendChild(newItem1);
+        container.appendChild(newItem2);
+      }
+
+      const newItems = [...originalItems, newItem1, newItem2];
+
+      blockSettings.flipper.activate(newItems);
+    });
+
+    const allItems = page.locator(POPOVER_ITEM_SELECTOR);
+    const count = await allItems.count();
+
+    expect(count).toBeGreaterThan(0);
+  });
+
+  test('activateCallback is invoked on Enter press', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    // Test that Enter press triggers the item click, which indirectly tests activateCallback
+    // The actual activateCallback is set during Flipper construction and is tested indirectly
+    // through the item click behavior
+    await triggerKey(plugin, KEY_CODES.ARROW_DOWN, { key: 'ArrowDown' });
+
+    await page.evaluate(() => {
+      const focusedItem = document.querySelector('.ce-popover-item--focused');
+
+      if (!focusedItem) {
+        throw new Error('No focused item found');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __activateCallbackCount?: number; __activateCallbackItem?: HTMLElement };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      context.__activateCallbackCount = 0;
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      context.__activateCallbackItem = undefined;
+
+      // Simulate what activateCallback would do
+      focusedItem.addEventListener('click', () => {
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        context.__activateCallbackCount = (context.__activateCallbackCount ?? 0) + 1;
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        context.__activateCallbackItem = focusedItem as HTMLElement;
+      }, { once: true });
+    });
+
+    await triggerKey(plugin, KEY_CODES.ENTER, { key: 'Enter' });
+
+    const callbackResult = await page.evaluate(() => {
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __activateCallbackCount?: number; __activateCallbackItem?: HTMLElement };
+
+      return {
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        count: context.__activateCallbackCount ?? 0,
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        itemText: context.__activateCallbackItem?.textContent ?? null,
+      };
+    });
+
+    // Enter should trigger the click, which simulates activateCallback behavior
+    expect(callbackResult.count).toBeGreaterThanOrEqual(1);
+  });
+
+  test('handles empty items array gracefully', async ({ page }) => {
+    await createEditor(page);
+
+    // Test that Flipper can be activated/deactivated even when there are no items
+    // This is tested indirectly through the editor's behavior
+    const result = await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        return { error: 'Editor not found' };
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        return { error: 'Flipper not found' };
+      }
+
+      const flipper = blockSettings.flipper;
+
+      // Test with empty items by activating with empty array
+      flipper.activate([]);
+
+      const hasFocus = flipper.hasFocus();
+      const isActivated = flipper.isActivated;
+
+      flipper.deactivate();
+
+      return {
+        hasFocus,
+        isActivated,
+        deactivated: !flipper.isActivated,
+      };
+    });
+
+    expect(result.error).toBeUndefined();
+    expect(result.isActivated).toBe(true);
+    expect(result.deactivated).toBe(true);
+  });
+
+  test('handles multiple activation/deactivation cycles', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        throw new Error('Editor not found');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        throw new Error('Flipper not found');
+      }
+
+      const flipper = blockSettings.flipper;
+
+      // Multiple activate/deactivate cycles
+      flipper.deactivate();
+      flipper.activate();
+      flipper.deactivate();
+      flipper.activate();
+      flipper.deactivate();
+      flipper.activate();
+
+      return flipper.isActivated;
+    });
+
+    const isActivated = await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        return null;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        return null;
+      }
+
+      return blockSettings.flipper.isActivated;
+    });
+
+    expect(isActivated).toBe(true);
+
+    await closeBlockTunes(page);
+
+    const isActivatedAfterClose = await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        return null;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        return null;
+      }
+
+      return blockSettings.flipper.isActivated;
+    });
+
+    expect(isActivatedAfterClose).toBe(false);
+  });
+
+  test('custom allowedKeys configuration works correctly', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    // Test that allowedKeys filtering works - ArrowLeft is not in the default allowedKeys
+    // for block settings (which uses Tab, Up, Down, Enter), so it should be ignored
+    await resetPluginHandlerCallCount(page);
+
+    // ArrowLeft should be handled by plugin since it's not in allowedKeys
+    await triggerKey(plugin, KEY_CODES.ARROW_LEFT, { key: 'ArrowLeft' });
+
+    const callCount = await getPluginHandlerCallCount(page);
+
+    // ArrowLeft should be handled by plugin (not blocked by flipper)
+    expect(callCount).toBeGreaterThan(0);
+  });
+
+  test('focusedItemClass is applied to focused items', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    // Test that the focusedItemClass (ce-popover-item--focused) is applied
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+    });
+
+    const focusedItem = page.locator('.ce-popover-item--focused');
+
+    await expect(focusedItem).toBeVisible();
+    await expect(focusedItem).toHaveCount(1);
+  });
+
+  test('handleEnterPress does not activate when not activated', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    await page.evaluate(() => {
+      const deleteItem = document.querySelector('[data-item-name="delete"]');
+
+      if (!deleteItem) {
+        throw new Error('Delete item not found');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __deleteItemClicks?: number };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      context.__deleteItemClicks = 0;
+
+      deleteItem.addEventListener('click', () => {
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        context.__deleteItemClicks = (context.__deleteItemClicks ?? 0) + 1;
+      });
+    });
+
+    await closeBlockTunes(page);
+
+    await triggerKey(plugin, KEY_CODES.ENTER, { key: 'Enter' });
+
+    const deleteItemClickCount = await page.evaluate(() => {
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __deleteItemClicks?: number };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      return context.__deleteItemClicks ?? 0;
+    });
+
+    // Enter should not trigger click when flipper is deactivated
+    expect(deleteItemClickCount).toBe(0);
+  });
+
+  test('multiple onFlip callbacks are all executed', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        throw new Error('Editor not found');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        throw new Error('Flipper not found');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __callback1Count?: number; __callback2Count?: number; __callback3Count?: number };
+
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      context.__callback1Count = 0;
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      context.__callback2Count = 0;
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      context.__callback3Count = 0;
+
+      const callback1 = (): void => {
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        context.__callback1Count = (context.__callback1Count ?? 0) + 1;
+      };
+
+      const callback2 = (): void => {
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        context.__callback2Count = (context.__callback2Count ?? 0) + 1;
+      };
+
+      const callback3 = (): void => {
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        context.__callback3Count = (context.__callback3Count ?? 0) + 1;
+      };
+
+      blockSettings.flipper.onFlip(callback1);
+      blockSettings.flipper.onFlip(callback2);
+      blockSettings.flipper.onFlip(callback3);
+    });
+
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+    });
+
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+    });
+
+    await triggerKey(plugin, KEY_CODES.TAB, {
+      key: 'Tab',
+      code: 'Tab',
+    });
+
+    const callbackCounts = await page.evaluate(() => {
+      // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+      const context = globalThis as typeof globalThis & { __callback1Count?: number; __callback2Count?: number; __callback3Count?: number };
+
+      return {
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        callback1: context.__callback1Count ?? 0,
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        callback2: context.__callback2Count ?? 0,
+        // eslint-disable-next-line @typescript-eslint/naming-convention -- test-only property
+        callback3: context.__callback3Count ?? 0,
+      };
+    });
+
+    expect(callbackCounts.callback1).toBeGreaterThan(0);
+    expect(callbackCounts.callback2).toBe(callbackCounts.callback1);
+    expect(callbackCounts.callback3).toBe(callbackCounts.callback1);
+  });
+
+  test('removeOnFlip with non-existent callback does not error', async ({ page }) => {
+    await createEditorWithPlugin(page, {
+      blocks: [
+        {
+          type: 'sometool',
+          data: {},
+        },
+      ],
+    });
+
+    const plugin = page.locator(PLUGIN_SELECTOR);
+
+    await plugin.click();
+    await openBlockTunesWithShortcut(page, plugin);
+
+    await page.evaluate(() => {
+      const editor = window.editorInstance;
+
+      if (!editor) {
+        throw new Error('Editor not found');
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing runtime property
+      const blockSettings = (editor as any).module?.toolbar?.blockSettings;
+
+      if (!blockSettings || !blockSettings.flipper) {
+        throw new Error('Flipper not found');
+      }
+
+      const nonExistentCallback = (): void => {};
+
+      // Should not throw error
+      blockSettings.flipper.removeOnFlip(nonExistentCallback);
+    });
+
+    // Test should complete without errors
+    expect(true).toBe(true);
+  });
+});
+
diff --git a/test/playwright/tests/utils/popover-search.spec.ts b/test/playwright/tests/utils/popover-search.spec.ts
new file mode 100644
index 000000000..499fe37f3
--- /dev/null
+++ b/test/playwright/tests/utils/popover-search.spec.ts
@@ -0,0 +1,1159 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { OutputData } from '@/types';
+import { PopoverItemType } from '@/types/utils/popover/popover-item-type';
+import { selectionChangeDebounceTimeout, EDITOR_INTERFACE_SELECTOR, MODIFIER_KEY } from '../../../../src/components/constants';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .cdx-block`;
+const BLOCK_TUNES_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-cy=block-tunes]`;
+const SETTINGS_BUTTON_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__settings-btn`;
+const SEARCH_INPUT_SELECTOR = `${BLOCK_TUNES_SELECTOR} .cdx-search-field__input`;
+const POPOVER_ITEM_SELECTOR = `${BLOCK_TUNES_SELECTOR} .ce-popover-item`;
+const NOTHING_FOUND_SELECTOR = `${BLOCK_TUNES_SELECTOR} .ce-popover__nothing-found-message`;
+const POPOVER_CONTAINER_SELECTOR = `${BLOCK_TUNES_SELECTOR} .ce-popover__container`;
+
+/**
+ * Clear the provided search input and emit an input event so filtering logic reacts
+ *
+ * @param searchInput - locator pointing to the search field
+ */
+const clearSearchInputField = async (searchInput: Locator): Promise<void> => {
+  await searchInput.evaluate((element) => {
+    if (!(element instanceof HTMLInputElement)) {
+      return;
+    }
+
+    const inputElement = element;
+
+    inputElement.value = '';
+
+    if (typeof InputEvent === 'function') {
+      inputElement.dispatchEvent(new InputEvent('input', {
+        bubbles: true,
+        cancelable: false,
+        data: null,
+        inputType: 'deleteContentBackward',
+      }));
+    } else {
+      inputElement.dispatchEvent(new Event('input', { bubbles: true }));
+    }
+  });
+};
+
+interface SerializableMenuChildren {
+  searchable?: boolean;
+  isOpen?: boolean;
+  isFlippable?: boolean;
+  items: SerializableMenuItem[];
+}
+
+interface SerializableMenuItemBase {
+  icon?: string;
+  title?: string;
+  label?: string;
+  secondaryLabel?: string;
+  name?: string;
+  toggle?: boolean | string;
+  closeOnActivate?: boolean;
+  isActive?: boolean;
+  isDisabled?: boolean;
+  type?: PopoverItemType.Default;
+}
+
+type SerializableMenuSeparator = {
+  type: PopoverItemType.Separator;
+};
+
+type SerializableMenuItem =
+  | (SerializableMenuItemBase & { children?: undefined })
+  | (SerializableMenuItemBase & { children?: SerializableMenuChildren })
+  | SerializableMenuSeparator;
+
+type SerializableMenuConfig = SerializableMenuItem | SerializableMenuItem[];
+
+interface SerializableToolConfig {
+  menu: SerializableMenuConfig;
+  isTune?: boolean;
+}
+
+type SerializableToolsConfig = Record<string, SerializableToolConfig>;
+
+const buildTestToolsConfig = (
+  menu: SerializableMenuConfig,
+  options: Omit<SerializableToolConfig, 'menu'> = {}
+): SerializableToolsConfig => ({
+  testTool: {
+    menu,
+    ...options,
+  },
+});
+
+/**
+ * Reset the editor holder and destroy any existing instance
+ *
+ * @param page - The Playwright page object
+ */
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ * Create editor with provided blocks and optional tools/tunes
+ *
+ * @param page - The Playwright page object
+ * @param blocks - The blocks data to initialize the editor with
+ * @param tools - Optional tools configuration
+ * @param tunes - Optional tunes configuration
+ */
+const createEditorWithBlocks = async (
+  page: Page,
+  blocks: OutputData['blocks'],
+  tools?: SerializableToolsConfig,
+  tunes?: string[]
+): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(
+    async ({ holderId, editorBlocks, editorTools, editorTunes, PopoverItemTypeValues }) => {
+      const mapMenuItem = (item: SerializableMenuItem): unknown => {
+        if (item.type === PopoverItemTypeValues.Separator) {
+          return { type: PopoverItemTypeValues.Separator };
+        }
+
+        const itemWithChildren = item as SerializableMenuItemBase & { children?: SerializableMenuChildren };
+        const { children, ...rest } = itemWithChildren;
+
+        if (children) {
+          return {
+            ...rest,
+            type: rest.type ?? PopoverItemTypeValues.Default,
+            children: {
+              ...children,
+              items: children.items.map((child: SerializableMenuItem) => mapMenuItem(child)),
+            },
+          };
+        }
+
+        return {
+          ...rest,
+          type: rest.type ?? PopoverItemTypeValues.Default,
+          onActivate: (): void => {},
+        };
+      };
+
+      const buildMenu = (menu: SerializableMenuConfig): unknown => {
+        if (Array.isArray(menu)) {
+          return menu.map((menuItem) => mapMenuItem(menuItem));
+        }
+
+        return mapMenuItem(menu);
+      };
+
+      const buildTools = (
+        toolsConfig?: SerializableToolsConfig
+      ): Record<string, unknown> | undefined => {
+        if (!toolsConfig) {
+          return undefined;
+        }
+
+        const toolEntries = Object.entries(toolsConfig).map(([toolName, toolConfig]) => {
+          const { menu, isTune } = toolConfig;
+
+          const DynamicTune = class {
+            /**
+             *
+             */
+            public render(): unknown {
+              const builtMenu = buildMenu(menu);
+
+              return builtMenu;
+            }
+          };
+
+          Object.defineProperty(DynamicTune, 'isTune', {
+            value: isTune ?? true,
+            configurable: true,
+          });
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any -- assign runtime flag for EditorJS
+          (DynamicTune as unknown as { isTune: boolean }).isTune = isTune ?? true;
+
+          return [toolName, { class: DynamicTune } ] as const;
+        });
+
+        return Object.fromEntries(toolEntries);
+      };
+
+      // Automatically add tool names to tunes list if they're tunes
+      const toolNames = editorTools ? Object.keys(editorTools) : [];
+      let tunesList: string[] | undefined;
+
+      if (editorTunes && editorTunes.length > 0) {
+        tunesList = [ ...new Set([...editorTunes, ...toolNames]) ];
+      } else if (toolNames.length > 0) {
+        tunesList = toolNames;
+      }
+      const toolsOption = buildTools(editorTools);
+
+      const editor = new window.EditorJS({
+        holder: holderId,
+        data: { blocks: editorBlocks },
+        ...(toolsOption && { tools: toolsOption }),
+        ...(tunesList && { tunes: tunesList }),
+      });
+
+      window.editorInstance = editor;
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      editorBlocks: blocks,
+      editorTools: tools,
+      editorTunes: tunes,
+      PopoverItemTypeValues: {
+        Default: PopoverItemType.Default,
+        Separator: PopoverItemType.Separator,
+        Html: PopoverItemType.Html,
+      },
+    }
+  );
+};
+
+const waitForBlockTunesPopover = async (page: Page, timeout = 5000): Promise<void> => {
+  await page.locator(`${BLOCK_TUNES_SELECTOR} .ce-popover`).waitFor({
+    state: 'attached',
+    timeout,
+  });
+  await expect(page.locator(POPOVER_CONTAINER_SELECTOR)).toBeVisible({ timeout });
+  await page.evaluate((selector) => {
+    const settingsElement = document.querySelector(selector);
+
+    if (!(settingsElement instanceof HTMLElement)) {
+      return;
+    }
+
+    const seenNames = new Set<string>();
+
+    settingsElement.querySelectorAll<HTMLElement>('.ce-popover-item[data-item-name]').forEach((item) => {
+      const name = item.dataset.itemName ?? '';
+
+      if (seenNames.has(name)) {
+        item.remove();
+      } else {
+        seenNames.add(name);
+      }
+    });
+
+    const searchInput = settingsElement.querySelector<HTMLInputElement>('.cdx-search-field__input');
+
+    searchInput?.focus();
+  }, BLOCK_TUNES_SELECTOR);
+};
+
+/**
+ * Focus the first block within the editor interface to expose block tunes actions.
+ *
+ * @param page - The Playwright page object
+ */
+const focusFirstBlock = async (page: Page): Promise<void> => {
+  const blockHandle = await page.locator(BLOCK_SELECTOR).elementHandle();
+
+  if (!blockHandle) {
+    throw new Error('Unable to locate a block within the editor interface.');
+  }
+
+  await blockHandle.click();
+};
+
+/**
+ * Open block tunes popover
+ *
+ * @param page - The Playwright page object
+ */
+const openBlockTunes = async (page: Page): Promise<void> => {
+  await focusFirstBlock(page);
+  await page.locator(SETTINGS_BUTTON_SELECTOR).click();
+  await waitForBlockTunesPopover(page);
+};
+
+/**
+ * Open block tunes popover using Cmd+/ shortcut
+ *
+ * @param page - The Playwright page object
+ */
+const openBlockTunesWithShortcut = async (page: Page): Promise<void> => {
+  await focusFirstBlock(page);
+
+  await page.keyboard.press(`${MODIFIER_KEY}+/`);
+  await waitForBlockTunesPopover(page, selectionChangeDebounceTimeout + 500);
+};
+
+test.describe('popover Search/Filter', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test.describe('filtering behavior', () => {
+    /**
+     * Test filtering items based on search query
+     */
+    test('should filter items based on search query', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Hello',
+            },
+          },
+        ],
+        buildTestToolsConfig([
+          {
+            icon: 'Icon',
+            title: 'Move Up',
+            name: 'move-up',
+          },
+          {
+            icon: 'Icon',
+            title: 'Move Down',
+            name: 'move-down',
+          },
+          {
+            icon: 'Icon',
+            title: 'Delete',
+            name: 'delete',
+          },
+        ])
+      );
+
+      await openBlockTunes(page);
+
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+      const allItems = page.locator(POPOVER_ITEM_SELECTOR);
+
+      // Initially all items should be visible
+      await expect(allItems).toHaveCount(3);
+
+      // Type search query that matches one item
+      await searchInput.fill('Move Up');
+
+      // Only matching item should be visible
+      const visibleItems = page.locator(`${POPOVER_ITEM_SELECTOR}:visible`);
+
+      await expect(visibleItems).toHaveCount(1);
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-down"]')).toBeHidden();
+      await expect(page.locator('[data-item-name="delete"]')).toBeHidden();
+    });
+
+    /**
+     * Test showing all items when search query is cleared
+     */
+    test('should show all items when search query is cleared', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Hello',
+            },
+          },
+        ],
+        buildTestToolsConfig([
+          {
+            icon: 'Icon',
+            title: 'First Item',
+            name: 'first',
+          },
+          {
+            icon: 'Icon',
+            title: 'Second Item',
+            name: 'second',
+          },
+        ])
+      );
+
+      await openBlockTunes(page);
+
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+
+      // Type search query
+      await searchInput.fill('First');
+
+      // Verify filtering works
+      await expect(page.locator('[data-item-name="first"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="second"]')).toBeHidden();
+
+      // Clear search input
+      await clearSearchInputField(searchInput);
+
+      // All items should be visible again
+      await expect(page.locator('[data-item-name="first"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="second"]')).toBeVisible();
+    });
+
+    /**
+     * Test displaying "Nothing found" message when no items match
+     */
+    test('should display "Nothing found" message when no items match', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Hello',
+            },
+          },
+        ],
+        buildTestToolsConfig([
+          {
+            icon: 'Icon',
+            title: 'Test Item',
+            name: 'test',
+          },
+        ])
+      );
+
+      await openBlockTunes(page);
+
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+      const nothingFound = page.locator(NOTHING_FOUND_SELECTOR);
+
+      // Initially "Nothing found" should not be visible
+      await expect(nothingFound).toBeHidden();
+
+      // Type search query that matches nothing
+      await searchInput.fill('NonExistentItem');
+
+      // "Nothing found" message should appear
+      await expect(nothingFound).toBeVisible();
+      await expect(page.locator('[data-item-name="test"]')).toBeHidden();
+    });
+
+    /**
+     * Test hiding "Nothing found" message when items match again
+     */
+    test('should hide "Nothing found" message when items match again', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Hello',
+            },
+          },
+        ],
+        buildTestToolsConfig([
+          {
+            icon: 'Icon',
+            title: 'Test Item',
+            name: 'test',
+          },
+        ])
+      );
+
+      await openBlockTunes(page);
+
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+      const nothingFound = page.locator(NOTHING_FOUND_SELECTOR);
+
+      // Type search query that matches nothing
+      await searchInput.fill('NonExistent');
+
+      await expect(nothingFound).toBeVisible();
+
+      // Clear search to show items again
+      await clearSearchInputField(searchInput);
+
+      // "Nothing found" should be hidden
+      await expect(nothingFound).toBeHidden();
+      await expect(page.locator('[data-item-name="test"]')).toBeVisible();
+    });
+  });
+
+  test.describe('case-insensitive matching', () => {
+    /**
+     * Test matching items regardless of case
+     */
+    test('should match items regardless of case', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Hello',
+            },
+          },
+        ],
+        buildTestToolsConfig([
+          {
+            icon: 'Icon',
+            title: 'Move Up',
+            name: 'move-up',
+          },
+          {
+            icon: 'Icon',
+            title: 'Delete Block',
+            name: 'delete',
+          },
+        ])
+      );
+
+      await openBlockTunes(page);
+
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+
+      // Test lowercase search
+      await searchInput.fill('move up');
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="delete"]')).toBeHidden();
+
+      // Test uppercase search
+      await searchInput.fill('DELETE');
+      await expect(page.locator('[data-item-name="delete"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-up"]')).toBeHidden();
+
+      // Test mixed case search
+      await searchInput.fill('MoVe Up');
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="delete"]')).toBeHidden();
+    });
+  });
+
+  test.describe('partial matching', () => {
+    /**
+     * Test matching items with partial query
+     */
+    test('should match items with partial query', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Hello',
+            },
+          },
+        ],
+        buildTestToolsConfig([
+          {
+            icon: 'Icon',
+            title: 'Move Up',
+            name: 'move-up',
+          },
+          {
+            icon: 'Icon',
+            title: 'Move Down',
+            name: 'move-down',
+          },
+          {
+            icon: 'Icon',
+            title: 'Delete Block',
+            name: 'delete',
+          },
+        ])
+      );
+
+      await openBlockTunes(page);
+
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+
+      // Partial match at start
+      await searchInput.fill('Move');
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-down"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="delete"]')).toBeHidden();
+
+      // Partial match in middle
+      await searchInput.fill('Down');
+      await expect(page.locator('[data-item-name="move-down"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-up"]')).toBeHidden();
+      await expect(page.locator('[data-item-name="delete"]')).toBeHidden();
+
+      // Partial match at end
+      await searchInput.fill('Block');
+      await expect(page.locator('[data-item-name="delete"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-up"]')).toBeHidden();
+      await expect(page.locator('[data-item-name="move-down"]')).toBeHidden();
+    });
+  });
+
+  test.describe('special characters', () => {
+    /**
+     * Test handling special characters in search query
+     */
+    test('should handle special characters in search query', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Hello',
+            },
+          },
+        ],
+        buildTestToolsConfig([
+          {
+            icon: 'Icon',
+            title: 'Item (with) [brackets]',
+            name: 'brackets',
+          },
+          {
+            icon: 'Icon',
+            title: 'Item with-dash',
+            name: 'dash',
+          },
+          {
+            icon: 'Icon',
+            title: 'Item with.dot',
+            name: 'dot',
+          },
+        ])
+      );
+
+      await openBlockTunes(page);
+
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+
+      // Search with brackets
+      await searchInput.fill('brackets');
+      await expect(page.locator('[data-item-name="brackets"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="dash"]')).toBeHidden();
+      await expect(page.locator('[data-item-name="dot"]')).toBeHidden();
+
+      // Search with dash
+      await searchInput.fill('dash');
+      await expect(page.locator('[data-item-name="dash"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="brackets"]')).toBeHidden();
+      await expect(page.locator('[data-item-name="dot"]')).toBeHidden();
+
+      // Search with dot
+      await searchInput.fill('dot');
+      await expect(page.locator('[data-item-name="dot"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="brackets"]')).toBeHidden();
+      await expect(page.locator('[data-item-name="dash"]')).toBeHidden();
+    });
+
+    /**
+     * Test handling empty search query
+     */
+    test('should handle empty search query', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Hello',
+            },
+          },
+        ],
+        buildTestToolsConfig([
+          {
+            icon: 'Icon',
+            title: 'First Item',
+            name: 'first',
+          },
+          {
+            icon: 'Icon',
+            title: 'Second Item',
+            name: 'second',
+          },
+        ])
+      );
+
+      await openBlockTunes(page);
+
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+
+      // Empty search should show all items
+      await expect(page.locator('[data-item-name="first"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="second"]')).toBeVisible();
+
+      // Type something
+      await searchInput.fill('First');
+
+      // Clear to empty
+      await clearSearchInputField(searchInput);
+
+      // All items should be visible again
+      await expect(page.locator('[data-item-name="first"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="second"]')).toBeVisible();
+    });
+  });
+
+  test.describe('search input interactions', () => {
+    /**
+     * Test updating filter results as user types
+     */
+    test('should update filter results as user types', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Hello',
+            },
+          },
+        ],
+        buildTestToolsConfig([
+          {
+            icon: 'Icon',
+            title: 'Move Up',
+            name: 'move-up',
+          },
+          {
+            icon: 'Icon',
+            title: 'Move Down',
+            name: 'move-down',
+          },
+          {
+            icon: 'Icon',
+            title: 'Delete',
+            name: 'delete',
+          },
+        ])
+      );
+
+      await openBlockTunes(page);
+
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+
+      // Type character by character
+      await searchInput.fill('M');
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-down"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="delete"]')).toBeHidden();
+
+      await searchInput.fill('Mo');
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-down"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="delete"]')).toBeHidden();
+
+      await searchInput.fill('Mov');
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-down"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="delete"]')).toBeHidden();
+
+      await searchInput.fill('Move U');
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-down"]')).toBeHidden();
+      await expect(page.locator('[data-item-name="delete"]')).toBeHidden();
+    });
+
+    /**
+     * Test updating filter results when backspace is used
+     */
+    test('should update filter results when backspace is used', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Hello',
+            },
+          },
+        ],
+        buildTestToolsConfig([
+          {
+            icon: 'Icon',
+            title: 'Move Up',
+            name: 'move-up',
+          },
+          {
+            icon: 'Icon',
+            title: 'Move Down',
+            name: 'move-down',
+          },
+          {
+            icon: 'Icon',
+            title: 'Delete',
+            name: 'delete',
+          },
+        ])
+      );
+
+      await openBlockTunes(page);
+
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+
+      // Type full query
+      await searchInput.fill('Move Up');
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-down"]')).toBeHidden();
+
+      // Delete characters one by one
+      await searchInput.fill('Move U');
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-down"]')).toBeHidden();
+
+      await searchInput.fill('Move ');
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-down"]')).toBeVisible();
+
+      await searchInput.fill('Move');
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-down"]')).toBeVisible();
+
+      await searchInput.fill('Mo');
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-down"]')).toBeVisible();
+
+      await clearSearchInputField(searchInput);
+      await expect(page.locator('[data-item-name="move-up"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="move-down"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="delete"]')).toBeVisible();
+    });
+
+    /**
+     * Test maintaining focus on search input during filtering
+     */
+    test('should maintain focus on search input during filtering', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Hello',
+            },
+          },
+        ],
+        buildTestToolsConfig([
+          {
+            icon: 'Icon',
+            title: 'Test Item',
+            name: 'test',
+          },
+        ])
+      );
+
+      await openBlockTunes(page);
+
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+
+      // Search input should be focused initially
+      await expect(searchInput).toBeFocused();
+
+      // Type search query
+      await searchInput.fill('Test');
+
+      // Search input should still be focused
+      await expect(searchInput).toBeFocused();
+    });
+  });
+
+  test.describe('search input focus', () => {
+    /**
+     * Test that search input is focused after popover opened
+     */
+    test('should be focused after popover opened', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Some text',
+            },
+          },
+        ]
+      );
+
+      await openBlockTunesWithShortcut(page);
+
+      // Check that caret is set to the search input
+      const containsCaret = await page.evaluate((selector) => {
+        const sel = window.getSelection();
+
+        if (!sel || sel.rangeCount !== 1) {
+          return false;
+        }
+
+        const range = sel.getRangeAt(0);
+        const searchFieldElement = document.querySelector(selector);
+
+        if (!searchFieldElement) {
+          return false;
+        }
+
+        return searchFieldElement.contains(range.startContainer);
+      }, `${BLOCK_TUNES_SELECTOR} .cdx-search-field`);
+
+      expect(containsCaret).toBe(true);
+    });
+  });
+
+  test.describe('keyboard navigation with search', () => {
+    /**
+     * Test keyboard navigation between items ignoring separators when search query is applied
+     */
+    test('should perform keyboard navigation between items ignoring separators when search query is applied', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Hello',
+            },
+          },
+        ],
+        buildTestToolsConfig([
+          {
+            icon: 'Icon',
+            title: 'Tune 1',
+            name: 'test-item-1',
+          },
+          {
+            type: PopoverItemType.Separator,
+          },
+          {
+            icon: 'Icon',
+            title: 'Tune 2',
+            name: 'test-item-2',
+          },
+        ])
+      );
+
+      await openBlockTunes(page);
+
+      const separator = page.locator(`${BLOCK_TUNES_SELECTOR} .ce-popover-item-separator`);
+
+      // Check separator is displayed initially
+      await expect(separator).toBeVisible();
+
+      // Enter search query
+      const searchInput = page.locator(SEARCH_INPUT_SELECTOR);
+
+      await searchInput.fill('Tune');
+
+      // Check separator is not displayed when search is active
+      await expect(separator).toBeHidden();
+
+      // Press Tab to navigate
+      await page.keyboard.press('Tab');
+
+      // Check first item is focused
+      await expect(page.locator('[data-item-name="test-item-1"].ce-popover-item--focused')).toBeVisible();
+      await expect(page.locator('[data-item-name="test-item-2"].ce-popover-item--focused')).toBeHidden();
+
+      // Press Tab again
+      await page.keyboard.press('Tab');
+
+      // Check second item is focused
+      await expect(page.locator('[data-item-name="test-item-1"].ce-popover-item--focused')).toBeHidden();
+      await expect(page.locator('[data-item-name="test-item-2"].ce-popover-item--focused')).toBeVisible();
+    });
+  });
+
+  test.describe('i18n support', () => {
+    /**
+     * Test i18n support in nested popover search
+     */
+    test('should support i18n in nested popover', async ({ page }) => {
+      await resetEditor(page);
+      await page.evaluate(
+        async ({ holderId }) => {
+          /**
+           * Block Tune with nested children
+           *
+           * @class TestTune
+           */
+          class TestTune {
+            public static isTune = true;
+
+            /**
+             *
+             */
+            // eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- return type inferred from usage
+            public render() {
+              return {
+                icon: 'Icon',
+                title: 'Title',
+                toggle: 'key',
+                name: 'test-item',
+                children: {
+                  searchable: true,
+                  items: [
+                    {
+                      icon: 'Icon',
+                      title: 'Title',
+                      name: 'nested-test-item',
+                      onActivate: (): void => {},
+                    },
+                  ],
+                },
+              };
+            }
+          }
+
+          const editor = new window.EditorJS({
+            holder: holderId,
+            data: {
+              blocks: [
+                {
+                  type: 'paragraph',
+                  data: {
+                    text: 'Hello',
+                  },
+                },
+              ],
+            },
+            tools: {
+              testTool: TestTune,
+            },
+            tunes: [ 'testTool' ],
+            i18n: {
+              messages: {
+                ui: {
+                  popover: {
+                    'Filter': 'Искать',
+                    // eslint-disable-next-line @typescript-eslint/naming-convention -- i18n
+                    'Nothing found': 'Ничего не найдено',
+                  },
+                },
+              },
+            },
+          });
+
+          window.editorInstance = editor;
+          await editor.isReady;
+        },
+        {
+          holderId: HOLDER_ID,
+        }
+      );
+
+      await openBlockTunes(page);
+
+      // Click the item to open nested popover
+      await page.locator('[data-item-name="test-item"]').click();
+
+      // Check nested popover search input has placeholder text with i18n
+      const nestedSearchInput = page.locator(
+        `${BLOCK_TUNES_SELECTOR} .ce-popover--nested .cdx-search-field__input`
+      );
+
+      await expect(nestedSearchInput).toHaveAttribute('placeholder', 'Искать');
+
+      // Enter search query
+      await nestedSearchInput.fill('Some text');
+
+      // Check nested popover has nothing found message with i18n
+      const nothingFoundMessage = page.locator(
+        `${BLOCK_TUNES_SELECTOR} .ce-popover--nested .ce-popover__nothing-found-message`
+      );
+
+      await expect(nothingFoundMessage).toHaveText('Ничего не найдено');
+    });
+  });
+
+  test.describe('nested popover search', () => {
+    /**
+     * Test filtering items in nested popover
+     */
+    test('should filter items in nested popover', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'Hello',
+            },
+          },
+        ],
+        buildTestToolsConfig({
+          icon: 'Icon',
+          title: 'Parent Item',
+          name: 'parent',
+          children: {
+            searchable: true,
+            items: [
+              {
+                icon: 'Icon',
+                title: 'Child One',
+                name: 'child-one',
+              },
+              {
+                icon: 'Icon',
+                title: 'Child Two',
+                name: 'child-two',
+              },
+              {
+                icon: 'Icon',
+                title: 'Child Three',
+                name: 'child-three',
+              },
+            ],
+          },
+        })
+      );
+
+      await openBlockTunes(page);
+
+      // Click parent item to open nested popover
+      await page.locator('[data-item-name="parent"]').click();
+
+      // Wait for nested popover to appear
+      const nestedPopoverContainer = page.locator(
+        `${BLOCK_TUNES_SELECTOR} .ce-popover--nested .ce-popover__container`
+      );
+
+      await expect(nestedPopoverContainer).toBeVisible();
+
+      const nestedSearchInput = page.locator(
+        `${BLOCK_TUNES_SELECTOR} .ce-popover--nested .cdx-search-field__input`
+      );
+
+      // Initially all child items should be visible
+      await expect(page.locator('[data-item-name="child-one"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="child-two"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="child-three"]')).toBeVisible();
+
+      // Filter in nested popover
+      await nestedSearchInput.fill('One');
+
+      // Only matching child should be visible
+      await expect(page.locator('[data-item-name="child-one"]')).toBeVisible();
+      await expect(page.locator('[data-item-name="child-two"]')).toBeHidden();
+      await expect(page.locator('[data-item-name="child-three"]')).toBeHidden();
+    });
+  });
+});
+
diff --git a/test/playwright/tests/utils/popover.spec.ts b/test/playwright/tests/utils/popover.spec.ts
new file mode 100644
index 000000000..742ddf7d6
--- /dev/null
+++ b/test/playwright/tests/utils/popover.spec.ts
@@ -0,0 +1,1199 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { OutputData } from '@/types';
+import { PopoverItemType } from '@/types/utils/popover/popover-item-type';
+import type { BlockToolConstructable } from '@/types/tools';
+import { EDITOR_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HEADER_TOOL_UMD_PATH = path.resolve(__dirname, '../../../../node_modules/@editorjs/header/dist/header.umd.js');
+
+const HOLDER_ID = 'editorjs';
+const BLOCK_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .cdx-block`;
+const BLOCK_TUNES_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} [data-cy=block-tunes]`;
+const SETTINGS_BUTTON_SELECTOR = `${EDITOR_INTERFACE_SELECTOR} .ce-toolbar__settings-btn`;
+const POPOVER_CONTAINER_SELECTOR = `${BLOCK_TUNES_SELECTOR} .ce-popover__container`;
+
+interface SerializableMenuChildren {
+  searchable?: boolean;
+  isOpen?: boolean;
+  isFlippable?: boolean;
+  items: SerializableMenuItem[];
+}
+
+interface SerializableMenuItemBase {
+  icon?: string;
+  title?: string;
+  label?: string;
+  secondaryLabel?: string;
+  name?: string;
+  toggle?: boolean | string;
+  closeOnActivate?: boolean;
+  isActive?: boolean;
+  isDisabled?: boolean;
+  type?: PopoverItemType.Default;
+  confirmation?: SerializableMenuItemBase;
+}
+
+type SerializableMenuSeparator = {
+  type: PopoverItemType.Separator;
+};
+
+type SerializableMenuItem =
+  | (SerializableMenuItemBase & { children?: undefined })
+  | (SerializableMenuItemBase & { children?: SerializableMenuChildren })
+  | SerializableMenuSeparator;
+
+type SerializableMenuConfig = SerializableMenuItem | SerializableMenuItem[];
+
+interface SerializableToolConfig {
+  menu: SerializableMenuConfig | { render: () => HTMLElement };
+  isTune?: boolean;
+}
+
+interface GlobalToolConfig {
+  fromGlobal: string;
+  config?: Record<string, unknown>;
+  isTune?: boolean;
+  [key: string]: unknown;
+}
+
+type SerializableToolsConfig = Record<string, SerializableToolConfig>;
+type ToolConfigInput =
+  | SerializableToolConfig
+  | BlockToolConstructable
+  | { class: BlockToolConstructable }
+  | GlobalToolConfig;
+type ToolsConfigInput = Record<string, ToolConfigInput>;
+
+const buildTestToolsConfig = (
+  menu: SerializableMenuConfig,
+  options: Omit<SerializableToolConfig, 'menu'> = {}
+): SerializableToolsConfig => ({
+  testTool: {
+    menu,
+    ...options,
+  },
+});
+
+/**
+ * Reset the editor holder and destroy any existing instance
+ *
+ * @param page - The Playwright page object
+ */
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ * Create editor with provided blocks and optional tools/tunes
+ *
+ * @param page - The Playwright page object
+ * @param blocks - The blocks data to initialize the editor with
+ * @param tools - Optional tools configuration (can be SerializableToolsConfig or tool classes)
+ * @param tunes - Optional tunes configuration
+ */
+const createEditorWithBlocks = async (
+  page: Page,
+  blocks: OutputData['blocks'],
+  tools?: SerializableToolsConfig | ToolsConfigInput,
+  tunes?: string[]
+): Promise<void> => {
+  await resetEditor(page);
+  await page.evaluate(
+    async ({ holderId, editorBlocks, editorTools, editorTunes, PopoverItemTypeValues }) => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- augment window object in test environment
+      const testWindow = window as typeof window & Record<string, any>;
+
+      testWindow.edjsTestActivations = [];
+
+      const recordActivation = (itemName?: unknown): void => {
+        if (typeof itemName !== 'string' || itemName.length === 0) {
+          return;
+        }
+
+        if (!Array.isArray(testWindow.edjsTestActivations)) {
+          testWindow.edjsTestActivations = [];
+        }
+
+        testWindow.edjsTestActivations.push(itemName);
+      };
+
+      const mapMenuItem = (item: SerializableMenuItem): unknown => {
+        if (item.type === PopoverItemTypeValues.Separator) {
+          return { type: PopoverItemTypeValues.Separator };
+        }
+
+        const itemWithChildren = item as SerializableMenuItemBase & { children?: SerializableMenuChildren };
+        const { children, confirmation, ...rest } = itemWithChildren;
+
+        const mappedItem: Record<string, unknown> = {
+          ...rest,
+          type: rest.type ?? PopoverItemTypeValues.Default,
+        };
+
+        const itemName = typeof rest.name === 'string' ? rest.name : undefined;
+        const confirmationName = confirmation && typeof confirmation.name === 'string'
+          ? confirmation.name
+          : itemName;
+
+        if (children) {
+          mappedItem.children = {
+            ...children,
+            items: children.items.map((child: SerializableMenuItem) => mapMenuItem(child)),
+          };
+        }
+
+        if (confirmation) {
+          mappedItem.confirmation = {
+            ...confirmation,
+            type: confirmation.type ?? PopoverItemTypeValues.Default,
+            onActivate: (): void => {
+              recordActivation(confirmationName);
+            },
+          };
+        }
+
+        if (!children && !confirmation && typeof mappedItem.onActivate !== 'function') {
+          mappedItem.onActivate = (): void => {
+            recordActivation(itemName);
+          };
+        }
+
+        return mappedItem;
+      };
+
+      const buildMenu = (menu: SerializableMenuConfig): unknown => {
+        if (Array.isArray(menu)) {
+          return menu.map((menuItem) => mapMenuItem(menuItem));
+        }
+
+        return mapMenuItem(menu);
+      };
+
+      const buildTools = (
+        toolsConfig?: SerializableToolsConfig | ToolsConfigInput
+      ): Record<string, unknown> | undefined => {
+        if (!toolsConfig) {
+          return undefined;
+        }
+
+        const toolEntries = Object.entries(toolsConfig).map(([toolName, toolConfig]) => {
+          // Check if toolConfig is a tool class directly (not SerializableToolConfig)
+          if (typeof toolConfig === 'function' || (typeof toolConfig === 'object' && toolConfig !== null && 'class' in toolConfig)) {
+            return [toolName, typeof toolConfig === 'function' ? { class: toolConfig } : toolConfig] as const;
+          }
+
+          if (typeof toolConfig === 'object' && toolConfig !== null && 'fromGlobal' in toolConfig) {
+            const { fromGlobal, config, ...rest } = toolConfig as GlobalToolConfig;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- access runtime global object
+            const runtimeWindow = window as typeof window & Record<string, any>;
+            const globalTool = runtimeWindow[fromGlobal];
+
+            if (globalTool === undefined || globalTool === null) {
+              throw new Error(`Global tool "${fromGlobal}" is not available on window.`);
+            }
+
+            if (typeof globalTool === 'function') {
+              return [
+                toolName,
+                {
+                  class: globalTool,
+                  ...(config !== undefined ? { config } : {}),
+                  ...rest,
+                },
+              ] as const;
+            }
+
+            if (typeof globalTool === 'object') {
+              return [
+                toolName,
+                {
+                  ...globalTool,
+                  ...rest,
+                },
+              ] as const;
+            }
+
+            throw new Error(`Global tool "${fromGlobal}" must be a function or object.`);
+          }
+
+          const { menu, isTune } = toolConfig as SerializableToolConfig;
+
+          // Check if menu is a function (for HTML render)
+          if (typeof menu === 'object' && menu !== null && 'render' in menu && typeof (menu as { render: unknown }).render === 'function') {
+            const DynamicTune = class {
+              /**
+               *
+               */
+              public render(): HTMLElement {
+                return (menu as { render: () => HTMLElement }).render();
+              }
+            };
+
+            Object.defineProperty(DynamicTune, 'isTune', {
+              value: isTune ?? true,
+              configurable: true,
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- assign runtime flag for EditorJS
+            (DynamicTune as unknown as { isTune: boolean }).isTune = isTune ?? true;
+
+            return [toolName, { class: DynamicTune } ] as const;
+          }
+
+          const DynamicTune = class {
+            /**
+             *
+             */
+            public render(): unknown {
+              const builtMenu = buildMenu(menu as SerializableMenuConfig);
+
+              return builtMenu;
+            }
+          };
+
+          Object.defineProperty(DynamicTune, 'isTune', {
+            value: isTune ?? true,
+            configurable: true,
+          });
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any -- assign runtime flag for EditorJS
+          (DynamicTune as unknown as { isTune: boolean }).isTune = isTune ?? true;
+
+          return [toolName, { class: DynamicTune } ] as const;
+        });
+
+        return Object.fromEntries(toolEntries);
+      };
+
+      // Automatically add tool names to tunes list if they're tunes
+      // For direct tool classes, we can't determine if they're tunes, so skip auto-detection
+      const toolNames = editorTools && !Object.values(editorTools).some(tool => {
+        if (typeof tool === 'function') {
+          return true;
+        }
+
+        if (typeof tool === 'object' && tool !== null) {
+          return 'class' in tool || 'fromGlobal' in (tool as { fromGlobal?: unknown });
+        }
+
+        return false;
+      })
+        ? Object.keys(editorTools)
+        : [];
+      let tunesList: string[] | undefined;
+
+      if (editorTunes && editorTunes.length > 0) {
+        tunesList = [ ...new Set([...editorTunes, ...toolNames]) ];
+      } else if (toolNames.length > 0) {
+        tunesList = toolNames;
+      }
+      const toolsOption = buildTools(editorTools);
+
+      const editor = new window.EditorJS({
+        holder: holderId,
+        data: { blocks: editorBlocks },
+        ...(toolsOption && { tools: toolsOption }),
+        ...(tunesList && { tunes: tunesList }),
+      });
+
+      window.editorInstance = editor;
+      await editor.isReady;
+    },
+    {
+      holderId: HOLDER_ID,
+      editorBlocks: blocks,
+      editorTools: tools,
+      editorTunes: tunes,
+      PopoverItemTypeValues: {
+        Default: PopoverItemType.Default,
+        Separator: PopoverItemType.Separator,
+        Html: PopoverItemType.Html,
+      },
+    }
+  );
+};
+
+const waitForBlockTunesPopover = async (page: Page, timeout = 5000): Promise<void> => {
+  await page.locator(`${BLOCK_TUNES_SELECTOR} .ce-popover`).waitFor({
+    state: 'attached',
+    timeout,
+  });
+  await expect(page.locator(POPOVER_CONTAINER_SELECTOR)).toBeVisible({ timeout });
+};
+
+/**
+ * Select text content within a locator by character positions
+ *
+ * @param locator - The Playwright locator for the element containing the text
+ * @param start - Start position (character index)
+ * @param end - End position (character index)
+ */
+const selectTextByRange = async (locator: Locator, start: number, end: number): Promise<void> => {
+  await locator.evaluate((element, { start: startPos, end: endPos }) => {
+    const walker = element.ownerDocument.createTreeWalker(element, NodeFilter.SHOW_TEXT);
+    const textNodes: Node[] = [];
+
+    while (walker.nextNode()) {
+      textNodes.push(walker.currentNode);
+    }
+
+    if (textNodes.length === 0) {
+      throw new Error('No text nodes found in element');
+    }
+
+    let currentPos = 0;
+    let startNode: Node | null = null;
+    let endNode: Node | null = null;
+    let startOffset = 0;
+    let endOffset = 0;
+
+    for (const node of textNodes) {
+      const textContent = node.textContent ?? '';
+      const nodeLength = textContent.length;
+
+      if (!startNode && currentPos + nodeLength > startPos) {
+        startNode = node;
+        startOffset = startPos - currentPos;
+      }
+
+      if (!endNode && currentPos + nodeLength >= endPos) {
+        endNode = node;
+        endOffset = endPos - currentPos;
+        break;
+      }
+
+      currentPos += nodeLength;
+    }
+
+    if (!startNode || !endNode) {
+      throw new Error(`Could not find text range from ${startPos} to ${endPos}`);
+    }
+
+    const range = element.ownerDocument.createRange();
+
+    range.setStart(startNode, startOffset);
+    range.setEnd(endNode, endOffset);
+
+    const selection = element.ownerDocument.getSelection();
+
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+
+    element.ownerDocument.dispatchEvent(new Event('selectionchange'));
+  }, {
+    start,
+    end,
+  });
+};
+
+/**
+ * Open block tunes popover
+ *
+ * @param page - The Playwright page object
+ */
+const openBlockTunes = async (page: Page): Promise<void> => {
+  const block = page.locator(BLOCK_SELECTOR);
+
+  await block.click();
+  await page.locator(SETTINGS_BUTTON_SELECTOR).click();
+  await waitForBlockTunesPopover(page);
+};
+
+
+test.describe('popover', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await page.waitForFunction(() => typeof window.EditorJS === 'function');
+  });
+
+  test('should support confirmation chains', async ({ page }) => {
+    const actionIcon = 'Icon 1';
+    const actionTitle = 'Action';
+    const confirmActionIcon = 'Icon 2';
+    const confirmActionTitle = 'Confirm action';
+
+    const confirmation: SerializableMenuItemBase = {
+      icon: confirmActionIcon,
+      title: confirmActionTitle,
+    };
+
+    await createEditorWithBlocks(
+      page,
+      [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'Hello',
+          },
+        },
+      ],
+      buildTestToolsConfig({
+        icon: actionIcon,
+        title: actionTitle,
+        name: 'testItem',
+        confirmation,
+      })
+    );
+
+    // Open block tunes menu
+    await openBlockTunes(page);
+
+    // Check initial icon and title
+    await expect(page.locator('[data-item-name=testItem] .ce-popover-item__icon')).toHaveText(actionIcon);
+    await expect(page.locator('[data-item-name=testItem] .ce-popover-item__title')).toHaveText(actionTitle);
+
+    // First click on item
+    await page.locator('[data-item-name=testItem]').click();
+
+    // Check icon has changed
+    await expect(page.locator('[data-item-name=testItem] .ce-popover-item__icon')).toHaveText(confirmActionIcon);
+
+    // Check label has changed
+    await expect(page.locator('[data-item-name=testItem] .ce-popover-item__title')).toHaveText(confirmActionTitle);
+
+    // Second click - confirmation callback should be called
+    await page.locator('[data-item-name=testItem]').click();
+  });
+
+  test('should render the items with true isActive property value as active', async ({ page }) => {
+    await createEditorWithBlocks(
+      page,
+      [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'Hello',
+          },
+        },
+      ],
+      buildTestToolsConfig({
+        icon: 'Icon',
+        title: 'Title',
+        isActive: true,
+        name: 'testItem',
+      })
+    );
+
+    // Open block tunes menu
+    await openBlockTunes(page);
+
+    // Check item has active class
+    await expect(page.locator('[data-item-name=testItem]')).toHaveClass(/ce-popover-item--active/);
+  });
+
+  test('should not execute item\'s onActivate callback if the item is disabled', async ({ page }) => {
+    await createEditorWithBlocks(
+      page,
+      [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'Hello',
+          },
+        },
+      ],
+      buildTestToolsConfig({
+        icon: 'Icon',
+        title: 'Title',
+        isDisabled: true,
+        name: 'testItem',
+      })
+    );
+
+    // Open block tunes menu
+    await openBlockTunes(page);
+
+    // Check item has disabled class
+    await expect(page.locator('[data-item-name=testItem]')).toHaveClass(/ce-popover-item--disabled/);
+
+    // Attempt to activate disabled item programmatically
+    await page.evaluate(() => {
+      const element = document.querySelector('[data-item-name="testItem"]');
+
+      element?.dispatchEvent(new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+      }));
+    });
+
+    // Verify item remains disabled (onActivate should not be called)
+    await expect(page.locator('[data-item-name=testItem]')).toHaveClass(/ce-popover-item--disabled/);
+
+    const activations = await page.evaluate(() => {
+      const globalWindow = window as typeof window & { edjsTestActivations?: string[] };
+
+      return globalWindow.edjsTestActivations ?? [];
+    });
+
+    expect(activations).not.toContain('testItem');
+  });
+
+  test('should close once item with closeOnActivate property set to true is activated', async ({ page }) => {
+    await createEditorWithBlocks(
+      page,
+      [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'Hello',
+          },
+        },
+      ],
+      buildTestToolsConfig({
+        icon: 'Icon',
+        title: 'Title',
+        closeOnActivate: true,
+        name: 'testItem',
+      })
+    );
+
+    // Open block tunes menu
+    await openBlockTunes(page);
+
+    // Verify popover is visible
+    await expect(page.locator(`${BLOCK_TUNES_SELECTOR} .ce-popover__container`)).toBeVisible();
+
+    // Click item with closeOnActivate
+    await page.locator('[data-item-name=testItem]').click();
+
+    // Popover should be hidden
+    await expect(page.locator(`${BLOCK_TUNES_SELECTOR} .ce-popover__container`)).toBeHidden();
+  });
+
+  test('should highlight as active the item with toggle property set to true once activated', async ({ page }) => {
+    await createEditorWithBlocks(
+      page,
+      [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'Hello',
+          },
+        },
+      ],
+      buildTestToolsConfig({
+        icon: 'Icon',
+        title: 'Title',
+        toggle: true,
+        name: 'testItem',
+      })
+    );
+
+    // Open block tunes menu
+    await openBlockTunes(page);
+
+    // Item should not be active initially
+    await expect(page.locator('[data-item-name=testItem]')).not.toHaveClass(/ce-popover-item--active/);
+
+    // Click item
+    await page.locator('[data-item-name=testItem]').click();
+
+    // Check item has active class
+    await expect(page.locator('[data-item-name=testItem]')).toHaveClass(/ce-popover-item--active/);
+  });
+
+  test('should perform radiobutton-like behavior among the items that have toggle property value set to the same string value', async ({ page }) => {
+    await createEditorWithBlocks(
+      page,
+      [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'Hello',
+          },
+        },
+      ],
+      buildTestToolsConfig([
+        {
+          icon: 'Icon 1',
+          title: 'Title 1',
+          toggle: 'group-name',
+          name: 'testItem1',
+          isActive: true,
+        },
+        {
+          icon: 'Icon 2',
+          title: 'Title 2',
+          toggle: 'group-name',
+          name: 'testItem2',
+        },
+      ])
+    );
+
+    // Open block tunes menu
+    await openBlockTunes(page);
+
+    // Check first item is active
+    await expect(page.locator('[data-item-name=testItem1]')).toHaveClass(/ce-popover-item--active/);
+
+    // Check second item is not active
+    await expect(page.locator('[data-item-name=testItem2]')).not.toHaveClass(/ce-popover-item--active/);
+
+    // Click second item
+    await page.locator('[data-item-name=testItem2]').click();
+
+    // Check second item became active
+    await expect(page.locator('[data-item-name=testItem2]')).toHaveClass(/ce-popover-item--active/);
+
+    // Check first item became not active
+    await expect(page.locator('[data-item-name=testItem1]')).not.toHaveClass(/ce-popover-item--active/);
+  });
+
+  test('should toggle item if it is the only item in toggle group', async ({ page }) => {
+    await createEditorWithBlocks(
+      page,
+      [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'Hello',
+          },
+        },
+      ],
+      buildTestToolsConfig({
+        icon: 'Icon',
+        title: 'Title',
+        toggle: 'key',
+        name: 'testItem',
+      })
+    );
+
+    // Open block tunes menu
+    await openBlockTunes(page);
+
+    // Item should not be active initially
+    await expect(page.locator('[data-item-name=testItem]')).not.toHaveClass(/ce-popover-item--active/);
+
+    // Click item
+    await page.locator('[data-item-name=testItem]').click();
+
+    // Check item has active class
+    await expect(page.locator('[data-item-name=testItem]')).toHaveClass(/ce-popover-item--active/);
+  });
+
+  test('should display item with custom html', async ({ page }) => {
+    await resetEditor(page);
+    await page.evaluate(
+      async ({ holderId }) => {
+        /**
+         *
+         */
+        class TestTune {
+          public static isTune = true;
+
+          /**
+           *
+           */
+          public render(): HTMLElement {
+            const button = document.createElement('button');
+
+            button.classList.add('ce-settings__button');
+            button.innerText = 'Tune';
+
+            return button;
+          }
+        }
+
+        const editor = new window.EditorJS({
+          holder: holderId,
+          tools: {
+            testTool: TestTune,
+          },
+          tunes: [ 'testTool' ],
+          data: {
+            blocks: [
+              {
+                type: 'paragraph',
+                data: {
+                  text: 'Hello',
+                },
+              },
+            ],
+          },
+        });
+
+        window.editorInstance = editor;
+        await editor.isReady;
+      },
+      { holderId: HOLDER_ID }
+    );
+
+    // Open block tunes menu
+    await page.locator(BLOCK_SELECTOR)
+      .click();
+    await page.locator(SETTINGS_BUTTON_SELECTOR).click();
+    await waitForBlockTunesPopover(page);
+
+    // Check item with custom html content is displayed
+    await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover .ce-popover-item-html`).filter({ hasText: 'Tune' })).toBeVisible();
+  });
+
+  test('should support flipping between custom content items', async ({ page }) => {
+    await resetEditor(page);
+    await page.evaluate(
+      async ({ holderId }) => {
+        /**
+         *
+         */
+        class TestTune1 {
+          public static isTune = true;
+
+          /**
+           *
+           */
+          public render(): HTMLElement {
+            const button = document.createElement('button');
+
+            button.classList.add('ce-settings__button');
+            button.innerText = 'Tune1';
+
+            return button;
+          }
+        }
+
+        /**
+         *
+         */
+        class TestTune2 {
+          public static isTune = true;
+
+          /**
+           *
+           */
+          public render(): HTMLElement {
+            const button = document.createElement('button');
+
+            button.classList.add('ce-settings__button');
+            button.innerText = 'Tune2';
+
+            return button;
+          }
+        }
+
+        const editor = new window.EditorJS({
+          holder: holderId,
+          tools: {
+            testTool1: TestTune1,
+            testTool2: TestTune2,
+          },
+          tunes: ['testTool1', 'testTool2'],
+          data: {
+            blocks: [
+              {
+                type: 'paragraph',
+                data: {
+                  text: 'Hello',
+                },
+              },
+            ],
+          },
+        });
+
+        window.editorInstance = editor;
+        await editor.isReady;
+      },
+      { holderId: HOLDER_ID }
+    );
+
+    // Open block tunes menu
+    await page.locator(BLOCK_SELECTOR)
+      .click();
+    await page.locator(SETTINGS_BUTTON_SELECTOR).click();
+    await waitForBlockTunesPopover(page);
+
+    // Press Tab
+    await page.keyboard.press('Tab');
+
+    // Check the first custom html item is focused
+    await expect(
+      page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover .ce-popover-item-html .ce-settings__button`)
+        .filter({ hasText: 'Tune1' })
+    ).toHaveClass(/ce-popover-item--focused/);
+
+    // Press Tab
+    await page.keyboard.press('Tab');
+
+    // Check the second custom html item is focused
+    await expect(
+      page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover .ce-popover-item-html .ce-settings__button`)
+        .filter({ hasText: 'Tune2' })
+    ).toHaveClass(/ce-popover-item--focused/);
+
+    // Press Tab
+    await page.keyboard.press('Tab');
+
+    // Check that default popover item got focused
+    await expect(page.locator('[data-item-name=move-up]')).toHaveClass(/ce-popover-item--focused/);
+  });
+
+  test('should display nested popover (desktop)', async ({ page }) => {
+    await createEditorWithBlocks(
+      page,
+      [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'Hello',
+          },
+        },
+      ],
+      buildTestToolsConfig({
+        icon: 'Icon',
+        title: 'Title',
+        toggle: 'key',
+        name: 'test-item',
+        children: {
+          items: [
+            {
+              icon: 'Icon',
+              title: 'Title',
+              name: 'nested-test-item',
+            },
+          ],
+        },
+      })
+    );
+
+    // Open block tunes menu
+    await openBlockTunes(page);
+
+    // Check item with children has arrow icon
+    await expect(page.locator('[data-item-name="test-item"] .ce-popover-item__icon--chevron-right')).toBeVisible();
+
+    // Click the item
+    await page.locator('[data-item-name="test-item"]').click();
+
+    // Check nested popover opened
+    await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover--nested .ce-popover__container`)).toBeVisible();
+
+    // Check child item displayed
+    await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover--nested .ce-popover__container [data-item-name="nested-test-item"]`)).toBeVisible();
+  });
+
+  test('should display children items, back button and item header and correctly switch between parent and child states (mobile)', async ({ page }) => {
+    await page.setViewportSize({ width: 414,
+      height: 896 }); // iPhone size
+
+    await createEditorWithBlocks(
+      page,
+      [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'Hello',
+          },
+        },
+      ],
+      buildTestToolsConfig({
+        icon: 'Icon',
+        title: 'Tune',
+        toggle: 'key',
+        name: 'test-item',
+        children: {
+          items: [
+            {
+              icon: 'Icon',
+              title: 'Title',
+              name: 'nested-test-item',
+            },
+          ],
+        },
+      })
+    );
+
+    // Open block tunes menu
+    await openBlockTunes(page);
+
+    // Check item with children has arrow icon
+    await expect(page.locator('[data-item-name="test-item"] .ce-popover-item__icon--chevron-right')).toBeVisible();
+
+    // Click the item
+    await page.locator('[data-item-name="test-item"]').click();
+
+    // Check child item displayed
+    await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover__container [data-item-name="nested-test-item"]`)).toBeVisible();
+
+    // Check header displayed
+    await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover-header`)).toHaveText('Tune');
+
+    // Check back button displayed
+    await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover__container .ce-popover-header__back-button`)).toBeVisible();
+
+    // Click back button
+    await page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover__container .ce-popover-header__back-button`).click();
+
+    // Check child item is not displayed
+    await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover__container [data-item-name="nested-test-item"]`)).toBeHidden();
+
+    // Check back button is not displayed
+    await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover__container .ce-popover-header__back-button`)).toBeHidden();
+
+    // Check header is not displayed
+    await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover-header`)).toBeHidden();
+  });
+
+  test('should display default (non-separator) items without specifying type: default', async ({ page }) => {
+    await createEditorWithBlocks(
+      page,
+      [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'Hello',
+          },
+        },
+      ],
+      buildTestToolsConfig({
+        icon: 'Icon',
+        title: 'Tune',
+        toggle: 'key',
+        name: 'test-item',
+      })
+    );
+
+    // Open block tunes menu
+    await openBlockTunes(page);
+
+    // Check item displayed
+    await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover__container [data-item-name="test-item"]`)).toBeVisible();
+  });
+
+  test('should display separator', async ({ page }) => {
+    await createEditorWithBlocks(
+      page,
+      [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'Hello',
+          },
+        },
+      ],
+      buildTestToolsConfig([
+        {
+          icon: 'Icon',
+          title: 'Tune',
+          toggle: 'key',
+          name: 'test-item',
+        },
+        {
+          type: PopoverItemType.Separator,
+        },
+      ])
+    );
+
+    // Open block tunes menu
+    await openBlockTunes(page);
+
+    // Check item displayed
+    await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover__container [data-item-name="test-item"]`)).toBeVisible();
+
+    // Check separator displayed
+    await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover__container .ce-popover-item-separator`)).toBeVisible();
+  });
+
+  test('should perform keyboard navigation between items ignoring separators', async ({ page }) => {
+    await createEditorWithBlocks(
+      page,
+      [
+        {
+          type: 'paragraph',
+          data: {
+            text: 'Hello',
+          },
+        },
+      ],
+      buildTestToolsConfig([
+        {
+          icon: 'Icon',
+          title: 'Tune 1',
+          name: 'test-item-1',
+        },
+        {
+          type: PopoverItemType.Separator,
+        },
+        {
+          icon: 'Icon',
+          title: 'Tune 2',
+          name: 'test-item-2',
+        },
+      ])
+    );
+
+    // Open block tunes menu
+    await openBlockTunes(page);
+
+    // Press Tab
+    await page.keyboard.press('Tab');
+
+    // Check first item is focused
+    await expect(page.locator('[data-item-name="test-item-1"].ce-popover-item--focused')).toBeVisible();
+
+    // Check second item is not focused
+    await expect(page.locator('[data-item-name="test-item-2"].ce-popover-item--focused')).toBeHidden();
+
+    // Press Tab
+    await page.keyboard.press('Tab');
+
+    // Check first item is not focused
+    await expect(page.locator('[data-item-name="test-item-1"].ce-popover-item--focused')).toBeHidden();
+
+    // Check second item is focused
+    await expect(page.locator('[data-item-name="test-item-2"].ce-popover-item--focused')).toBeVisible();
+  });
+
+  test.describe('inline popover', () => {
+    test.beforeEach(async ({ page }) => {
+      await page.addScriptTag({ path: HEADER_TOOL_UMD_PATH });
+    });
+
+    test('should open nested popover on click instead of hover', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'First block text',
+            },
+          },
+        ],
+        {
+          header: { fromGlobal: 'Header' },
+        }
+      );
+
+      // Open Inline Toolbar
+      const paragraph = page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-paragraph`);
+
+      await paragraph.click();
+      await selectTextByRange(paragraph, 0, 5); // Select "First"
+
+      // Hover Convert To item which has nested popover
+      await page.locator('[data-item-name=convert-to]').hover();
+
+      // Check nested popover didn't open
+      await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover--nested .ce-popover__container`)).toBeHidden();
+
+      // Click Convert To item which has nested popover
+      await page.locator('[data-item-name=convert-to]').click();
+
+      // Check nested popover opened
+      await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover--nested .ce-popover__container`)).toBeVisible();
+    });
+
+    test('should support keyboard navigation between items', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'First block text',
+            },
+          },
+        ],
+        {
+          header: { fromGlobal: 'Header' },
+        }
+      );
+
+      // Open Inline Toolbar
+      const paragraph = page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-paragraph`);
+
+      await paragraph.click();
+      await selectTextByRange(paragraph, 0, 5); // Select "block"
+
+      // Check Inline Popover opened
+      await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-inline-toolbar .ce-popover__container`)).toBeVisible();
+
+      // Check first item is NOT focused
+      await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-inline-toolbar .ce-popover__container [data-item-name="convert-to"].ce-popover-item--focused`)).toBeHidden();
+
+      // Press Tab
+      await page.keyboard.press('Tab');
+
+      // Check first item became focused after tab
+      await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-inline-toolbar .ce-popover__container [data-item-name="convert-to"].ce-popover-item--focused`)).toBeVisible();
+
+      // Check second item is NOT focused
+      await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-inline-toolbar .ce-popover__container [data-item-name="link"] .ce-popover-item--focused`)).toBeHidden();
+
+      // Press Tab
+      await page.keyboard.press('Tab');
+
+      // Check second item became focused after tab
+      await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-inline-toolbar .ce-popover__container [data-item-name="link"] .ce-popover-item--focused`)).toBeVisible();
+    });
+
+    test('should allow to reach nested popover via keyboard', async ({ page }) => {
+      await createEditorWithBlocks(
+        page,
+        [
+          {
+            type: 'paragraph',
+            data: {
+              text: 'First block text',
+            },
+          },
+        ],
+        {
+          header: { fromGlobal: 'Header' },
+        }
+      );
+
+      // Open Inline Toolbar
+      const paragraph = page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-paragraph`);
+
+      await paragraph.click();
+      await selectTextByRange(paragraph, 0, 5); // Select "block"
+
+      // Check Inline Popover opened
+      await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-inline-toolbar .ce-popover__container`)).toBeVisible();
+
+      // Press Tab
+      await page.keyboard.press('Tab');
+
+      // Press Enter on convert-to item
+      await page.locator('[data-item-name="convert-to"]').press('Enter');
+
+      // Check nested popover opened
+      await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-inline-toolbar .ce-popover--nested .ce-popover__container`)).toBeVisible();
+
+      // Check first item is NOT focused
+      await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover__container [data-item-name="header"].ce-popover-item--focused`)).toBeHidden();
+
+      // Press Tab
+      await page.keyboard.press('Tab');
+
+      // Check first item is focused
+      await expect(page.locator(`${EDITOR_INTERFACE_SELECTOR} .ce-popover__container [data-item-name="header"].ce-popover-item--focused`)).toBeVisible();
+    });
+  });
+});
+
diff --git a/test/playwright/tests/utils/tooltip.spec.ts b/test/playwright/tests/utils/tooltip.spec.ts
new file mode 100644
index 000000000..948a31b91
--- /dev/null
+++ b/test/playwright/tests/utils/tooltip.spec.ts
@@ -0,0 +1,1454 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ensureEditorBundleBuilt } from '../helpers/ensure-build';
+import { TOOLTIP_INTERFACE_SELECTOR } from '../../../../src/components/constants';
+
+const TEST_PAGE_URL = pathToFileURL(
+  path.resolve(__dirname, '../../fixtures/test.html')
+).href;
+
+const HOLDER_ID = 'editorjs';
+
+/**
+ * Reset the editor holder and destroy any existing instance
+ *
+ * @param page - The Playwright page object
+ */
+const resetEditor = async (page: Page): Promise<void> => {
+  await page.evaluate(async ({ holderId }) => {
+    if (window.editorInstance) {
+      await window.editorInstance.destroy?.();
+      window.editorInstance = undefined;
+    }
+
+    document.getElementById(holderId)?.remove();
+
+    const container = document.createElement('div');
+
+    container.id = holderId;
+    container.dataset.cy = holderId;
+    container.style.border = '1px dotted #388AE5';
+
+    document.body.appendChild(container);
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ * Create editor instance
+ *
+ * @param page - The Playwright page object
+ */
+const createEditor = async (page: Page): Promise<void> => {
+  await page.waitForFunction(() => typeof window.EditorJS === 'function');
+
+  await page.evaluate(async ({ holderId }) => {
+    const editor = new window.EditorJS({
+      holder: holderId,
+    });
+
+    window.editorInstance = editor;
+    await editor.isReady;
+  }, { holderId: HOLDER_ID });
+};
+
+/**
+ * Wait for tooltip to appear and verify it's visible
+ *
+ * @param page - The Playwright page object
+ * @returns The tooltip locator
+ */
+const waitForTooltip = async (page: Page): Promise<Locator> => {
+  const tooltip = page.locator(TOOLTIP_INTERFACE_SELECTOR);
+
+  await expect(tooltip).toBeVisible();
+
+  return tooltip;
+};
+
+/**
+ * Wait for tooltip to disappear
+ *
+ * @param page - The Playwright page object
+ */
+const waitForTooltipToHide = async (page: Page): Promise<void> => {
+  const tooltip = page.locator(TOOLTIP_INTERFACE_SELECTOR);
+
+  await expect(tooltip).toBeHidden();
+};
+
+test.describe('tooltip API', () => {
+  test.beforeAll(() => {
+    ensureEditorBundleBuilt();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(TEST_PAGE_URL);
+    await resetEditor(page);
+    await createEditor(page);
+  });
+
+  test.describe('show()', () => {
+    test('should show tooltip with text content', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('button');
+
+        element.textContent = 'Test Button';
+        element.id = 'test-button';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Test tooltip text');
+        }
+      }, { elementId: testElement.id });
+
+      const tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toContainText('Test tooltip text');
+    });
+
+    test('should show tooltip with HTML content', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('div');
+
+        element.textContent = 'Hover me';
+        element.id = 'test-element';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          const htmlContent = document.createElement('div');
+
+          htmlContent.innerHTML = '<strong>Bold</strong> tooltip';
+          editor.tooltip.show(element, htmlContent);
+        }
+      }, { elementId: testElement.id });
+
+      const tooltip = await waitForTooltip(page);
+
+      await expect(tooltip.locator('strong')).toContainText('Bold');
+      await expect(tooltip).toContainText('tooltip');
+    });
+
+    test('should show tooltip with options', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('span');
+
+        element.textContent = 'Test';
+        element.id = 'test-span';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Tooltip with options', {
+            placement: 'top',
+            hidingDelay: 100,
+          });
+        }
+      }, { elementId: testElement.id });
+
+      const tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toBeVisible();
+      await expect(tooltip).toContainText('Tooltip with options');
+    });
+
+    test('should replace existing tooltip when showing new one', async ({ page }) => {
+      const testElements = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element1 = document.createElement('button');
+
+        element1.textContent = 'Button 1';
+        element1.id = 'button-1';
+        const element2 = document.createElement('button');
+
+        element2.textContent = 'Button 2';
+        element2.id = 'button-2';
+        container?.appendChild(element1);
+        container?.appendChild(element2);
+
+        return {
+          id1: element1.id,
+          id2: element2.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      // Show first tooltip
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'First tooltip');
+        }
+      }, { elementId: testElements.id1 });
+
+      let tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toContainText('First tooltip');
+
+      // Show second tooltip - should replace the first
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Second tooltip');
+        }
+      }, { elementId: testElements.id2 });
+
+      tooltip = await waitForTooltip(page);
+      await expect(tooltip).toContainText('Second tooltip');
+      await expect(tooltip).not.toContainText('First tooltip');
+    });
+
+    test('should throw when content is neither string nor Node', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('div');
+
+        element.textContent = 'Invalid content test';
+        element.id = 'invalid-content';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      const errorMessage = await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (!element || !editor?.tooltip) {
+          return null;
+        }
+
+        try {
+          const invalidContent = { text: 'invalid' } as unknown as Node;
+
+          editor.tooltip.show(element, invalidContent);
+
+          return 'no error';
+        } catch (error) {
+          if (error instanceof Error) {
+            return error.message;
+          }
+
+          return String(error);
+        }
+      }, { elementId: testElement.id });
+
+      expect(errorMessage).not.toBeNull();
+      expect(errorMessage).not.toBe('no error');
+      expect(errorMessage).toContain('[CodeX Tooltip] Wrong type');
+    });
+  });
+
+  test.describe('hide()', () => {
+    test('should hide visible tooltip', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('button');
+
+        element.textContent = 'Test Button';
+        element.id = 'test-button';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      // Show tooltip
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Test tooltip');
+        }
+      }, { elementId: testElement.id });
+
+      const tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toContainText('Test tooltip');
+
+      // Hide tooltip
+      await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (editor?.tooltip) {
+          editor.tooltip.hide();
+        }
+      });
+
+      await waitForTooltipToHide(page);
+    });
+
+    test('should hide tooltip when hide() is called', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('div');
+
+        element.textContent = 'Test';
+        element.id = 'test-element';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      // Show tooltip with hiding delay
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Tooltip with delay', {
+            hidingDelay: 1000,
+          });
+        }
+      }, { elementId: testElement.id });
+
+      const tooltipBeforeHide = await waitForTooltip(page);
+
+      await expect(tooltipBeforeHide).toBeVisible();
+
+      // Hide tooltip
+      await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (editor?.tooltip) {
+          editor.tooltip.hide();
+        }
+      });
+
+      // Should hide
+      await waitForTooltipToHide(page);
+    });
+
+    test('should bypass hiding delay when hide(true) is called', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('span');
+
+        element.textContent = 'Skip delay element';
+        element.id = 'skip-delay';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Delayed tooltip', {
+            hidingDelay: 1000,
+          });
+        }
+      }, { elementId: testElement.id });
+
+      const tooltipBeforeHide = await waitForTooltip(page);
+
+      await expect(tooltipBeforeHide).toBeVisible();
+
+      await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (editor?.tooltip) {
+          (editor.tooltip as unknown as { hide(skipDelay?: boolean): void }).hide(true);
+        }
+      });
+
+      await waitForTooltipToHide(page);
+    });
+
+    test('should handle hide() when no tooltip is visible', async ({ page }) => {
+      // Calling hide() when no tooltip is visible should not throw
+      await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (editor?.tooltip) {
+          editor.tooltip.hide();
+        }
+      });
+
+      // Verify no tooltip appears
+      const tooltip = page.locator(TOOLTIP_INTERFACE_SELECTOR);
+
+      await expect(tooltip).toBeHidden();
+    });
+  });
+
+  test.describe('onHover()', () => {
+    test('should show tooltip on mouseenter', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('button');
+
+        element.textContent = 'Hover me';
+        element.id = 'hover-button';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.onHover(element, 'Hover tooltip');
+        }
+      }, { elementId: testElement.id });
+
+      const button = page.locator(`#${testElement.id}`);
+
+      await button.hover();
+
+      const tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toContainText('Hover tooltip');
+    });
+
+    test('should hide tooltip on mouseleave', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('div');
+
+        element.textContent = 'Hover area';
+        element.id = 'hover-area';
+        element.style.padding = '20px';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.onHover(element, 'Hover tooltip');
+        }
+      }, { elementId: testElement.id });
+
+      const hoverArea = page.locator(`#${testElement.id}`);
+
+      await hoverArea.hover();
+
+      const tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toBeVisible();
+
+      // Move mouse away
+      await page.mouse.move(0, 0);
+
+      await waitForTooltipToHide(page);
+    });
+
+    test('should show tooltip on hover with HTML content', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('span');
+
+        element.textContent = 'Rich tooltip';
+        element.id = 'rich-tooltip';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          const htmlContent = document.createElement('div');
+
+          htmlContent.innerHTML = '<em>Italic</em> content';
+          editor.tooltip.onHover(element, htmlContent);
+        }
+      }, { elementId: testElement.id });
+
+      const element = page.locator(`#${testElement.id}`);
+
+      await element.hover();
+
+      const tooltip = await waitForTooltip(page);
+
+      await expect(tooltip.locator('em')).toContainText('Italic');
+      await expect(tooltip).toContainText('content');
+    });
+
+    test('should show tooltip on hover with options', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('button');
+
+        element.textContent = 'Configured tooltip';
+        element.id = 'configured-button';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.onHover(element, 'Tooltip with config', {
+            placement: 'bottom',
+            delay: 200,
+          });
+        }
+      }, { elementId: testElement.id });
+
+      const button = page.locator(`#${testElement.id}`);
+
+      await button.hover();
+
+      // Wait for tooltip to appear (accounting for delay)
+      const tooltip = page.locator(TOOLTIP_INTERFACE_SELECTOR);
+
+      await expect(tooltip).toBeVisible({ timeout: 500 });
+      await expect(tooltip).toContainText('Tooltip with config');
+    });
+  });
+
+  test.describe('integration', () => {
+    test('should handle multiple show/hide cycles', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('button');
+
+        element.textContent = 'Toggle';
+        element.id = 'toggle-button';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      // First cycle
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'First');
+        }
+      }, { elementId: testElement.id });
+
+      const firstTooltip = await waitForTooltip(page);
+
+      await expect(firstTooltip).toContainText('First');
+
+      await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (editor?.tooltip) {
+          editor.tooltip.hide();
+        }
+      });
+
+      await waitForTooltipToHide(page);
+
+      // Second cycle
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Second');
+        }
+      }, { elementId: testElement.id });
+
+      const tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toContainText('Second');
+    });
+
+    test('should work with different element types', async ({ page }) => {
+      const testElements = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const button = document.createElement('button');
+
+        button.textContent = 'Button';
+        button.id = 'test-button';
+        const div = document.createElement('div');
+
+        div.textContent = 'Div';
+        div.id = 'test-div';
+        const span = document.createElement('span');
+
+        span.textContent = 'Span';
+        span.id = 'test-span';
+        container?.appendChild(button);
+        container?.appendChild(div);
+        container?.appendChild(span);
+
+        return {
+          buttonId: button.id,
+          divId: div.id,
+          spanId: span.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      // Test with button
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Button tooltip');
+        }
+      }, { elementId: testElements.buttonId });
+
+      let tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toContainText('Button tooltip');
+
+      await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (editor?.tooltip) {
+          editor.tooltip.hide();
+        }
+      });
+
+      await waitForTooltipToHide(page);
+
+      // Test with div
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Div tooltip');
+        }
+      }, { elementId: testElements.divId });
+
+      tooltip = await waitForTooltip(page);
+      await expect(tooltip).toContainText('Div tooltip');
+
+      await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (editor?.tooltip) {
+          editor.tooltip.hide();
+        }
+      });
+
+      await waitForTooltipToHide(page);
+
+      // Test with span
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Span tooltip');
+        }
+      }, { elementId: testElements.spanId });
+
+      tooltip = await waitForTooltip(page);
+      await expect(tooltip).toContainText('Span tooltip');
+    });
+  });
+
+  test.describe('destroy()', () => {
+    test('should destroy tooltip library and allow reinitialization', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('button');
+
+        element.textContent = 'Test';
+        element.id = 'test-button';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      // Show tooltip before destroy
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Before destroy');
+        }
+      }, { elementId: testElement.id });
+
+      await waitForTooltip(page);
+
+      // Destroy editor (which calls tooltip.destroy())
+      await page.evaluate(async () => {
+        if (window.editorInstance) {
+          await window.editorInstance.destroy();
+          window.editorInstance = undefined;
+        }
+      });
+
+      // Recreate editor
+      await createEditor(page);
+
+      // Recreate test element if the holder was cleared during destroy
+      await page.evaluate(({ holderId, elementId }) => {
+        const container = document.getElementById(holderId);
+        let element = document.getElementById(elementId);
+
+        if (!element && container) {
+          element = document.createElement('button');
+          element.textContent = 'Test';
+          element.id = elementId;
+          container.appendChild(element);
+        }
+      }, { holderId: HOLDER_ID,
+        elementId: testElement.id });
+
+      // Tooltip should work after reinitialization
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'After recreate');
+        }
+      }, { elementId: testElement.id });
+
+      const tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toContainText('After recreate');
+    });
+
+    test('should reuse existing tooltip stylesheet across reinitializations', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('button');
+
+        element.textContent = 'Stylesheet check';
+        element.id = 'stylesheet-button';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Stylesheet tooltip', {
+            delay: 0,
+          });
+        }
+      }, { elementId: testElement.id });
+
+      await waitForTooltip(page);
+
+      const initialStyleCount = await page.evaluate(() => {
+        return document.querySelectorAll('#codex-tooltips-style').length;
+      });
+
+      expect(initialStyleCount).toBe(1);
+
+      await page.evaluate(async () => {
+        if (window.editorInstance) {
+          await window.editorInstance.destroy();
+          window.editorInstance = undefined;
+        }
+      });
+
+      const afterDestroyStyleCount = await page.evaluate(() => {
+        return document.querySelectorAll('#codex-tooltips-style').length;
+      });
+
+      expect(afterDestroyStyleCount).toBe(1);
+
+      await createEditor(page);
+
+      await page.evaluate(({ holderId, elementId }) => {
+        const container = document.getElementById(holderId);
+        let element = document.getElementById(elementId);
+
+        if (!element && container) {
+          element = document.createElement('button');
+          element.textContent = 'Stylesheet check';
+          element.id = elementId;
+          container.appendChild(element);
+        }
+      }, { holderId: HOLDER_ID,
+        elementId: testElement.id });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Stylesheet tooltip reinit', {
+            delay: 0,
+          });
+        }
+      }, { elementId: testElement.id });
+
+      await waitForTooltip(page);
+
+      const afterReinitStyleCount = await page.evaluate(() => {
+        return document.querySelectorAll('#codex-tooltips-style').length;
+      });
+
+      expect(afterReinitStyleCount).toBe(1);
+    });
+  });
+
+  test.describe('edge cases', () => {
+    test('should handle calling onHover() multiple times on same element', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('button');
+
+        element.textContent = 'Hover me';
+        element.id = 'hover-button';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      // First onHover binding
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.onHover(element, 'First binding');
+        }
+      }, { elementId: testElement.id });
+
+      // Second onHover binding (should replace first)
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.onHover(element, 'Second binding');
+        }
+      }, { elementId: testElement.id });
+
+      const button = page.locator(`#${testElement.id}`);
+
+      await button.hover();
+
+      const tooltip = await waitForTooltip(page);
+
+      // Should show the second binding
+      await expect(tooltip).toContainText('Second binding');
+      await expect(tooltip).not.toContainText('First binding');
+    });
+
+    test('should handle calling show() multiple times on same element', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('div');
+
+        element.textContent = 'Test';
+        element.id = 'test-element';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      // First show
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'First show');
+        }
+      }, { elementId: testElement.id });
+
+      let tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toContainText('First show');
+
+      // Second show on same element
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Second show');
+        }
+      }, { elementId: testElement.id });
+
+      tooltip = await waitForTooltip(page);
+
+      // Should replace with second show
+      await expect(tooltip).toContainText('Second show');
+      await expect(tooltip).not.toContainText('First show');
+    });
+
+    test('should handle empty string content', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('button');
+
+        element.textContent = 'Test';
+        element.id = 'test-button';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, '');
+        }
+      }, { elementId: testElement.id });
+
+      // Tooltip should still appear (even if empty)
+      const tooltip = page.locator(TOOLTIP_INTERFACE_SELECTOR);
+
+      await expect(tooltip).toBeVisible();
+    });
+
+    test('should handle very long content', async ({ page }) => {
+      const longText = 'A'.repeat(500);
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('div');
+
+        element.textContent = 'Test';
+        element.id = 'test-element';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId, text }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, text);
+        }
+      }, { elementId: testElement.id,
+        text: longText });
+
+      const tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toContainText(longText.substring(0, 100));
+    });
+
+    test('should handle special characters in content', async ({ page }) => {
+      const specialChars = '<>&"\'`';
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('span');
+
+        element.textContent = 'Test';
+        element.id = 'test-element';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId, text }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, text);
+        }
+      }, { elementId: testElement.id,
+        text: specialChars });
+
+      const tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toBeVisible();
+    });
+
+    test('should handle interaction between show() and onHover()', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('button');
+
+        element.textContent = 'Test';
+        element.id = 'test-button';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      // First bind onHover
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.onHover(element, 'Hover tooltip');
+        }
+      }, { elementId: testElement.id });
+
+      // Then show programmatically
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Programmatic tooltip');
+        }
+      }, { elementId: testElement.id });
+
+      const tooltip = await waitForTooltip(page);
+
+      // Should show programmatic tooltip
+      await expect(tooltip).toContainText('Programmatic tooltip');
+
+      // Hide it
+      await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (editor?.tooltip) {
+          editor.tooltip.hide();
+        }
+      });
+
+      await waitForTooltipToHide(page);
+
+      // Hover should still work
+      const button = page.locator(`#${testElement.id}`);
+
+      await button.hover();
+
+      const hoverTooltip = await waitForTooltip(page);
+
+      await expect(hoverTooltip).toContainText('Hover tooltip');
+    });
+
+    test('should handle hide() called multiple times', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('div');
+
+        element.textContent = 'Test';
+        element.id = 'test-element';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      // Show tooltip
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Test');
+        }
+      }, { elementId: testElement.id });
+
+      const tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toBeVisible();
+
+      // Call hide() multiple times
+      await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (editor?.tooltip) {
+          editor.tooltip.hide();
+          editor.tooltip.hide();
+          editor.tooltip.hide();
+        }
+      });
+
+      // Should still be hidden (no errors)
+      await waitForTooltipToHide(page);
+    });
+
+    test('should hide tooltip when window scrolls', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('button');
+
+        element.textContent = 'Scroll target';
+        element.id = 'scroll-target';
+        element.style.marginTop = '800px';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(() => {
+        document.body.style.height = '2000px';
+      });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Scroll tooltip', {
+            delay: 0,
+          });
+        }
+      }, { elementId: testElement.id });
+
+      const tooltipBeforeScroll = await waitForTooltip(page);
+
+      await expect(tooltipBeforeScroll).toBeVisible();
+
+      await page.evaluate(() => {
+        window.scrollTo(0, 100);
+        window.dispatchEvent(new Event('scroll'));
+      });
+
+      await waitForTooltipToHide(page);
+
+      await page.evaluate(() => {
+        document.body.style.height = '';
+        window.scrollTo(0, 0);
+      });
+    });
+
+    test('should sync aria-hidden and visibility with tooltip state', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('button');
+
+        element.textContent = 'Accessibility target';
+        element.id = 'accessibility-target';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Accessible tooltip', {
+            delay: 0,
+          });
+        }
+      }, { elementId: testElement.id });
+
+      const tooltip = await waitForTooltip(page);
+
+      await expect(tooltip).toHaveAttribute('role', 'tooltip');
+      await expect(tooltip).toHaveAttribute('aria-hidden', 'false');
+
+      const shownState = await page.evaluate((selector) => {
+        const tooltipElement = document.querySelector(selector) as HTMLElement | null;
+
+        if (!tooltipElement) {
+          return null;
+        }
+
+        return {
+          ariaHidden: tooltipElement.getAttribute('aria-hidden'),
+          visibility: tooltipElement.style.visibility,
+        };
+      }, TOOLTIP_INTERFACE_SELECTOR);
+
+      expect(shownState).not.toBeNull();
+      expect(shownState?.ariaHidden).toBe('false');
+      expect(shownState?.visibility).toBe('visible');
+
+      await page.evaluate(() => {
+        const editor = window.editorInstance;
+
+        if (editor?.tooltip) {
+          editor.tooltip.hide();
+        }
+      });
+
+      await waitForTooltipToHide(page);
+
+      const hiddenState = await page.evaluate((selector) => {
+        const tooltipElement = document.querySelector(selector) as HTMLElement | null;
+
+        if (!tooltipElement) {
+          return null;
+        }
+
+        return {
+          ariaHidden: tooltipElement.getAttribute('aria-hidden'),
+          visibility: tooltipElement.style.visibility,
+        };
+      }, TOOLTIP_INTERFACE_SELECTOR);
+
+      expect(hiddenState).not.toBeNull();
+      expect(hiddenState?.ariaHidden).toBe('true');
+      expect(hiddenState?.visibility).toBe('hidden');
+    });
+
+    test('should update aria-hidden when tooltip class changes', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('span');
+
+        element.textContent = 'Mutation target';
+        element.id = 'mutation-target';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Mutation tooltip', {
+            delay: 0,
+          });
+        }
+      }, { elementId: testElement.id });
+
+      await waitForTooltip(page);
+
+      await page.evaluate((selector) => {
+        const tooltipElement = document.querySelector(selector) as HTMLElement | null;
+
+        tooltipElement?.classList.remove('ct--shown');
+      }, TOOLTIP_INTERFACE_SELECTOR);
+
+      await page.waitForFunction((selector) => {
+        const tooltipElement = document.querySelector(selector);
+
+        return tooltipElement?.getAttribute('aria-hidden') === 'true';
+      }, TOOLTIP_INTERFACE_SELECTOR);
+
+      const state = await page.evaluate((selector) => {
+        const tooltipElement = document.querySelector(selector) as HTMLElement | null;
+
+        if (!tooltipElement) {
+          return null;
+        }
+
+        return {
+          ariaHidden: tooltipElement.getAttribute('aria-hidden'),
+          visibility: tooltipElement.style.visibility,
+        };
+      }, TOOLTIP_INTERFACE_SELECTOR);
+
+      expect(state).not.toBeNull();
+      expect(state?.ariaHidden).toBe('true');
+      expect(state?.visibility).toBe('hidden');
+    });
+
+    test('should apply placement offsets for left and right positions', async ({ page }) => {
+      const testElement = await page.evaluate(({ holderId }) => {
+        const container = document.getElementById(holderId);
+        const element = document.createElement('div');
+
+        element.textContent = 'Placement target';
+        element.id = 'placement-target';
+        element.style.margin = '200px';
+        element.style.display = 'inline-block';
+        element.style.padding = '16px';
+        container?.appendChild(element);
+
+        return {
+          id: element.id,
+        };
+      }, { holderId: HOLDER_ID });
+
+      // Left placement without margin
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Left placement', {
+            placement: 'left',
+            delay: 0,
+          });
+        }
+      }, { elementId: testElement.id });
+
+      await waitForTooltip(page);
+
+      const leftPlacement = await page.evaluate((selector) => {
+        const tooltipElement = document.querySelector(selector) as HTMLElement | null;
+
+        if (!tooltipElement) {
+          return null;
+        }
+
+        return {
+          left: parseFloat(tooltipElement.style.left),
+          classes: Array.from(tooltipElement.classList),
+        };
+      }, TOOLTIP_INTERFACE_SELECTOR);
+
+      expect(leftPlacement).not.toBeNull();
+      expect(leftPlacement?.classes).toContain('ct--left');
+
+      // Left placement with margin
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Left margin placement', {
+            placement: 'left',
+            delay: 0,
+            marginLeft: 40,
+          });
+        }
+      }, { elementId: testElement.id });
+
+      await waitForTooltip(page);
+
+      const leftPlacementWithMargin = await page.evaluate((selector) => {
+        const tooltipElement = document.querySelector(selector) as HTMLElement | null;
+
+        if (!tooltipElement) {
+          return null;
+        }
+
+        return parseFloat(tooltipElement.style.left);
+      }, TOOLTIP_INTERFACE_SELECTOR);
+
+      expect(leftPlacementWithMargin).not.toBeNull();
+      expect(leftPlacementWithMargin as number).toBeLessThan(leftPlacement?.left ?? Number.POSITIVE_INFINITY);
+
+      // Right placement without margin
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Right placement', {
+            placement: 'right',
+            delay: 0,
+          });
+        }
+      }, { elementId: testElement.id });
+
+      await waitForTooltip(page);
+
+      const rightPlacement = await page.evaluate((selector) => {
+        const tooltipElement = document.querySelector(selector) as HTMLElement | null;
+
+        if (!tooltipElement) {
+          return null;
+        }
+
+        return {
+          left: parseFloat(tooltipElement.style.left),
+          classes: Array.from(tooltipElement.classList),
+        };
+      }, TOOLTIP_INTERFACE_SELECTOR);
+
+      expect(rightPlacement).not.toBeNull();
+      expect(rightPlacement?.classes).toContain('ct--right');
+
+      // Right placement with margin
+      await page.evaluate(({ elementId }) => {
+        const editor = window.editorInstance;
+        const element = document.getElementById(elementId);
+
+        if (element && editor?.tooltip) {
+          editor.tooltip.show(element, 'Right margin placement', {
+            placement: 'right',
+            delay: 0,
+            marginRight: 40,
+          });
+        }
+      }, { elementId: testElement.id });
+
+      await waitForTooltip(page);
+
+      const rightPlacementWithMargin = await page.evaluate((selector) => {
+        const tooltipElement = document.querySelector(selector) as HTMLElement | null;
+
+        if (!tooltipElement) {
+          return null;
+        }
+
+        return parseFloat(tooltipElement.style.left);
+      }, TOOLTIP_INTERFACE_SELECTOR);
+
+      expect(rightPlacementWithMargin).not.toBeNull();
+      expect(rightPlacementWithMargin as number).toBeGreaterThan(rightPlacement?.left ?? Number.NEGATIVE_INFINITY);
+    });
+  });
+});
diff --git a/test/testcases.md b/test/testcases.md
index 353c30be2..22ff10eac 100644
--- a/test/testcases.md
+++ b/test/testcases.md
@@ -66,7 +66,7 @@ This document will describe various test cases of the editor.js functionality. F
         - [ ] If `object` passed Editor.js should initialize `tool` and pass this object as `config` parameter of the tool's constructor
       - [ ] Checking the `shortcut` property
         - [ ] If `string` passed Editor.js should append the `tool` when such keys combination executed.
-      - [ ] Checking the `inilineToolbar` property
+      - [ ] Checking the `inlineToolbar` property
         - [ ] If `true` passed, the Editor.js should show the Inline Toolbar for this tool with [common](https://editorjs.io/configuration#inline-toolbar-order) settings.
         - [ ] If `false` passed, the Editor.js should not show the Inline Toolbar for this tool.
         - [ ] If `array` passed, the Editor.js should show the Inline Toolbar for this tool with a passed list of tools and their order.
@@ -90,7 +90,7 @@ This document will describe various test cases of the editor.js functionality. F
   - [ ] If `object` passed
     - [ ] Checking the `blocks` property
       - [ ] If `array` of `object` passed,
-        - [ ] for each `object` 
+        - [ ] for each `object`
           - [ ] Checking the `type` and `data` property
             - [ ] the Editor.js should be initialize with `block` of class `type`
             - [ ] If `type` not present in `tools`, the Editor.js should throw an error.
@@ -101,8 +101,8 @@ This document will describe various test cases of the editor.js functionality. F
 - [ ] `readOnly` property
   - [ ] If `true` passed,
     - [ ] If any `tool` have not readOnly getter defined,The Editor.js should throw an error.
-    - [ ] otherwise, the Editor.js should be initialize with readOnly mode. 
+    - [ ] otherwise, the Editor.js should be initialize with readOnly mode.
   - [ ] If `false` passed,the Editor.js should be initialized with the `tools` only.
   - [ ] If omitted,the Editor.js should be initialized with the `tools` only.
 
-- [ ] `i18n` property
\ No newline at end of file
+- [ ] `i18n` property
diff --git a/test/unit/codex.test.ts b/test/unit/codex.test.ts
new file mode 100644
index 000000000..6c5ef75fb
--- /dev/null
+++ b/test/unit/codex.test.ts
@@ -0,0 +1,736 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import type { EditorConfig } from '../../types';
+import type Core from '../../src/components/core';
+import type { EditorModules } from '../../src/types-internal/editor-modules';
+
+// Mock VERSION global variable
+declare global {
+  // eslint-disable-next-line no-var -- TypeScript requires 'var' for global declarations
+  var VERSION: string;
+}
+
+// Define VERSION before importing codex
+(global as { VERSION?: string }).VERSION = '2.31.0-test';
+
+// Mock dependencies
+vi.mock('../../src/components/utils/tooltip', () => {
+  const mockDestroyTooltip = vi.fn();
+
+  return {
+    destroy: mockDestroyTooltip,
+    mockDestroyTooltip,
+  };
+});
+
+vi.mock('../../src/components/utils', async () => {
+  const actual = await vi.importActual('../../src/components/utils');
+  const mockIsObject = vi.fn((v: unknown) => typeof v === 'object' && v !== null && !Array.isArray(v));
+  const mockIsFunction = vi.fn((fn: unknown) => typeof fn === 'function');
+
+  return {
+    ...actual,
+    isObject: mockIsObject,
+    isFunction: mockIsFunction,
+    mockIsObject,
+    mockIsFunction,
+  };
+});
+
+// Mock Core class - use factory function to avoid hoisting issues
+vi.mock('../../src/components/core', () => {
+  const createMockModuleInstances = (): Partial<EditorModules> => ({
+    API: {
+      methods: {
+        blocks: {
+          clear: vi.fn(),
+          render: vi.fn(),
+        } as unknown as EditorModules['API']['methods']['blocks'],
+        caret: {
+          focus: vi.fn(),
+        } as unknown as EditorModules['API']['methods']['caret'],
+        events: {
+          on: vi.fn(),
+          off: vi.fn(),
+          emit: vi.fn(),
+        },
+        saver: {
+          save: vi.fn(),
+        },
+      } as unknown as EditorModules['API']['methods'],
+    } as unknown as EditorModules['API'],
+    Toolbar: {
+      blockSettings: undefined,
+      inlineToolbar: undefined,
+    } as unknown as EditorModules['Toolbar'],
+    BlockSettings: {} as unknown as EditorModules['BlockSettings'],
+    InlineToolbar: {} as unknown as EditorModules['InlineToolbar'],
+  });
+
+  const mockModuleInstances = createMockModuleInstances();
+  const lastInstanceRef = { value: undefined as Core | undefined };
+
+  /**
+   *
+   */
+  class MockCore {
+    public configuration: Record<string, unknown> = {};
+    public moduleInstances: Partial<EditorModules>;
+    public isReady: Promise<void>;
+
+    /**
+     *
+     */
+    constructor() {
+      this.moduleInstances = {
+        ...mockModuleInstances,
+      };
+      this.isReady = Promise.resolve();
+      // Store the last instance for test access
+      lastInstanceRef.value = this as unknown as Core;
+    }
+  }
+
+  return {
+    default: MockCore,
+    mockModuleInstances,
+    lastInstance: () => lastInstanceRef.value,
+  };
+});
+
+// Mock @babel/register
+vi.mock('@babel/register', () => ({}));
+
+// Mock polyfills
+vi.mock('../../src/components/polyfills', () => ({}));
+
+// Import EditorJS after mocks are set up
+import EditorJS from '../../src/codex';
+
+describe('EditorJS', () => {
+  // Get mocked instances
+  const mocks = {
+    mockModuleInstances: undefined as Partial<EditorModules> | undefined,
+    mockIsObject: undefined as ReturnType<typeof vi.fn> | undefined,
+    mockIsFunction: undefined as ReturnType<typeof vi.fn> | undefined,
+    mockDestroyTooltip: undefined as ReturnType<typeof vi.fn> | undefined,
+  };
+
+  beforeEach(async () => {
+    // Import the mocked modules to access the mock instances
+    const coreModule = await import('../../src/components/core') as {
+      default: new (...args: unknown[]) => Core;
+      mockModuleInstances?: Partial<EditorModules>;
+    };
+
+    const utilsModule = await import('../../src/components/utils') as {
+      mockIsObject?: ReturnType<typeof vi.fn>;
+      mockIsFunction?: ReturnType<typeof vi.fn>;
+    };
+
+    const tooltipModule = await import('../../src/components/utils/tooltip') as {
+      mockDestroyTooltip?: ReturnType<typeof vi.fn>;
+    };
+
+    mocks.mockModuleInstances = coreModule.mockModuleInstances as Partial<EditorModules>;
+    mocks.mockIsObject = utilsModule.mockIsObject as ReturnType<typeof vi.fn>;
+    mocks.mockIsFunction = utilsModule.mockIsFunction as ReturnType<typeof vi.fn>;
+    mocks.mockDestroyTooltip = tooltipModule.mockDestroyTooltip as ReturnType<typeof vi.fn>;
+
+    vi.clearAllMocks();
+    mocks.mockModuleInstances!.API = {
+      methods: {
+        blocks: {
+          clear: vi.fn(),
+          render: vi.fn(),
+        } as unknown as EditorModules['API']['methods']['blocks'],
+        caret: {
+          focus: vi.fn(),
+        } as unknown as EditorModules['API']['methods']['caret'],
+        events: {
+          on: vi.fn(),
+          off: vi.fn(),
+          emit: vi.fn(),
+        },
+        saver: {
+          save: vi.fn(),
+        },
+      } as unknown as EditorModules['API']['methods'],
+    } as unknown as EditorModules['API'];
+    mocks.mockModuleInstances!.Toolbar = {
+      blockSettings: undefined,
+      inlineToolbar: undefined,
+    } as unknown as EditorModules['Toolbar'];
+    mocks.mockModuleInstances!.BlockSettings = {} as unknown as EditorModules['BlockSettings'];
+    mocks.mockModuleInstances!.InlineToolbar = {} as unknown as EditorModules['InlineToolbar'];
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with no configuration', async () => {
+      const editor = new EditorJS();
+
+      expect(editor.isReady).toBeInstanceOf(Promise);
+      expect(editor.destroy).toBeDefined();
+      expect(typeof editor.destroy).toBe('function');
+
+      await editor.isReady;
+    });
+
+    it('should initialize with string configuration (holderId)', async () => {
+      const holderId = 'my-editor';
+
+      const editor = new EditorJS(holderId);
+
+      expect(editor.isReady).toBeInstanceOf(Promise);
+
+      await editor.isReady;
+    });
+
+    it('should initialize with EditorConfig object', async () => {
+      const config: EditorConfig = {
+        holder: 'editorjs',
+        placeholder: 'Start typing...',
+      };
+
+      const editor = new EditorJS(config);
+
+      expect(editor.isReady).toBeInstanceOf(Promise);
+
+      await editor.isReady;
+    });
+
+    it('should call onReady callback when provided', async () => {
+      const onReady = vi.fn();
+      const config: EditorConfig = {
+        holder: 'editorjs',
+        onReady,
+      };
+
+      mocks.mockIsObject!.mockReturnValue(true);
+      mocks.mockIsFunction!.mockReturnValue(true);
+
+      const editor = new EditorJS(config);
+
+      await editor.isReady;
+
+      expect(onReady).toHaveBeenCalledTimes(1);
+    });
+
+    it('should use default empty onReady function when not provided', async () => {
+      const config: EditorConfig = {
+        holder: 'editorjs',
+      };
+
+      mocks.mockIsObject!.mockReturnValue(true);
+      mocks.mockIsFunction!.mockReturnValue(false);
+
+      const editor = new EditorJS(config);
+
+      await editor.isReady;
+
+      // Should not throw
+      expect(editor.isReady).toBeInstanceOf(Promise);
+    });
+
+    it('should initialize destroy as no-op before exportAPI', () => {
+      const editor = new EditorJS();
+
+      // Before isReady resolves, destroy should be a no-op
+      expect(editor.destroy).toBeDefined();
+      expect(() => editor.destroy()).not.toThrow();
+    });
+  });
+
+  describe('isReady promise', () => {
+    it('should resolve when Core is ready', async () => {
+      const editor = new EditorJS();
+
+      await expect(editor.isReady).resolves.toBeUndefined();
+    });
+
+    it('should call exportAPI when Core is ready', async () => {
+      const editor = new EditorJS();
+      const exportAPISpy = vi.spyOn(editor, 'exportAPI');
+
+      await editor.isReady;
+
+      // Get the actual Core instance that was created
+      const coreModule = await import('../../src/components/core') as {
+        lastInstance?: () => Core | undefined;
+      };
+      const lastCall = coreModule.lastInstance?.();
+
+      expect(exportAPISpy).toHaveBeenCalled();
+      if (lastCall) {
+        expect(exportAPISpy).toHaveBeenCalledWith(lastCall);
+      }
+    });
+  });
+
+  describe('exportAPI', () => {
+    it('should export configuration field', async () => {
+      const config: EditorConfig = {
+        holder: 'editorjs',
+        placeholder: 'Test placeholder',
+      };
+
+      const editor = new EditorJS(config);
+
+      await editor.isReady;
+
+      expect((editor as unknown as Record<string, unknown>).configuration).toEqual(config);
+    });
+
+    it('should set prototype to API methods', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Get the actual Core instance that was created
+      const coreModule = await import('../../src/components/core') as {
+        default: new (...args: unknown[]) => Core;
+        lastInstance?: () => Core | undefined;
+      };
+      const lastCall = coreModule.lastInstance?.();
+
+      expect(Object.getPrototypeOf(editor)).toBe(lastCall?.moduleInstances.API?.methods);
+    });
+
+    it('should create module aliases', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      const moduleAliases = (editor as unknown as { module: Record<string, unknown> }).module;
+
+      expect(moduleAliases).toBeDefined();
+      expect(typeof moduleAliases).toBe('object');
+    });
+
+    it('should create lowercase aliases for uppercase module names', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Get the actual Core instance that was created
+      const coreModule = await import('../../src/components/core') as {
+        lastInstance?: () => Core | undefined;
+      };
+      const lastCall = coreModule.lastInstance?.();
+      const instances = lastCall?.moduleInstances;
+
+      if (!instances) {
+        throw new Error('Core instance not found');
+      }
+
+      instances.API = {
+        methods: {},
+      } as EditorModules['API'];
+      instances.Toolbar = {} as EditorModules['Toolbar'];
+
+      const moduleAliases = (editor as unknown as { module: Record<string, unknown> }).module;
+
+      // API should become 'api'
+      expect(moduleAliases.api).toBe(instances.API);
+      // Toolbar should become 'toolbar'
+      expect(moduleAliases.toolbar).toBe(instances.Toolbar);
+    });
+
+    it('should create camelCase aliases for PascalCase module names', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Get the actual Core instance that was created
+      const coreModule = await import('../../src/components/core') as {
+        lastInstance?: () => Core | undefined;
+      };
+      const lastCall = coreModule.lastInstance?.();
+      const instances = lastCall?.moduleInstances;
+
+      if (!instances || !lastCall) {
+        throw new Error('Core instance not found');
+      }
+
+      instances.BlockSettings = {} as EditorModules['BlockSettings'];
+      instances.InlineToolbar = {} as EditorModules['InlineToolbar'];
+
+      const moduleAliases = (editor as unknown as { module: Record<string, unknown> }).module;
+
+      expect(moduleAliases.blockSettings).toBe(instances.BlockSettings);
+      expect(moduleAliases.inlineToolbar).toBe(instances.InlineToolbar);
+    });
+
+    it('should skip undefined module instances', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Get the actual Core instance that was created
+      const coreModule = await import('../../src/components/core') as {
+        lastInstance?: () => Core | undefined;
+      };
+      const lastCall = coreModule.lastInstance?.();
+      const instances = lastCall?.moduleInstances;
+
+      if (!instances || !lastCall) {
+        throw new Error('Core instance not found');
+      }
+
+      instances.API = {
+        methods: {},
+      } as EditorModules['API'];
+      instances.Toolbar = undefined as unknown as EditorModules['Toolbar'];
+
+      const moduleAliases = (editor as unknown as { module: Record<string, unknown> }).module;
+
+      expect(moduleAliases.toolbar).toBeUndefined();
+    });
+
+    it('should attach blockSettings to toolbar module if not already present', async () => {
+      const mockToolbar = {
+        blockSettings: undefined,
+      };
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Get the actual Core instance that was created
+      const coreModule = await import('../../src/components/core') as {
+        lastInstance?: () => Core | undefined;
+      };
+      const lastCall = coreModule.lastInstance?.();
+      const instances = lastCall?.moduleInstances;
+
+      if (!instances || !lastCall) {
+        throw new Error('Core instance not found');
+      }
+
+      instances.Toolbar = mockToolbar as unknown as EditorModules['Toolbar'];
+      instances.BlockSettings = {} as unknown as EditorModules['BlockSettings'];
+
+      // Re-export API to apply the changes
+      (editor as unknown as { exportAPI: (core: Core) => void }).exportAPI(lastCall);
+
+      expect(mockToolbar.blockSettings).toBe(instances.BlockSettings);
+    });
+
+    it('should not override existing blockSettings on toolbar module', async () => {
+      const existingBlockSettings = { existing: true };
+      const mockToolbar = {
+        blockSettings: existingBlockSettings,
+      };
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Get the actual Core instance that was created
+      const coreModule = await import('../../src/components/core') as {
+        lastInstance?: () => Core | undefined;
+      };
+      const lastCall = coreModule.lastInstance?.();
+      const instances = lastCall?.moduleInstances;
+
+      if (!instances || !lastCall) {
+        throw new Error('Core instance not found');
+      }
+
+      instances.Toolbar = mockToolbar as unknown as EditorModules['Toolbar'];
+      instances.BlockSettings = {} as unknown as EditorModules['BlockSettings'];
+
+      // Re-export API to apply the changes
+      (editor as unknown as { exportAPI: (core: Core) => void }).exportAPI(lastCall);
+
+      expect(mockToolbar.blockSettings).toBe(existingBlockSettings);
+      expect(mockToolbar.blockSettings).not.toBe(instances.BlockSettings);
+    });
+
+    it('should attach inlineToolbar to toolbar module if not already present', async () => {
+      const mockToolbar = {
+        inlineToolbar: undefined,
+      };
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Get the actual Core instance that was created
+      const coreModule = await import('../../src/components/core') as {
+        lastInstance?: () => Core | undefined;
+      };
+      const lastCall = coreModule.lastInstance?.();
+      const instances = lastCall?.moduleInstances;
+
+      if (!instances || !lastCall) {
+        throw new Error('Core instance not found');
+      }
+
+      instances.Toolbar = mockToolbar as unknown as EditorModules['Toolbar'];
+      instances.InlineToolbar = {} as unknown as EditorModules['InlineToolbar'];
+
+      // Re-export API to apply the changes
+      (editor as unknown as { exportAPI: (core: Core) => void }).exportAPI(lastCall);
+
+      expect(mockToolbar.inlineToolbar).toBe(instances.InlineToolbar);
+    });
+
+    it('should not override existing inlineToolbar on toolbar module', async () => {
+      const existingInlineToolbar = { existing: true };
+      const mockToolbar = {
+        inlineToolbar: existingInlineToolbar,
+      };
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Get the actual Core instance that was created
+      const coreModule = await import('../../src/components/core') as {
+        lastInstance?: () => Core | undefined;
+      };
+      const lastCall = coreModule.lastInstance?.();
+      const instances = lastCall?.moduleInstances;
+
+      if (!instances || !lastCall) {
+        throw new Error('Core instance not found');
+      }
+
+      instances.Toolbar = mockToolbar as unknown as EditorModules['Toolbar'];
+      instances.InlineToolbar = {} as unknown as EditorModules['InlineToolbar'];
+
+      // Re-export API to apply the changes
+      (editor as unknown as { exportAPI: (core: Core) => void }).exportAPI(lastCall);
+
+      expect(mockToolbar.inlineToolbar).toBe(existingInlineToolbar);
+      expect(mockToolbar.inlineToolbar).not.toBe(instances.InlineToolbar);
+    });
+
+    it('should create shorthands for blocks methods', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Get the actual Core instance that was created
+      const coreModule = await import('../../src/components/core') as {
+        lastInstance?: () => Core | undefined;
+      };
+      const lastCall = coreModule.lastInstance?.();
+      const instances = lastCall?.moduleInstances;
+
+      if (!instances || !lastCall) {
+        throw new Error('Core instance not found');
+      }
+
+      expect((editor as unknown as { clear: unknown }).clear).toBe(instances.API?.methods.blocks.clear);
+      expect((editor as unknown as { render: unknown }).render).toBe(instances.API?.methods.blocks.render);
+    });
+
+    it('should create shorthands for caret methods', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Get the actual Core instance that was created
+      const coreModule = await import('../../src/components/core') as {
+        lastInstance?: () => Core | undefined;
+      };
+      const lastCall = coreModule.lastInstance?.();
+      const instances = lastCall?.moduleInstances;
+
+      if (!instances || !lastCall) {
+        throw new Error('Core instance not found');
+      }
+
+      expect((editor as unknown as { focus: unknown }).focus).toBe(instances.API?.methods.caret.focus);
+    });
+
+    it('should create shorthands for events methods', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Get the actual Core instance that was created
+      const coreModule = await import('../../src/components/core') as {
+        lastInstance?: () => Core | undefined;
+      };
+      const lastCall = coreModule.lastInstance?.();
+      const instances = lastCall?.moduleInstances;
+
+      if (!instances || !lastCall) {
+        throw new Error('Core instance not found');
+      }
+
+      expect((editor as unknown as { on: unknown }).on).toBe(instances.API?.methods.events.on);
+      expect((editor as unknown as { off: unknown }).off).toBe(instances.API?.methods.events.off);
+      expect((editor as unknown as { emit: unknown }).emit).toBe(instances.API?.methods.events.emit);
+    });
+
+    it('should create shorthands for saver methods', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Get the actual Core instance that was created
+      const coreModule = await import('../../src/components/core') as {
+        lastInstance?: () => Core | undefined;
+      };
+      const lastCall = coreModule.lastInstance?.();
+      const instances = lastCall?.moduleInstances;
+
+      if (!instances || !lastCall) {
+        throw new Error('Core instance not found');
+      }
+
+      expect((editor as unknown as { save: unknown }).save).toBe(instances.API?.methods.saver.save);
+    });
+
+    it('should delete exportAPI method after export', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      expect(Object.prototype.hasOwnProperty.call(editor, 'exportAPI')).toBe(false);
+      expect(typeof (editor as unknown as { exportAPI: unknown }).exportAPI).toBe('function');
+    });
+
+    it('should make module property non-enumerable', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      const descriptor = Object.getOwnPropertyDescriptor(editor, 'module');
+
+      expect(descriptor).toBeDefined();
+      expect(descriptor?.enumerable).toBe(false);
+      expect(descriptor?.configurable).toBe(true);
+      expect(descriptor?.writable).toBe(false);
+    });
+  });
+
+  describe('destroy', () => {
+    it('should call destroy on all module instances that have destroy method', async () => {
+      const mockDestroy1 = vi.fn();
+      const mockDestroy2 = vi.fn();
+      const mockModule1 = { destroy: mockDestroy1 };
+      const mockModule2 = { destroy: mockDestroy2 };
+      const mockModule3 = { noDestroy: true };
+
+      mocks.mockModuleInstances!.Toolbar = mockModule1 as unknown as EditorModules['Toolbar'];
+      mocks.mockModuleInstances!.BlockSettings = mockModule2 as unknown as EditorModules['BlockSettings'];
+      mocks.mockModuleInstances!.InlineToolbar = mockModule3 as unknown as EditorModules['InlineToolbar'];
+
+      const editor = new EditorJS();
+
+      await editor.isReady;
+      editor.destroy();
+
+      expect(mockDestroy1).toHaveBeenCalledTimes(1);
+      expect(mockDestroy2).toHaveBeenCalledTimes(1);
+    });
+
+    it('should remove all listeners from module instances', async () => {
+      const mockRemoveAll = vi.fn();
+      const mockModule = {
+        listeners: {
+          removeAll: mockRemoveAll,
+        },
+      };
+
+      mocks.mockModuleInstances!.Toolbar = mockModule as unknown as EditorModules['Toolbar'];
+
+      const editor = new EditorJS();
+
+      await editor.isReady;
+      editor.destroy();
+
+      expect(mockRemoveAll).toHaveBeenCalled();
+    });
+
+    it('should call destroyTooltip', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+      editor.destroy();
+
+      expect(mocks.mockDestroyTooltip).toHaveBeenCalledTimes(1);
+    });
+
+    it('should delete all own properties', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Add some test properties
+      const testValue = 123;
+
+      (editor as unknown as Record<string, unknown>).testProperty = 'test';
+      (editor as unknown as Record<string, unknown>).anotherProperty = testValue;
+
+      expect((editor as unknown as Record<string, unknown>).testProperty).toBe('test');
+      expect((editor as unknown as Record<string, unknown>).anotherProperty).toBe(testValue);
+
+      editor.destroy();
+
+      expect((editor as unknown as Record<string, unknown>).testProperty).toBeUndefined();
+      expect((editor as unknown as Record<string, unknown>).anotherProperty).toBeUndefined();
+    });
+
+    it('should set prototype to null', async () => {
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Before destroy, prototype should be API methods
+      expect(Object.getPrototypeOf(editor)).toBe(mocks.mockModuleInstances!.API?.methods);
+
+      editor.destroy();
+
+      // After destroy, prototype should be null
+      expect(Object.getPrototypeOf(editor)).toBeNull();
+    });
+
+    it('should handle modules without listeners property', async () => {
+      const mockModule = {
+        destroy: vi.fn(),
+        // No listeners property
+      };
+
+      mocks.mockModuleInstances!.Toolbar = mockModule as unknown as EditorModules['Toolbar'];
+
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Should not throw
+      expect(() => editor.destroy()).not.toThrow();
+    });
+
+    it('should handle modules without destroy method', async () => {
+      const mockModule = {
+        listeners: {
+          removeAll: vi.fn(),
+        },
+        // No destroy method
+      };
+
+      mocks.mockModuleInstances!.Toolbar = mockModule as unknown as EditorModules['Toolbar'];
+
+      const editor = new EditorJS();
+
+      await editor.isReady;
+
+      // Should not throw
+      expect(() => editor.destroy()).not.toThrow();
+      expect(mockModule.listeners.removeAll).toHaveBeenCalled();
+    });
+  });
+
+  describe('static version', () => {
+    it('should expose version as static property', () => {
+      expect(EditorJS.version).toBeDefined();
+      expect(typeof EditorJS.version).toBe('string');
+    });
+  });
+});
+
diff --git a/test/unit/components/block-tunes/block-tune-move-down.test.ts b/test/unit/components/block-tunes/block-tune-move-down.test.ts
new file mode 100644
index 000000000..c5c0f3057
--- /dev/null
+++ b/test/unit/components/block-tunes/block-tune-move-down.test.ts
@@ -0,0 +1,166 @@
+import { IconChevronDown } from '@codexteam/icons';
+import type { Mock } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import MoveDownTune from '../../../../src/components/block-tunes/block-tune-move-down';
+import type { API } from '../../../../types';
+import type { PopoverItemDefaultBaseParams } from '../../../../types/utils/popover';
+
+type BlocksMocks = {
+  getCurrentBlockIndex: Mock<[], number>;
+  getBlockByIndex: Mock<[number], { holder: HTMLElement } | undefined>;
+  move: Mock<[number], void>;
+};
+
+type ToolbarMocks = {
+  toggleBlockSettings: Mock<[boolean], void>;
+};
+
+type I18nMocks = {
+  t: Mock<[string], string>;
+};
+
+const createApiMocks = (): {
+  api: API;
+  blocks: BlocksMocks;
+  toolbar: ToolbarMocks;
+  i18n: I18nMocks;
+} => {
+  const blocks: BlocksMocks = {
+    getCurrentBlockIndex: vi.fn<[], number>().mockReturnValue(0),
+    getBlockByIndex: vi.fn<[number], { holder: HTMLElement } | undefined>(),
+    move: vi.fn<[number], void>(),
+  };
+
+  const toolbar: ToolbarMocks = {
+    toggleBlockSettings: vi.fn<[boolean], void>(),
+  };
+
+  const i18n: I18nMocks = {
+    t: vi.fn<[string], string>().mockImplementation((text) => text),
+  };
+
+  const api = {
+    blocks: blocks as unknown as API['blocks'],
+    toolbar: toolbar as unknown as API['toolbar'],
+    i18n: i18n as unknown as API['i18n'],
+  } as unknown as API;
+
+  return {
+    api,
+    blocks,
+    toolbar,
+    i18n,
+  };
+};
+
+const createBlockElement = (top: number, height: number): HTMLDivElement => {
+  const element = document.createElement('div');
+
+  Object.defineProperty(element, 'offsetHeight', {
+    configurable: true,
+    value: height,
+  });
+
+  vi.spyOn(element, 'getBoundingClientRect').mockReturnValue({
+    bottom: top + height,
+    height,
+    left: 0,
+    right: 0,
+    top,
+    width: 0,
+    x: 0,
+    y: top,
+    toJSON: () => ({}),
+  } as DOMRect);
+
+  return element;
+};
+
+describe('MoveDownTune', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('renders block tune config with translated title and handler', () => {
+    const { api, i18n } = createApiMocks();
+    const tune = new MoveDownTune({ api });
+    const handleClickSpy = vi.spyOn(tune, 'handleClick').mockImplementation(() => {});
+
+    const config = tune.render() as PopoverItemDefaultBaseParams;
+
+    expect(i18n.t).toHaveBeenCalledWith('Move down');
+    expect(config.icon).toBe(IconChevronDown);
+    expect(config.title).toBe('Move down');
+    expect(config.name).toBe('move-down');
+
+    config.onActivate(config);
+
+    expect(handleClickSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('moves the block down and scrolls relative to current position when next block is visible', () => {
+    const { api, blocks, toolbar } = createApiMocks();
+    const tune = new MoveDownTune({ api });
+
+    blocks.getCurrentBlockIndex.mockReturnValue(2);
+
+    const nextBlockElement = createBlockElement(400, 180);
+
+    blocks.getBlockByIndex.mockReturnValue({
+      holder: nextBlockElement,
+    });
+
+    vi.spyOn(window, 'innerHeight', 'get').mockReturnValue(800);
+    vi.spyOn(window, 'scrollY', 'get').mockReturnValue(150);
+
+    const scrollToSpy = vi.spyOn(window, 'scrollTo').mockImplementation(() => {});
+
+    tune.handleClick();
+
+    expect(blocks.getBlockByIndex).toHaveBeenCalledWith(3);
+    expect(scrollToSpy).toHaveBeenCalledWith(0, 330);
+    expect(blocks.move).toHaveBeenCalledWith(3);
+    expect(toolbar.toggleBlockSettings).toHaveBeenCalledWith(true);
+  });
+
+  it('moves the block down and scrolls by viewport delta when next block is below the fold', () => {
+    const { api, blocks, toolbar } = createApiMocks();
+    const tune = new MoveDownTune({ api });
+
+    blocks.getCurrentBlockIndex.mockReturnValue(0);
+
+    const nextBlockElement = createBlockElement(1_000, 200);
+
+    blocks.getBlockByIndex.mockReturnValue({
+      holder: nextBlockElement,
+    });
+
+    vi.spyOn(window, 'innerHeight', 'get').mockReturnValue(600);
+    vi.spyOn(window, 'scrollY', 'get').mockReturnValue(50);
+
+    const scrollToSpy = vi.spyOn(window, 'scrollTo').mockImplementation(() => {});
+
+    tune.handleClick();
+
+    expect(blocks.getBlockByIndex).toHaveBeenCalledWith(1);
+    expect(scrollToSpy).toHaveBeenCalledWith(0, 400);
+    expect(blocks.move).toHaveBeenCalledWith(1);
+    expect(toolbar.toggleBlockSettings).toHaveBeenCalledWith(true);
+  });
+
+  it('throws when there is no block below the current one', () => {
+    const { api, blocks, toolbar } = createApiMocks();
+    const tune = new MoveDownTune({ api });
+
+    blocks.getCurrentBlockIndex.mockReturnValue(5);
+    blocks.getBlockByIndex.mockReturnValue(undefined);
+    const scrollToSpy = vi.spyOn(window, 'scrollTo').mockImplementation(() => {});
+
+    expect(() => tune.handleClick()).toThrowError('Unable to move Block down since it is already the last');
+    expect(blocks.move).not.toHaveBeenCalled();
+    expect(toolbar.toggleBlockSettings).not.toHaveBeenCalled();
+    expect(scrollToSpy).not.toHaveBeenCalled();
+  });
+});
+
diff --git a/test/unit/components/block-tunes/block-tune-move-up.test.ts b/test/unit/components/block-tunes/block-tune-move-up.test.ts
new file mode 100644
index 000000000..0aee24f29
--- /dev/null
+++ b/test/unit/components/block-tunes/block-tune-move-up.test.ts
@@ -0,0 +1,176 @@
+import { IconChevronUp } from '@codexteam/icons';
+import type { Mock } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import MoveUpTune from '../../../../src/components/block-tunes/block-tune-move-up';
+import type { API } from '../../../../types';
+import type { PopoverItemDefaultBaseParams } from '../../../../types/utils/popover';
+
+type BlocksMocks = {
+  getCurrentBlockIndex: Mock<[], number>;
+  getBlockByIndex: Mock<[number], { holder: HTMLElement } | undefined>;
+  move: Mock<[number], void>;
+};
+
+type ToolbarMocks = {
+  toggleBlockSettings: Mock<[boolean], void>;
+};
+
+type I18nMocks = {
+  t: Mock<[string], string>;
+};
+
+const createApiMocks = (): {
+  api: API;
+  blocks: BlocksMocks;
+  toolbar: ToolbarMocks;
+  i18n: I18nMocks;
+} => {
+  const blocks: BlocksMocks = {
+    getCurrentBlockIndex: vi.fn<[], number>().mockReturnValue(0),
+    getBlockByIndex: vi.fn<[number], { holder: HTMLElement } | undefined>(),
+    move: vi.fn<[number], void>(),
+  };
+
+  const toolbar: ToolbarMocks = {
+    toggleBlockSettings: vi.fn<[boolean], void>(),
+  };
+
+  const i18n: I18nMocks = {
+    t: vi.fn<[string], string>().mockImplementation((text) => text),
+  };
+
+  const api = {
+    blocks: blocks as unknown as API['blocks'],
+    toolbar: toolbar as unknown as API['toolbar'],
+    i18n: i18n as unknown as API['i18n'],
+  } as unknown as API;
+
+  return {
+    api,
+    blocks,
+    toolbar,
+    i18n,
+  };
+};
+
+const createBlockElement = (top: number, height: number): HTMLDivElement => {
+  const element = document.createElement('div');
+
+  vi.spyOn(element, 'getBoundingClientRect').mockReturnValue({
+    bottom: top + height,
+    height,
+    left: 0,
+    right: 0,
+    top,
+    width: 0,
+    x: 0,
+    y: top,
+    toJSON: () => ({}),
+  } as DOMRect);
+
+  return element;
+};
+
+describe('MoveUpTune', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('renders block tune config with translated title and handler', () => {
+    const { api, i18n } = createApiMocks();
+    const tune = new MoveUpTune({ api });
+    const handleClickSpy = vi.spyOn(tune, 'handleClick').mockImplementation(() => {});
+
+    const config = tune.render() as PopoverItemDefaultBaseParams;
+
+    expect(i18n.t).toHaveBeenCalledWith('Move up');
+    expect(config.icon).toBe(IconChevronUp);
+    expect(config.title).toBe('Move up');
+    expect(config.name).toBe('move-up');
+
+    config.onActivate(config);
+
+    expect(handleClickSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('moves the block up and scrolls relative to blocks when previous block is visible', () => {
+    const { api, blocks, toolbar } = createApiMocks();
+    const tune = new MoveUpTune({ api });
+
+    blocks.getCurrentBlockIndex.mockReturnValue(2);
+
+    const currentBlockElement = createBlockElement(500, 180);
+    const previousBlockElement = createBlockElement(200, 160);
+
+    blocks.getBlockByIndex.mockImplementation((index) => {
+      if (index === 2) {
+        return { holder: currentBlockElement };
+      }
+
+      if (index === 1) {
+        return { holder: previousBlockElement };
+      }
+
+      return undefined;
+    });
+
+    const scrollBySpy = vi.spyOn(window, 'scrollBy').mockImplementation(() => {});
+
+    tune.handleClick();
+
+    expect(blocks.getBlockByIndex).toHaveBeenCalledWith(1);
+    expect(scrollBySpy).toHaveBeenCalledWith(0, -(Math.abs(500) - Math.abs(200)));
+    expect(blocks.move).toHaveBeenCalledWith(1);
+    expect(toolbar.toggleBlockSettings).toHaveBeenCalledWith(true);
+  });
+
+  it('moves the block up and scrolls by delta when previous block is above the viewport', () => {
+    const { api, blocks, toolbar } = createApiMocks();
+    const tune = new MoveUpTune({ api });
+
+    blocks.getCurrentBlockIndex.mockReturnValue(3);
+
+    const currentBlockElement = createBlockElement(400, 160);
+    const previousBlockElement = createBlockElement(-150, 120);
+
+    blocks.getBlockByIndex.mockImplementation((index) => {
+      if (index === 3) {
+        return { holder: currentBlockElement };
+      }
+
+      if (index === 2) {
+        return { holder: previousBlockElement };
+      }
+
+      return undefined;
+    });
+
+    const scrollBySpy = vi.spyOn(window, 'scrollBy').mockImplementation(() => {});
+
+    tune.handleClick();
+
+    expect(blocks.getBlockByIndex).toHaveBeenCalledWith(2);
+    expect(scrollBySpy).toHaveBeenCalledWith(0, -(Math.abs(400) + 120));
+    expect(blocks.move).toHaveBeenCalledWith(2);
+    expect(toolbar.toggleBlockSettings).toHaveBeenCalledWith(true);
+  });
+
+  it('throws when block is already the first or previous block is missing', () => {
+    const { api, blocks, toolbar } = createApiMocks();
+    const tune = new MoveUpTune({ api });
+
+    blocks.getCurrentBlockIndex.mockReturnValue(0);
+    blocks.getBlockByIndex.mockReturnValue(undefined);
+
+    const scrollBySpy = vi.spyOn(window, 'scrollBy').mockImplementation(() => {});
+
+    expect(() => tune.handleClick()).toThrowError(
+      'Unable to move Block up since it is already the first'
+    );
+    expect(blocks.move).not.toHaveBeenCalled();
+    expect(toolbar.toggleBlockSettings).not.toHaveBeenCalled();
+    expect(scrollBySpy).not.toHaveBeenCalled();
+  });
+});
+
diff --git a/test/unit/components/block/api.test.ts b/test/unit/components/block/api.test.ts
new file mode 100644
index 000000000..57c7a19ae
--- /dev/null
+++ b/test/unit/components/block/api.test.ts
@@ -0,0 +1,179 @@
+import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
+
+import BlockAPIConstructor from '../../../../src/components/block/api';
+import type Block from '../../../../src/components/block';
+import type { BlockToolData, ToolConfig, ToolboxConfigEntry } from '../../../../types/tools';
+import type { SavedData } from '../../../../types/data-formats';
+import type { BlockAPI as BlockAPIInterface } from '../../../../types/api';
+
+type MockBlockShape = {
+  id: string;
+  name: string;
+  config: ToolConfig;
+  holder: HTMLElement;
+  isEmpty: boolean;
+  selected: boolean;
+  stretched: boolean;
+  focusable: boolean;
+  setStretchState: (state: boolean) => void;
+  call: (methodName: string, param?: object) => unknown;
+  save: () => Promise<void | SavedData>;
+  validate: (data: BlockToolData) => Promise<boolean>;
+  dispatchChange: () => void;
+  getActiveToolboxEntry: () => Promise<ToolboxConfigEntry | undefined>;
+};
+
+type MockFn<T> = T extends (...args: infer TArgs) => infer TReturn ? Mock<TArgs, TReturn> : never;
+
+const createMockBlock = (): {
+  block: Block;
+  shape: MockBlockShape;
+  mocks: {
+    setStretchState: MockFn<MockBlockShape['setStretchState']>;
+    call: MockFn<MockBlockShape['call']>;
+    save: MockFn<MockBlockShape['save']>;
+    validate: MockFn<MockBlockShape['validate']>;
+    dispatchChange: MockFn<MockBlockShape['dispatchChange']>;
+    getActiveToolboxEntry: MockFn<MockBlockShape['getActiveToolboxEntry']>;
+  };
+  config: ToolConfig;
+  holder: HTMLElement;
+  savedData: SavedData;
+  toolboxEntry: ToolboxConfigEntry;
+} => {
+  const holder = document.createElement('div');
+  const config: ToolConfig = { placeholder: 'Test placeholder' };
+  const savedData: SavedData = {
+    id: 'block-id',
+    tool: 'paragraph',
+    data: { text: 'saved text' } as BlockToolData,
+    time: 42,
+  };
+  const toolboxEntry: ToolboxConfigEntry = {
+    title: 'Paragraph',
+    icon: '<svg></svg>',
+    data: { preset: 'default' } as BlockToolData,
+  };
+
+  const callMock: MockFn<MockBlockShape['call']> = vi.fn<Parameters<MockBlockShape['call']>, ReturnType<MockBlockShape['call']>>()
+    .mockReturnValue('call-result');
+  const saveMock: MockFn<MockBlockShape['save']> = vi.fn<Parameters<MockBlockShape['save']>, ReturnType<MockBlockShape['save']>>()
+    .mockResolvedValue(savedData);
+  const validateMock: MockFn<MockBlockShape['validate']> = vi.fn<Parameters<MockBlockShape['validate']>, ReturnType<MockBlockShape['validate']>>()
+    .mockResolvedValue(true);
+  const dispatchChangeMock: MockFn<MockBlockShape['dispatchChange']> = vi.fn<Parameters<MockBlockShape['dispatchChange']>, ReturnType<MockBlockShape['dispatchChange']>>();
+  const getActiveToolboxEntryMock: MockFn<MockBlockShape['getActiveToolboxEntry']> = vi.fn<Parameters<MockBlockShape['getActiveToolboxEntry']>, ReturnType<MockBlockShape['getActiveToolboxEntry']>>()
+    .mockResolvedValue(toolboxEntry);
+  const setStretchStateMock: MockFn<MockBlockShape['setStretchState']> = vi.fn<Parameters<MockBlockShape['setStretchState']>, ReturnType<MockBlockShape['setStretchState']>>();
+
+  const shape: MockBlockShape = {
+    id: 'block-id',
+    name: 'paragraph',
+    config,
+    holder,
+    isEmpty: false,
+    selected: false,
+    stretched: false,
+    focusable: true,
+    setStretchState: (state: boolean) => {
+      shape.stretched = state;
+    },
+    call: callMock,
+    save: saveMock,
+    validate: validateMock,
+    dispatchChange: dispatchChangeMock,
+    getActiveToolboxEntry: getActiveToolboxEntryMock,
+  };
+
+  shape.setStretchState = setStretchStateMock.mockImplementation((state: boolean) => {
+    shape.stretched = state;
+  });
+
+  return {
+    block: shape as unknown as Block,
+    shape,
+    mocks: {
+      setStretchState: setStretchStateMock,
+      call: callMock,
+      save: saveMock,
+      validate: validateMock,
+      dispatchChange: dispatchChangeMock,
+      getActiveToolboxEntry: getActiveToolboxEntryMock,
+    },
+    config,
+    holder,
+    savedData,
+    toolboxEntry,
+  };
+};
+
+describe('BlockAPI', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('exposes block metadata and state properties', () => {
+    const { block, config, holder, shape } = createMockBlock();
+    const blockAPI = new BlockAPIConstructor(block);
+
+    expect(blockAPI.id).toBe(shape.id);
+    expect(blockAPI.name).toBe(shape.name);
+    expect(blockAPI.config).toBe(config);
+    expect(blockAPI.holder).toBe(holder);
+    expect(blockAPI.isEmpty).toBe(shape.isEmpty);
+    expect(blockAPI.selected).toBe(shape.selected);
+    expect(blockAPI.focusable).toBe(shape.focusable);
+    expect(blockAPI.stretched).toBe(shape.stretched);
+  });
+
+  it('updates stretch state through setter and reflects changes', () => {
+    const { block, shape, mocks } = createMockBlock();
+    const blockAPI = new BlockAPIConstructor(block);
+
+    blockAPI.stretched = true;
+
+    expect(mocks.setStretchState).toHaveBeenCalledWith(true);
+    expect(shape.stretched).toBe(true);
+    expect(blockAPI.stretched).toBe(true);
+  });
+
+  it('delegates method calls to the underlying block', async () => {
+    const { block, mocks, savedData, toolboxEntry } = createMockBlock();
+    const blockAPI = new BlockAPIConstructor(block);
+    const callParams = { value: 123 };
+    const methodName = 'method';
+    const validationData = { text: 'validate' } as BlockToolData;
+
+    const callResult = blockAPI.call(methodName, callParams);
+    const saveResult = await blockAPI.save();
+    const validationResult = await blockAPI.validate(validationData);
+
+    blockAPI.dispatchChange();
+    const activeToolboxEntry = await blockAPI.getActiveToolboxEntry();
+
+    expect(mocks.call).toHaveBeenCalledWith(methodName, callParams);
+    expect(callResult).toBe('call-result');
+
+    expect(mocks.save).toHaveBeenCalledTimes(1);
+    expect(saveResult).toBe(savedData);
+
+    expect(mocks.validate).toHaveBeenCalledWith(validationData);
+    expect(validationResult).toBe(true);
+
+    expect(mocks.dispatchChange).toHaveBeenCalledTimes(1);
+
+    expect(mocks.getActiveToolboxEntry).toHaveBeenCalledTimes(1);
+    expect(activeToolboxEntry).toBe(toolboxEntry);
+  });
+
+  it('creates BlockAPI instances compatible with BlockAPIInterface', () => {
+    const { block } = createMockBlock();
+    const blockAPI = new BlockAPIConstructor(block);
+
+    const apiInterface: BlockAPIInterface = blockAPI;
+
+    expect(apiInterface.id).toBe(blockAPI.id);
+    expect(apiInterface.name).toBe(blockAPI.name);
+  });
+});
+
diff --git a/test/unit/components/blocks.test.ts b/test/unit/components/blocks.test.ts
new file mode 100644
index 000000000..0a319086f
--- /dev/null
+++ b/test/unit/components/blocks.test.ts
@@ -0,0 +1,996 @@
+import { describe, it, expect, vi } from 'vitest';
+import Blocks from '../../../src/components/blocks';
+import type Block from '../../../src/components/block';
+import { BlockToolAPI } from '../../../src/components/block';
+
+/**
+ * Unit tests for Blocks class
+ *
+ * Tests internal block management functionality
+ */
+describe('Blocks', () => {
+  const workingArea: HTMLElement = document.createElement('div');
+
+  /**
+   * Create a mock Block instance
+   *
+   * @param id - The block ID
+   * @param name - The block name (default: 'paragraph')
+   */
+  const createMockBlock = (id: string, name: string = 'paragraph'): Block => {
+    const holder = document.createElement('div');
+
+    holder.className = 'ce-block';
+    holder.setAttribute('data-id', id);
+
+    const mockBlock = {
+      id,
+      name,
+      holder,
+      call: vi.fn(),
+      tool: {
+        name,
+      },
+    } as unknown as Block;
+
+    return mockBlock;
+  };
+
+  /**
+   * Create a fresh Blocks instance for testing
+   */
+  const createBlocks = (): Blocks => {
+    // Reset working area for each test
+    workingArea.className = 'codex-editor';
+    workingArea.innerHTML = '';
+    if (!document.body.contains(workingArea)) {
+      document.body.appendChild(workingArea);
+    }
+
+    return new Blocks(workingArea);
+  };
+
+  describe('constructor', () => {
+    it('should initialize with empty blocks array', () => {
+      const blocks = createBlocks();
+
+      expect(blocks.blocks).toEqual([]);
+      expect(blocks.length).toBe(0);
+    });
+
+    it('should set workingArea', () => {
+      const blocks = createBlocks();
+
+      expect(blocks.workingArea).toBe(workingArea);
+    });
+  });
+
+  describe('getters', () => {
+    describe('length', () => {
+      it('should return 0 for empty blocks array', () => {
+        const blocks = createBlocks();
+
+        expect(blocks.length).toBe(0);
+      });
+
+      it('should return correct length after adding blocks', () => {
+        const blocks = createBlocks();
+        const block1 = createMockBlock('block-1');
+        const block2 = createMockBlock('block-2');
+
+        blocks.push(block1);
+        expect(blocks.length).toBe(1);
+
+        blocks.push(block2);
+        expect(blocks.length).toBe(2);
+      });
+    });
+
+    describe('array', () => {
+      it('should return empty array initially', () => {
+        const blocks = createBlocks();
+
+        expect(blocks.array).toEqual([]);
+      });
+
+      it('should return array of blocks', () => {
+        const blocks = createBlocks();
+        const block1 = createMockBlock('block-1');
+        const block2 = createMockBlock('block-2');
+
+        blocks.push(block1);
+        blocks.push(block2);
+
+        expect(blocks.array).toHaveLength(2);
+        expect(blocks.array[0]).toBe(block1);
+        expect(blocks.array[1]).toBe(block2);
+      });
+    });
+
+    describe('nodes', () => {
+      it('should return empty array when no blocks', () => {
+        const blocks = createBlocks();
+
+        expect(blocks.nodes).toEqual([]);
+      });
+
+      it('should return array of block holder elements', () => {
+        const blocks = createBlocks();
+        const block1 = createMockBlock('block-1');
+        const block2 = createMockBlock('block-2');
+
+        blocks.push(block1);
+        blocks.push(block2);
+
+        const nodes = blocks.nodes;
+
+        expect(nodes).toHaveLength(2);
+        expect(nodes[0]).toBe(block1.holder);
+        expect(nodes[1]).toBe(block2.holder);
+      });
+    });
+  });
+
+  describe('Proxy traps', () => {
+    describe('Blocks.set', () => {
+      it('should set non-numeric properties via Reflect', () => {
+        const blocks = createBlocks();
+        const testValue = 'test';
+
+        Blocks.set(blocks, 'testProperty', testValue);
+
+        expect((blocks as unknown as { testProperty: string }).testProperty).toBe(testValue);
+      });
+
+      it('should call insert for numeric properties', () => {
+        const blocks = createBlocks();
+        const block = createMockBlock('block-1');
+        const insertSpy = vi.spyOn(blocks, 'insert');
+
+        Blocks.set(blocks, '0', block);
+
+        expect(insertSpy).toHaveBeenCalledWith(0, block);
+      });
+    });
+
+    describe('Blocks.get', () => {
+      it('should get non-numeric properties via Reflect', () => {
+        const blocks = createBlocks();
+
+        (blocks as unknown as { testProperty: string }).testProperty = 'test';
+
+        const result = Blocks.get(blocks, 'testProperty');
+
+        expect(result).toBe('test');
+      });
+
+      it('should call get method for numeric properties', () => {
+        const blocks = createBlocks();
+        const block = createMockBlock('block-1');
+
+        blocks.push(block);
+
+        const result = Blocks.get(blocks, '0');
+
+        expect(result).toBe(block);
+      });
+
+      it('should return undefined for out of bounds numeric property', () => {
+        const blocks = createBlocks();
+        const result = Blocks.get(blocks, '999');
+
+        expect(result).toBeUndefined();
+      });
+    });
+  });
+
+  describe('push', () => {
+    it('should add block to blocks array', () => {
+      const blocks = createBlocks();
+      const block = createMockBlock('block-1');
+
+      blocks.push(block);
+
+      expect(blocks.blocks).toContain(block);
+      expect(blocks.length).toBe(1);
+    });
+
+    it('should append block holder to workingArea', () => {
+      const blocks = createBlocks();
+      const block = createMockBlock('block-1');
+
+      blocks.push(block);
+
+      expect(workingArea.children).toContain(block.holder);
+      expect(workingArea.children.length).toBe(1);
+    });
+
+    it('should call RENDERED event on block', () => {
+      const blocks = createBlocks();
+      const block = createMockBlock('block-1');
+
+      blocks.push(block);
+
+      expect(block.call).toHaveBeenCalledWith(BlockToolAPI.RENDERED);
+    });
+
+    it('should add multiple blocks in order', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+      blocks.push(block2);
+      blocks.push(block3);
+
+      const expectedLength = 3;
+
+      expect(blocks.length).toBe(expectedLength);
+      expect(blocks.blocks[0]).toBe(block1);
+      expect(blocks.blocks[1]).toBe(block2);
+      expect(blocks.blocks[2]).toBe(block3);
+    });
+  });
+
+  describe('swap', () => {
+    it('should swap two blocks', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      blocks.swap(0, 1);
+
+      expect(blocks.blocks[0]).toBe(block2);
+      expect(blocks.blocks[1]).toBe(block1);
+    });
+
+    it('should swap blocks in DOM', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      blocks.swap(0, 1);
+
+      expect(workingArea.children[0]).toBe(block2.holder);
+      expect(workingArea.children[1]).toBe(block1.holder);
+    });
+  });
+
+  describe('move', () => {
+    it('should move block from one index to another', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+      blocks.push(block2);
+      blocks.push(block3);
+
+      blocks.move(0, 2);
+
+      expect(blocks.blocks[0]).toBe(block3);
+      expect(blocks.blocks[1]).toBe(block1);
+      expect(blocks.blocks[2]).toBe(block2);
+    });
+
+    it('should move block to beginning (index 0)', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      blocks.move(0, 1);
+
+      expect(blocks.blocks[0]).toBe(block2);
+      expect(blocks.blocks[1]).toBe(block1);
+    });
+
+    it('should move block to end', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+      blocks.push(block2);
+      blocks.push(block3);
+
+      blocks.move(2, 0);
+
+      expect(blocks.blocks[0]).toBe(block2);
+      expect(blocks.blocks[1]).toBe(block3);
+      expect(blocks.blocks[2]).toBe(block1);
+    });
+
+    it('should call MOVED event on block', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      blocks.move(0, 1);
+
+      expect(block2.call).toHaveBeenCalledWith(
+        BlockToolAPI.MOVED,
+        expect.objectContaining({
+          detail: expect.objectContaining({
+            fromIndex: 1,
+            toIndex: 0,
+          }),
+        })
+      );
+    });
+
+    it('should handle moving to same index', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      blocks.move(1, 1);
+
+      expect(blocks.blocks[0]).toBe(block1);
+      expect(blocks.blocks[1]).toBe(block2);
+    });
+
+    it('should handle moving first block to index 0 (no-op)', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      blocks.move(0, 0);
+
+      expect(blocks.blocks[0]).toBe(block1);
+      expect(blocks.blocks[1]).toBe(block2);
+    });
+
+    it('should handle moving last block to beginning', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+      blocks.push(block2);
+      blocks.push(block3);
+
+      blocks.move(0, 2);
+
+      expect(blocks.blocks[0]).toBe(block3);
+      expect(blocks.blocks[1]).toBe(block1);
+      expect(blocks.blocks[2]).toBe(block2);
+    });
+
+    it('should handle moving block forward in array', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+      const block4 = createMockBlock('block-4');
+
+      blocks.push(block1);
+      blocks.push(block2);
+      blocks.push(block3);
+      blocks.push(block4);
+
+      const targetIndex = 3;
+      const destinationIndex = 1;
+
+      blocks.move(targetIndex, destinationIndex);
+
+      expect(blocks.blocks[0]).toBe(block1);
+      expect(blocks.blocks[1]).toBe(block3);
+      expect(blocks.blocks[2]).toBe(block4);
+      expect(blocks.blocks[3]).toBe(block2);
+    });
+
+    it('should handle moving block backward in array', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+      const block4 = createMockBlock('block-4');
+
+      blocks.push(block1);
+      blocks.push(block2);
+      blocks.push(block3);
+      blocks.push(block4);
+
+      const sourceIndex = 1;
+      const targetIndex = 3;
+
+      blocks.move(sourceIndex, targetIndex);
+
+      expect(blocks.blocks[0]).toBe(block1);
+      expect(blocks.blocks[1]).toBe(block4);
+      expect(blocks.blocks[2]).toBe(block2);
+      expect(blocks.blocks[3]).toBe(block3);
+    });
+  });
+
+  describe('insert', () => {
+    it('should insert block at specified index', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      blocks.insert(1, block3);
+
+      expect(blocks.blocks[0]).toBe(block1);
+      expect(blocks.blocks[1]).toBe(block3);
+      expect(blocks.blocks[2]).toBe(block2);
+    });
+
+    it('should insert block at beginning (index 0)', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+
+      blocks.insert(0, block2);
+
+      expect(blocks.blocks[0]).toBe(block2);
+      expect(blocks.blocks[1]).toBe(block1);
+    });
+
+    it('should insert block at end when index equals length', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+
+      blocks.insert(1, block2);
+
+      expect(blocks.blocks[0]).toBe(block1);
+      expect(blocks.blocks[1]).toBe(block2);
+    });
+
+    it('should clamp index to length when index exceeds length', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+
+      const outOfBoundsIndex = 999;
+
+      blocks.insert(outOfBoundsIndex, block2);
+
+      expect(blocks.blocks[0]).toBe(block1);
+      expect(blocks.blocks[1]).toBe(block2);
+    });
+
+    it('should push block when blocks array is empty', () => {
+      const blocks = createBlocks();
+      const block = createMockBlock('block-1');
+
+      blocks.insert(0, block);
+
+      expect(blocks.blocks).toContain(block);
+      expect(blocks.length).toBe(1);
+    });
+
+    it('should replace block when replace is true', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+
+      const removeSpy = vi.spyOn(block1.holder, 'remove');
+
+      blocks.insert(0, block2, true);
+
+      expect(blocks.blocks[0]).toBe(block2);
+      expect(blocks.length).toBe(1);
+      expect(removeSpy).toHaveBeenCalled();
+      expect(block1.call).toHaveBeenCalledWith(BlockToolAPI.REMOVED);
+    });
+
+    it('should insert block after previous block when index > 0', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      const insertAdjacentSpy = vi.spyOn(block1.holder, 'insertAdjacentElement');
+
+      blocks.insert(1, block3);
+
+      expect(insertAdjacentSpy).toHaveBeenCalledWith('afterend', block3.holder);
+    });
+
+    it('should insert block before next block when index is 0 and next block exists', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+
+      const insertAdjacentSpy = vi.spyOn(block1.holder, 'insertAdjacentElement');
+
+      blocks.insert(0, block2);
+
+      expect(insertAdjacentSpy).toHaveBeenCalledWith('beforebegin', block2.holder);
+    });
+
+    it('should append to workingArea when index is 0 and no next block', () => {
+      const blocks = createBlocks();
+      const block = createMockBlock('block-1');
+
+      const appendChildSpy = vi.spyOn(workingArea, 'appendChild');
+
+      blocks.insert(0, block);
+
+      expect(appendChildSpy).toHaveBeenCalledWith(block.holder);
+    });
+
+    it('should call RENDERED event on inserted block', () => {
+      const blocks = createBlocks();
+      const block = createMockBlock('block-1');
+
+      blocks.insert(0, block);
+
+      expect(block.call).toHaveBeenCalledWith(BlockToolAPI.RENDERED);
+    });
+  });
+
+  describe('replace', () => {
+    it('should replace block at specified index', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+
+      blocks.replace(0, block2);
+
+      expect(blocks.blocks[0]).toBe(block2);
+      expect(blocks.length).toBe(1);
+    });
+
+    it('should replace block holder in DOM', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+
+      const replaceWithSpy = vi.spyOn(block1.holder, 'replaceWith');
+
+      blocks.replace(0, block2);
+
+      expect(replaceWithSpy).toHaveBeenCalledWith(block2.holder);
+    });
+
+    it('should throw error for incorrect index', () => {
+      const blocks = createBlocks();
+      const block = createMockBlock('block-1');
+
+      const invalidIndex = 999;
+
+      expect(() => {
+        blocks.replace(invalidIndex, block);
+      }).toThrow('Incorrect index');
+    });
+  });
+
+  describe('insertMany', () => {
+    it('should insert multiple blocks at specified index', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+
+      blocks.insertMany([block2, block3], 0);
+
+      const expectedLength = 3;
+
+      expect(blocks.blocks[0]).toBe(block2);
+      expect(blocks.blocks[1]).toBe(block3);
+      expect(blocks.blocks[2]).toBe(block1);
+      expect(blocks.length).toBe(expectedLength);
+    });
+
+    it('should insert blocks at beginning when index is 0', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+
+      const prependSpy = vi.spyOn(workingArea, 'prepend');
+
+      blocks.insertMany([block2, block3], 0);
+
+      expect(prependSpy).toHaveBeenCalled();
+      expect(blocks.blocks[0]).toBe(block2);
+      expect(blocks.blocks[1]).toBe(block3);
+    });
+
+    it('should insert blocks after previous block when index > 0', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+
+      const afterSpy = vi.spyOn(block1.holder, 'after');
+
+      blocks.insertMany([block2, block3], 1);
+
+      expect(afterSpy).toHaveBeenCalled();
+      expect(blocks.blocks[1]).toBe(block2);
+      expect(blocks.blocks[2]).toBe(block3);
+    });
+
+    it('should append blocks when blocks array is empty', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      const appendChildSpy = vi.spyOn(workingArea, 'appendChild');
+
+      blocks.insertMany([block1, block2], 0);
+
+      expect(appendChildSpy).toHaveBeenCalled();
+      expect(blocks.length).toBe(2);
+    });
+
+    it('should call RENDERED event on each inserted block', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.insertMany([block1, block2], 0);
+
+      expect(block1.call).toHaveBeenCalledWith(BlockToolAPI.RENDERED);
+      expect(block2.call).toHaveBeenCalledWith(BlockToolAPI.RENDERED);
+    });
+
+    it('should handle index greater than length', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+
+      const outOfBoundsIndex = 999;
+
+      blocks.insertMany([block2, block3], outOfBoundsIndex);
+
+      expect(blocks.blocks[0]).toBe(block1);
+      expect(blocks.blocks[1]).toBe(block2);
+      expect(blocks.blocks[2]).toBe(block3);
+    });
+  });
+
+  describe('remove', () => {
+    it('should remove block at specified index', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      blocks.remove(0);
+
+      expect(blocks.length).toBe(1);
+      expect(blocks.blocks[0]).toBe(block2);
+    });
+
+    it('should remove last block when index is NaN', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      blocks.remove(NaN);
+
+      expect(blocks.length).toBe(1);
+      expect(blocks.blocks[0]).toBe(block1);
+    });
+
+    it('should remove block holder from DOM', () => {
+      const blocks = createBlocks();
+      const block = createMockBlock('block-1');
+
+      blocks.push(block);
+
+      const removeSpy = vi.spyOn(block.holder, 'remove');
+
+      blocks.remove(0);
+
+      expect(removeSpy).toHaveBeenCalled();
+    });
+
+    it('should call REMOVED event on block', () => {
+      const blocks = createBlocks();
+      const block = createMockBlock('block-1');
+
+      blocks.push(block);
+
+      blocks.remove(0);
+
+      expect(block.call).toHaveBeenCalledWith(BlockToolAPI.REMOVED);
+    });
+  });
+
+  describe('removeAll', () => {
+    it('should remove all blocks', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+      blocks.push(block2);
+      blocks.push(block3);
+
+      blocks.removeAll();
+
+      expect(blocks.length).toBe(0);
+      expect(blocks.blocks).toEqual([]);
+    });
+
+    it('should clear workingArea innerHTML', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      blocks.removeAll();
+
+      expect(workingArea.innerHTML).toBe('');
+    });
+
+    it('should call REMOVED event on each block', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      blocks.removeAll();
+
+      expect(block1.call).toHaveBeenCalledWith(BlockToolAPI.REMOVED);
+      expect(block2.call).toHaveBeenCalledWith(BlockToolAPI.REMOVED);
+    });
+
+    it('should handle empty blocks array', () => {
+      const blocks = createBlocks();
+
+      expect(() => {
+        blocks.removeAll();
+      }).not.toThrow();
+
+      expect(blocks.length).toBe(0);
+    });
+  });
+
+  describe('insertAfter', () => {
+    it('should insert block after target block', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      blocks.insertAfter(block1, block3);
+
+      expect(blocks.blocks[0]).toBe(block1);
+      expect(blocks.blocks[1]).toBe(block3);
+      expect(blocks.blocks[2]).toBe(block2);
+    });
+
+    it('should insert at end when target is last block', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+
+      blocks.insertAfter(block1, block2);
+
+      expect(blocks.blocks[0]).toBe(block1);
+      expect(blocks.blocks[1]).toBe(block2);
+    });
+  });
+
+  describe('get', () => {
+    it('should return block at specified index', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+      blocks.push(block2);
+
+      expect(blocks.get(0)).toBe(block1);
+      expect(blocks.get(1)).toBe(block2);
+    });
+
+    it('should return undefined for out of bounds index', () => {
+      const blocks = createBlocks();
+
+      expect(blocks.get(0)).toBeUndefined();
+
+      const outOfBoundsIndex = 999;
+
+      expect(blocks.get(outOfBoundsIndex)).toBeUndefined();
+    });
+
+    it('should return undefined for negative index', () => {
+      const blocks = createBlocks();
+      const block = createMockBlock('block-1');
+
+      blocks.push(block);
+
+      expect(blocks.get(-1)).toBeUndefined();
+    });
+  });
+
+  describe('indexOf', () => {
+    it('should return index of block', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+      blocks.push(block2);
+      blocks.push(block3);
+
+      expect(blocks.indexOf(block1)).toBe(0);
+      expect(blocks.indexOf(block2)).toBe(1);
+      expect(blocks.indexOf(block3)).toBe(2);
+    });
+
+    it('should return -1 for block not in array', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+
+      expect(blocks.indexOf(block2)).toBe(-1);
+    });
+
+    it('should return -1 for empty array', () => {
+      const blocks = createBlocks();
+      const block = createMockBlock('block-1');
+
+      expect(blocks.indexOf(block)).toBe(-1);
+    });
+  });
+
+  describe('edge cases and integration', () => {
+    it('should handle complex sequence of operations', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+      const block4 = createMockBlock('block-4');
+
+      // Push initial blocks
+      blocks.push(block1);
+      blocks.push(block2);
+
+      // Insert in middle
+      blocks.insert(1, block3);
+
+      const expectedLengthAfterInsert = 3;
+
+      expect(blocks.length).toBe(expectedLengthAfterInsert);
+      expect(blocks.blocks[1]).toBe(block3);
+
+      // Move block
+      blocks.move(0, 2);
+
+      expect(blocks.blocks[0]).toBe(block2);
+      expect(blocks.blocks[1]).toBe(block1);
+      expect(blocks.blocks[2]).toBe(block3);
+
+      // Insert many
+      blocks.insertMany([ block4 ], 1);
+
+      const expectedLengthAfterInsertMany = 4;
+
+      expect(blocks.length).toBe(expectedLengthAfterInsertMany);
+      expect(blocks.blocks[1]).toBe(block4);
+
+      // Remove
+      blocks.remove(2);
+
+      const expectedLengthAfterRemove = 3;
+
+      expect(blocks.length).toBe(expectedLengthAfterRemove);
+      expect(blocks.blocks[2]).toBe(block3);
+    });
+
+    it('should maintain DOM order after multiple operations', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+      const block3 = createMockBlock('block-3');
+
+      blocks.push(block1);
+      blocks.push(block2);
+      blocks.insert(1, block3);
+
+      const nodes = blocks.nodes;
+
+      expect(nodes[0]).toBe(block1.holder);
+      expect(nodes[1]).toBe(block3.holder);
+      expect(nodes[2]).toBe(block2.holder);
+    });
+
+    it('should handle insertMany with empty array', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+
+      blocks.push(block1);
+
+      blocks.insertMany([], 0);
+
+      expect(blocks.length).toBe(1);
+      expect(blocks.blocks[0]).toBe(block1);
+    });
+
+    it('should handle replace followed by remove', () => {
+      const blocks = createBlocks();
+      const block1 = createMockBlock('block-1');
+      const block2 = createMockBlock('block-2');
+
+      blocks.push(block1);
+
+      blocks.replace(0, block2);
+
+      expect(blocks.blocks[0]).toBe(block2);
+
+      blocks.remove(0);
+
+      expect(blocks.length).toBe(0);
+    });
+  });
+});
+
diff --git a/test/unit/components/core.test.ts b/test/unit/components/core.test.ts
new file mode 100644
index 000000000..883eb0c7b
--- /dev/null
+++ b/test/unit/components/core.test.ts
@@ -0,0 +1,456 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { EditorConfig } from '../../../types';
+import type { EditorModules } from '../../../src/types-internal/editor-modules';
+import { CriticalError } from '../../../src/components/errors/critical';
+
+const mockRegistry = vi.hoisted(() => ({
+  dom: {
+    get: vi.fn(),
+    isElement: vi.fn(),
+  },
+  utils: {
+    isObject: vi.fn(),
+    isString: vi.fn(),
+    isEmpty: vi.fn(),
+    setLogLevel: vi.fn(),
+    log: vi.fn(),
+    deprecationAssert: vi.fn(),
+  },
+  i18n: {
+    setDictionary: vi.fn(),
+  },
+  modules: {
+    toolsPrepare: vi.fn(),
+    uiPrepare: vi.fn(),
+    uiCheckEmptiness: vi.fn(),
+    blockManagerPrepare: vi.fn(),
+    pastePrepare: vi.fn(),
+    blockSelectionPrepare: vi.fn(),
+    rectangleSelectionPrepare: vi.fn(),
+    crossBlockSelectionPrepare: vi.fn(),
+    readOnlyPrepare: vi.fn(),
+    rendererPrepare: vi.fn(),
+    rendererRender: vi.fn(() => Promise.resolve()),
+    modificationsObserverPrepare: vi.fn(),
+    modificationsObserverEnable: vi.fn(),
+    caretPrepare: vi.fn(),
+    caretSetToBlock: vi.fn(),
+  },
+}));
+
+vi.mock('../../../src/components/dom', () => ({
+  __esModule: true,
+  default: {
+    get: mockRegistry.dom.get,
+    isElement: mockRegistry.dom.isElement,
+  },
+}));
+
+vi.mock('../../../src/components/utils', () => ({
+  __esModule: true,
+  isObject: mockRegistry.utils.isObject,
+  isString: mockRegistry.utils.isString,
+  isEmpty: mockRegistry.utils.isEmpty,
+  setLogLevel: mockRegistry.utils.setLogLevel,
+  log: mockRegistry.utils.log,
+  deprecationAssert: mockRegistry.utils.deprecationAssert,
+  LogLevels: {
+    VERBOSE: 'VERBOSE',
+    INFO: 'INFO',
+  },
+}));
+
+vi.mock('../../../src/components/i18n', () => ({
+  __esModule: true,
+  default: {
+    setDictionary: mockRegistry.i18n.setDictionary,
+  },
+}));
+
+vi.mock('../../../src/components/modules', () => {
+  /**
+   * Minimal Tools module stub used in Core tests.
+   */
+  class MockTools {
+    public state?: EditorModules;
+    public prepare = mockRegistry.modules.toolsPrepare;
+  }
+
+  /**
+   * Minimal UI module stub used in Core tests.
+   */
+  class MockUI {
+    public state?: EditorModules;
+    public prepare = mockRegistry.modules.uiPrepare;
+    public checkEmptiness = mockRegistry.modules.uiCheckEmptiness;
+  }
+
+  /**
+   * Minimal BlockManager module stub used in Core tests.
+   */
+  class MockBlockManager {
+    public state?: EditorModules;
+    public prepare = mockRegistry.modules.blockManagerPrepare;
+    public blocks = [ { id: 'block-1' } ];
+  }
+
+  /**
+   * Minimal Paste module stub used in Core tests.
+   */
+  class MockPaste {
+    public state?: EditorModules;
+    public prepare = mockRegistry.modules.pastePrepare;
+  }
+
+  /**
+   * Minimal BlockSelection module stub used in Core tests.
+   */
+  class MockBlockSelection {
+    public state?: EditorModules;
+    public prepare = mockRegistry.modules.blockSelectionPrepare;
+  }
+
+  /**
+   * Minimal RectangleSelection module stub used in Core tests.
+   */
+  class MockRectangleSelection {
+    public state?: EditorModules;
+    public prepare = mockRegistry.modules.rectangleSelectionPrepare;
+  }
+
+  /**
+   * Minimal CrossBlockSelection module stub used in Core tests.
+   */
+  class MockCrossBlockSelection {
+    public state?: EditorModules;
+    public prepare = mockRegistry.modules.crossBlockSelectionPrepare;
+  }
+
+  /**
+   * Minimal ReadOnly module stub used in Core tests.
+   */
+  class MockReadOnly {
+    public state?: EditorModules;
+    public prepare = mockRegistry.modules.readOnlyPrepare;
+  }
+
+  /**
+   * Minimal Renderer module stub used in Core tests.
+   */
+  class MockRenderer {
+    public state?: EditorModules;
+    public prepare = mockRegistry.modules.rendererPrepare;
+    public render = mockRegistry.modules.rendererRender;
+  }
+
+  /**
+   * Minimal ModificationsObserver module stub used in Core tests.
+   */
+  class MockModificationsObserver {
+    public state?: EditorModules;
+    public prepare = mockRegistry.modules.modificationsObserverPrepare;
+    public enable = mockRegistry.modules.modificationsObserverEnable;
+  }
+
+  /**
+   * Minimal Caret module stub used in Core tests.
+   */
+  class MockCaret {
+    public state?: EditorModules;
+    public prepare = mockRegistry.modules.caretPrepare;
+    public setToBlock = mockRegistry.modules.caretSetToBlock;
+
+    /**
+     * Provides the caret positions map required by Core.
+     */
+    public get positions(): { START: string } {
+      return {
+        START: 'start',
+      };
+    }
+  }
+
+  return {
+    __esModule: true,
+    default: {
+      Tools: MockTools,
+      UI: MockUI,
+      BlockManager: MockBlockManager,
+      Paste: MockPaste,
+      BlockSelection: MockBlockSelection,
+      RectangleSelection: MockRectangleSelection,
+      CrossBlockSelection: MockCrossBlockSelection,
+      ReadOnly: MockReadOnly,
+      Renderer: MockRenderer,
+      ModificationsObserver: MockModificationsObserver,
+      Caret: MockCaret,
+    },
+  };
+});
+
+const { dom, utils, i18n, modules: moduleMocks } = mockRegistry;
+const { get: mockDomGet, isElement: mockDomIsElement } = dom;
+const {
+  isObject: mockIsObject,
+  isString: mockIsString,
+  isEmpty: mockIsEmpty,
+  setLogLevel: mockSetLogLevel,
+  log: mockLog,
+} = utils;
+const { setDictionary: mockSetDictionary } = i18n;
+const {
+  toolsPrepare: mockToolsPrepare,
+  uiPrepare: mockUIPrepare,
+  uiCheckEmptiness: mockUICheckEmptiness,
+  blockManagerPrepare: mockBlockManagerPrepare,
+  pastePrepare: mockPastePrepare,
+  blockSelectionPrepare: mockBlockSelectionPrepare,
+  rectangleSelectionPrepare: mockRectangleSelectionPrepare,
+  crossBlockSelectionPrepare: mockCrossBlockSelectionPrepare,
+  readOnlyPrepare: mockReadOnlyPrepare,
+  rendererRender: mockRendererRender,
+  modificationsObserverEnable: mockModificationsObserverEnable,
+  caretSetToBlock: mockCaretSetToBlock,
+} = moduleMocks;
+
+// Import Core after mocks are configured
+import Core from '../../../src/components/core';
+
+const createReadyCore = async (config?: EditorConfig | string): Promise<Core> => {
+  const core = new Core(config);
+
+  await core.isReady;
+
+  return core;
+};
+
+describe('Core', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockDomIsElement.mockReturnValue(true);
+    mockDomGet.mockImplementation((id: string) => ({ id }) as unknown as HTMLElement);
+
+    mockIsObject.mockImplementation(
+      (value: unknown): value is Record<string, unknown> =>
+        typeof value === 'object' && value !== null && !Array.isArray(value)
+    );
+    mockIsString.mockImplementation((value: unknown): value is string => typeof value === 'string');
+    mockIsEmpty.mockImplementation((value: unknown): boolean => {
+      if (value == null) {
+        return true;
+      }
+
+      if (Array.isArray(value)) {
+        return value.length === 0;
+      }
+
+      if (typeof value === 'object') {
+        return Object.keys(value).length === 0;
+      }
+
+      return false;
+    });
+
+    mockRendererRender.mockResolvedValue(undefined);
+  });
+
+  describe('configuration', () => {
+    it('normalizes holderId and sets default values', async () => {
+      const core = await createReadyCore({ holderId: 'my-holder' });
+
+      expect(core.configuration.holder).toBe('my-holder');
+      expect(core.configuration.holderId).toBeUndefined();
+      expect(core.configuration.defaultBlock).toBe('paragraph');
+      expect(core.configuration.minHeight).toBe(300);
+      expect(core.configuration.data?.blocks).toHaveLength(1);
+      expect(core.configuration.data?.blocks?.[0]?.type).toBe('paragraph');
+      expect(core.configuration.readOnly).toBe(false);
+      expect(mockSetLogLevel).toHaveBeenCalledWith('VERBOSE');
+    });
+
+    it('retains provided data and applies i18n dictionary', async () => {
+      const config: EditorConfig = {
+        holder: 'holder',
+        defaultBlock: 'header',
+        data: {
+          blocks: [
+            {
+              id: '1',
+              type: 'quote',
+              data: { text: 'Hello' },
+            },
+          ],
+        },
+        i18n: {
+          direction: 'rtl',
+          messages: {
+            toolNames: {
+              paragraph: 'Paragraph',
+            },
+          },
+        },
+      };
+
+      const core = await createReadyCore(config);
+
+      expect(core.configuration.defaultBlock).toBe('header');
+      expect(core.configuration.data).toEqual(config.data);
+      expect(core.configuration.i18n?.direction).toBe('rtl');
+      expect(mockSetDictionary).toHaveBeenCalledWith(config.i18n?.messages);
+    });
+  });
+
+  describe('validate', () => {
+    it('throws when both holder and holderId are provided', async () => {
+      const core = await createReadyCore();
+
+      core.configuration = {
+        holder: 'element',
+        holderId: 'other',
+      } as EditorConfig;
+
+      expect(() => core.validate()).toThrow('«holderId» and «holder» param can\'t assign at the same time.');
+    });
+
+    it('throws when holder element is missing', async () => {
+      const core = await createReadyCore();
+
+      mockDomGet.mockImplementation((id: string) => {
+        if (id === 'missing') {
+          return undefined;
+        }
+
+        return { id } as unknown as HTMLElement;
+      });
+
+      core.configuration = {
+        holder: 'missing',
+      } as EditorConfig;
+
+      expect(() => core.validate()).toThrow('element with ID «missing» is missing. Pass correct holder\'s ID.');
+    });
+
+    it('throws when holder is not a DOM element', async () => {
+      const core = await createReadyCore();
+
+      mockDomIsElement.mockReturnValue(false);
+
+      core.configuration = {
+        holder: {} as unknown as HTMLElement,
+      } as EditorConfig;
+
+      expect(() => core.validate()).toThrow('«holder» value must be an Element node');
+    });
+  });
+
+  describe('modules initialization', () => {
+    it('constructs modules and provides state without self references', async () => {
+      const core = await createReadyCore();
+      const { moduleInstances } = core;
+
+      expect(moduleInstances.Tools).toBeDefined();
+      expect(moduleInstances.UI).toBeDefined();
+
+      const toolsState = moduleInstances.Tools.state as Partial<EditorModules>;
+
+      expect(toolsState.Tools).toBeUndefined();
+      expect(toolsState.UI).toBe(moduleInstances.UI);
+      expect(toolsState.BlockManager).toBe(moduleInstances.BlockManager);
+    });
+  });
+
+  describe('start', () => {
+    it('prepares all required modules', async () => {
+      await createReadyCore();
+
+      expect(mockToolsPrepare).toHaveBeenCalled();
+      expect(mockUIPrepare).toHaveBeenCalled();
+      expect(mockBlockManagerPrepare).toHaveBeenCalled();
+      expect(mockPastePrepare).toHaveBeenCalled();
+      expect(mockBlockSelectionPrepare).toHaveBeenCalled();
+      expect(mockRectangleSelectionPrepare).toHaveBeenCalled();
+      expect(mockCrossBlockSelectionPrepare).toHaveBeenCalled();
+      expect(mockReadOnlyPrepare).toHaveBeenCalled();
+    });
+
+    it('logs warning when non-critical module fails to prepare', async () => {
+      const core = await createReadyCore();
+      const nonCriticalError = new Error('skip me');
+
+      mockPastePrepare.mockImplementationOnce(() => {
+        throw nonCriticalError;
+      });
+
+      await expect(core.start()).resolves.toBeUndefined();
+      expect(mockLog).toHaveBeenCalledWith('Module Paste was skipped because of %o', 'warn', nonCriticalError);
+    });
+
+    it('rethrows when a module fails with CriticalError', async () => {
+      const core = await createReadyCore();
+
+      mockReadOnlyPrepare.mockImplementationOnce(() => {
+        throw new CriticalError('read-only failure');
+      });
+
+      await expect(core.start()).rejects.toThrow('read-only failure');
+    });
+  });
+
+  describe('render', () => {
+    it('invokes renderer with current blocks', async () => {
+      const core = await createReadyCore();
+      const render = (core as unknown as { render: () => Promise<void> }).render.bind(core);
+
+      await render();
+
+      expect(mockRendererRender).toHaveBeenLastCalledWith(core.configuration.data?.blocks);
+    });
+
+    it('throws when renderer module is missing', async () => {
+      const core = await createReadyCore();
+      const render = (core as unknown as { render: () => Promise<void> }).render.bind(core);
+
+      delete (core.moduleInstances as Partial<EditorModules>).Renderer;
+
+      expect(() => render()).toThrow('Renderer module is not initialized');
+    });
+
+    it('throws when editor data is missing', async () => {
+      const core = await createReadyCore();
+      const render = (core as unknown as { render: () => Promise<void> }).render.bind(core);
+
+      (core.configuration as EditorConfig).data = undefined;
+
+      expect(() => render()).toThrow('Editor data is not initialized');
+    });
+  });
+
+  describe('ready workflow', () => {
+    it('checks UI, enables observer and moves caret on autofocus', async () => {
+      const config: EditorConfig = {
+        holder: 'holder',
+        autofocus: true,
+        data: {
+          blocks: [
+            {
+              id: 'custom',
+              type: 'paragraph',
+              data: {},
+            },
+          ],
+        },
+      };
+
+      const core = await createReadyCore(config);
+
+      expect(mockUICheckEmptiness).toHaveBeenCalledTimes(1);
+      expect(mockModificationsObserverEnable).toHaveBeenCalledTimes(1);
+      expect(mockCaretSetToBlock).toHaveBeenCalledWith(
+        core.moduleInstances.BlockManager.blocks[0],
+        'start'
+      );
+    });
+  });
+});
+
diff --git a/test/unit/components/dom.test.ts b/test/unit/components/dom.test.ts
new file mode 100644
index 000000000..18af3451c
--- /dev/null
+++ b/test/unit/components/dom.test.ts
@@ -0,0 +1,396 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import Dom, { isCollapsedWhitespaces, calculateBaseline, toggleEmptyMark } from '../../../src/components/dom';
+
+describe('Dom helper utilities', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  afterEach(() => {
+    document.body.innerHTML = '';
+    vi.restoreAllMocks();
+  });
+
+  describe('element creation helpers', () => {
+    it('creates elements with classes and attributes via make()', () => {
+      const button = Dom.make('button', ['btn', undefined, 'primary'], {
+        type: 'button',
+        title: 'Action',
+        disabled: true,
+        'data-testid': 'make-button',
+      });
+
+      expect(button.tagName).toBe('BUTTON');
+      expect(button.className).toBe('btn primary');
+      expect(button.getAttribute('data-testid')).toBe('make-button');
+      expect((button as HTMLButtonElement).disabled).toBe(true);
+
+      const input = Dom.make('input', 'field', {
+        value: 'Hello',
+      });
+
+      expect((input as HTMLInputElement).value).toBe('Hello');
+    });
+
+    it('creates text nodes via text()', () => {
+      const node = Dom.text('EditorJS');
+
+      expect(node.nodeType).toBe(Node.TEXT_NODE);
+      expect(node.textContent).toBe('EditorJS');
+    });
+  });
+
+  describe('dom mutations', () => {
+    it('appends arrays and fragments via append()', () => {
+      const parent = document.createElement('div');
+      const first = document.createElement('span');
+      const second = document.createElement('span');
+
+      Dom.append(parent, [first, second]);
+
+      expect(parent.children[0]).toBe(first);
+      expect(parent.children[1]).toBe(second);
+    });
+
+    it('prepends arrays with preserved order via prepend()', () => {
+      const parent = document.createElement('div');
+      const initial = document.createElement('span');
+      const first = document.createElement('span');
+      const second = document.createElement('span');
+
+      parent.appendChild(initial);
+      Dom.prepend(parent, [first, second]);
+
+      expect(Array.from(parent.children)).toEqual([second, first, initial]);
+    });
+
+    it('swaps elements in place via swap()', () => {
+      const parent = document.createElement('div');
+      const first = document.createElement('span');
+      const second = document.createElement('span');
+
+      first.id = 'first';
+      second.id = 'second';
+
+      parent.append(first, second);
+
+      Dom.swap(first, second);
+
+      expect(Array.from(parent.children).map((el) => el.id)).toEqual(['second', 'first']);
+    });
+  });
+
+  describe('selectors', () => {
+    it('finds nodes via find, findAll, and get', () => {
+      const holder = document.createElement('div');
+
+      holder.id = 'holder';
+      holder.innerHTML = '<span class="item">one</span><span class="item">two</span>';
+      document.body.appendChild(holder);
+
+      const first = Dom.find(holder, '.item');
+
+      expect(first?.textContent).toBe('one');
+      expect(Dom.findAll(holder, '.item')).toHaveLength(2);
+      expect(Dom.get('holder')).toBe(holder);
+    });
+  });
+
+  describe('tag helpers', () => {
+    it('checks for single or line break tags', () => {
+      const br = document.createElement('br');
+      const div = document.createElement('div');
+
+      expect(Dom.isSingleTag(br)).toBe(true);
+      expect(Dom.isSingleTag(div)).toBe(false);
+      expect(Dom.isLineBreakTag(br)).toBe(true);
+    });
+
+    it('detects native inputs and contenteditable elements', () => {
+      const input = document.createElement('input');
+      const textarea = document.createElement('textarea');
+      const editable = document.createElement('div');
+
+      editable.contentEditable = 'true';
+      input.type = 'text';
+
+      expect(Dom.isNativeInput(input)).toBe(true);
+      expect(Dom.isNativeInput(textarea)).toBe(true);
+      expect(Dom.isContentEditable(editable)).toBe(true);
+      expect(Dom.isContentEditable(document.createElement('div'))).toBe(false);
+    });
+
+    it('determines when caret can be placed', () => {
+      const textInput = document.createElement('input');
+      const fileInput = document.createElement('input');
+      const editable = document.createElement('div');
+
+      textInput.type = 'text';
+      fileInput.type = 'file';
+      editable.contentEditable = 'true';
+
+      expect(Dom.canSetCaret(textInput)).toBe(true);
+      expect(Dom.canSetCaret(fileInput)).toBe(false);
+      expect(Dom.canSetCaret(editable)).toBe(true);
+    });
+  });
+
+  describe('inputs discovery', () => {
+    it('finds contenteditable descendants and native inputs', () => {
+      const holder = document.createElement('div');
+      const editableWithBlock = document.createElement('div');
+      const editableInlineOnly = document.createElement('div');
+      const textarea = document.createElement('textarea');
+      const input = document.createElement('input');
+      const paragraph = document.createElement('p');
+      const inlineSpan = document.createElement('span');
+
+      editableWithBlock.setAttribute('contenteditable', 'true');
+      editableInlineOnly.setAttribute('contenteditable', 'true');
+
+      paragraph.textContent = 'Block content';
+      inlineSpan.textContent = 'Inline content';
+
+      editableWithBlock.appendChild(paragraph);
+      editableInlineOnly.appendChild(inlineSpan);
+
+      input.type = 'text';
+
+      holder.append(editableWithBlock, editableInlineOnly, textarea, input);
+
+      const inputs = Dom.findAllInputs(holder);
+
+      expect(inputs).toContain(textarea);
+      expect(inputs).toContain(input);
+      expect(inputs).toContain(paragraph);
+      expect(inputs).toContain(editableInlineOnly);
+    });
+  });
+
+  describe('deepest node helpers', () => {
+    it('finds deepest nodes from start or end', () => {
+      const root = document.createElement('div');
+      const wrapper = document.createElement('div');
+      const span = document.createElement('span');
+      const text = document.createTextNode('Hello');
+      const altText = document.createTextNode('World');
+
+      span.appendChild(text);
+      wrapper.append(span);
+      wrapper.append(altText);
+      root.appendChild(wrapper);
+
+      expect(Dom.getDeepestNode(root)).toBe(text);
+      expect(Dom.getDeepestNode(root, true)).toBe(altText);
+    });
+
+    it('returns the same node for non-element containers', () => {
+      const fragment = document.createDocumentFragment();
+
+      expect(Dom.getDeepestNode(fragment)).toBe(fragment);
+      expect(Dom.getDeepestNode(null)).toBeNull();
+    });
+  });
+
+  describe('emptiness checks', () => {
+    it('checks individual nodes via isNodeEmpty()', () => {
+      const zeroWidthText = document.createTextNode('\u200B');
+      const text = document.createTextNode('text');
+      const input = document.createElement('input');
+      const ignoreText = document.createTextNode('customcustom');
+
+      input.value = 'filled';
+
+      expect(Dom.isNodeEmpty(zeroWidthText)).toBe(true);
+      expect(Dom.isNodeEmpty(text)).toBe(false);
+      expect(Dom.isNodeEmpty(input)).toBe(false);
+      expect(Dom.isNodeEmpty(ignoreText, 'custom')).toBe(true);
+    });
+
+    it('checks trees via isEmpty()', () => {
+      const wrapper = document.createElement('div');
+
+      wrapper.appendChild(document.createTextNode(' '));
+      expect(Dom.isEmpty(wrapper)).toBe(false);
+      expect(Dom.isEmpty(wrapper, ' ')).toBe(true);
+
+      wrapper.appendChild(document.createTextNode('filled'));
+      expect(Dom.isEmpty(wrapper)).toBe(false);
+    });
+
+    it('checks leaf nodes', () => {
+      const leaf = document.createElement('span');
+      const parent = document.createElement('div');
+
+      parent.appendChild(leaf);
+
+      expect(Dom.isLeaf(leaf)).toBe(true);
+      leaf.appendChild(document.createElement('b'));
+      expect(Dom.isLeaf(leaf)).toBe(false);
+    });
+  });
+
+  describe('string and content helpers', () => {
+    it('detects HTML strings', () => {
+      expect(Dom.isHTMLString('<div></div>')).toBe(true);
+      expect(Dom.isHTMLString('plain text')).toBe(false);
+    });
+
+    it('returns content lengths', () => {
+      const input = document.createElement('input');
+      const text = document.createTextNode('abc');
+      const span = document.createElement('span');
+
+      input.value = 'value';
+      span.textContent = 'longer';
+
+      expect(Dom.getContentLength(input)).toBe(5);
+      expect(Dom.getContentLength(text)).toBe(3);
+      expect(Dom.getContentLength(span)).toBe(6);
+    });
+  });
+
+  describe('block helpers', () => {
+    it('detects inline-only trees', () => {
+      const inline = document.createElement('div');
+      const block = document.createElement('div');
+
+      inline.innerHTML = '<span>text</span><b>bold</b>';
+      block.innerHTML = '<p>paragraph</p>';
+
+      expect(Dom.containsOnlyInlineElements(inline)).toBe(true);
+      expect(Dom.containsOnlyInlineElements(block)).toBe(false);
+    });
+
+    it('collects deepest block elements', () => {
+      const parent = document.createElement('div');
+      const section = document.createElement('section');
+      const article = document.createElement('article');
+      const span = document.createElement('span');
+
+      span.textContent = 'inline';
+      article.appendChild(span);
+      section.appendChild(article);
+      parent.appendChild(section);
+
+      const blocks = Dom.getDeepestBlockElements(parent);
+
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0]).toBe(article);
+    });
+  });
+
+  describe('holder and anchor helpers', () => {
+    it('resolves holders by id or element', () => {
+      const el = document.createElement('div');
+
+      el.id = 'holder-element';
+      document.body.appendChild(el);
+
+      expect(Dom.getHolder(el)).toBe(el);
+      expect(Dom.getHolder('holder-element')).toBe(el);
+      expect(() => Dom.getHolder('missing')).toThrow('Element with id "missing" not found');
+    });
+
+    it('detects anchors', () => {
+      const link = document.createElement('a');
+      const div = document.createElement('div');
+
+      expect(Dom.isAnchor(link)).toBe(true);
+      expect(Dom.isAnchor(div)).toBe(false);
+    });
+  });
+
+  describe('geometry helpers', () => {
+    it('calculates offsets relative to document', () => {
+      const element = document.createElement('div');
+
+      document.body.appendChild(element);
+      document.documentElement.scrollLeft = 35;
+      document.documentElement.scrollTop = 15;
+
+      const rect: DOMRect = {
+        x: 20,
+        y: 10,
+        width: 100,
+        height: 40,
+        top: 10,
+        left: 20,
+        right: 120,
+        bottom: 50,
+        toJSON() {
+          return {};
+        },
+      };
+
+      vi.spyOn(element, 'getBoundingClientRect').mockReturnValue(rect);
+
+      const offset = Dom.offset(element);
+
+      expect(offset).toEqual({
+        top: 25,
+        left: 55,
+        bottom: 65,
+        right: 155,
+      });
+    });
+  });
+
+  describe('text traversal helper', () => {
+    it('returns node and offset for given total offset', () => {
+      const root = document.createElement('div');
+      const text1 = document.createTextNode('Hello ');
+      const span = document.createElement('span');
+      const text2 = document.createTextNode('world');
+
+      span.appendChild(text2);
+      root.append(text1, span);
+
+      const exact = Dom.getNodeByOffset(root, 8);
+      const beyond = Dom.getNodeByOffset(root, 999);
+
+      expect(exact.node).toBe(text2);
+      expect(exact.offset).toBe(2);
+      expect(beyond.node).toBe(text2);
+      expect(beyond.offset).toBe(text2.textContent?.length ?? 0);
+    });
+  });
+
+  describe('standalone helpers', () => {
+    it('detects collapsed whitespaces', () => {
+      expect(isCollapsedWhitespaces('   ')).toBe(true);
+      expect(isCollapsedWhitespaces(' text ')).toBe(false);
+    });
+
+    it('calculates baselines using computed styles', () => {
+      const element = document.createElement('div');
+      const style = {
+        fontSize: '20px',
+        lineHeight: '30px',
+        paddingTop: '4px',
+        borderTopWidth: '1px',
+        marginTop: '2px',
+      } as CSSStyleDeclaration;
+
+      vi.spyOn(window, 'getComputedStyle').mockReturnValue(style);
+
+      const baseline = calculateBaseline(element);
+
+      // marginTop + borderTopWidth + paddingTop + (lineHeight - fontSize)/2 + fontSize * 0.8
+      expect(baseline).toBeCloseTo(28);
+    });
+
+    it('toggles empty marks based on element content', () => {
+      const element = document.createElement('div');
+
+      element.textContent = '';
+      toggleEmptyMark(element);
+      expect(element.dataset.empty).toBe('true');
+
+      element.textContent = 'filled';
+      toggleEmptyMark(element);
+      expect(element.dataset.empty).toBe('false');
+    });
+  });
+});
+
diff --git a/test/unit/components/domIterator.test.ts b/test/unit/components/domIterator.test.ts
new file mode 100644
index 000000000..d654ada22
--- /dev/null
+++ b/test/unit/components/domIterator.test.ts
@@ -0,0 +1,158 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import DomIterator from '../../../src/components/domIterator';
+
+const hoistedMocks = vi.hoisted(() => {
+  return {
+    canSetCaretMock: vi.fn(),
+    setCursorMock: vi.fn(),
+    delayMock: vi.fn(),
+  };
+});
+
+vi.mock('../../../src/components/dom', () => ({
+  ['__esModule']: true,
+  default: {
+    canSetCaret: hoistedMocks.canSetCaretMock,
+  },
+}));
+
+vi.mock('../../../src/components/selection', () => ({
+  ['__esModule']: true,
+  default: {
+    setCursor: hoistedMocks.setCursorMock,
+  },
+}));
+
+vi.mock('../../../src/components/utils', async () => {
+  const actual = await vi.importActual('../../../src/components/utils');
+
+  return {
+    ...actual,
+    delay: hoistedMocks.delayMock,
+  };
+});
+
+const createItems = (count = 3): HTMLElement[] => {
+  return Array.from({ length: count }, (_, index) => {
+    const element = document.createElement('button');
+
+    element.textContent = `Item ${index + 1}`;
+
+    return element;
+  });
+};
+
+describe('DomIterator', () => {
+  const focusedClass = 'is-focused';
+
+  beforeEach(() => {
+    hoistedMocks.delayMock.mockReset();
+    hoistedMocks.delayMock.mockImplementation((method: (...args: unknown[]) => unknown) => {
+      return (...args: unknown[]) => {
+        method(...args);
+      };
+    });
+    hoistedMocks.canSetCaretMock.mockReset();
+    hoistedMocks.canSetCaretMock.mockReturnValue(false);
+    hoistedMocks.setCursorMock.mockReset();
+  });
+
+  afterEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  it('reports no items when constructed with null list', () => {
+    const iterator = new DomIterator(null, focusedClass);
+
+    expect(iterator.hasItems()).toBe(false);
+    expect(iterator.currentItem).toBeNull();
+  });
+
+  it('updates iterable items via setItems', () => {
+    const iterator = new DomIterator([], focusedClass);
+    const items = createItems();
+
+    expect(iterator.hasItems()).toBe(false);
+
+    iterator.setItems(items);
+
+    expect(iterator.hasItems()).toBe(true);
+    expect(iterator.currentItem).toBeNull();
+  });
+
+  it('highlights the first item when moving next from initial state', () => {
+    const items = createItems();
+    const iterator = new DomIterator(items, focusedClass);
+
+    iterator.next();
+
+    expect(iterator.currentItem).toBe(items[0]);
+    expect(items[0].classList.contains(focusedClass)).toBe(true);
+    expect(hoistedMocks.canSetCaretMock).toHaveBeenCalledWith(items[0]);
+    expect(hoistedMocks.setCursorMock).not.toHaveBeenCalled();
+  });
+
+  it('moves focus forward and removes the previous focus class', () => {
+    const items = createItems();
+    const iterator = new DomIterator(items, focusedClass);
+
+    iterator.next();
+    iterator.next();
+
+    expect(iterator.currentItem).toBe(items[1]);
+    expect(items[1].classList.contains(focusedClass)).toBe(true);
+    expect(items[0].classList.contains(focusedClass)).toBe(false);
+  });
+
+  it('wraps to the last item when navigating previous from initial state', () => {
+    const items = createItems();
+    const iterator = new DomIterator(items, focusedClass);
+
+    iterator.previous();
+
+    const lastItem = items[items.length - 1];
+
+    expect(iterator.currentItem).toBe(lastItem);
+    expect(lastItem.classList.contains(focusedClass)).toBe(true);
+  });
+
+  it('drops cursor and removes focus class from the current item', () => {
+    const items = createItems();
+    const iterator = new DomIterator(items, focusedClass);
+
+    iterator.next();
+    iterator.dropCursor();
+
+    expect(iterator.currentItem).toBeNull();
+    expect(items[0].classList.contains(focusedClass)).toBe(false);
+  });
+
+  it('sets cursor to a specific index when setCursor is called with valid value', () => {
+    const items = createItems();
+    const iterator = new DomIterator(items, focusedClass);
+
+    iterator.setCursor(1);
+
+    expect(iterator.currentItem).toBe(items[1]);
+    expect(items[1].classList.contains(focusedClass)).toBe(true);
+
+    iterator.setCursor(10);
+
+    expect(iterator.currentItem).toBe(items[1]);
+    expect(items[1].classList.contains(focusedClass)).toBe(true);
+  });
+
+  it('calls SelectionUtils.setCursor via delay when caret can be set', () => {
+    const items = createItems();
+    const iterator = new DomIterator(items, focusedClass);
+
+    hoistedMocks.canSetCaretMock.mockReturnValue(true);
+
+    iterator.next();
+
+    expect(hoistedMocks.delayMock).toHaveBeenCalledWith(expect.any(Function), 50);
+    expect(hoistedMocks.setCursorMock).toHaveBeenCalledTimes(1);
+    expect(hoistedMocks.setCursorMock).toHaveBeenCalledWith(items[0]);
+  });
+});
+
diff --git a/test/unit/components/i18n/namespace-internal.test.ts b/test/unit/components/i18n/namespace-internal.test.ts
new file mode 100644
index 000000000..0226fd084
--- /dev/null
+++ b/test/unit/components/i18n/namespace-internal.test.ts
@@ -0,0 +1,87 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+type DictionaryMock = Record<string, unknown>;
+type NamespaceTree = Record<string, string | Record<string, string | Record<string, string | Record<string, string>>>>;
+
+const modulePath = '../../../../src/components/i18n/namespace-internal';
+const dictionaryPath = '../../../../src/components/i18n/locales/en/messages.json';
+
+const loadNamespaces = async (dictionary?: DictionaryMock): Promise<NamespaceTree> => {
+  vi.resetModules();
+
+  if (!dictionary) {
+    const moduleExports = await import(modulePath);
+
+    return moduleExports.I18nInternalNS as NamespaceTree;
+  }
+
+  vi.doMock(dictionaryPath, () => ({
+    default: dictionary,
+  }));
+
+  try {
+    const moduleExports = await import(modulePath);
+
+    return moduleExports.I18nInternalNS as NamespaceTree;
+  } finally {
+    vi.doUnmock(dictionaryPath);
+  }
+};
+
+describe('namespace-internal', () => {
+  afterEach(() => {
+    vi.resetModules();
+  });
+
+  it('flattens last-level sections to namespace paths', async () => {
+    const namespaces = await loadNamespaces({
+      ui: {
+        toolbar: {
+          toolbox: {
+            Add: '',
+            Remove: '',
+          },
+        },
+      },
+    });
+
+    expect(((namespaces.ui as Record<string, unknown>).toolbar as Record<string, unknown>).toolbox).toBe('ui.toolbar.toolbox');
+  });
+
+  it('retains nested objects for intermediate sections', async () => {
+    const namespaces = await loadNamespaces({
+      ui: {
+        toolbar: {
+          actions: {
+            Add: '',
+          },
+          nested: {
+            converter: {
+              'Convert to': '',
+            },
+          },
+        },
+      },
+    });
+
+    const ui = namespaces.ui as Record<string, unknown>;
+
+    expect(typeof ui.toolbar).toBe('object');
+    expect(((ui.toolbar as Record<string, unknown>).nested as Record<string, unknown>).converter).toBe('ui.toolbar.nested.converter');
+  });
+
+  it('keeps primitive values untouched when section is not an object', async () => {
+    const namespaces = await loadNamespaces({
+      plain: 'value',
+    });
+
+    expect(namespaces.plain).toBe('value');
+  });
+
+  it('generates namespaces for the default dictionary', async () => {
+    const namespaces = await loadNamespaces();
+
+    expect(((namespaces.ui as Record<string, unknown>).blockTunes as Record<string, unknown>).toggler).toBe('ui.blockTunes.toggler');
+    expect(namespaces.toolNames).toBe('toolNames');
+  });
+});
diff --git a/test/unit/components/inline-tools/inline-tool-italic.test.ts b/test/unit/components/inline-tools/inline-tool-italic.test.ts
new file mode 100644
index 000000000..6fbcc86c2
--- /dev/null
+++ b/test/unit/components/inline-tools/inline-tool-italic.test.ts
@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { IconItalic } from '@codexteam/icons';
+
+import ItalicInlineTool from '../../../../src/components/inline-tools/inline-tool-italic';
+
+type DocumentCommandKey = 'execCommand' | 'queryCommandState';
+
+const setDocumentCommand = <K extends DocumentCommandKey>(
+  key: K,
+  implementation: Document[K]
+): void => {
+  Object.defineProperty(document, key, {
+    configurable: true,
+    value: implementation,
+    writable: true,
+  });
+};
+
+describe('ItalicInlineTool', () => {
+  let tool: ItalicInlineTool;
+  let execCommandMock: ReturnType<typeof vi.fn<[], boolean>>;
+  let queryCommandStateMock: ReturnType<typeof vi.fn<[], boolean>>;
+
+  beforeEach(() => {
+    execCommandMock = vi.fn(() => true);
+    queryCommandStateMock = vi.fn(() => false);
+
+    setDocumentCommand('execCommand', execCommandMock as Document['execCommand']);
+    setDocumentCommand('queryCommandState', queryCommandStateMock as Document['queryCommandState']);
+
+    tool = new ItalicInlineTool();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('exposes inline metadata and sanitizer config', () => {
+    expect(ItalicInlineTool.isInline).toBe(true);
+    expect(ItalicInlineTool.title).toBe('Italic');
+    expect(ItalicInlineTool.sanitize).toStrictEqual({ i: {} });
+  });
+
+  it('renders an inline toolbar button with italic icon', () => {
+    const element = tool.render();
+    const button = element as HTMLButtonElement;
+    const expectedIcon = document.createElement('div');
+
+    expectedIcon.innerHTML = IconItalic;
+
+    expect(button).toBeInstanceOf(HTMLButtonElement);
+    expect(button.type).toBe('button');
+    expect(button.classList.contains('ce-inline-tool')).toBe(true);
+    expect(button.classList.contains('ce-inline-tool--italic')).toBe(true);
+    expect(button.innerHTML).toBe(expectedIcon.innerHTML);
+  });
+
+  it('executes italic command when surround is called', () => {
+    tool.surround();
+
+    expect(execCommandMock).toHaveBeenCalledWith('italic');
+  });
+
+  it('synchronizes button active state with document command state', () => {
+    const button = tool.render();
+
+    queryCommandStateMock.mockReturnValue(true);
+
+    expect(tool.checkState()).toBe(true);
+    expect(button.classList.contains('ce-inline-tool--active')).toBe(true);
+
+    queryCommandStateMock.mockReturnValue(false);
+
+    expect(tool.checkState()).toBe(false);
+    expect(button.classList.contains('ce-inline-tool--active')).toBe(false);
+  });
+
+  it('exposes CMD+I shortcut', () => {
+    expect(tool.shortcut).toBe('CMD+I');
+  });
+});
+
diff --git a/test/unit/components/modules/api/blocks.test.ts b/test/unit/components/modules/api/blocks.test.ts
new file mode 100644
index 000000000..664be1235
--- /dev/null
+++ b/test/unit/components/modules/api/blocks.test.ts
@@ -0,0 +1,801 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+import BlocksAPI from '../../../../../src/components/modules/api/blocks';
+import EventsDispatcher from '../../../../../src/components/utils/events';
+import * as utils from '../../../../../src/components/utils';
+
+import type { ModuleConfig } from '../../../../../src/types-internal/module-config';
+import type { EditorConfig, OutputBlockData, OutputData, BlockToolData } from '../../../../../types';
+import type { EditorEventMap } from '../../../../../src/components/events';
+import type { BlockTuneData } from '../../../../../types/block-tunes/block-tune-data';
+import type { EditorModules } from '../../../../../src/types-internal/editor-modules';
+
+const { blockConstructorSpy, blockAPIConstructorSpy } = vi.hoisted(() => {
+  return {
+    blockConstructorSpy: vi.fn(),
+    blockAPIConstructorSpy: vi.fn(),
+  };
+});
+
+vi.mock('../../../../../src/components/block', () => ({
+  ['__esModule']: true,
+  default: blockConstructorSpy,
+}));
+
+vi.mock('../../../../../src/components/block/api', () => ({
+  ['__esModule']: true,
+  default: blockAPIConstructorSpy,
+}));
+
+type BlockStub = {
+  id: string;
+  name: string;
+  holder: HTMLElement;
+  stretched: boolean;
+  data: BlockToolData;
+};
+
+type BlockManagerInsertOptions = {
+  id?: string;
+  tool: string;
+  data?: BlockToolData;
+  index?: number;
+  needToFocus?: boolean;
+  replace?: boolean;
+};
+
+type MockBlockConstructorOptions = {
+  tool?: { name: string };
+  data?: BlockToolData;
+};
+
+const createBlockStub = (overrides: Partial<BlockStub> = {}): BlockStub => {
+  return {
+    id: overrides.id ?? `block-${Math.random()
+      .toString(36)
+      .slice(2, 8)}`,
+    name: overrides.name ?? 'paragraph',
+    holder: overrides.holder ?? document.createElement('div'),
+    stretched: overrides.stretched ?? false,
+    data: overrides.data ?? {},
+  };
+};
+
+type BlockManagerMock = {
+  blocks: BlockStub[];
+  currentBlockIndex: number;
+  currentBlock: BlockStub | null;
+  getBlockByIndex: ReturnType<typeof vi.fn>;
+  getBlockById: ReturnType<typeof vi.fn>;
+  getBlockIndex: ReturnType<typeof vi.fn>;
+  getBlock: ReturnType<typeof vi.fn>;
+  swap: ReturnType<typeof vi.fn>;
+  move: ReturnType<typeof vi.fn>;
+  removeBlock: ReturnType<typeof vi.fn>;
+  insert: ReturnType<typeof vi.fn>;
+  insertMany: ReturnType<typeof vi.fn>;
+  composeBlock: ReturnType<typeof vi.fn>;
+  clear: ReturnType<typeof vi.fn>;
+  update: ReturnType<typeof vi.fn>;
+  convert: ReturnType<typeof vi.fn>;
+};
+
+const createBlockManagerMock = (initialBlocks: BlockStub[] = [ createBlockStub() ]): BlockManagerMock => {
+  const blockManager: BlockManagerMock = {
+    blocks: [ ...initialBlocks ],
+    currentBlockIndex: 0,
+    currentBlock: initialBlocks[0] ?? null,
+    getBlockByIndex: vi.fn((index: number) => {
+      return blockManager.blocks[index];
+    }) as ReturnType<typeof vi.fn>,
+    getBlockById: vi.fn((id: string) => {
+      return blockManager.blocks.find((block) => block.id === id);
+    }) as ReturnType<typeof vi.fn>,
+    getBlockIndex: vi.fn((block: BlockStub) => {
+      return blockManager.blocks.indexOf(block);
+    }) as ReturnType<typeof vi.fn>,
+    getBlock: vi.fn((element: HTMLElement) => {
+      return blockManager.blocks.find((block) => block.holder === element);
+    }) as ReturnType<typeof vi.fn>,
+    swap: vi.fn() as ReturnType<typeof vi.fn>,
+    move: vi.fn() as ReturnType<typeof vi.fn>,
+    removeBlock: vi.fn((block?: BlockStub) => {
+      if (!block) {
+        throw new Error('Block not found');
+      }
+
+      const index = blockManager.blocks.indexOf(block);
+
+      if (index === -1) {
+        throw new Error('Block not found');
+      }
+      blockManager.blocks.splice(index, 1);
+      blockManager.currentBlock = blockManager.blocks[blockManager.currentBlockIndex] ?? null;
+    }) as ReturnType<typeof vi.fn>,
+    insert: vi.fn((options?: BlockManagerInsertOptions) => {
+      const initialLength = blockManager.blocks.length;
+
+      const resolvedOptions: BlockManagerInsertOptions = options ?? {
+        tool: 'paragraph',
+        data: {},
+      };
+
+      const block = createBlockStub({
+        id: resolvedOptions.id,
+        name: resolvedOptions.tool,
+        data: resolvedOptions.data ?? {},
+      });
+
+      if (typeof resolvedOptions.index === 'number') {
+        if (resolvedOptions.replace) {
+          blockManager.blocks.splice(resolvedOptions.index, 1, block);
+        } else {
+          blockManager.blocks.splice(resolvedOptions.index + 1, 0, block);
+        }
+      } else {
+        blockManager.blocks.push(block);
+      }
+
+      if (initialLength > 0) {
+        blockManager.currentBlock = blockManager.blocks[blockManager.currentBlockIndex] ?? null;
+      }
+
+      return block;
+    }) as ReturnType<typeof vi.fn>,
+    insertMany: vi.fn((blocksToInsert: BlockStub[], index: number) => {
+      blockManager.blocks.splice(index, 0, ...blocksToInsert);
+      blockManager.currentBlock = blockManager.blocks[blockManager.currentBlockIndex] ?? null;
+    }) as ReturnType<typeof vi.fn>,
+    composeBlock: vi.fn(({ id, tool, data }: { id?: string; tool: string; data?: BlockToolData }) => {
+      return createBlockStub({
+        id,
+        name: tool,
+        data: data ?? {},
+      });
+    }) as ReturnType<typeof vi.fn>,
+    clear: vi.fn(async () => {
+      blockManager.blocks = [];
+      blockManager.currentBlock = null;
+    }) as ReturnType<typeof vi.fn>,
+    update: vi.fn(async (block: BlockStub, data?: Partial<BlockToolData>, _tunes?: Record<string, BlockTuneData>) => {
+      const updatedBlock: BlockStub = {
+        ...block,
+        data: {
+          ...block.data,
+          ...(data ?? {}),
+        },
+      };
+
+      const index = blockManager.blocks.indexOf(block);
+
+      if (index !== -1) {
+        blockManager.blocks.splice(index, 1, updatedBlock);
+      }
+
+      return updatedBlock;
+    }) as ReturnType<typeof vi.fn>,
+    convert: vi.fn(async (block: BlockStub, newType: string, dataOverrides?: BlockToolData) => {
+      const converted: BlockStub = {
+        ...createBlockStub({
+          id: block.id,
+          name: newType,
+          data: {
+            ...block.data,
+            ...dataOverrides,
+          },
+        }),
+        holder: block.holder,
+        stretched: block.stretched,
+      };
+
+      const index = blockManager.blocks.indexOf(block);
+
+      if (index !== -1) {
+        blockManager.blocks.splice(index, 1, converted);
+      }
+
+      return converted;
+    }) as ReturnType<typeof vi.fn>,
+  };
+
+  return blockManager;
+};
+
+type EditorStub = {
+  BlockManager: BlockManagerMock;
+  Caret: {
+    setToBlock: ReturnType<typeof vi.fn>;
+    positions: {
+      END: string;
+    };
+  };
+  Toolbar: {
+    close: ReturnType<typeof vi.fn>;
+  };
+  InlineToolbar: {
+    close: ReturnType<typeof vi.fn>;
+  };
+  ModificationsObserver: {
+    disable: ReturnType<typeof vi.fn>;
+    enable: ReturnType<typeof vi.fn>;
+  };
+  Renderer: {
+    render: ReturnType<typeof vi.fn>;
+  };
+  Paste: {
+    processText: ReturnType<typeof vi.fn>;
+  };
+  Tools: {
+    blockTools: Map<string, { conversionConfig?: { export?: () => unknown; import?: () => unknown } }>;
+  };
+  API: Record<string, unknown>;
+};
+
+const createEditorStub = (
+  blockManager: BlockManagerMock,
+  overrides: Partial<EditorStub> = {}
+): EditorStub => {
+  const base: EditorStub = {
+    BlockManager: blockManager,
+    Caret: {
+      setToBlock: vi.fn(() => true) as ReturnType<typeof vi.fn>,
+      positions: {
+        END: 'end',
+      },
+    },
+    Toolbar: {
+      close: vi.fn() as ReturnType<typeof vi.fn>,
+    },
+    InlineToolbar: {
+      close: vi.fn() as ReturnType<typeof vi.fn>,
+    },
+    ModificationsObserver: {
+      disable: vi.fn() as ReturnType<typeof vi.fn>,
+      enable: vi.fn() as ReturnType<typeof vi.fn>,
+    },
+    Renderer: {
+      render: vi.fn(async (_blocks: OutputBlockData[]) => {}) as ReturnType<typeof vi.fn>,
+    },
+    Paste: {
+      processText: vi.fn(async (_html: string, _sanitize: boolean) => {}) as ReturnType<typeof vi.fn>,
+    },
+    Tools: {
+      blockTools: new Map(),
+    },
+    API: {},
+  };
+
+  return {
+    ...base,
+    ...overrides,
+  };
+};
+
+const createBlocksApi = (options: {
+  blocks?: BlockStub[];
+  blockManager?: BlockManagerMock;
+  editorOverrides?: Partial<EditorStub>;
+  configOverrides?: Partial<EditorConfig>;
+} = {}): { blocksApi: BlocksAPI; editor: EditorStub; blockManager: BlockManagerMock } => {
+  const blockManager = options.blockManager ?? createBlockManagerMock(options.blocks);
+  const editor = createEditorStub(blockManager, options.editorOverrides);
+
+  const eventsDispatcher = new EventsDispatcher<EditorEventMap>();
+  const moduleConfig: ModuleConfig = {
+    config: {
+      defaultBlock: 'paragraph',
+      ...(options.configOverrides ?? {}),
+    } as EditorConfig,
+    eventsDispatcher,
+  };
+
+  const blocksApi = new BlocksAPI(moduleConfig);
+
+  blocksApi.state = editor as unknown as EditorModules;
+
+  return {
+    blocksApi,
+    editor,
+    blockManager,
+  };
+};
+
+describe('BlocksAPI', () => {
+  beforeEach(() => {
+    blockConstructorSpy.mockReset();
+    blockConstructorSpy.mockImplementation((options: MockBlockConstructorOptions = {}) => {
+      if (!options?.tool) {
+        throw new Error('Tool is required');
+      }
+
+      return {
+        data: options.data ?? {
+          mock: true,
+        },
+      };
+    });
+
+    blockAPIConstructorSpy.mockReset();
+    blockAPIConstructorSpy.mockImplementation((block: unknown) => {
+      return { wrappedBlock: block };
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('basic getters', () => {
+    it('returns amount of blocks via getBlocksCount()', () => {
+      const initialBlocks = [createBlockStub(), createBlockStub()];
+      const { blocksApi } = createBlocksApi({ blocks: initialBlocks });
+
+      expect(blocksApi.getBlocksCount()).toBe(initialBlocks.length);
+    });
+
+    it('returns current block index via getCurrentBlockIndex()', () => {
+      const { blocksApi, blockManager } = createBlocksApi();
+
+      blockManager.currentBlockIndex = 2;
+
+      expect(blocksApi.getCurrentBlockIndex()).toBe(2);
+    });
+  });
+
+  describe('block lookup helpers', () => {
+    it('returns block index when block exists', () => {
+      const block = createBlockStub({ id: 'target' });
+      const { blocksApi } = createBlocksApi({ blocks: [ block ] });
+
+      expect(blocksApi.getBlockIndex('target')).toBe(0);
+    });
+
+    it('logs warning when block index requested for missing id', () => {
+      const { blocksApi } = createBlocksApi({ blocks: [] });
+      const logSpy = vi.spyOn(utils, 'logLabeled').mockImplementation(() => {});
+
+      expect(blocksApi.getBlockIndex('missing')).toBeUndefined();
+      expect(logSpy).toHaveBeenCalledWith('There is no block with id `missing`', 'warn');
+
+      logSpy.mockRestore();
+    });
+
+    it('wraps block by index into BlockAPI instance', () => {
+      const block = createBlockStub({ id: 'b-1' });
+      const { blocksApi, blockManager } = createBlocksApi({ blocks: [ block ] });
+
+      const result = blocksApi.getBlockByIndex(0);
+
+      expect(blockManager.getBlockByIndex).toHaveBeenCalledWith(0);
+      expect(blockAPIConstructorSpy).toHaveBeenCalledWith(block);
+      expect(result).toEqual({ wrappedBlock: block });
+    });
+
+    it('logs warning when requesting block by missing index', () => {
+      const { blocksApi, blockManager } = createBlocksApi({ blocks: [] });
+      const logSpy = vi.spyOn(utils, 'logLabeled').mockImplementation(() => {});
+
+      blockManager.getBlockByIndex.mockReturnValueOnce(undefined);
+
+      expect(blocksApi.getBlockByIndex(0)).toBeUndefined();
+      expect(logSpy).toHaveBeenCalledWith('There is no block at index `0`', 'warn');
+
+      logSpy.mockRestore();
+    });
+
+    it('wraps block by id into BlockAPI instance', () => {
+      const block = createBlockStub({ id: 'block-id' });
+      const { blocksApi, blockManager } = createBlocksApi({ blocks: [ block ] });
+
+      const result = blocksApi.getById('block-id');
+
+      expect(blockManager.getBlockById).toHaveBeenCalledWith('block-id');
+      expect(blockAPIConstructorSpy).toHaveBeenCalledWith(block);
+      expect(result).toEqual({ wrappedBlock: block });
+    });
+
+    it('returns null when block by id is missing', () => {
+      const { blocksApi, blockManager } = createBlocksApi({ blocks: [] });
+      const logSpy = vi.spyOn(utils, 'logLabeled').mockImplementation(() => {});
+
+      blockManager.getBlockById.mockReturnValueOnce(undefined);
+
+      expect(blocksApi.getById('missing-id')).toBeNull();
+      expect(logSpy).toHaveBeenCalledWith('There is no block with id `missing-id`', 'warn');
+
+      logSpy.mockRestore();
+    });
+
+    it('wraps block by element into BlockAPI instance', () => {
+      const block = createBlockStub();
+      const { blocksApi, blockManager } = createBlocksApi({ blocks: [ block ] });
+
+      blockManager.getBlock.mockReturnValueOnce(block);
+
+      const result = blocksApi.getBlockByElement(block.holder);
+
+      expect(blockManager.getBlock).toHaveBeenCalledWith(block.holder);
+      expect(blockAPIConstructorSpy).toHaveBeenCalledWith(block);
+      expect(result).toEqual({ wrappedBlock: block });
+    });
+
+    it('logs warning when block is not found for element', () => {
+      const { blocksApi, blockManager } = createBlocksApi({ blocks: [] });
+      const logSpy = vi.spyOn(utils, 'logLabeled').mockImplementation(() => {});
+      const element = document.createElement('div');
+
+      blockManager.getBlock.mockReturnValueOnce(undefined);
+
+      expect(blocksApi.getBlockByElement(element)).toBeUndefined();
+      expect(logSpy).toHaveBeenCalledWith(
+        'There is no block corresponding to element `' + element + '`',
+        'warn'
+      );
+
+      logSpy.mockRestore();
+    });
+  });
+
+  describe('block ordering', () => {
+    it('delegates swap to BlockManager and logs deprecation notice', () => {
+      const { blocksApi, blockManager } = createBlocksApi();
+      const logSpy = vi.spyOn(utils, 'log').mockImplementation(() => {});
+
+      blocksApi.swap(1, 2);
+
+      expect(blockManager.swap).toHaveBeenCalledWith(1, 2);
+      expect(logSpy).toHaveBeenCalledWith(
+        '`blocks.swap()` method is deprecated and will be removed in the next major release. ' +
+        'Use `block.move()` method instead',
+        'info'
+      );
+
+      logSpy.mockRestore();
+    });
+
+    it('delegates move to BlockManager', () => {
+      const { blocksApi, blockManager } = createBlocksApi();
+
+      blocksApi.move(4, 1);
+
+      expect(blockManager.move).toHaveBeenCalledWith(4, 1);
+    });
+  });
+
+  describe('block deletion', () => {
+    it('removes block and re-focuses current block', () => {
+      const blocks = [createBlockStub({ id: 'a' }), createBlockStub({ id: 'b' })];
+      const { blocksApi, blockManager, editor } = createBlocksApi({ blocks });
+
+      blockManager.currentBlockIndex = 0;
+
+      blocksApi.delete(0);
+
+      expect(blockManager.getBlockByIndex).toHaveBeenCalledWith(0);
+      expect(blockManager.removeBlock).toHaveBeenCalledWith(expect.objectContaining({ id: 'a' }));
+      expect(editor.Caret.setToBlock).toHaveBeenCalledWith(
+        blockManager.currentBlock,
+        editor.Caret.positions.END
+      );
+      expect(editor.Toolbar.close).toHaveBeenCalled();
+    });
+
+    it('inserts default block when last block is removed', () => {
+      const block = createBlockStub({ id: 'only' });
+      const { blocksApi, blockManager, editor } = createBlocksApi({ blocks: [ block ] });
+
+      blockManager.removeBlock.mockImplementationOnce(() => {
+        blockManager.blocks = [];
+        blockManager.currentBlock = null;
+      });
+
+      blocksApi.delete(0);
+
+      expect(blockManager.insert).toHaveBeenCalledTimes(1);
+      expect(editor.Caret.setToBlock).not.toHaveBeenCalled();
+      expect(editor.Toolbar.close).toHaveBeenCalled();
+    });
+
+    it('logs warning when block removal throws', () => {
+      const block = createBlockStub({ id: 'faulty' });
+      const { blocksApi, blockManager, editor } = createBlocksApi({ blocks: [ block ] });
+      const error = new Error('remove failed');
+      const logSpy = vi.spyOn(utils, 'logLabeled').mockImplementation(() => {});
+
+      blockManager.removeBlock.mockImplementationOnce(() => {
+        throw error;
+      });
+
+      blocksApi.delete(0);
+
+      expect(logSpy).toHaveBeenCalledWith(error, 'warn');
+      expect(blockManager.insert).not.toHaveBeenCalled();
+      expect(editor.Toolbar.close).not.toHaveBeenCalled();
+
+      logSpy.mockRestore();
+    });
+  });
+
+  describe('clearing and rendering', () => {
+    it('clears editor via BlockManager and closes inline toolbar', async () => {
+      const { blocksApi, blockManager, editor } = createBlocksApi();
+
+      await blocksApi.clear();
+
+      expect(blockManager.clear).toHaveBeenCalledWith(true);
+      expect(editor.InlineToolbar.close).toHaveBeenCalled();
+    });
+
+    it('renders new data via renderer', async () => {
+      const { blocksApi, blockManager, editor } = createBlocksApi();
+      const data: OutputData = {
+        blocks: [
+          {
+            id: 'id-1',
+            type: 'paragraph',
+            data: { text: 'text' },
+          },
+        ],
+      };
+
+      await blocksApi.render(data);
+
+      expect(editor.ModificationsObserver.disable).toHaveBeenCalled();
+      expect(blockManager.clear).toHaveBeenCalledWith();
+      expect(editor.Renderer.render).toHaveBeenCalledWith(data.blocks);
+      expect(editor.ModificationsObserver.enable).toHaveBeenCalled();
+
+      const disableOrder = editor.ModificationsObserver.disable.mock.invocationCallOrder[0];
+      const clearOrder = blockManager.clear.mock.invocationCallOrder[0];
+      const renderOrder = editor.Renderer.render.mock.invocationCallOrder[0];
+      const enableOrder = editor.ModificationsObserver.enable.mock.invocationCallOrder[0];
+
+      expect(disableOrder).toBeLessThan(clearOrder);
+      expect(clearOrder).toBeLessThan(renderOrder);
+      expect(renderOrder).toBeLessThan(enableOrder);
+    });
+
+    it('throws when render data is malformed', async () => {
+      const { blocksApi } = createBlocksApi();
+
+      await expect(blocksApi.render({} as OutputData)).rejects.toThrow('Incorrect data passed to the render() method');
+    });
+
+    it('renders from HTML string', async () => {
+      const { blocksApi, blockManager, editor } = createBlocksApi();
+
+      await blocksApi.renderFromHTML('<p>Hello</p>');
+
+      expect(blockManager.clear).toHaveBeenCalledWith();
+      expect(editor.Paste.processText).toHaveBeenCalledWith('<p>Hello</p>', true);
+    });
+  });
+
+  describe('block stretching', () => {
+    it('sets stretched state on block', () => {
+      const block = createBlockStub({ stretched: false });
+      const { blocksApi, blockManager } = createBlocksApi({ blocks: [ block ] });
+      const assertSpy = vi.spyOn(utils, 'deprecationAssert').mockImplementation(() => {});
+
+      blocksApi.stretchBlock(0, true);
+
+      expect(assertSpy).toHaveBeenCalledWith(
+        true,
+        'blocks.stretchBlock()',
+        'BlockAPI'
+      );
+      expect(blockManager.getBlockByIndex).toHaveBeenCalledWith(0);
+      expect(block.stretched).toBe(true);
+
+      assertSpy.mockRestore();
+    });
+
+    it('does nothing when block for stretch is missing', () => {
+      const { blocksApi, blockManager } = createBlocksApi({ blocks: [] });
+      const assertSpy = vi.spyOn(utils, 'deprecationAssert').mockImplementation(() => {});
+
+      blockManager.getBlockByIndex.mockReturnValueOnce(undefined);
+
+      blocksApi.stretchBlock(0, false);
+
+      expect(assertSpy).toHaveBeenCalled();
+      expect(blockManager.getBlockByIndex).toHaveBeenCalledWith(0);
+
+      assertSpy.mockRestore();
+    });
+  });
+
+  describe('block insertion APIs', () => {
+    it('inserts a new block and wraps it with BlockAPI', () => {
+      const { blocksApi, blockManager } = createBlocksApi();
+      const data: BlockToolData = { text: 'inserted' };
+
+      const result = blocksApi.insert('paragraph', data, {}, 0, true, false, 'custom');
+
+      expect(blockManager.insert).toHaveBeenCalledWith({
+        id: 'custom',
+        tool: 'paragraph',
+        data,
+        index: 0,
+        needToFocus: true,
+        replace: false,
+      });
+      expect(blockAPIConstructorSpy).toHaveBeenCalled();
+      expect(result).toEqual({ wrappedBlock: expect.objectContaining({ id: 'custom' }) });
+    });
+
+    it('uses default block type when insert arguments are omitted', () => {
+      const { blocksApi, blockManager } = createBlocksApi({
+        configOverrides: { defaultBlock: 'header' },
+      });
+
+      blocksApi.insert();
+
+      expect(blockManager.insert).toHaveBeenCalledWith(expect.objectContaining({
+        tool: 'header',
+      }));
+    });
+
+    it('logs deprecation when insertNewBlock is called', () => {
+      const { blocksApi, blockManager } = createBlocksApi();
+      const logSpy = vi.spyOn(utils, 'log').mockImplementation(() => {});
+
+      blocksApi.insertNewBlock();
+
+      expect(logSpy).toHaveBeenCalledWith(
+        'Method blocks.insertNewBlock() is deprecated and it will be removed in the next major release. ' +
+        'Use blocks.insert() instead.',
+        'warn'
+      );
+      expect(blockManager.insert).toHaveBeenCalled();
+
+      logSpy.mockRestore();
+    });
+
+    it('composes block data through Block constructor', async () => {
+      const toolName = 'custom-tool';
+      const tool = { name: toolName };
+      const { blocksApi, editor } = createBlocksApi();
+
+      editor.Tools.blockTools.set(toolName, tool as { conversionConfig?: { export?: () => unknown; import?: () => unknown } });
+      blockConstructorSpy.mockImplementationOnce((options: MockBlockConstructorOptions & { tool: { name: string } }) => {
+        return {
+          data: {
+            createdFrom: options.tool.name,
+          },
+        };
+      });
+
+      const data = await blocksApi.composeBlockData(toolName);
+
+      expect(blockConstructorSpy).toHaveBeenCalledWith(expect.objectContaining({
+        tool,
+        readOnly: true,
+        data: {},
+        tunesData: {},
+      }));
+      expect(data).toEqual({ createdFrom: toolName });
+    });
+
+    it('throws when composeBlockData received unknown tool', async () => {
+      const { blocksApi } = createBlocksApi();
+
+      await expect(blocksApi.composeBlockData('unknown')).rejects.toThrow();
+    });
+
+    it('inserts multiple blocks via insertMany', () => {
+      const { blocksApi, blockManager } = createBlocksApi();
+      const blocksToInsert: OutputBlockData[] = [
+        { id: '1',
+          type: 'paragraph',
+          data: { text: 'one' } },
+        { id: '2',
+          type: 'header',
+          data: { text: 'two' } },
+      ];
+
+      const result = blocksApi.methods.insertMany(blocksToInsert, 0);
+
+      expect(blockManager.composeBlock).toHaveBeenCalledTimes(2);
+      expect(blockManager.insertMany).toHaveBeenCalledWith(
+        expect.arrayContaining([ expect.objectContaining({ id: '1' }) ]),
+        0
+      );
+      expect(result).toHaveLength(2);
+      expect(result[0]).toHaveProperty('wrappedBlock');
+    });
+
+    it('validates insertMany index type', () => {
+      const { blocksApi } = createBlocksApi();
+
+      expect(() => {
+        blocksApi.methods.insertMany([], 'invalid' as unknown as number);
+      }).toThrow('Index should be a number');
+    });
+
+    it('validates insertMany index bounds', () => {
+      const { blocksApi } = createBlocksApi();
+
+      expect(() => {
+        blocksApi.methods.insertMany([], -1);
+      }).toThrow('Index should be greater than or equal to 0');
+    });
+  });
+
+  describe('block updates and conversion', () => {
+    it('updates block data via BlockManager', async () => {
+      const block = createBlockStub({ id: 'to-update' });
+      const { blocksApi, blockManager } = createBlocksApi({ blocks: [ block ] });
+      const newData: Partial<BlockToolData> = { text: 'updated' };
+
+      blockManager.update.mockImplementationOnce(async (current, data?: Partial<BlockToolData>, _tunes?: Record<string, BlockTuneData>) => {
+        return {
+          ...current,
+          data: {
+            ...current.data,
+            ...data,
+          },
+        };
+      });
+
+      const result = await blocksApi.update('to-update', newData);
+
+      expect(blockManager.getBlockById).toHaveBeenCalledWith('to-update');
+      expect(blockManager.update).toHaveBeenCalledWith(block, newData, undefined);
+      expect(blockAPIConstructorSpy).toHaveBeenCalled();
+      expect(result).toEqual({ wrappedBlock: expect.objectContaining({ id: 'to-update' }) });
+    });
+
+    it('throws when updating block that does not exist', async () => {
+      const { blocksApi, blockManager } = createBlocksApi({ blocks: [] });
+
+      blockManager.getBlockById.mockReturnValueOnce(undefined);
+
+      await expect(blocksApi.update('missing', {})).rejects.toThrow('Block with id "missing" not found');
+    });
+
+    it('converts block to another type when conversion config exists', async () => {
+      const block = createBlockStub({ id: 'convertible',
+        name: 'paragraph' });
+      const { blocksApi, blockManager, editor } = createBlocksApi({ blocks: [ block ] });
+      const originalTool = { conversionConfig: { export: () => ({}) } };
+      const targetTool = { conversionConfig: { import: () => ({}) } };
+
+      editor.Tools.blockTools.set('paragraph', originalTool);
+      editor.Tools.blockTools.set('header', targetTool);
+
+      const result = await blocksApi.methods.convert('convertible', 'header');
+
+      expect(blockManager.convert).toHaveBeenCalledWith(
+        block,
+        'header',
+        undefined
+      );
+      expect(blockAPIConstructorSpy).toHaveBeenCalled();
+      expect(result).toEqual({ wrappedBlock: expect.objectContaining({ name: 'header' }) });
+    });
+
+    it('throws when conversion target tool lacks conversionConfig', async () => {
+      const block = createBlockStub({ id: 'convertible',
+        name: 'paragraph' });
+      const { blocksApi, editor } = createBlocksApi({ blocks: [ block ] });
+      const originalTool = { conversionConfig: { export: () => ({}) } };
+      const targetTool = {};
+
+      editor.Tools.blockTools.set('paragraph', originalTool);
+      editor.Tools.blockTools.set('header', targetTool);
+
+      await expect(blocksApi.methods.convert('convertible', 'header')).rejects.toThrow(
+        'Conversion from "paragraph" to "header" is not possible. Header tool(s) should provide a "conversionConfig"'
+      );
+    });
+
+    it('throws when block to convert does not exist', async () => {
+      const { blocksApi } = createBlocksApi({ blocks: [] });
+
+      await expect(blocksApi.methods.convert('missing', 'header')).rejects.toThrow('Block with id "missing" not found');
+    });
+  });
+});
+
+
diff --git a/test/unit/components/modules/api/i18n.test.ts b/test/unit/components/modules/api/i18n.test.ts
new file mode 100644
index 000000000..6ab4bfda7
--- /dev/null
+++ b/test/unit/components/modules/api/i18n.test.ts
@@ -0,0 +1,95 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+import I18nAPI from '../../../../../src/components/modules/api/i18n';
+import EventsDispatcher from '../../../../../src/components/utils/events';
+
+import type { ModuleConfig } from '../../../../../src/types-internal/module-config';
+import type { EditorConfig } from '../../../../../types';
+import type { EditorEventMap } from '../../../../../src/components/events';
+
+type EsModuleKey = '__esModule';
+type EsModule<T extends object> = T & { [K in EsModuleKey]: true };
+type WithEsModuleFlag = <T extends object>(moduleMock: T) => EsModule<T>;
+
+/**
+ *
+ * @param moduleMock - The module object to add the ES module flag to
+ */
+const withEsModuleFlag: WithEsModuleFlag = vi.hoisted(() => {
+  return (<T extends object>(moduleMock: T): EsModule<T> => {
+    return Object.defineProperty(moduleMock, '__esModule', {
+      configurable: true,
+      enumerable: true,
+      value: true,
+    }) as EsModule<T>;
+  });
+});
+
+const { logLabeledMock, translateMock } = vi.hoisted(() => {
+  return {
+    logLabeledMock: vi.fn(),
+    translateMock: vi.fn(),
+  };
+});
+
+vi.mock('../../../../../src/components/utils', () =>
+  withEsModuleFlag({
+    logLabeled: logLabeledMock,
+  })
+);
+
+vi.mock('../../../../../src/components/i18n', () =>
+  withEsModuleFlag({
+    default: {
+      t: translateMock,
+    },
+  })
+);
+
+const createI18nApi = (): I18nAPI => {
+  const eventsDispatcher = new EventsDispatcher<EditorEventMap>();
+  const moduleConfig: ModuleConfig = {
+    config: {} as EditorConfig,
+    eventsDispatcher,
+  };
+
+  return new I18nAPI(moduleConfig);
+};
+
+describe('I18nAPI', () => {
+  beforeEach(() => {
+    logLabeledMock.mockReset();
+    translateMock.mockReset();
+  });
+
+  it('warns and returns an empty string when calling global t()', () => {
+    const api = createI18nApi();
+
+    const result = api.methods.t('global');
+
+    expect(result).toBe('');
+    expect(logLabeledMock).toHaveBeenCalledWith(
+      'I18n.t() method can be accessed only from Tools',
+      'warn'
+    );
+  });
+
+  it('translates using tools namespace for regular tool', () => {
+    const api = createI18nApi();
+    const methods = api.getMethodsForTool('paragraph', false);
+
+    methods.t('label');
+
+    expect(translateMock).toHaveBeenCalledWith('tools.paragraph', 'label');
+  });
+
+  it('translates using blockTunes namespace for block tune', () => {
+    const api = createI18nApi();
+    const methods = api.getMethodsForTool('settings', true);
+
+    methods.t('title');
+
+    expect(translateMock).toHaveBeenCalledWith('blockTunes.settings', 'title');
+  });
+});
+
diff --git a/test/unit/components/modules/api/saver.test.ts b/test/unit/components/modules/api/saver.test.ts
new file mode 100644
index 000000000..ec88da2d8
--- /dev/null
+++ b/test/unit/components/modules/api/saver.test.ts
@@ -0,0 +1,135 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import SaverAPI from '../../../../../src/components/modules/api/saver';
+import EventsDispatcher from '../../../../../src/components/utils/events';
+import * as utils from '../../../../../src/components/utils';
+
+import type { ModuleConfig } from '../../../../../src/types-internal/module-config';
+import type { EditorConfig, OutputData } from '../../../../../types';
+import type { EditorEventMap } from '../../../../../src/components/events';
+import type { EditorModules } from '../../../../../src/types-internal/editor-modules';
+
+const READ_ONLY_ERROR_TEXT = 'Editor\'s content can not be saved in read-only mode';
+const SAVE_FALLBACK_ERROR_TEXT = 'Editor\'s content can not be saved because collecting data failed';
+
+type SaverSaveMock = ReturnType<typeof vi.fn<[], Promise<OutputData | undefined>>>;
+type SaverLastErrorMock = ReturnType<typeof vi.fn<[], unknown>>;
+
+type EditorStub = {
+  ReadOnly: { isEnabled: boolean };
+  Saver: {
+    save: SaverSaveMock;
+    getLastSaveError?: SaverLastErrorMock;
+  };
+};
+
+type EditorStubOverrides = {
+  ReadOnly?: Partial<EditorStub['ReadOnly']>;
+  Saver?: Partial<EditorStub['Saver']>;
+};
+
+const createSaverApi = (overrides: EditorStubOverrides = {}): { saverApi: SaverAPI; editor: EditorStub } => {
+  const moduleConfig: ModuleConfig = {
+    config: {} as EditorConfig,
+    eventsDispatcher: new EventsDispatcher<EditorEventMap>(),
+  };
+
+  const saverApi = new SaverAPI(moduleConfig);
+
+  const editor: EditorStub = {
+    ReadOnly: {
+      isEnabled: false,
+    },
+    Saver: {
+      save: vi.fn<[], Promise<OutputData | undefined>>().mockResolvedValue({ blocks: [] }),
+      getLastSaveError: vi.fn(),
+    },
+  };
+
+  if (overrides.ReadOnly) {
+    Object.assign(editor.ReadOnly, overrides.ReadOnly);
+  }
+
+  if (overrides.Saver) {
+    Object.assign(editor.Saver, overrides.Saver);
+  }
+
+  saverApi.state = editor as unknown as EditorModules;
+
+  return { saverApi,
+    editor };
+};
+
+describe('SaverAPI', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('exposes a save method that proxies to the class method', async () => {
+    const { saverApi } = createSaverApi();
+    const saveSpy = vi.spyOn(saverApi, 'save').mockResolvedValue({ blocks: [] });
+
+    await saverApi.methods.save();
+
+    expect(saveSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('throws and logs when editor is in read-only mode', async () => {
+    const logSpy = vi.spyOn(utils, 'logLabeled').mockImplementation(() => undefined);
+    const { saverApi, editor } = createSaverApi({
+      ReadOnly: { isEnabled: true },
+    });
+
+    await expect(saverApi.save()).rejects.toThrow(READ_ONLY_ERROR_TEXT);
+    expect(editor.Saver.save).not.toHaveBeenCalled();
+    expect(logSpy).toHaveBeenCalledWith(READ_ONLY_ERROR_TEXT, 'warn');
+  });
+
+  it('returns saved data when saver succeeds', async () => {
+    const output: OutputData = {
+      blocks: [
+        {
+          id: 'paragraph-1',
+          type: 'paragraph',
+          data: { text: 'Hello' },
+        },
+      ],
+    };
+    const { saverApi, editor } = createSaverApi();
+
+    editor.Saver.save.mockResolvedValueOnce(output);
+
+    await expect(saverApi.save()).resolves.toEqual(output);
+    expect(editor.Saver.save).toHaveBeenCalledTimes(1);
+  });
+
+  it('rethrows the last saver error when it is an Error instance', async () => {
+    const lastError = new Error('save crashed');
+    const { saverApi, editor } = createSaverApi();
+
+    editor.Saver.save.mockResolvedValueOnce(undefined);
+    editor.Saver.getLastSaveError = vi.fn().mockReturnValue(lastError);
+
+    await expect(saverApi.save()).rejects.toBe(lastError);
+  });
+
+  it('converts non-error last error values to strings', async () => {
+    const { saverApi, editor } = createSaverApi();
+
+    editor.Saver.save.mockResolvedValueOnce(undefined);
+    editor.Saver.getLastSaveError = vi.fn().mockReturnValue(404);
+
+    await expect(saverApi.save()).rejects.toThrow('404');
+  });
+
+  it('throws a fallback error when saver returns undefined without details', async () => {
+    const { saverApi, editor } = createSaverApi();
+
+    editor.Saver.save.mockResolvedValueOnce(undefined);
+    editor.Saver.getLastSaveError = undefined;
+
+    await expect(saverApi.save()).rejects.toThrow(SAVE_FALLBACK_ERROR_TEXT);
+  });
+});
+
+
diff --git a/test/unit/components/modules/api/toolbar.test.ts b/test/unit/components/modules/api/toolbar.test.ts
new file mode 100644
index 000000000..eb7aea09f
--- /dev/null
+++ b/test/unit/components/modules/api/toolbar.test.ts
@@ -0,0 +1,186 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import ToolbarAPI from '../../../../../src/components/modules/api/toolbar';
+import EventsDispatcher from '../../../../../src/components/utils/events';
+import * as utils from '../../../../../src/components/utils';
+import type { ModuleConfig } from '../../../../../src/types-internal/module-config';
+import type { EditorModules } from '../../../../../src/types-internal/editor-modules';
+import type { EditorConfig } from '../../../../../types';
+import type { EditorEventMap } from '../../../../../src/components/events';
+
+type ToolbarEditorMock = {
+  BlockManager: {
+    currentBlockIndex: number;
+  };
+  BlockSettings: {
+    opened: boolean;
+    open: ReturnType<typeof vi.fn>;
+    close: ReturnType<typeof vi.fn>;
+  };
+  Toolbar: {
+    moveAndOpen: ReturnType<typeof vi.fn>;
+    close: ReturnType<typeof vi.fn>;
+    toolbox: {
+      opened: boolean;
+      open: ReturnType<typeof vi.fn>;
+      close: ReturnType<typeof vi.fn>;
+    };
+  };
+};
+
+describe('ToolbarAPI', () => {
+  let toolbarApi: ToolbarAPI;
+  let editorMock: ToolbarEditorMock;
+
+  const createToolbarApi = (overrides?: Partial<ToolbarEditorMock>): void => {
+    const eventsDispatcher = new EventsDispatcher<EditorEventMap>();
+    const moduleConfig: ModuleConfig = {
+      config: {} as EditorConfig,
+      eventsDispatcher,
+    };
+
+    toolbarApi = new ToolbarAPI(moduleConfig);
+    editorMock = {
+      BlockManager: {
+        currentBlockIndex: 0,
+      },
+      BlockSettings: {
+        opened: false,
+        open: vi.fn(),
+        close: vi.fn(),
+      },
+      Toolbar: {
+        moveAndOpen: vi.fn(),
+        close: vi.fn(),
+        toolbox: {
+          opened: false,
+          open: vi.fn(),
+          close: vi.fn(),
+        },
+      },
+      ...overrides,
+    };
+
+    toolbarApi.state = editorMock as unknown as EditorModules;
+  };
+
+  beforeEach(() => {
+    createToolbarApi();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('opens the toolbar via Editor module', () => {
+    toolbarApi.open();
+
+    expect(editorMock.Toolbar.moveAndOpen).toHaveBeenCalledTimes(1);
+  });
+
+  it('closes the toolbar via Editor module', () => {
+    toolbarApi.close();
+
+    expect(editorMock.Toolbar.close).toHaveBeenCalledTimes(1);
+  });
+
+  it('opens block settings when toggleBlockSettings decides to open', () => {
+    toolbarApi.toggleBlockSettings(undefined as unknown as boolean);
+
+    expect(editorMock.Toolbar.moveAndOpen).toHaveBeenCalledTimes(1);
+    expect(editorMock.BlockSettings.open).toHaveBeenCalledTimes(1);
+    expect(editorMock.BlockSettings.close).not.toHaveBeenCalled();
+  });
+
+  it('closes block settings when toggleBlockSettings decides to close', () => {
+    editorMock.BlockSettings.opened = true;
+
+    toolbarApi.toggleBlockSettings(undefined as unknown as boolean);
+
+    expect(editorMock.BlockSettings.close).toHaveBeenCalledTimes(1);
+    expect(editorMock.Toolbar.moveAndOpen).not.toHaveBeenCalled();
+    expect(editorMock.BlockSettings.open).not.toHaveBeenCalled();
+  });
+
+  it('forces opening block settings when openingState is true', () => {
+    editorMock.BlockSettings.opened = true;
+
+    toolbarApi.toggleBlockSettings(true);
+
+    expect(editorMock.Toolbar.moveAndOpen).toHaveBeenCalledTimes(1);
+    expect(editorMock.BlockSettings.open).toHaveBeenCalledTimes(1);
+    expect(editorMock.BlockSettings.close).not.toHaveBeenCalled();
+  });
+
+  it('forces closing block settings when openingState is false', () => {
+    toolbarApi.toggleBlockSettings(false);
+
+    expect(editorMock.BlockSettings.close).toHaveBeenCalledTimes(1);
+    expect(editorMock.Toolbar.moveAndOpen).not.toHaveBeenCalled();
+    expect(editorMock.BlockSettings.open).not.toHaveBeenCalled();
+  });
+
+  it('logs a warning when no block is selected for toggleBlockSettings', () => {
+    const logSpy = vi.spyOn(utils, 'logLabeled').mockImplementation(() => {});
+
+    editorMock.BlockManager.currentBlockIndex = -1;
+
+    toolbarApi.toggleBlockSettings(true);
+
+    expect(logSpy).toHaveBeenCalledWith(
+      'Could\'t toggle the Toolbar because there is no block selected ',
+      'warn'
+    );
+    expect(editorMock.Toolbar.moveAndOpen).not.toHaveBeenCalled();
+    expect(editorMock.BlockSettings.open).not.toHaveBeenCalled();
+    expect(editorMock.BlockSettings.close).not.toHaveBeenCalled();
+  });
+
+  it('opens toolbox when toggleToolbox receives opening state', () => {
+    toolbarApi.toggleToolbox(true);
+
+    expect(editorMock.Toolbar.moveAndOpen).toHaveBeenCalledTimes(1);
+    expect(editorMock.Toolbar.toolbox.open).toHaveBeenCalledTimes(1);
+    expect(editorMock.Toolbar.toolbox.close).not.toHaveBeenCalled();
+  });
+
+  it('closes toolbox when toggleToolbox receives closing state', () => {
+    toolbarApi.toggleToolbox(false);
+
+    expect(editorMock.Toolbar.toolbox.close).toHaveBeenCalledTimes(1);
+    expect(editorMock.Toolbar.moveAndOpen).not.toHaveBeenCalled();
+    expect(editorMock.Toolbar.toolbox.open).not.toHaveBeenCalled();
+  });
+
+  it('toggles toolbox when opening state is omitted', () => {
+    toolbarApi.toggleToolbox(undefined as unknown as boolean);
+
+    expect(editorMock.Toolbar.moveAndOpen).toHaveBeenCalledTimes(1);
+    expect(editorMock.Toolbar.toolbox.open).toHaveBeenCalledTimes(1);
+
+    vi.clearAllMocks();
+    editorMock.Toolbar.toolbox.opened = true;
+
+    toolbarApi.toggleToolbox(undefined as unknown as boolean);
+
+    expect(editorMock.Toolbar.toolbox.close).toHaveBeenCalledTimes(1);
+    expect(editorMock.Toolbar.moveAndOpen).not.toHaveBeenCalled();
+    expect(editorMock.Toolbar.toolbox.open).not.toHaveBeenCalled();
+  });
+
+  it('logs a warning when no block is selected for toggleToolbox', () => {
+    const logSpy = vi.spyOn(utils, 'logLabeled').mockImplementation(() => {});
+
+    editorMock.BlockManager.currentBlockIndex = -1;
+
+    toolbarApi.toggleToolbox(true);
+
+    expect(logSpy).toHaveBeenCalledWith(
+      'Could\'t toggle the Toolbox because there is no block selected ',
+      'warn'
+    );
+    expect(editorMock.Toolbar.moveAndOpen).not.toHaveBeenCalled();
+    expect(editorMock.Toolbar.toolbox.open).not.toHaveBeenCalled();
+    expect(editorMock.Toolbar.toolbox.close).not.toHaveBeenCalled();
+  });
+});
+
diff --git a/test/unit/components/modules/blockEvents.test.ts b/test/unit/components/modules/blockEvents.test.ts
new file mode 100644
index 000000000..7b67f518f
--- /dev/null
+++ b/test/unit/components/modules/blockEvents.test.ts
@@ -0,0 +1,1116 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('@editorjs/caret', () => ({
+  focus: vi.fn(),
+}));
+
+import { focus } from '@editorjs/caret';
+import BlockEvents from '../../../../src/components/modules/blockEvents';
+import EventsDispatcher from '../../../../src/components/utils/events';
+import type { EditorModules } from '../../../../src/types-internal/editor-modules';
+import type { EditorConfig } from '../../../../types';
+import type { EditorEventMap } from '../../../../src/components/events';
+import type Block from '../../../../src/components/block';
+import SelectionUtils from '../../../../src/components/selection';
+import * as caretUtils from '../../../../src/components/utils/caret';
+import * as blocksUtils from '../../../../src/components/utils/blocks';
+import { keyCodes } from '../../../../src/components/utils';
+
+const createBlockEvents = (overrides: Partial<EditorModules> = {}): BlockEvents => {
+  const blockEvents = new BlockEvents({
+    config: {} as EditorConfig,
+    eventsDispatcher: new EventsDispatcher<EditorEventMap>(),
+  });
+
+  const wrapper = document.createElement('div');
+
+  const defaults: Partial<EditorModules> = {
+    Toolbar: {
+      opened: false,
+      close: vi.fn(),
+      moveAndOpen: vi.fn(),
+      toolbox: {
+        open: vi.fn(),
+      },
+    } as unknown as EditorModules['Toolbar'],
+    BlockSelection: {
+      anyBlockSelected: false,
+      clearSelection: vi.fn(),
+      copySelectedBlocks: vi.fn(() => Promise.resolve()),
+      selectedBlocks: [],
+    } as unknown as EditorModules['BlockSelection'],
+    InlineToolbar: {
+      opened: false,
+      tryToShow: vi.fn(async () => undefined),
+    } as unknown as EditorModules['InlineToolbar'],
+    BlockManager: {
+      currentBlock: undefined,
+      currentBlockIndex: 0,
+      previousBlock: null,
+      nextBlock: null,
+      getBlockByChildNode: vi.fn(),
+      insertDefaultBlockAtIndex: vi.fn(),
+      removeBlock: vi.fn(),
+      removeSelectedBlocks: vi.fn(),
+      split: vi.fn(),
+    } as unknown as EditorModules['BlockManager'],
+    Caret: {
+      navigateNext: vi.fn(() => false),
+      navigatePrevious: vi.fn(() => false),
+      setToBlock: vi.fn(),
+      insertContentAtCaretPosition: vi.fn(),
+      positions: {
+        START: 'start-position',
+        END: 'end-position',
+      },
+    } as unknown as EditorModules['Caret'],
+    UI: {
+      nodes: {
+        wrapper,
+      },
+      someToolbarOpened: false,
+      someFlipperButtonFocused: false,
+      checkEmptiness: vi.fn(),
+      closeAllToolbars: vi.fn(),
+    } as unknown as EditorModules['UI'],
+    BlockSettings: {
+      opened: false,
+      open: vi.fn(),
+    } as unknown as EditorModules['BlockSettings'],
+    CrossBlockSelection: {
+      toggleBlockSelectedState: vi.fn(),
+    } as unknown as EditorModules['CrossBlockSelection'],
+  };
+
+  const mergedState: Partial<EditorModules> = { ...defaults };
+
+  for (const [moduleName, moduleOverrides] of Object.entries(overrides) as Array<[keyof EditorModules, unknown]>) {
+    const defaultModule = defaults[moduleName];
+
+    if (
+      defaultModule !== undefined &&
+      defaultModule !== null &&
+      typeof defaultModule === 'object' &&
+      moduleOverrides !== null &&
+      typeof moduleOverrides === 'object'
+    ) {
+      (mergedState as Record<keyof EditorModules, EditorModules[keyof EditorModules]>)[moduleName] = {
+        ...(defaultModule as object),
+        ...(moduleOverrides as object),
+      } as EditorModules[typeof moduleName];
+    } else if (moduleOverrides !== undefined) {
+      (mergedState as Record<keyof EditorModules, EditorModules[keyof EditorModules]>)[moduleName] = moduleOverrides as EditorModules[typeof moduleName];
+    }
+  }
+
+  blockEvents.state = mergedState as EditorModules;
+
+  return blockEvents;
+};
+
+const createKeyboardEvent = (options: Partial<KeyboardEvent>): KeyboardEvent => {
+  return {
+    keyCode: 0,
+    key: '',
+    code: '',
+    ctrlKey: false,
+    metaKey: false,
+    altKey: false,
+    shiftKey: false,
+    preventDefault: vi.fn(),
+    target: document.createElement('div'),
+    ...options,
+  } as KeyboardEvent;
+};
+
+const createDragEvent = (options: Partial<DragEvent>): DragEvent => {
+  return {
+    ...options,
+  } as DragEvent;
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('BlockEvents', () => {
+  describe('keyup', () => {
+    it('calls UI.checkEmptiness when Shift is not pressed', () => {
+      const checkEmptiness = vi.fn();
+      const blockEvents = createBlockEvents({
+        UI: {
+          checkEmptiness,
+        } as unknown as EditorModules['UI'],
+      });
+
+      blockEvents.keyup(createKeyboardEvent({ shiftKey: false }));
+
+      expect(checkEmptiness).toHaveBeenCalledTimes(1);
+    });
+
+    it('skips UI.checkEmptiness when Shift is pressed', () => {
+      const checkEmptiness = vi.fn();
+      const blockEvents = createBlockEvents({
+        UI: {
+          checkEmptiness,
+        } as unknown as EditorModules['UI'],
+      });
+
+      blockEvents.keyup(createKeyboardEvent({ shiftKey: true }));
+
+      expect(checkEmptiness).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('drag events', () => {
+    it('sets dropTarget to true on dragOver', () => {
+      const block = { dropTarget: false } as unknown as Block;
+      const getBlockByChildNode = vi.fn().mockReturnValue(block);
+      const blockEvents = createBlockEvents({
+        BlockManager: {
+          getBlockByChildNode,
+        } as unknown as EditorModules['BlockManager'],
+      });
+      const target = document.createElement('div');
+
+      blockEvents.dragOver(createDragEvent({ target }));
+
+      expect(getBlockByChildNode).toHaveBeenCalledWith(target);
+      expect(block.dropTarget).toBe(true);
+    });
+
+    it('sets dropTarget to false on dragLeave', () => {
+      const block = { dropTarget: true } as unknown as Block;
+      const getBlockByChildNode = vi.fn().mockReturnValue(block);
+      const blockEvents = createBlockEvents({
+        BlockManager: {
+          getBlockByChildNode,
+        } as unknown as EditorModules['BlockManager'],
+      });
+      const target = document.createElement('div');
+
+      blockEvents.dragLeave(createDragEvent({ target }));
+
+      expect(getBlockByChildNode).toHaveBeenCalledWith(target);
+      expect(block.dropTarget).toBe(false);
+    });
+  });
+
+  describe('handleCommandC', () => {
+    it('copies selected blocks when any block is selected', () => {
+      const copySelectedBlocks = vi.fn();
+      const blockEvents = createBlockEvents({
+        BlockSelection: {
+          anyBlockSelected: true,
+          copySelectedBlocks,
+        } as unknown as EditorModules['BlockSelection'],
+      });
+      const event = new Event('copy') as ClipboardEvent;
+
+      blockEvents.handleCommandC(event);
+
+      expect(copySelectedBlocks).toHaveBeenCalledWith(event);
+    });
+
+    it('does nothing when no blocks are selected', () => {
+      const copySelectedBlocks = vi.fn();
+      const blockEvents = createBlockEvents({
+        BlockSelection: {
+          anyBlockSelected: false,
+          copySelectedBlocks,
+        } as unknown as EditorModules['BlockSelection'],
+      });
+
+      blockEvents.handleCommandC(new Event('copy') as ClipboardEvent);
+
+      expect(copySelectedBlocks).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('handleCommandX', () => {
+    it('cuts selected blocks and restores caret position', async () => {
+      const copySelectedBlocks = vi.fn().mockResolvedValue(undefined);
+      const removeSelectedBlocks = vi.fn().mockReturnValue(3);
+      const insertDefaultBlockAtIndex = vi.fn().mockReturnValue({} as Block);
+      const clearSelection = vi.fn();
+      const setToBlock = vi.fn();
+
+      const blockEvents = createBlockEvents({
+        BlockSelection: {
+          anyBlockSelected: true,
+          copySelectedBlocks,
+          clearSelection,
+        } as unknown as EditorModules['BlockSelection'],
+        BlockManager: {
+          removeSelectedBlocks,
+          insertDefaultBlockAtIndex,
+        } as unknown as EditorModules['BlockManager'],
+        Caret: {
+          setToBlock,
+          positions: {
+            START: 'start-position',
+          },
+        } as unknown as EditorModules['Caret'],
+      });
+      const event = new Event('cut') as ClipboardEvent;
+
+      blockEvents.handleCommandX(event);
+      await copySelectedBlocks.mock.results[0]!.value;
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(copySelectedBlocks).toHaveBeenCalledWith(event);
+      expect(removeSelectedBlocks).toHaveBeenCalledTimes(1);
+      expect(insertDefaultBlockAtIndex).toHaveBeenCalledWith(3, true);
+      expect(setToBlock).toHaveBeenCalledWith(insertDefaultBlockAtIndex.mock.results[0]!.value, 'start-position');
+      expect(clearSelection).toHaveBeenCalledWith(event);
+    });
+
+    it('does nothing when there is no block selection', () => {
+      const copySelectedBlocks = vi.fn().mockResolvedValue(undefined);
+      const blockEvents = createBlockEvents({
+        BlockSelection: {
+          anyBlockSelected: false,
+          copySelectedBlocks,
+        } as unknown as EditorModules['BlockSelection'],
+      });
+
+      blockEvents.handleCommandX(new Event('cut') as ClipboardEvent);
+
+      expect(copySelectedBlocks).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('keydown', () => {
+    const handlers: Array<{ keyCode: number; handler: 'backspace' | 'delete' | 'enter' | 'arrowRightAndDown' | 'arrowLeftAndUp' | 'tabPressed' }> = [
+      { keyCode: keyCodes.BACKSPACE,
+        handler: 'backspace' },
+      { keyCode: keyCodes.DELETE,
+        handler: 'delete' },
+      { keyCode: keyCodes.ENTER,
+        handler: 'enter' },
+      { keyCode: keyCodes.DOWN,
+        handler: 'arrowRightAndDown' },
+      { keyCode: keyCodes.RIGHT,
+        handler: 'arrowRightAndDown' },
+      { keyCode: keyCodes.UP,
+        handler: 'arrowLeftAndUp' },
+      { keyCode: keyCodes.LEFT,
+        handler: 'arrowLeftAndUp' },
+      { keyCode: keyCodes.TAB,
+        handler: 'tabPressed' },
+    ];
+
+    it.each(handlers)('delegates keyCode %s to %s', ({ keyCode, handler }) => {
+      const blockEvents = createBlockEvents();
+      const spy = vi
+        .spyOn(blockEvents as unknown as Record<typeof handler, (event: KeyboardEvent) => void>, handler)
+        .mockImplementation(() => undefined);
+      const event = createKeyboardEvent({ keyCode });
+
+      blockEvents.keydown(event);
+
+      expect(spy).toHaveBeenCalledWith(event);
+    });
+
+    it('calls slashPressed when "/" is typed without modifiers', () => {
+      const blockEvents = createBlockEvents();
+      const slashSpy = vi
+        .spyOn(blockEvents as unknown as { slashPressed: (event: KeyboardEvent) => void }, 'slashPressed')
+        .mockImplementation(() => undefined);
+      const event = createKeyboardEvent({ keyCode: keyCodes.SLASH,
+        key: '/' });
+
+      blockEvents.keydown(event);
+
+      expect(slashSpy).toHaveBeenCalledWith(event);
+    });
+
+    it('skips slashPressed when modifier key is pressed', () => {
+      const blockEvents = createBlockEvents();
+      const slashSpy = vi
+        .spyOn(blockEvents as unknown as { slashPressed: (event: KeyboardEvent) => void }, 'slashPressed')
+        .mockImplementation(() => undefined);
+      const event = createKeyboardEvent({ keyCode: keyCodes.SLASH,
+        key: '/',
+        ctrlKey: true });
+
+      blockEvents.keydown(event);
+
+      expect(slashSpy).not.toHaveBeenCalled();
+    });
+
+    it('activates command slash when Slash code is used with control modifier', () => {
+      const blockEvents = createBlockEvents();
+      const commandSpy = vi
+        .spyOn(blockEvents as unknown as { commandSlashPressed: () => void }, 'commandSlashPressed')
+        .mockImplementation(() => undefined);
+      const event = createKeyboardEvent({ code: 'Slash',
+        ctrlKey: true });
+
+      blockEvents.keydown(event);
+
+      expect(event.preventDefault).toHaveBeenCalledTimes(1);
+      expect(commandSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('tabPressed', () => {
+    it('skips navigation when inline toolbar is open', () => {
+      const navigateNext = vi.fn();
+      const blockEvents = createBlockEvents({
+        InlineToolbar: {
+          opened: true,
+        } as unknown as EditorModules['InlineToolbar'],
+        Caret: {
+          navigateNext,
+        } as unknown as EditorModules['Caret'],
+      });
+      const event = createKeyboardEvent({ keyCode: keyCodes.TAB });
+
+      (blockEvents as unknown as { tabPressed: (event: KeyboardEvent) => void }).tabPressed(event);
+
+      expect(navigateNext).not.toHaveBeenCalled();
+      expect(event.preventDefault).not.toHaveBeenCalled();
+    });
+
+    it('prevents default when navigation succeeds', () => {
+      const navigateNext = vi.fn().mockReturnValue(true);
+      const blockEvents = createBlockEvents({
+        Caret: {
+          navigateNext,
+        } as unknown as EditorModules['Caret'],
+      });
+      const event = createKeyboardEvent({ keyCode: keyCodes.TAB });
+
+      (blockEvents as unknown as { tabPressed: (event: KeyboardEvent) => void }).tabPressed(event);
+
+      expect(navigateNext).toHaveBeenCalledWith(true);
+      expect(event.preventDefault).toHaveBeenCalledTimes(1);
+    });
+
+    it('navigates to previous input on Shift+Tab', () => {
+      const navigatePrevious = vi.fn().mockReturnValue(true);
+      const blockEvents = createBlockEvents({
+        Caret: {
+          navigatePrevious,
+        } as unknown as EditorModules['Caret'],
+      });
+      const event = createKeyboardEvent({ keyCode: keyCodes.TAB,
+        shiftKey: true });
+
+      (blockEvents as unknown as { tabPressed: (event: KeyboardEvent) => void }).tabPressed(event);
+
+      expect(navigatePrevious).toHaveBeenCalledWith(true);
+      expect(event.preventDefault).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('slashPressed', () => {
+    it('ignores events fired outside the editor wrapper', () => {
+      const insertContentAtCaretPosition = vi.fn();
+      const blockEvents = createBlockEvents({
+        Caret: {
+          insertContentAtCaretPosition,
+        } as unknown as EditorModules['Caret'],
+      });
+      const event = createKeyboardEvent({
+        keyCode: keyCodes.SLASH,
+        key: '/',
+        target: document.createElement('div'),
+      });
+
+      (blockEvents as unknown as { slashPressed: (event: KeyboardEvent) => void }).slashPressed(event);
+
+      expect(insertContentAtCaretPosition).not.toHaveBeenCalled();
+      expect(event.preventDefault).not.toHaveBeenCalled();
+    });
+
+    it('opens toolbox for empty block inside editor', () => {
+      const insertContentAtCaretPosition = vi.fn();
+      const currentBlock = {
+        isEmpty: true,
+      } as unknown as Block;
+      const wrapper = document.createElement('div');
+      const target = document.createElement('div');
+
+      wrapper.appendChild(target);
+      document.body.appendChild(wrapper);
+      const blockEvents = createBlockEvents({
+        Caret: {
+          insertContentAtCaretPosition,
+        } as unknown as EditorModules['Caret'],
+        BlockManager: {
+          currentBlock,
+        } as unknown as EditorModules['BlockManager'],
+        UI: {
+          nodes: {
+            wrapper,
+          },
+        } as unknown as EditorModules['UI'],
+      });
+      const activateSpy = vi
+        .spyOn(blockEvents as unknown as { activateToolbox: () => void }, 'activateToolbox')
+        .mockImplementation(() => undefined);
+      const event = createKeyboardEvent({
+        keyCode: keyCodes.SLASH,
+        key: '/',
+        target,
+      });
+
+      (blockEvents as unknown as { slashPressed: (event: KeyboardEvent) => void }).slashPressed(event);
+
+      expect(event.preventDefault).toHaveBeenCalledTimes(1);
+      expect(insertContentAtCaretPosition).toHaveBeenCalledWith('/');
+      expect(activateSpy).toHaveBeenCalledTimes(1);
+
+      wrapper.remove();
+    });
+
+    it('does nothing when current block is not empty', () => {
+      const insertContentAtCaretPosition = vi.fn();
+      const currentBlock = {
+        isEmpty: false,
+      } as unknown as Block;
+      const wrapper = document.createElement('div');
+      const target = document.createElement('div');
+
+      wrapper.appendChild(target);
+      document.body.appendChild(wrapper);
+      const blockEvents = createBlockEvents({
+        Caret: {
+          insertContentAtCaretPosition,
+        } as unknown as EditorModules['Caret'],
+        BlockManager: {
+          currentBlock,
+        } as unknown as EditorModules['BlockManager'],
+        UI: {
+          nodes: {
+            wrapper,
+          },
+        } as unknown as EditorModules['UI'],
+      });
+      const activateSpy = vi
+        .spyOn(blockEvents as unknown as { activateToolbox: () => void }, 'activateToolbox')
+        .mockImplementation(() => undefined);
+      const event = createKeyboardEvent({
+        keyCode: keyCodes.SLASH,
+        key: '/',
+        target,
+      });
+
+      (blockEvents as unknown as { slashPressed: (event: KeyboardEvent) => void }).slashPressed(event);
+
+      expect(event.preventDefault).not.toHaveBeenCalled();
+      expect(insertContentAtCaretPosition).not.toHaveBeenCalled();
+      expect(activateSpy).not.toHaveBeenCalled();
+
+      wrapper.remove();
+    });
+  });
+
+  describe('enter', () => {
+    it('returns early when line breaks are enabled', () => {
+      const moveAndOpen = vi.fn();
+      const currentBlock = {
+        tool: {
+          isLineBreaksEnabled: true,
+        },
+      } as unknown as Block;
+      const blockEvents = createBlockEvents({
+        Toolbar: {
+          moveAndOpen,
+        } as unknown as EditorModules['Toolbar'],
+        BlockManager: {
+          currentBlock,
+        } as unknown as EditorModules['BlockManager'],
+      });
+      const event = createKeyboardEvent({ keyCode: keyCodes.ENTER });
+
+      (blockEvents as unknown as { enter: (event: KeyboardEvent) => void }).enter(event);
+
+      expect(moveAndOpen).not.toHaveBeenCalled();
+      expect(event.preventDefault).not.toHaveBeenCalled();
+    });
+
+    it('inserts a new block when caret is at the end of the block', () => {
+      const moveAndOpen = vi.fn();
+      const setToBlock = vi.fn();
+      const insertDefaultBlockAtIndex = vi.fn().mockReturnValue({ id: 'inserted' } as unknown as Block);
+      const currentInput = document.createElement('div');
+      const currentBlock = {
+        tool: {
+          isLineBreaksEnabled: false,
+        },
+        currentInput,
+        hasMedia: false,
+      } as unknown as Block;
+
+      vi.spyOn(caretUtils, 'isCaretAtStartOfInput').mockReturnValue(false);
+      vi.spyOn(caretUtils, 'isCaretAtEndOfInput').mockReturnValue(true);
+      const blockEvents = createBlockEvents({
+        Toolbar: {
+          moveAndOpen,
+        } as unknown as EditorModules['Toolbar'],
+        BlockManager: {
+          currentBlock,
+          currentBlockIndex: 2,
+          insertDefaultBlockAtIndex,
+        } as unknown as EditorModules['BlockManager'],
+        Caret: {
+          setToBlock,
+          positions: {
+            START: 'start-position',
+            END: 'end-position',
+          },
+        } as unknown as EditorModules['Caret'],
+      });
+      const event = createKeyboardEvent({ keyCode: keyCodes.ENTER });
+
+      (blockEvents as unknown as { enter: (event: KeyboardEvent) => void }).enter(event);
+
+      expect(insertDefaultBlockAtIndex).toHaveBeenCalledWith(3);
+      expect(setToBlock).toHaveBeenCalledWith(insertDefaultBlockAtIndex.mock.results[0]!.value);
+      expect(moveAndOpen).toHaveBeenCalledWith(insertDefaultBlockAtIndex.mock.results[0]!.value);
+      expect(event.preventDefault).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('backspace', () => {
+    it('returns early when selection is not collapsed', () => {
+      vi.spyOn(SelectionUtils, 'isCollapsed', 'get').mockReturnValue(false);
+      const blockEvents = createBlockEvents();
+      const event = createKeyboardEvent({ keyCode: keyCodes.BACKSPACE });
+
+      (blockEvents as unknown as { backspace: (event: KeyboardEvent) => void }).backspace(event);
+
+      expect(event.preventDefault).not.toHaveBeenCalled();
+    });
+
+    it('merges blocks when previous block is mergeable', () => {
+      const toolbarClose = vi.fn();
+      const mergeableInput = document.createElement('div');
+      const currentBlock = {
+        currentInput: mergeableInput,
+        firstInput: mergeableInput,
+        isEmpty: false,
+        hasMedia: false,
+      } as unknown as Block;
+      const previousBlock = {
+        isEmpty: false,
+      } as unknown as Block;
+
+      vi.spyOn(SelectionUtils, 'isCollapsed', 'get').mockReturnValue(true);
+      vi.spyOn(caretUtils, 'isCaretAtStartOfInput').mockReturnValue(true);
+      vi.spyOn(blocksUtils, 'areBlocksMergeable').mockReturnValue(true);
+      const blockEvents = createBlockEvents({
+        Toolbar: {
+          close: toolbarClose,
+        } as unknown as EditorModules['Toolbar'],
+        BlockManager: {
+          currentBlock,
+          previousBlock,
+        } as unknown as EditorModules['BlockManager'],
+      });
+      const mergeSpy = vi
+        .spyOn(blockEvents as unknown as { mergeBlocks: (target: Block, source: Block) => void }, 'mergeBlocks')
+        .mockImplementation(() => undefined);
+      const event = createKeyboardEvent({ keyCode: keyCodes.BACKSPACE });
+
+      (blockEvents as unknown as { backspace: (event: KeyboardEvent) => void }).backspace(event);
+
+      expect(event.preventDefault).toHaveBeenCalledTimes(1);
+      expect(toolbarClose).toHaveBeenCalledTimes(1);
+      expect(mergeSpy).toHaveBeenCalledWith(previousBlock, currentBlock);
+    });
+  });
+
+  describe('delete', () => {
+    it('merges with next block when mergeable', () => {
+      const toolbarClose = vi.fn();
+      const mergeableInput = document.createElement('div');
+      const currentBlock = {
+        currentInput: mergeableInput,
+        lastInput: mergeableInput,
+        isEmpty: false,
+      } as unknown as Block;
+      const nextBlock = {
+        isEmpty: false,
+      } as unknown as Block;
+
+      vi.spyOn(SelectionUtils, 'isCollapsed', 'get').mockReturnValue(true);
+      vi.spyOn(caretUtils, 'isCaretAtEndOfInput').mockReturnValue(true);
+      vi.spyOn(blocksUtils, 'areBlocksMergeable').mockReturnValue(true);
+      const blockEvents = createBlockEvents({
+        Toolbar: {
+          close: toolbarClose,
+        } as unknown as EditorModules['Toolbar'],
+        BlockManager: {
+          currentBlock,
+          nextBlock,
+        } as unknown as EditorModules['BlockManager'],
+      });
+      const mergeSpy = vi
+        .spyOn(blockEvents as unknown as { mergeBlocks: (target: Block, source: Block) => void }, 'mergeBlocks')
+        .mockImplementation(() => undefined);
+      const event = createKeyboardEvent({ keyCode: keyCodes.DELETE });
+
+      (blockEvents as unknown as { delete: (event: KeyboardEvent) => void }).delete(event);
+
+      expect(event.preventDefault).toHaveBeenCalledTimes(1);
+      expect(toolbarClose).toHaveBeenCalledTimes(1);
+      expect(mergeSpy).toHaveBeenCalledWith(currentBlock, nextBlock);
+    });
+  });
+
+  describe('arrowRightAndDown', () => {
+    it('returns early when toolbar handles the key combination', () => {
+      const toolbarClose = vi.fn();
+      const blockEvents = createBlockEvents({
+        UI: {
+          someToolbarOpened: true,
+        } as unknown as EditorModules['UI'],
+        Toolbar: {
+          close: toolbarClose,
+        } as unknown as EditorModules['Toolbar'],
+      });
+      const event = createKeyboardEvent({ keyCode: keyCodes.DOWN });
+
+      (blockEvents as unknown as { arrowRightAndDown: (event: KeyboardEvent) => void }).arrowRightAndDown(event);
+
+      expect(toolbarClose).not.toHaveBeenCalled();
+      expect(event.preventDefault).not.toHaveBeenCalled();
+    });
+
+    it('toggles cross-block selection when extending selection with Shift+Down', () => {
+      const toggleBlockSelectedState = vi.fn();
+      const blockEvents = createBlockEvents({
+        BlockSelection: {
+          anyBlockSelected: true,
+        } as unknown as EditorModules['BlockSelection'],
+        CrossBlockSelection: {
+          toggleBlockSelectedState,
+        } as unknown as EditorModules['CrossBlockSelection'],
+      });
+      const event = createKeyboardEvent({ keyCode: keyCodes.DOWN,
+        shiftKey: true });
+
+      (blockEvents as unknown as { arrowRightAndDown: (event: KeyboardEvent) => void }).arrowRightAndDown(event);
+
+      expect(toggleBlockSelectedState).toHaveBeenCalledTimes(1);
+      expect(event.preventDefault).not.toHaveBeenCalled();
+    });
+
+    it('prevents default when caret navigation succeeds', () => {
+      const toolbarClose = vi.fn();
+      const navigateNext = vi.fn().mockReturnValue(true);
+      const clearSelection = vi.fn();
+      const blockEvents = createBlockEvents({
+        Toolbar: {
+          close: toolbarClose,
+        } as unknown as EditorModules['Toolbar'],
+        Caret: {
+          navigateNext,
+        } as unknown as EditorModules['Caret'],
+        BlockSelection: {
+          clearSelection,
+        } as unknown as EditorModules['BlockSelection'],
+      });
+      const event = createKeyboardEvent({ keyCode: keyCodes.DOWN });
+
+      (blockEvents as unknown as { arrowRightAndDown: (event: KeyboardEvent) => void }).arrowRightAndDown(event);
+
+      expect(toolbarClose).toHaveBeenCalledTimes(1);
+      expect(navigateNext).toHaveBeenCalledTimes(1);
+      expect(event.preventDefault).toHaveBeenCalledTimes(1);
+      expect(clearSelection).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('arrowLeftAndUp', () => {
+    it('returns early when toolbar is opened and handles the key', () => {
+      const closeAllToolbars = vi.fn();
+      const blockEvents = createBlockEvents({
+        UI: {
+          someToolbarOpened: true,
+          closeAllToolbars,
+        } as unknown as EditorModules['UI'],
+      });
+      const event = createKeyboardEvent({ keyCode: keyCodes.LEFT });
+
+      (blockEvents as unknown as { arrowLeftAndUp: (event: KeyboardEvent) => void }).arrowLeftAndUp(event);
+
+      expect(closeAllToolbars).not.toHaveBeenCalled();
+      expect(event.preventDefault).not.toHaveBeenCalled();
+    });
+
+    it('toggles cross-block selection when extending selection with Shift+Up', () => {
+      const toggleBlockSelectedState = vi.fn();
+      const blockEvents = createBlockEvents({
+        BlockSelection: {
+          anyBlockSelected: true,
+        } as unknown as EditorModules['BlockSelection'],
+        CrossBlockSelection: {
+          toggleBlockSelectedState,
+        } as unknown as EditorModules['CrossBlockSelection'],
+      });
+      const event = createKeyboardEvent({ keyCode: keyCodes.UP,
+        shiftKey: true });
+
+      (blockEvents as unknown as { arrowLeftAndUp: (event: KeyboardEvent) => void }).arrowLeftAndUp(event);
+
+      expect(toggleBlockSelectedState).toHaveBeenCalledWith(false);
+      expect(event.preventDefault).not.toHaveBeenCalled();
+    });
+
+    it('prevents default when navigating to previous element succeeds', () => {
+      const toolbarClose = vi.fn();
+      const navigatePrevious = vi.fn().mockReturnValue(true);
+      const clearSelection = vi.fn();
+      const blockEvents = createBlockEvents({
+        Toolbar: {
+          close: toolbarClose,
+        } as unknown as EditorModules['Toolbar'],
+        Caret: {
+          navigatePrevious,
+        } as unknown as EditorModules['Caret'],
+        BlockSelection: {
+          clearSelection,
+        } as unknown as EditorModules['BlockSelection'],
+      });
+      const event = createKeyboardEvent({ keyCode: keyCodes.UP });
+
+      (blockEvents as unknown as { arrowLeftAndUp: (event: KeyboardEvent) => void }).arrowLeftAndUp(event);
+
+      expect(toolbarClose).toHaveBeenCalledTimes(1);
+      expect(navigatePrevious).toHaveBeenCalledTimes(1);
+      expect(event.preventDefault).toHaveBeenCalledTimes(1);
+      expect(clearSelection).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('commandSlashPressed', () => {
+    it('activates block settings when a single block is selected', () => {
+      const blockEvents = createBlockEvents({
+        BlockSelection: {
+          selectedBlocks: [ {} ],
+        } as unknown as EditorModules['BlockSelection'],
+      });
+      const activateSpy = vi
+        .spyOn(blockEvents as unknown as { activateBlockSettings: () => void }, 'activateBlockSettings')
+        .mockImplementation(() => undefined);
+
+      (blockEvents as unknown as { commandSlashPressed: () => void }).commandSlashPressed();
+
+      expect(activateSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('skips activation when multiple blocks are selected', () => {
+      const blockEvents = createBlockEvents({
+        BlockSelection: {
+          selectedBlocks: [ {}, {} ],
+        } as unknown as EditorModules['BlockSelection'],
+      });
+      const activateSpy = vi
+        .spyOn(blockEvents as unknown as { activateBlockSettings: () => void }, 'activateBlockSettings')
+        .mockImplementation(() => undefined);
+
+      (blockEvents as unknown as { commandSlashPressed: () => void }).commandSlashPressed();
+
+      expect(activateSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('needToolbarClosing', () => {
+    const createToolbarMocks = (): Partial<EditorModules> => ({
+      Toolbar: {
+        toolbox: {
+          opened: false,
+        },
+      } as unknown as EditorModules['Toolbar'],
+      BlockSettings: {
+        opened: false,
+      } as unknown as EditorModules['BlockSettings'],
+      InlineToolbar: {
+        opened: false,
+      } as unknown as EditorModules['InlineToolbar'],
+    });
+
+    it('returns false when Shift is pressed', () => {
+      const blockEvents = createBlockEvents(createToolbarMocks() as Partial<EditorModules>);
+      const event = createKeyboardEvent({ shiftKey: true });
+
+      const result = (blockEvents as unknown as { needToolbarClosing: (event: KeyboardEvent) => boolean })
+        .needToolbarClosing(event);
+
+      expect(result).toBe(false);
+    });
+
+    it('returns false when Tab is pressed', () => {
+      const blockEvents = createBlockEvents(createToolbarMocks() as Partial<EditorModules>);
+      const event = createKeyboardEvent({ keyCode: 9 });
+
+      const result = (blockEvents as unknown as { needToolbarClosing: (event: KeyboardEvent) => boolean })
+        .needToolbarClosing(event);
+
+      expect(result).toBe(false);
+    });
+
+    it('returns false when toolbox item is selected and Enter pressed', () => {
+      const blockEvents = createBlockEvents({
+        Toolbar: {
+          toolbox: {
+            opened: true,
+          },
+        },
+        BlockSettings: {
+          opened: false,
+        },
+        InlineToolbar: {
+          opened: false,
+        },
+      } as Partial<EditorModules>);
+      const event = createKeyboardEvent({ keyCode: 13 });
+
+      const result = (blockEvents as unknown as { needToolbarClosing: (event: KeyboardEvent) => boolean })
+        .needToolbarClosing(event);
+
+      expect(result).toBe(false);
+    });
+
+    it('returns true when none of the skip conditions met', () => {
+      const blockEvents = createBlockEvents(createToolbarMocks() as Partial<EditorModules>);
+      const event = createKeyboardEvent({ keyCode: 65 });
+
+      const result = (blockEvents as unknown as { needToolbarClosing: (event: KeyboardEvent) => boolean })
+        .needToolbarClosing(event);
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('beforeKeydownProcessing', () => {
+    it('closes toolbar and clears selection for printable keys without modifiers', () => {
+      const close = vi.fn();
+      const clearSelection = vi.fn();
+      const blockEvents = createBlockEvents({
+        Toolbar: {
+          close,
+        } as unknown as EditorModules['Toolbar'],
+        BlockSelection: {
+          clearSelection,
+        } as unknown as EditorModules['BlockSelection'],
+      });
+      const event = createKeyboardEvent({ keyCode: 65 });
+
+      vi.spyOn(blockEvents as unknown as { needToolbarClosing: (event: KeyboardEvent) => boolean }, 'needToolbarClosing')
+        .mockReturnValue(true);
+
+      blockEvents.beforeKeydownProcessing(event);
+
+      expect(close).toHaveBeenCalledTimes(1);
+      expect(clearSelection).toHaveBeenCalledWith(event);
+    });
+
+    it('keeps selection when shortcut modifier is pressed', () => {
+      const close = vi.fn();
+      const clearSelection = vi.fn();
+      const blockEvents = createBlockEvents({
+        Toolbar: {
+          close,
+        } as unknown as EditorModules['Toolbar'],
+        BlockSelection: {
+          clearSelection,
+        } as unknown as EditorModules['BlockSelection'],
+      });
+      const event = createKeyboardEvent({ keyCode: 65,
+        ctrlKey: true });
+
+      vi.spyOn(blockEvents as unknown as { needToolbarClosing: (event: KeyboardEvent) => boolean }, 'needToolbarClosing')
+        .mockReturnValue(true);
+
+      blockEvents.beforeKeydownProcessing(event);
+
+      expect(close).toHaveBeenCalledTimes(1);
+      expect(clearSelection).not.toHaveBeenCalled();
+    });
+
+    it('skips processing when toolbar should not be closed', () => {
+      const close = vi.fn();
+      const clearSelection = vi.fn();
+      const blockEvents = createBlockEvents({
+        Toolbar: {
+          close,
+        } as unknown as EditorModules['Toolbar'],
+        BlockSelection: {
+          clearSelection,
+        } as unknown as EditorModules['BlockSelection'],
+      });
+
+      vi.spyOn(blockEvents as unknown as { needToolbarClosing: (event: KeyboardEvent) => boolean }, 'needToolbarClosing')
+        .mockReturnValue(false);
+
+      blockEvents.beforeKeydownProcessing(createKeyboardEvent({ keyCode: 65 }));
+
+      expect(close).not.toHaveBeenCalled();
+      expect(clearSelection).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('activateToolbox', () => {
+    it('opens toolbar when it is closed', () => {
+      const moveAndOpen = vi.fn();
+      const open = vi.fn();
+      const toolbar = {
+        opened: false,
+        moveAndOpen,
+        toolbox: {
+          open,
+        },
+      };
+      const blockEvents = createBlockEvents({
+        Toolbar: toolbar as unknown as EditorModules['Toolbar'],
+      });
+
+      (blockEvents as unknown as { activateToolbox: () => void }).activateToolbox();
+
+      expect(moveAndOpen).toHaveBeenCalledTimes(1);
+      expect(open).toHaveBeenCalledTimes(1);
+    });
+
+    it('skips moveAndOpen when toolbar already opened', () => {
+      const moveAndOpen = vi.fn();
+      const open = vi.fn();
+      const toolbar = {
+        opened: true,
+        moveAndOpen,
+        toolbox: {
+          open,
+        },
+      };
+      const blockEvents = createBlockEvents({
+        Toolbar: toolbar as unknown as EditorModules['Toolbar'],
+      });
+
+      (blockEvents as unknown as { activateToolbox: () => void }).activateToolbox();
+
+      expect(moveAndOpen).not.toHaveBeenCalled();
+      expect(open).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('activateBlockSettings', () => {
+    it('opens toolbar and block settings when closed', () => {
+      const moveAndOpen = vi.fn();
+      const open = vi.fn();
+      const blockEvents = createBlockEvents({
+        Toolbar: {
+          opened: false,
+          moveAndOpen,
+        } as unknown as EditorModules['Toolbar'],
+        BlockSettings: {
+          opened: false,
+          open,
+        } as unknown as EditorModules['BlockSettings'],
+      });
+
+      (blockEvents as unknown as { activateBlockSettings: () => void }).activateBlockSettings();
+
+      expect(moveAndOpen).toHaveBeenCalledTimes(1);
+      expect(open).toHaveBeenCalledTimes(1);
+    });
+
+    it('skips reopening toolbar when it is already opened', () => {
+      const moveAndOpen = vi.fn();
+      const open = vi.fn();
+      const blockEvents = createBlockEvents({
+        Toolbar: {
+          opened: true,
+          moveAndOpen,
+        } as unknown as EditorModules['Toolbar'],
+        BlockSettings: {
+          opened: false,
+          open,
+        } as unknown as EditorModules['BlockSettings'],
+      });
+
+      (blockEvents as unknown as { activateBlockSettings: () => void }).activateBlockSettings();
+
+      expect(moveAndOpen).not.toHaveBeenCalled();
+      expect(open).toHaveBeenCalledTimes(1);
+    });
+
+    it('does not reopen block settings when already opened', () => {
+      const moveAndOpen = vi.fn();
+      const open = vi.fn();
+      const blockEvents = createBlockEvents({
+        Toolbar: {
+          opened: true,
+          moveAndOpen,
+        } as unknown as EditorModules['Toolbar'],
+        BlockSettings: {
+          opened: true,
+          open,
+        } as unknown as EditorModules['BlockSettings'],
+      });
+
+      (blockEvents as unknown as { activateBlockSettings: () => void }).activateBlockSettings();
+
+      expect(open).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('mergeBlocks', () => {
+    it('focuses the target block, merges blocks and closes toolbar', async () => {
+      const mergeBlocksFn = vi.fn().mockResolvedValue(undefined);
+      const closeToolbar = vi.fn();
+      const targetBlock = {
+        lastInput: document.createElement('div'),
+      } as unknown as Block;
+      const blockToMerge = {} as Block;
+      const blockEvents = createBlockEvents({
+        BlockManager: {
+          mergeBlocks: mergeBlocksFn,
+        } as unknown as EditorModules['BlockManager'],
+        Toolbar: {
+          close: closeToolbar,
+        } as unknown as EditorModules['Toolbar'],
+      });
+
+      (blockEvents as unknown as { mergeBlocks: (target: Block, source: Block) => void }).mergeBlocks(
+        targetBlock,
+        blockToMerge
+      );
+      await mergeBlocksFn.mock.results[0]!.value;
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(focus).toHaveBeenCalledWith(targetBlock.lastInput, false);
+      expect(mergeBlocksFn).toHaveBeenCalledWith(targetBlock, blockToMerge);
+      expect(closeToolbar).toHaveBeenCalledTimes(1);
+    });
+
+    it('returns early when target block has no lastInput', () => {
+      const mergeBlocksFn = vi.fn().mockResolvedValue(undefined);
+      const blockEvents = createBlockEvents({
+        BlockManager: {
+          mergeBlocks: mergeBlocksFn,
+        } as unknown as EditorModules['BlockManager'],
+        Toolbar: {
+          close: vi.fn(),
+        } as unknown as EditorModules['Toolbar'],
+      });
+
+      (blockEvents as unknown as { mergeBlocks: (target: Block, source: Block) => void }).mergeBlocks(
+        {} as Block,
+        {} as Block
+      );
+
+      expect(mergeBlocksFn).not.toHaveBeenCalled();
+      expect(focus).not.toHaveBeenCalled();
+    });
+  });
+});
+
diff --git a/test/unit/components/modules/blockManager.test.ts b/test/unit/components/modules/blockManager.test.ts
new file mode 100644
index 000000000..cffe8a128
--- /dev/null
+++ b/test/unit/components/modules/blockManager.test.ts
@@ -0,0 +1,395 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { Mock, MockInstance } from 'vitest';
+
+import BlockManager from '../../../../src/components/modules/blockManager';
+import EventsDispatcher from '../../../../src/components/utils/events';
+import type { EditorConfig } from '../../../../types';
+import type { EditorModules } from '../../../../src/types-internal/editor-modules';
+import type { EditorEventMap } from '../../../../src/components/events';
+import type Block from '../../../../src/components/block';
+import { BlockAddedMutationType } from '../../../../types/events/block/BlockAdded';
+import { BlockRemovedMutationType } from '../../../../types/events/block/BlockRemoved';
+import { BlockMovedMutationType } from '../../../../types/events/block/BlockMoved';
+import { BlockChangedMutationType } from '../../../../types/events/block/BlockChanged';
+
+type BlockManagerContext = {
+  blockManager: BlockManager;
+  blocksStub: ReturnType<typeof createBlocksStub>;
+};
+
+type BlocksStub = {
+  proxy: Block[] & Record<PropertyKey, unknown>;
+  insert: Mock<[index: number, block: Block, replace?: boolean], void>;
+  insertMany: Mock<[items: Block[], index?: number], void>;
+  replace: Mock<[index: number, block: Block], void>;
+  move: Mock<[toIndex: number, fromIndex: number], void>;
+  remove: Mock<[index: number], void>;
+  indexOf: Mock<[block: Block], number>;
+  blocks: Block[];
+};
+
+type CreateBlockManagerOptions = {
+  initialBlocks?: Block[];
+  editorOverrides?: Partial<EditorModules>;
+};
+
+const createBlockStub = (options: {
+  id?: string;
+  name?: string;
+  data?: object;
+  tunes?: Record<string, unknown>;
+} = {}): Block => {
+  const holder = document.createElement('div');
+  const inputs = [ document.createElement('div') ];
+  const data = options.data ?? {};
+
+  const block = {
+    id: options.id ?? `block-${Math.random().toString(16)
+      .slice(2)}`,
+    name: options.name ?? 'paragraph',
+    holder,
+    call: vi.fn(),
+    destroy: vi.fn(),
+    tool: {
+      name: options.name ?? 'paragraph',
+      sanitizeConfig: {},
+      conversionConfig: {},
+      settings: {},
+    } as Record<string, unknown>,
+    tunes: options.tunes ?? {},
+    mergeable: false,
+    mergeWith: vi.fn(),
+    exportDataAsString: vi.fn().mockResolvedValue('{}'),
+    inputs,
+    isEmpty: false,
+    updateCurrentInput: vi.fn(),
+    focusable: true,
+    selected: false,
+    dispatchChange: vi.fn(),
+    save: vi.fn().mockResolvedValue(undefined),
+    validate: vi.fn().mockResolvedValue(true),
+    setStretchState: vi.fn(),
+    stretched: false,
+    getActiveToolboxEntry: vi.fn().mockResolvedValue(undefined),
+    config: {},
+  } as Record<string, unknown>;
+
+  Object.defineProperty(block, 'tool', {
+    value: block.tool,
+    writable: true,
+    configurable: true,
+  });
+
+  Object.defineProperty(block, 'tunes', {
+    value: block.tunes,
+    writable: true,
+    configurable: true,
+  });
+
+  Object.defineProperty(block, 'data', {
+    get: () => Promise.resolve(data),
+  });
+
+  Object.defineProperty(block, 'firstInput', {
+    get: () => inputs[0],
+  });
+
+  return block as unknown as Block;
+};
+
+const createBlocksStub = (initialBlocks: Block[] = []): BlocksStub => {
+  const blocks = [ ...initialBlocks ];
+
+  const stub = {
+    get array(): Block[] {
+      return blocks;
+    },
+    get length(): number {
+      return blocks.length;
+    },
+    get nodes(): HTMLElement[] {
+      return blocks.map((block) => block.holder);
+    },
+    insert: vi.fn((index: number, block: Block, replace = false) => {
+      const targetIndex = index ?? blocks.length;
+
+      if (replace) {
+        blocks.splice(targetIndex, 1, block);
+      } else {
+        blocks.splice(targetIndex, 0, block);
+      }
+    }),
+    insertMany: vi.fn((items: Block[], index = 0) => {
+      blocks.splice(index, 0, ...items);
+    }),
+    replace: vi.fn((index: number, block: Block) => {
+      blocks[index] = block;
+    }),
+    move: vi.fn((toIndex: number, fromIndex: number) => {
+      const [ movedBlock ] = blocks.splice(fromIndex, 1);
+
+      blocks.splice(toIndex, 0, movedBlock);
+    }),
+    remove: vi.fn((index: number) => {
+      blocks.splice(index, 1);
+    }),
+    indexOf: vi.fn((block: Block) => blocks.indexOf(block)),
+    get: vi.fn((index: number) => blocks[index]),
+  };
+
+  const proxy = new Proxy(stub, {
+    get(target, property: string | symbol) {
+      if (typeof property === 'string' && !Number.isNaN(Number(property))) {
+        return blocks[Number(property)];
+      }
+
+      return Reflect.get(target, property);
+    },
+    set(target, property: string | symbol, value: Block) {
+      if (typeof property === 'string' && !Number.isNaN(Number(property))) {
+        blocks[Number(property)] = value;
+
+        return true;
+      }
+
+      Reflect.set(target, property, value);
+
+      return true;
+    },
+  }) as unknown as BlocksStub['proxy'];
+
+  const result: BlocksStub = {
+    proxy,
+    insert: stub.insert,
+    insertMany: stub.insertMany,
+    replace: stub.replace,
+    move: stub.move,
+    remove: stub.remove,
+    indexOf: stub.indexOf,
+    blocks,
+  };
+
+  return result;
+};
+
+const createBlockManager = (
+  options: CreateBlockManagerOptions = {}
+): BlockManagerContext => {
+  const eventsDispatcher = new EventsDispatcher<EditorEventMap>();
+  const config = {
+    defaultBlock: 'paragraph',
+    sanitizer: {},
+  } as EditorConfig;
+
+  const blockManager = new BlockManager({
+    config,
+    eventsDispatcher,
+  });
+
+  const defaultEditorState: Partial<EditorModules> = {
+    BlockEvents: {
+      handleCommandC: vi.fn(),
+      handleCommandX: vi.fn(),
+      keydown: vi.fn(),
+      keyup: vi.fn(),
+      dragOver: vi.fn(),
+      dragLeave: vi.fn(),
+    } as unknown as EditorModules['BlockEvents'],
+    ReadOnly: {
+      isEnabled: false,
+    } as unknown as EditorModules['ReadOnly'],
+    UI: {
+      nodes: {
+        holder: document.createElement('div'),
+        redactor: document.createElement('div'),
+        wrapper: document.createElement('div'),
+      },
+      CSS: {
+        editorWrapper: 'codex-editor',
+        editorWrapperNarrow: 'codex-editor--narrow',
+        editorZone: 'codex-editor__redactor',
+        editorZoneHidden: 'codex-editor__redactor--hidden',
+        editorEmpty: 'codex-editor--empty',
+        editorRtlFix: 'codex-editor--rtl',
+      },
+      checkEmptiness: vi.fn(),
+    } as unknown as EditorModules['UI'],
+  };
+
+  blockManager.state = {
+    ...defaultEditorState,
+    ...options.editorOverrides,
+  } as EditorModules;
+
+  const blocksStub = createBlocksStub(options.initialBlocks);
+
+  (blockManager as unknown as { _blocks: unknown })._blocks = blocksStub.proxy;
+
+  if (options.initialBlocks?.length) {
+    blockManager.currentBlockIndex = 0;
+  }
+
+  return {
+    blockManager,
+    blocksStub,
+  };
+};
+
+type BlockDidMutated = BlockManager['blockDidMutated'];
+type ComposeBlock = BlockManager['composeBlock'];
+
+const getBlockDidMutatedSpy = (
+  blockManager: BlockManager
+): MockInstance<Parameters<BlockDidMutated>, ReturnType<BlockDidMutated>> => {
+  return vi.spyOn(
+    blockManager as unknown as { blockDidMutated: BlockDidMutated },
+    'blockDidMutated'
+  );
+};
+
+const getComposeBlockSpy = (
+  blockManager: BlockManager
+): MockInstance<Parameters<ComposeBlock>, ReturnType<ComposeBlock>> => {
+  return vi.spyOn(
+    blockManager as unknown as { composeBlock: ComposeBlock },
+    'composeBlock'
+  );
+};
+
+describe('BlockManager', () => {
+  it('inserts a block and dispatches added mutation', () => {
+    const existingBlock = createBlockStub({ id: 'existing' });
+    const { blockManager, blocksStub } = createBlockManager({
+      initialBlocks: [ existingBlock ],
+    });
+    const newBlock = createBlockStub({ id: 'new-block' });
+    const composeBlockSpy = getComposeBlockSpy(blockManager).mockReturnValue(newBlock);
+    const blockDidMutatedSpy = getBlockDidMutatedSpy(blockManager);
+
+    const result = blockManager.insert({ replace: true,
+      needToFocus: true });
+
+    expect(result).toBe(newBlock);
+    expect(blocksStub.insert).toHaveBeenCalledWith(0, newBlock, true);
+    expect(blockManager.currentBlockIndex).toBe(0);
+    expect(blockDidMutatedSpy).toHaveBeenCalledWith(
+      BlockRemovedMutationType,
+      existingBlock,
+      expect.objectContaining({ index: 0 })
+    );
+    expect(blockDidMutatedSpy).toHaveBeenCalledWith(
+      BlockAddedMutationType,
+      newBlock,
+      expect.objectContaining({ index: 0 })
+    );
+    expect(composeBlockSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ tool: 'paragraph' })
+    );
+  });
+
+  it('removes a block, updates current index, and emits removal mutation', async () => {
+    const firstBlock = createBlockStub({ id: 'block-1' });
+    const secondBlock = createBlockStub({ id: 'block-2' });
+    const { blockManager, blocksStub } = createBlockManager({
+      initialBlocks: [firstBlock, secondBlock],
+    });
+
+    blockManager.currentBlockIndex = 1;
+    const blockDidMutatedSpy = getBlockDidMutatedSpy(blockManager);
+
+    await blockManager.removeBlock(firstBlock, false);
+
+    expect(blocksStub.remove).toHaveBeenCalledWith(0);
+    expect(firstBlock.destroy).toHaveBeenCalledTimes(1);
+    expect(blockManager.currentBlockIndex).toBe(0);
+    expect(blockDidMutatedSpy).toHaveBeenCalledWith(
+      BlockRemovedMutationType,
+      firstBlock,
+      expect.objectContaining({ index: 0 })
+    );
+    expect(blockManager.blocks).toEqual([ secondBlock ]);
+  });
+
+  it('inserts a default block when the last block is removed', async () => {
+    const block = createBlockStub({ id: 'single-block' });
+    const { blockManager, blocksStub } = createBlockManager({
+      initialBlocks: [ block ],
+    });
+    const newBlock = createBlockStub({ id: 'default' });
+    const insertSpy = vi
+      .spyOn(blockManager as unknown as { insert: BlockManager['insert'] }, 'insert')
+      .mockReturnValue(newBlock);
+
+    await blockManager.removeBlock(block);
+
+    expect(blocksStub.remove).toHaveBeenCalledWith(0);
+    expect(insertSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('moves a block and emits movement mutation', () => {
+    const firstBlock = createBlockStub({ id: 'block-1' });
+    const secondBlock = createBlockStub({ id: 'block-2' });
+    const { blockManager, blocksStub } = createBlockManager({
+      initialBlocks: [firstBlock, secondBlock],
+    });
+
+    blockManager.currentBlockIndex = 1;
+    const blockDidMutatedSpy = getBlockDidMutatedSpy(blockManager);
+
+    blockManager.move(0, 1);
+
+    expect(blocksStub.move).toHaveBeenCalledWith(0, 1);
+    expect(blockManager.currentBlockIndex).toBe(0);
+    expect(blockManager.currentBlock).toBe(secondBlock);
+    expect(blockDidMutatedSpy).toHaveBeenCalledWith(
+      BlockMovedMutationType,
+      secondBlock,
+      expect.objectContaining({ fromIndex: 1,
+        toIndex: 0 })
+    );
+  });
+
+  it('recreates block with merged data when updating', async () => {
+    const block = createBlockStub({ id: 'block-1',
+      data: { text: 'Hello' },
+      tunes: { alignment: 'left' } });
+    const { blockManager, blocksStub } = createBlockManager({
+      initialBlocks: [ block ],
+    });
+    const newBlock = createBlockStub({ id: 'block-1' });
+    const composeBlockSpy = getComposeBlockSpy(blockManager).mockReturnValue(newBlock);
+    const blockDidMutatedSpy = getBlockDidMutatedSpy(blockManager);
+
+    const result = await blockManager.update(block, { text: 'Updated' }, { alignment: 'center' });
+
+    expect(composeBlockSpy).toHaveBeenCalledWith({
+      id: 'block-1',
+      tool: 'paragraph',
+      data: { text: 'Updated' },
+      tunes: { alignment: 'center' },
+    });
+    expect(blocksStub.replace).toHaveBeenCalledWith(0, newBlock);
+    expect(blockDidMutatedSpy).toHaveBeenCalledWith(
+      BlockChangedMutationType,
+      newBlock,
+      expect.objectContaining({ index: 0 })
+    );
+    expect(result).toBe(newBlock);
+  });
+
+  it('returns original block when neither data nor tunes provided on update', async () => {
+    const block = createBlockStub({ id: 'block-1' });
+    const { blockManager, blocksStub } = createBlockManager({
+      initialBlocks: [ block ],
+    });
+    const composeBlockSpy = getComposeBlockSpy(blockManager);
+    const blockDidMutatedSpy = getBlockDidMutatedSpy(blockManager);
+
+    const result = await blockManager.update(block);
+
+    expect(result).toBe(block);
+    expect(composeBlockSpy).not.toHaveBeenCalled();
+    expect(blocksStub.replace).not.toHaveBeenCalled();
+    expect(blockDidMutatedSpy).not.toHaveBeenCalled();
+  });
+});
diff --git a/test/unit/components/modules/blockSelection.test.ts b/test/unit/components/modules/blockSelection.test.ts
new file mode 100644
index 000000000..dc5b27c15
--- /dev/null
+++ b/test/unit/components/modules/blockSelection.test.ts
@@ -0,0 +1,638 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import BlockSelection from '../../../../src/components/modules/blockSelection';
+import EventsDispatcher from '../../../../src/components/utils/events';
+import type { EditorEventMap } from '../../../../src/components/events';
+import type { EditorModules } from '../../../../src/types-internal/editor-modules';
+import type { EditorConfig } from '../../../../types';
+import SelectionUtils from '../../../../src/components/selection';
+import Shortcuts from '../../../../src/components/utils/shortcuts';
+import * as utils from '../../../../src/components/utils';
+import type { SanitizerConfig } from '../../../../types/configs';
+import type Block from '../../../../src/components/block';
+
+type ModuleOverrides = Partial<EditorModules>;
+
+type SelectionSpy = {
+  save: ReturnType<typeof vi.fn>;
+  restore: ReturnType<typeof vi.fn>;
+  clearSaved: ReturnType<typeof vi.fn>;
+};
+
+type BlockSelectionSetup = {
+  blockSelection: BlockSelection;
+  modules: EditorModules;
+  blocks: Block[];
+  selectionSpy: SelectionSpy;
+  redactor: HTMLDivElement;
+};
+
+const createBlockStub = (options?: { html?: string; inputs?: HTMLElement[]; initiallySelected?: boolean }): Block => {
+  const holder = document.createElement('div');
+
+  holder.className = 'ce-block';
+  holder.innerHTML = options?.html ?? '<p>Sample text</p>';
+
+  const inputs = options?.inputs ?? [ document.createElement('div') ];
+  let isSelected = options?.initiallySelected ?? false;
+
+  const blockStub = {
+    holder,
+    inputs,
+    save: vi.fn().mockResolvedValue({
+      id: 'test',
+      tool: 'paragraph',
+      data: { text: 'Sample text' },
+      tunes: {},
+      time: 0,
+    }),
+  };
+
+  Object.defineProperty(blockStub, 'selected', {
+    configurable: true,
+    enumerable: true,
+    get(): boolean {
+      return isSelected;
+    },
+    set(nextState: boolean) {
+      isSelected = nextState;
+      holder.classList.toggle('ce-block--selected', nextState);
+    },
+  });
+
+  return blockStub as unknown as Block;
+};
+
+const createBlockSelection = (overrides: ModuleOverrides = {}): BlockSelectionSetup => {
+  const redactor = document.createElement('div');
+  const blocks = [
+    createBlockStub(),
+    createBlockStub(),
+    createBlockStub(),
+  ];
+
+  const blockManager = {
+    blocks,
+    currentBlock: blocks[0],
+    getBlockByIndex: vi.fn((index: number) => blocks[index]),
+    getBlock: vi.fn((element: HTMLElement) => blocks.find((block) => block.holder === element) ?? null),
+    removeSelectedBlocks: vi.fn(() => 0),
+    insertDefaultBlockAtIndex: vi.fn(),
+  };
+
+  const defaults: ModuleOverrides = {
+    BlockManager: blockManager as unknown as EditorModules['BlockManager'],
+    Caret: {
+      setToBlock: vi.fn(),
+      insertContentAtCaretPosition: vi.fn(),
+    } as unknown as EditorModules['Caret'],
+    RectangleSelection: {
+      clearSelection: vi.fn(),
+      isRectActivated: vi.fn(() => false),
+    } as unknown as EditorModules['RectangleSelection'],
+    CrossBlockSelection: {
+      clear: vi.fn(),
+    } as unknown as EditorModules['CrossBlockSelection'],
+    InlineToolbar: {
+      close: vi.fn(),
+    } as unknown as EditorModules['InlineToolbar'],
+    ReadOnly: {
+      isEnabled: false,
+    } as unknown as EditorModules['ReadOnly'],
+    UI: {
+      nodes: {
+        redactor,
+      },
+    } as unknown as EditorModules['UI'],
+    Paste: {
+      MIME_TYPE: 'application/editorjs',
+    } as unknown as EditorModules['Paste'],
+  };
+
+  const mergedState = { ...defaults,
+    ...overrides } as EditorModules;
+  const blockSelection = new BlockSelection({
+    config: { sanitizer: {} } as EditorConfig,
+    eventsDispatcher: new EventsDispatcher<EditorEventMap>(),
+  });
+
+  blockSelection.state = mergedState;
+
+  const selectionSpy: SelectionSpy = {
+    save: vi.fn(),
+    restore: vi.fn(),
+    clearSaved: vi.fn(),
+  };
+
+  (blockSelection as unknown as { selection: SelectionUtils }).selection = selectionSpy as unknown as SelectionUtils;
+
+  return {
+    blockSelection,
+    modules: mergedState,
+    blocks,
+    selectionSpy,
+    redactor,
+  };
+};
+
+describe('BlockSelection', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  describe('allBlocksSelected', () => {
+    it('returns true only when every block is selected', () => {
+      const { blockSelection, blocks } = createBlockSelection();
+
+      for (const currentBlock of blocks) {
+        currentBlock.selected = true;
+      }
+
+      expect(blockSelection.allBlocksSelected).toBe(true);
+
+      blocks[1].selected = false;
+
+      expect(blockSelection.allBlocksSelected).toBe(false);
+    });
+
+    it('setter selects every block and clears cache', () => {
+      const { blockSelection, blocks } = createBlockSelection();
+
+      const cacheAware = blockSelection as unknown as { anyBlockSelectedCache: boolean | null };
+
+      // Warm the cache with false
+      expect(blockSelection.anyBlockSelected).toBe(false);
+      expect(cacheAware.anyBlockSelectedCache).toBe(false);
+
+      blockSelection.allBlocksSelected = true;
+
+      expect(blocks.every((block) => block.selected)).toBe(true);
+      expect(cacheAware.anyBlockSelectedCache).toBeNull();
+    });
+  });
+
+  describe('anyBlockSelected', () => {
+    it('reuses cached value until cache is cleared', () => {
+      const { blockSelection, blocks } = createBlockSelection();
+
+      expect(blockSelection.anyBlockSelected).toBe(false);
+
+      blocks[0].selected = true;
+
+      expect(blockSelection.anyBlockSelected).toBe(false);
+
+      blockSelection.clearCache();
+
+      expect(blockSelection.anyBlockSelected).toBe(true);
+    });
+  });
+
+  describe('selectedBlocks', () => {
+    it('returns only the blocks marked as selected', () => {
+      const { blockSelection, blocks } = createBlockSelection();
+
+      blocks[0].selected = true;
+      blocks[2].selected = true;
+
+      expect(blockSelection.selectedBlocks).toEqual([blocks[0], blocks[2]]);
+    });
+  });
+
+  describe('selectBlock', () => {
+    it('saves selection, clears native selection and selects block', () => {
+      const { blockSelection, blocks, modules, selectionSpy } = createBlockSelection();
+      const removeAllRanges = vi.fn();
+
+      vi.spyOn(SelectionUtils, 'get').mockReturnValue({
+        removeAllRanges,
+      } as unknown as Selection);
+
+      const inlineToolbarClose = modules.InlineToolbar.close as ReturnType<typeof vi.fn>;
+
+      blockSelection.selectBlock(blocks[0]);
+
+      expect(selectionSpy.save).toHaveBeenCalledTimes(1);
+      expect(removeAllRanges).toHaveBeenCalledTimes(1);
+      expect(blocks[0].selected).toBe(true);
+      expect(inlineToolbarClose).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('unSelectBlockByIndex', () => {
+    it('unselects the block by explicit index', () => {
+      const { blockSelection, blocks, modules } = createBlockSelection();
+      const blockManager = modules.BlockManager as unknown as {
+        getBlockByIndex: (index: number) => Block | undefined;
+      };
+
+      blocks[2].selected = true;
+      blockSelection.unSelectBlockByIndex(2);
+
+      expect(blocks[2].selected).toBe(false);
+      expect(blockManager.getBlockByIndex).toHaveBeenCalledWith(2);
+    });
+
+    it('falls back to current block when index is not provided', () => {
+      const { blockSelection, blocks, modules } = createBlockSelection();
+      const blockManager = modules.BlockManager as unknown as { currentBlock: Block | null };
+
+      blockManager.currentBlock = blocks[1];
+      blocks[1].selected = true;
+      blockSelection.unSelectBlockByIndex(undefined);
+
+      expect(blocks[1].selected).toBe(false);
+    });
+  });
+
+  describe('unselectBlock', () => {
+    it('clears selection on provided block and resets cache', () => {
+      const { blockSelection, blocks } = createBlockSelection();
+      const cacheAware = blockSelection as unknown as { anyBlockSelectedCache: boolean | null };
+
+      cacheAware.anyBlockSelectedCache = true;
+      blocks[1].selected = true;
+
+      blockSelection.unselectBlock(blocks[1]);
+
+      expect(blocks[1].selected).toBe(false);
+      expect(cacheAware.anyBlockSelectedCache).toBeNull();
+    });
+  });
+
+  describe('selectBlockByIndex', () => {
+    it('selects block returned by block manager', () => {
+      const { blockSelection, blocks } = createBlockSelection();
+
+      blocks[2].selected = false;
+
+      blockSelection.selectBlockByIndex(2);
+
+      expect(blocks[2].selected).toBe(true);
+    });
+
+    it('ignores unknown block indexes', () => {
+      const { blockSelection, modules } = createBlockSelection();
+      const blockManager = modules.BlockManager as unknown as {
+        getBlockByIndex: (index: number) => Block | undefined;
+      };
+
+      (blockManager.getBlockByIndex as ReturnType<typeof vi.fn>).mockReturnValueOnce(undefined);
+
+      expect(() => blockSelection.selectBlockByIndex(99)).not.toThrow();
+    });
+  });
+
+  describe('clearSelection', () => {
+    it('clears selected blocks on pointer interaction', () => {
+      const { blockSelection, blocks, modules } = createBlockSelection();
+      const rectangleSelection = modules.RectangleSelection as unknown as {
+        clearSelection: () => void;
+        isRectActivated: () => boolean;
+      };
+      const crossBlockSelection = modules.CrossBlockSelection as unknown as {
+        clear: (reason?: Event) => void;
+      };
+
+      blocks[0].selected = true;
+      blocks[1].selected = true;
+
+      const event = new MouseEvent('click');
+
+      blockSelection.clearSelection(event);
+
+      expect(blocks[0].selected).toBe(false);
+      expect(blocks[1].selected).toBe(false);
+      expect(crossBlockSelection.clear).toHaveBeenCalledWith(event);
+      expect(rectangleSelection.clearSelection).not.toHaveBeenCalled();
+    });
+
+    it('restores previous selection when requested', () => {
+      const { blockSelection, selectionSpy } = createBlockSelection();
+      const selectionAccessor = blockSelection as unknown as {
+        needToSelectAll: boolean;
+        readyToBlockSelection: boolean;
+      };
+
+      selectionAccessor.needToSelectAll = true;
+      selectionAccessor.readyToBlockSelection = true;
+
+      blockSelection.clearSelection(undefined, true);
+
+      expect(selectionSpy.restore).toHaveBeenCalledTimes(1);
+      expect(selectionAccessor.needToSelectAll).toBe(false);
+      expect(selectionAccessor.readyToBlockSelection).toBe(false);
+    });
+
+    it('replaces selected blocks with printable keys when applicable', () => {
+      const { blockSelection, blocks } = createBlockSelection();
+      const replacerHost = blockSelection as unknown as {
+        replaceSelectedBlocksWithPrintableKey: (event: KeyboardEvent) => void;
+      };
+      const replaceSpy = vi.spyOn(replacerHost, 'replaceSelectedBlocksWithPrintableKey');
+
+      blocks[0].selected = true;
+
+      vi.spyOn(utils, 'isPrintableKey').mockReturnValue(true);
+      vi.spyOn(SelectionUtils, 'isSelectionExists', 'get').mockReturnValue(false);
+
+      const event = new KeyboardEvent('keydown', { key: 'x' });
+
+      Object.defineProperty(event, 'keyCode', { value: 88 });
+
+      blockSelection.clearSelection(event);
+
+      expect(replaceSpy).toHaveBeenCalledWith(event);
+    });
+  });
+
+  describe('copySelectedBlocks', () => {
+    it('serializes selected blocks and writes clipboard data', async () => {
+      const { blockSelection, blocks, modules } = createBlockSelection();
+      const clipboardData = {
+        setData: vi.fn(),
+      };
+      const clipboardEvent = {
+        preventDefault: vi.fn(),
+        clipboardData,
+      } as unknown as ClipboardEvent;
+
+      const firstBlock = blocks[0];
+      const secondBlock = blocks[1];
+
+      firstBlock.holder.innerHTML = '<p>First</p>';
+      secondBlock.holder.innerHTML = '<p>Second</p>';
+      firstBlock.selected = true;
+      secondBlock.selected = true;
+
+      await blockSelection.copySelectedBlocks(clipboardEvent);
+
+      expect(clipboardEvent.preventDefault).toHaveBeenCalledTimes(1);
+      expect(clipboardData.setData).toHaveBeenCalledWith('text/plain', 'First\n\nSecond');
+      expect(clipboardData.setData).toHaveBeenCalledWith('text/html', '<p>First</p><p>Second</p>');
+      expect(clipboardData.setData).toHaveBeenCalledWith(
+        (modules.Paste as unknown as { MIME_TYPE: string }).MIME_TYPE,
+        expect.stringContaining('"tool":"paragraph"')
+      );
+      expect(firstBlock.save).toHaveBeenCalledTimes(1);
+      expect(secondBlock.save).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('sanitizerConfig', () => {
+    it('provides default tag white-list when no overrides supplied', () => {
+      const { blockSelection } = createBlockSelection();
+      const config = (blockSelection as unknown as { sanitizerConfig: SanitizerConfig }).sanitizerConfig;
+
+      expect(config).toMatchObject({
+        p: {},
+        img: {
+          src: true,
+          width: true,
+          height: true,
+        },
+        a: { href: true },
+      });
+    });
+
+    it('merges provided sanitizer overrides with defaults', () => {
+      const { blockSelection } = createBlockSelection();
+      const override: SanitizerConfig = {
+        a: { rel: 'nofollow' },
+      };
+      const internals = blockSelection as unknown as { config: EditorConfig };
+
+      internals.config = {
+        ...internals.config,
+        sanitizer: override,
+      };
+
+      const config = (blockSelection as unknown as { sanitizerConfig: SanitizerConfig }).sanitizerConfig;
+
+      expect(config.a).toMatchObject({
+        href: true,
+        rel: 'nofollow',
+      });
+    });
+  });
+
+  describe('toggleReadOnly', () => {
+    it('removes native selection and unselects blocks', () => {
+      const { blockSelection, blocks } = createBlockSelection();
+      const selectionMock = {
+        removeAllRanges: vi.fn(),
+      };
+
+      for (const currentBlock of blocks) {
+        currentBlock.selected = true;
+      }
+
+      vi.spyOn(SelectionUtils, 'get').mockReturnValue(selectionMock as unknown as Selection);
+
+      blockSelection.toggleReadOnly();
+
+      expect(selectionMock.removeAllRanges).toHaveBeenCalledTimes(1);
+      expect(blocks.every((block) => block.selected === false)).toBe(true);
+    });
+  });
+
+  describe('handleCommandA', () => {
+    it('selects all blocks on second invocation for single-input tools', () => {
+      const { blockSelection, blocks } = createBlockSelection();
+      const internal = blockSelection as unknown as { needToSelectAll: boolean };
+      const selectAllSpy = vi.spyOn(blockSelection as unknown as { selectAllBlocks: () => void }, 'selectAllBlocks');
+      const event = {
+        target: blocks[0].holder,
+        preventDefault: vi.fn(),
+      } as unknown as KeyboardEvent;
+
+      (blockSelection as unknown as { selection: SelectionUtils }).selection = {
+        save: vi.fn(),
+        restore: vi.fn(),
+        clearSaved: vi.fn(),
+      } as unknown as SelectionUtils;
+
+      const handler = blockSelection as unknown as { handleCommandA: (keyboardEvent: KeyboardEvent) => void };
+
+      handler.handleCommandA(event);
+      expect(internal.needToSelectAll).toBe(true);
+      expect(selectAllSpy).not.toHaveBeenCalled();
+
+      handler.handleCommandA(event);
+
+      expect(event.preventDefault).toHaveBeenCalledTimes(1);
+      expect(selectAllSpy).toHaveBeenCalledTimes(1);
+      expect(internal.needToSelectAll).toBe(false);
+    });
+
+    it('selects current block when tool exposes multiple inputs', () => {
+      const multiInput = document.createElement('div');
+      const { blockSelection, blocks } = createBlockSelection();
+      const blockManager = (blockSelection as unknown as { Editor: EditorModules }).Editor.BlockManager;
+      const targetBlock = blocks[0];
+
+      (targetBlock as unknown as { inputs: HTMLElement[] }).inputs = [multiInput, document.createElement('div')];
+      const selectBlockSpy = vi.spyOn(blockSelection, 'selectBlock');
+      const handler = blockSelection as unknown as { handleCommandA: (keyboardEvent: KeyboardEvent) => void };
+
+      const event = {
+        target: targetBlock.holder,
+        preventDefault: vi.fn(),
+      } as unknown as KeyboardEvent;
+
+      (blockManager.getBlock as (element: HTMLElement) => Block | null).call(blockManager, targetBlock.holder);
+
+      handler.handleCommandA(event);
+      expect(selectBlockSpy).not.toHaveBeenCalled();
+
+      handler.handleCommandA(event);
+      expect(event.preventDefault).toHaveBeenCalledTimes(1);
+      expect(selectBlockSpy).toHaveBeenCalledWith(targetBlock);
+    });
+
+    it('defers to native input selection before enabling block selection', () => {
+      const { blockSelection, modules } = createBlockSelection();
+      const rectangleSelection = modules.RectangleSelection as unknown as { clearSelection: ReturnType<typeof vi.fn> };
+      const handler = blockSelection as unknown as {
+        handleCommandA: (event: KeyboardEvent) => void;
+        readyToBlockSelection: boolean;
+      };
+      const event = {
+        target: document.createElement('input'),
+        preventDefault: vi.fn(),
+      } as unknown as KeyboardEvent;
+
+      handler.handleCommandA(event);
+
+      expect(rectangleSelection.clearSelection).toHaveBeenCalledTimes(1);
+      expect(handler.readyToBlockSelection).toBe(true);
+      expect(event.preventDefault).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('replaceSelectedBlocksWithPrintableKey', () => {
+    it('inserts new block and types printable character', () => {
+      const { blockSelection, modules } = createBlockSelection();
+      const blockManager = modules.BlockManager as unknown as {
+        removeSelectedBlocks: ReturnType<typeof vi.fn>;
+        insertDefaultBlockAtIndex: ReturnType<typeof vi.fn>;
+        currentBlock: Block | null;
+      };
+      const caret = modules.Caret as unknown as {
+        setToBlock: ReturnType<typeof vi.fn>;
+        insertContentAtCaretPosition: ReturnType<typeof vi.fn>;
+      };
+      const insertedBlock = createBlockStub();
+      const delaySpy = vi.spyOn(utils, 'delay').mockImplementation((fn) => {
+        return () => fn();
+      });
+
+      blockManager.currentBlock = null;
+      blockManager.removeSelectedBlocks = vi.fn().mockReturnValue(1);
+      blockManager.insertDefaultBlockAtIndex = vi.fn().mockImplementation(() => {
+        blockManager.currentBlock = insertedBlock;
+      });
+
+      const host = blockSelection as unknown as {
+        replaceSelectedBlocksWithPrintableKey: (event: KeyboardEvent) => void;
+      };
+
+      host.replaceSelectedBlocksWithPrintableKey({ key: 'x' } as KeyboardEvent);
+
+      expect(blockManager.removeSelectedBlocks).toHaveBeenCalledTimes(1);
+      expect(blockManager.insertDefaultBlockAtIndex).toHaveBeenCalledWith(1, true);
+      expect(caret.setToBlock).toHaveBeenCalledWith(insertedBlock);
+      expect(caret.insertContentAtCaretPosition).toHaveBeenCalledWith('x');
+      expect(delaySpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('inserts empty string for non-printable keys', () => {
+      const { blockSelection, modules } = createBlockSelection();
+      const blockManager = modules.BlockManager as unknown as {
+        removeSelectedBlocks: ReturnType<typeof vi.fn>;
+        insertDefaultBlockAtIndex: ReturnType<typeof vi.fn>;
+        currentBlock: Block | null;
+      };
+      const caret = modules.Caret as unknown as {
+        setToBlock: ReturnType<typeof vi.fn>;
+        insertContentAtCaretPosition: ReturnType<typeof vi.fn>;
+      };
+      const insertedBlock = createBlockStub();
+
+      vi.spyOn(utils, 'delay').mockImplementation((fn) => {
+        return () => fn();
+      });
+
+      blockManager.currentBlock = null;
+      blockManager.removeSelectedBlocks = vi.fn().mockReturnValue(2);
+      blockManager.insertDefaultBlockAtIndex = vi.fn().mockImplementation(() => {
+        blockManager.currentBlock = insertedBlock;
+      });
+
+      const host = blockSelection as unknown as {
+        replaceSelectedBlocksWithPrintableKey: (event: KeyboardEvent) => void;
+      };
+
+      host.replaceSelectedBlocksWithPrintableKey({ key: 'Enter' } as KeyboardEvent);
+
+      expect(blockManager.insertDefaultBlockAtIndex).toHaveBeenCalledWith(2, true);
+      expect(caret.setToBlock).toHaveBeenCalledWith(insertedBlock);
+      expect(caret.insertContentAtCaretPosition).toHaveBeenCalledWith('');
+    });
+  });
+
+  describe('prepare', () => {
+    it('creates selection instance and registers shortcut handler', () => {
+      const { blockSelection, redactor } = createBlockSelection();
+      const shortcutsAdd = vi.spyOn(Shortcuts, 'add').mockImplementation(() => undefined);
+
+      blockSelection.prepare();
+
+      expect(shortcutsAdd).toHaveBeenCalledWith(
+        expect.objectContaining({ name: 'CMD+A',
+          on: redactor })
+      );
+      expect((blockSelection as unknown as { selection: SelectionUtils }).selection).toBeInstanceOf(SelectionUtils);
+    });
+
+    it('handles read-only mode by selecting all blocks via shortcut handler', () => {
+      const { blockSelection, modules } = createBlockSelection();
+
+      Object.defineProperty(modules.ReadOnly, 'isEnabled', {
+        value: true,
+        writable: true,
+        configurable: true,
+      });
+      const selectAllSpy = vi.spyOn(blockSelection as unknown as { selectAllBlocks: () => void }, 'selectAllBlocks');
+      const shortcutsAdd = vi.spyOn(Shortcuts, 'add').mockImplementation(() => undefined);
+
+      blockSelection.prepare();
+
+      expect(shortcutsAdd).toHaveBeenCalledTimes(1);
+
+      const handler = (shortcutsAdd.mock.calls[0]?.[0] as { handler: (event: KeyboardEvent) => void }).handler;
+      const event = {
+        preventDefault: vi.fn(),
+      } as unknown as KeyboardEvent;
+
+      handler(event);
+
+      expect(event.preventDefault).toHaveBeenCalledTimes(1);
+      expect(selectAllSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('destroy', () => {
+    it('removes the CMD+A shortcut', () => {
+      const { blockSelection, modules } = createBlockSelection();
+      const shortcutsRemove = vi.spyOn(Shortcuts, 'remove').mockImplementation(() => undefined);
+
+      blockSelection.destroy();
+
+      expect(shortcutsRemove).toHaveBeenCalledWith(modules.UI.nodes.redactor, 'CMD+A');
+    });
+  });
+});
diff --git a/test/unit/components/modules/caret.test.ts b/test/unit/components/modules/caret.test.ts
new file mode 100644
index 000000000..1b0dde33a
--- /dev/null
+++ b/test/unit/components/modules/caret.test.ts
@@ -0,0 +1,576 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import Caret from '../../../../src/components/modules/caret';
+import EventsDispatcher from '../../../../src/components/utils/events';
+import type { EditorEventMap } from '../../../../src/components/events';
+import type { EditorModules } from '../../../../src/types-internal/editor-modules';
+import type { EditorConfig } from '../../../../types';
+import type Block from '../../../../src/components/block';
+import Selection from '../../../../src/components/selection';
+import * as caretUtils from '../../../../src/components/utils/caret';
+
+type BlockManagerStub = {
+  currentBlock?: Block;
+  nextBlock: Block | null;
+  previousBlock: Block | null;
+  lastBlock?: Block;
+  insertAtEnd: ReturnType<typeof vi.fn>;
+  setCurrentBlockByChildNode: ReturnType<typeof vi.fn>;
+};
+
+type BlockSelectionStub = {
+  clearSelection: ReturnType<typeof vi.fn>;
+  selectBlock: ReturnType<typeof vi.fn>;
+};
+
+type CaretSetup = {
+  caret: Caret;
+  blockManager: BlockManagerStub;
+  blockSelection: BlockSelectionStub;
+};
+
+type BlockOptions = {
+  focusable?: boolean;
+  isEmpty?: boolean;
+  tool?: { isDefault: boolean };
+  inputs?: {
+    first?: HTMLElement;
+    last?: HTMLElement;
+    current?: HTMLElement;
+    next?: HTMLElement;
+    previous?: HTMLElement;
+  };
+};
+
+const createContentEditable = (html = 'text'): HTMLElement => {
+  const element = document.createElement('div');
+
+  element.contentEditable = 'true';
+  element.innerHTML = html;
+
+  return element;
+};
+
+const attachInput = (holder: HTMLElement, input?: HTMLElement): HTMLElement | undefined => {
+  if (!input) {
+    return undefined;
+  }
+
+  if (!holder.contains(input)) {
+    holder.appendChild(input);
+  }
+
+  return input;
+};
+
+const createBlock = (options: BlockOptions = {}): Block => {
+  const holder = document.createElement('div');
+
+  holder.classList.add('ce-block');
+
+  const defaultInput = attachInput(holder, options.inputs?.current) ?? createContentEditable();
+
+  attachInput(holder, options.inputs?.first);
+  attachInput(holder, options.inputs?.last);
+
+  const blockStub = {
+    holder,
+    focusable: options.focusable ?? true,
+    isEmpty: options.isEmpty ?? false,
+    tool: options.tool ?? { isDefault: true },
+    firstInput: options.inputs?.first ?? defaultInput,
+    lastInput: options.inputs?.last ?? defaultInput,
+    currentInput: defaultInput,
+    nextInput: options.inputs?.next,
+    previousInput: options.inputs?.previous,
+  };
+
+  return blockStub as unknown as Block;
+};
+
+const createCaret = (overrides: Partial<EditorModules> = {}): CaretSetup => {
+  const blockManager: BlockManagerStub = {
+    currentBlock: undefined,
+    nextBlock: null,
+    previousBlock: null,
+    lastBlock: undefined,
+    insertAtEnd: vi.fn(),
+    setCurrentBlockByChildNode: vi.fn(),
+  };
+
+  const blockSelection: BlockSelectionStub = {
+    clearSelection: vi.fn(),
+    selectBlock: vi.fn(),
+  };
+
+  const defaults: Partial<EditorModules> = {
+    BlockManager: blockManager as unknown as EditorModules['BlockManager'],
+    BlockSelection: blockSelection as unknown as EditorModules['BlockSelection'],
+  };
+
+  const caret = new Caret({
+    config: { sanitizer: {} } as EditorConfig,
+    eventsDispatcher: new EventsDispatcher<EditorEventMap>(),
+  });
+
+  caret.state = {
+    ...defaults,
+    ...overrides,
+  } as EditorModules;
+
+  return {
+    caret,
+    blockManager,
+    blockSelection,
+  };
+};
+
+const setCollapsedSelection = (node: Node, offset: number): void => {
+  const selection = window.getSelection();
+  const range = document.createRange();
+
+  range.setStart(node, offset);
+  range.setEnd(node, offset);
+
+  selection?.removeAllRanges();
+  selection?.addRange(range);
+};
+
+describe('Caret module', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    window.getSelection()?.removeAllRanges();
+  });
+
+  describe('setToBlock', () => {
+    it('highlights non focusable block instead of moving caret', () => {
+      const { caret, blockSelection, blockManager } = createCaret();
+      const block = createBlock({ focusable: false });
+      const removeAllRanges = vi.fn();
+
+      vi.spyOn(window, 'getSelection').mockReturnValue({
+        removeAllRanges,
+      } as unknown as globalThis.Selection | null);
+
+      caret.setToBlock(block);
+
+      expect(blockSelection.clearSelection).toHaveBeenCalledTimes(1);
+      expect(removeAllRanges).toHaveBeenCalledTimes(1);
+      expect(blockSelection.selectBlock).toHaveBeenCalledWith(block);
+      expect(blockManager.currentBlock).toBe(block);
+    });
+
+    it('places caret at the start of the first input', () => {
+      const { caret, blockManager } = createCaret();
+      const input = createContentEditable('Hello');
+      const textNode = input.firstChild as Text;
+      const block = createBlock({
+        inputs: { first: input,
+          current: input },
+      });
+      const setSpy = vi.spyOn(caret, 'set').mockImplementation(() => undefined);
+
+      blockManager.setCurrentBlockByChildNode.mockImplementation(() => {
+        blockManager.currentBlock = block;
+      });
+
+      caret.setToBlock(block, caret.positions.START);
+
+      expect(setSpy).toHaveBeenCalledTimes(1);
+      const [node, offset] = setSpy.mock.calls[0];
+
+      expect(node).toBe(textNode);
+      expect(offset).toBe(0);
+      expect(blockManager.currentBlock?.currentInput).toBe(input);
+    });
+
+    it('prefers last meaningful nested text node when setting caret to the end', () => {
+      const { caret, blockManager } = createCaret();
+      const lastMeaningful = document.createElement('strong');
+
+      lastMeaningful.textContent = 'Hello';
+
+      const trailingPunctuation = document.createElement('span');
+
+      trailingPunctuation.textContent = '!!!';
+
+      const input = createContentEditable('');
+
+      input.append(lastMeaningful, trailingPunctuation);
+
+      const block = createBlock({
+        inputs: { last: input,
+          current: input },
+      });
+      const setSpy = vi.spyOn(caret, 'set').mockImplementation(() => undefined);
+
+      blockManager.setCurrentBlockByChildNode.mockImplementation(() => {
+        blockManager.currentBlock = block;
+      });
+
+      caret.setToBlock(block, caret.positions.END);
+
+      expect(setSpy).toHaveBeenCalledTimes(1);
+      const [node, offset] = setSpy.mock.calls[0];
+
+      expect(node?.textContent).toBe('Hello');
+      expect(offset).toBe(5);
+    });
+  });
+
+  describe('setToInput', () => {
+    it('moves caret to requested position and updates current input reference', () => {
+      const { caret, blockManager } = createCaret();
+      const input = createContentEditable('Sample text');
+      const textNode = input.firstChild as Text;
+      const block = createBlock({
+        inputs: { current: input },
+      });
+
+      blockManager.currentBlock = block;
+
+      const setSpy = vi.spyOn(caret, 'set').mockImplementation(() => undefined);
+
+      caret.setToInput(input, caret.positions.END);
+
+      expect(setSpy).toHaveBeenCalledTimes(1);
+      const [node, offset] = setSpy.mock.calls[0];
+
+      expect(node).toBe(textNode);
+      expect(offset).toBe(textNode.length);
+      expect(block.currentInput).toBe(input);
+    });
+
+    it('uses provided offset only for default position', () => {
+      const { caret } = createCaret();
+      const input = createContentEditable('abc');
+      const setSpy = vi.spyOn(caret, 'set').mockImplementation(() => undefined);
+
+      caret.setToInput(input, caret.positions.DEFAULT, 2);
+
+      expect(setSpy).toHaveBeenCalledWith(input.firstChild, 2);
+    });
+  });
+
+  describe('navigateNext', () => {
+    it('focuses next input when caret is at the end', () => {
+      const { caret, blockManager } = createCaret();
+      const currentInput = createContentEditable('A');
+      const nextInput = createContentEditable('B');
+      const block = createBlock({
+        inputs: {
+          current: currentInput,
+          next: nextInput,
+        },
+      });
+
+      blockManager.currentBlock = block;
+      const setToInput = vi.spyOn(caret, 'setToInput').mockImplementation(() => undefined);
+
+      vi.spyOn(caretUtils, 'isCaretAtEndOfInput').mockReturnValue(true);
+
+      const result = caret.navigateNext();
+
+      expect(result).toBe(true);
+      expect(setToInput).toHaveBeenCalledWith(nextInput, caret.positions.START);
+    });
+
+    it('creates a default block when there is no next block', () => {
+      const { caret, blockManager } = createCaret();
+      const block = createBlock({
+        tool: { isDefault: false },
+        inputs: { current: createContentEditable('text') },
+      });
+
+      blockManager.currentBlock = block;
+      blockManager.nextBlock = null;
+
+      const insertedBlock = createBlock();
+
+      blockManager.insertAtEnd.mockReturnValue(insertedBlock);
+      const setToBlock = vi.spyOn(caret, 'setToBlock').mockImplementation(() => undefined);
+
+      vi.spyOn(caretUtils, 'isCaretAtEndOfInput').mockReturnValue(true);
+
+      const result = caret.navigateNext();
+
+      expect(result).toBe(true);
+      expect(blockManager.insertAtEnd).toHaveBeenCalledTimes(1);
+      expect(setToBlock).toHaveBeenCalledWith(insertedBlock, caret.positions.START);
+    });
+
+    it('does not move caret when navigation is not allowed', () => {
+      const { caret, blockManager } = createCaret();
+      const block = createBlock({
+        tool: { isDefault: true },
+        inputs: { current: createContentEditable('text') },
+      });
+
+      blockManager.currentBlock = block;
+      blockManager.nextBlock = null;
+
+      vi.spyOn(caretUtils, 'isCaretAtEndOfInput').mockReturnValue(false);
+
+      expect(caret.navigateNext()).toBe(false);
+      expect(blockManager.insertAtEnd).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('navigatePrevious', () => {
+    it('focuses previous input when caret is at the start', () => {
+      const { caret, blockManager } = createCaret();
+      const previousInput = createContentEditable('previous');
+      const currentInput = createContentEditable('current');
+      const block = createBlock({
+        inputs: {
+          current: currentInput,
+          previous: previousInput,
+        },
+      });
+
+      blockManager.currentBlock = block;
+
+      const setToInput = vi.spyOn(caret, 'setToInput').mockImplementation(() => undefined);
+
+      vi.spyOn(caretUtils, 'isCaretAtStartOfInput').mockReturnValue(true);
+
+      const result = caret.navigatePrevious();
+
+      expect(result).toBe(true);
+      expect(setToInput).toHaveBeenCalledWith(previousInput, caret.positions.END);
+    });
+
+    it('moves to previous block when available', () => {
+      const { caret, blockManager } = createCaret();
+      const currentBlock = createBlock({
+        inputs: { current: createContentEditable('content') },
+      });
+      const previousBlock = createBlock({
+        inputs: { current: createContentEditable('prev') },
+      });
+
+      blockManager.currentBlock = currentBlock;
+      blockManager.previousBlock = previousBlock;
+
+      const setToBlock = vi.spyOn(caret, 'setToBlock').mockImplementation(() => undefined);
+
+      vi.spyOn(caretUtils, 'isCaretAtStartOfInput').mockReturnValue(true);
+
+      const result = caret.navigatePrevious();
+
+      expect(result).toBe(true);
+      expect(setToBlock).toHaveBeenCalledWith(previousBlock, caret.positions.END);
+    });
+
+    it('stays on current block when caret is not at the start', () => {
+      const { caret, blockManager } = createCaret();
+      const currentBlock = createBlock({
+        inputs: { current: createContentEditable('content') },
+      });
+
+      blockManager.currentBlock = currentBlock;
+      blockManager.previousBlock = null;
+
+      vi.spyOn(caretUtils, 'isCaretAtStartOfInput').mockReturnValue(false);
+
+      expect(caret.navigatePrevious()).toBe(false);
+    });
+  });
+
+  describe('setToTheLastBlock', () => {
+    it('moves caret to the last default empty block', () => {
+      const { caret, blockManager } = createCaret();
+      const lastBlock = createBlock({
+        tool: { isDefault: true },
+        isEmpty: true,
+      });
+      const setToBlock = vi.spyOn(caret, 'setToBlock').mockImplementation(() => undefined);
+
+      blockManager.lastBlock = lastBlock;
+
+      caret.setToTheLastBlock();
+
+      expect(setToBlock).toHaveBeenCalledWith(lastBlock);
+    });
+
+    it('appends new block when the last one is filled or custom', () => {
+      const { caret, blockManager } = createCaret();
+      const lastBlock = createBlock({
+        tool: { isDefault: false },
+        isEmpty: false,
+      });
+      const newBlock = createBlock();
+      const setToBlock = vi.spyOn(caret, 'setToBlock').mockImplementation(() => undefined);
+
+      blockManager.lastBlock = lastBlock;
+      blockManager.insertAtEnd.mockReturnValue(newBlock);
+
+      caret.setToTheLastBlock();
+
+      expect(blockManager.insertAtEnd).toHaveBeenCalledTimes(1);
+      expect(setToBlock).toHaveBeenCalledWith(newBlock);
+    });
+  });
+
+  describe('extractFragmentFromCaretPosition', () => {
+    it('returns fragment from native inputs and updates value', () => {
+      const { caret, blockManager } = createCaret();
+      const input = document.createElement('input');
+
+      input.value = 'HelloWorld';
+      input.selectionStart = 5;
+      input.selectionEnd = 5;
+
+      const block = createBlock();
+
+      block.currentInput = input;
+      blockManager.currentBlock = block;
+
+      const selection = {
+        rangeCount: 1,
+        getRangeAt: vi.fn(() => ({
+          deleteContents: vi.fn(),
+        })),
+      } as unknown as globalThis.Selection;
+
+      vi.spyOn(Selection, 'get').mockReturnValue(selection);
+
+      const fragment = caret.extractFragmentFromCaretPosition();
+
+      expect(fragment?.textContent).toBe('World');
+      expect(input.value).toBe('Hello');
+    });
+
+    it('extracts contenteditable fragment starting from caret', () => {
+      const { caret, blockManager } = createCaret();
+      const input = createContentEditable('abcdef');
+      const textNode = input.firstChild as Text;
+      const block = createBlock({
+        inputs: { current: input },
+      });
+
+      document.body.appendChild(input);
+      setCollapsedSelection(textNode, 2);
+
+      blockManager.currentBlock = block;
+
+      const fragment = caret.extractFragmentFromCaretPosition();
+
+      expect(fragment).toBeInstanceOf(DocumentFragment);
+      expect(fragment?.textContent).toBe('cdef');
+      expect(input.textContent).toBe('ab');
+    });
+  });
+
+  describe('insertContentAtCaretPosition', () => {
+    it('inserts provided html fragment and updates selection', () => {
+      const { caret } = createCaret();
+      const container = createContentEditable('Hello');
+      const textNode = container.firstChild as Text;
+
+      document.body.appendChild(container);
+      setCollapsedSelection(textNode, textNode.length);
+
+      caret.insertContentAtCaretPosition('<span>!</span>');
+
+      expect(container.innerHTML).toBe('Hello<span>!</span>');
+
+      const selection = window.getSelection();
+
+      expect(selection?.focusNode?.textContent).toBe('!');
+      expect(selection?.focusOffset).toBe(1);
+    });
+
+    it('appends empty text node when fragment has no nodes', () => {
+      const { caret } = createCaret();
+      const container = createContentEditable('Hello');
+      const textNode = container.firstChild as Text;
+
+      document.body.appendChild(container);
+      setCollapsedSelection(textNode, textNode.length);
+
+      caret.insertContentAtCaretPosition('');
+
+      const lastChild = container.lastChild as Text;
+
+      expect(lastChild).toBeInstanceOf(Text);
+      expect(lastChild.textContent).toBe('');
+    });
+  });
+
+  describe('shadow caret helpers', () => {
+    it('creates and removes shadow caret element', () => {
+      const { caret } = createCaret();
+      const container = createContentEditable('text');
+
+      document.body.appendChild(container);
+
+      caret.createShadow(container);
+
+      const shadow = container.querySelector('.cdx-shadow-caret');
+
+      expect(shadow).not.toBeNull();
+
+      caret.restoreCaret(container);
+
+      expect(container.querySelector('.cdx-shadow-caret')).toBeNull();
+    });
+  });
+
+  describe('resolveEndPositionNode', () => {
+    it('returns native input node with its content length', () => {
+      const { caret } = createCaret();
+      const input = document.createElement('textarea');
+
+      input.value = 'text';
+
+      const resolver = (caret as unknown as {
+        resolveEndPositionNode: (el: HTMLElement) => { node: Node | null; offset: number };
+      }).resolveEndPositionNode;
+
+      const { node, offset } = resolver(input);
+
+      expect(node).toBe(input);
+      expect(offset).toBe(4);
+    });
+
+    it('returns last text node when punctuation is at the root level', () => {
+      const { caret } = createCaret();
+      const element = createContentEditable('');
+      const firstText = document.createTextNode('Hello');
+      const punctuation = document.createTextNode('!!!');
+
+      element.append(firstText, punctuation);
+
+      const resolver = (caret as unknown as {
+        resolveEndPositionNode: (el: HTMLElement) => { node: Node | null; offset: number };
+      }).resolveEndPositionNode;
+
+      const { node, offset } = resolver(element);
+
+      expect(node).toBe(punctuation);
+      expect(offset).toBe(3);
+    });
+
+    it('treats unicode punctuation as meaningful text', () => {
+      const { caret } = createCaret();
+      const element = createContentEditable('');
+      const first = document.createTextNode('Hi');
+      const unicodePunctuation = document.createTextNode('—');
+
+      element.append(first, unicodePunctuation);
+
+      const resolver = (caret as unknown as {
+        resolveEndPositionNode: (el: HTMLElement) => { node: Node | null; offset: number };
+      }).resolveEndPositionNode;
+
+      const { node, offset } = resolver(element);
+
+      expect(node).toBe(unicodePunctuation);
+      expect(offset).toBe(1);
+    });
+  });
+});
diff --git a/test/unit/components/modules/crossBlockSelection.test.ts b/test/unit/components/modules/crossBlockSelection.test.ts
new file mode 100644
index 000000000..d07542e6c
--- /dev/null
+++ b/test/unit/components/modules/crossBlockSelection.test.ts
@@ -0,0 +1,459 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import CrossBlockSelection from '../../../../src/components/modules/crossBlockSelection';
+import * as _ from '../../../../src/components/utils';
+import type Block from '../../../../src/components/block';
+import type Listeners from '../../../../src/components/utils/listeners';
+
+type MutableSelection = Selection & {
+  isCollapsed: boolean;
+  removeAllRanges: ReturnType<typeof vi.fn>;
+  addRange: ReturnType<typeof vi.fn>;
+  rangeCount: number;
+  anchorNode: Node | null;
+  focusNode: Node | null;
+};
+
+type BlockWithSelection = Block & {
+  scrollIntoView: ReturnType<typeof vi.fn>;
+};
+
+const accessPrivate = <T>(instance: CrossBlockSelection, key: string): T =>
+  (instance as unknown as Record<string, T>)[key];
+
+const setPrivate = <T>(instance: CrossBlockSelection, key: string, value: T): void => {
+  // eslint-disable-next-line no-param-reassign
+  (instance as unknown as Record<string, T>)[key] = value;
+};
+
+const createBlockStub = (): BlockWithSelection => {
+  const holder = document.createElement('div');
+
+  holder.scrollIntoView = vi.fn() as ReturnType<typeof vi.fn>;
+  let selected = false;
+
+  const stub = {
+    holder,
+  } as Record<string, unknown>;
+
+  Object.defineProperty(stub, 'selected', {
+    configurable: true,
+    get: () => selected,
+    set: (value: boolean) => {
+      selected = value;
+    },
+  });
+
+  return stub as unknown as BlockWithSelection;
+};
+
+describe('CrossBlockSelection', () => {
+  let crossBlockSelection: CrossBlockSelection;
+  let blocks: BlockWithSelection[];
+  let toolbarClose: ReturnType<typeof vi.fn>;
+  let inlineToolbarClose: ReturnType<typeof vi.fn>;
+  let blockSelectionClearCache: ReturnType<typeof vi.fn>;
+  let blockSelectionClearSelection: ReturnType<typeof vi.fn>;
+  let caretSetToBlock: ReturnType<typeof vi.fn>;
+  let selectionMock: MutableSelection;
+  let redactor: HTMLElement;
+
+  beforeEach(() => {
+    toolbarClose = vi.fn();
+    inlineToolbarClose = vi.fn();
+    blockSelectionClearCache = vi.fn();
+    blockSelectionClearSelection = vi.fn();
+    caretSetToBlock = vi.fn();
+
+    blocks = Array.from({ length: 4 }, () => createBlockStub());
+
+    crossBlockSelection = new CrossBlockSelection({
+      config: {},
+      eventsDispatcher: {
+        on: vi.fn(),
+        off: vi.fn(),
+      } as unknown as typeof crossBlockSelection['eventsDispatcher'],
+    });
+
+    redactor = document.createElement('div');
+
+    blocks.forEach((block) => {
+      redactor.appendChild(block.holder);
+    });
+
+    const findBlockByNode = (node: Node | null): BlockWithSelection | null => {
+      if (!node) {
+        return null;
+      }
+
+      return (
+        blocks.find((candidate) => candidate.holder === node || candidate.holder.contains(node)) ?? null
+      );
+    };
+
+    const blockManager = {
+      blocks,
+      currentBlock: blocks[0],
+      getBlock: vi.fn((element: HTMLElement) => findBlockByNode(element)),
+      getBlockByChildNode: vi.fn((node: Node) => findBlockByNode(node)),
+    };
+
+    crossBlockSelection.state = {
+      BlockManager: blockManager,
+      BlockSelection: {
+        clearCache: blockSelectionClearCache,
+        clearSelection: blockSelectionClearSelection,
+        anyBlockSelected: false,
+      },
+      InlineToolbar: {
+        close: inlineToolbarClose,
+      },
+      Toolbar: {
+        close: toolbarClose,
+      },
+      Caret: {
+        positions: {
+          START: 'start',
+          END: 'end',
+          DEFAULT: 'default',
+        },
+        setToBlock: caretSetToBlock,
+      },
+      UI: {
+        nodes: {
+          redactor,
+        },
+      },
+    } as unknown as CrossBlockSelection['Editor'];
+
+    setPrivate(crossBlockSelection, 'firstSelectedBlock', blocks[0]);
+    setPrivate(crossBlockSelection, 'lastSelectedBlock', blocks[0]);
+
+    selectionMock = {
+      removeAllRanges: vi.fn(),
+      addRange: vi.fn(),
+      rangeCount: 0,
+      anchorNode: null,
+      focusNode: null,
+      isCollapsed: true,
+    } as unknown as MutableSelection;
+
+    vi.spyOn(window, 'getSelection').mockReturnValue(selectionMock);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('prepare', () => {
+    it('subscribes to document mousedown and forwards events to enableCrossBlockSelection', async () => {
+      const listeners = accessPrivate<Listeners>(crossBlockSelection, 'listeners');
+      const onSpy = vi.spyOn(listeners, 'on');
+      const enableSpy = vi.spyOn(
+        crossBlockSelection as unknown as { enableCrossBlockSelection: (event: MouseEvent) => void },
+        'enableCrossBlockSelection'
+      );
+      let capturedHandler: ((event: MouseEvent) => void) | undefined;
+
+      onSpy.mockImplementation((_element, _event, handler) => {
+        capturedHandler = handler as (event: MouseEvent) => void;
+
+        return 'listener-id';
+      });
+
+      await crossBlockSelection.prepare();
+
+      expect(onSpy).toHaveBeenCalledWith(document, 'mousedown', expect.any(Function));
+      expect(capturedHandler).toBeDefined();
+
+      const event = new MouseEvent('mousedown');
+
+      capturedHandler?.(event);
+
+      expect(enableSpy).toHaveBeenCalledWith(event);
+    });
+  });
+
+  describe('watchSelection', () => {
+    it('sets selection bounds and attaches mouse listeners when left button is pressed', () => {
+      const listeners = accessPrivate<Listeners>(crossBlockSelection, 'listeners');
+      const onSpy = vi.spyOn(listeners, 'on').mockReturnValue('listener-id');
+      const editorState = accessPrivate<CrossBlockSelection['Editor']>(crossBlockSelection, 'Editor');
+      const blockManager = editorState.BlockManager;
+
+      (blockManager.getBlock as ReturnType<typeof vi.fn>).mockReturnValue(blocks[1]);
+
+      crossBlockSelection.watchSelection({
+        button: _.mouseButtons.LEFT,
+        target: blocks[1].holder,
+      } as unknown as MouseEvent);
+
+      expect(blockManager.getBlock).toHaveBeenCalledWith(blocks[1].holder);
+      expect(onSpy).toHaveBeenCalledWith(document, 'mouseover', expect.any(Function));
+      expect(onSpy).toHaveBeenCalledWith(document, 'mouseup', expect.any(Function));
+      expect(accessPrivate<Block>(crossBlockSelection, 'firstSelectedBlock')).toBe(blocks[1]);
+      expect(accessPrivate<Block>(crossBlockSelection, 'lastSelectedBlock')).toBe(blocks[1]);
+    });
+
+    it('ignores non-left mouse buttons', () => {
+      const listeners = accessPrivate<Listeners>(crossBlockSelection, 'listeners');
+      const onSpy = vi.spyOn(listeners, 'on');
+      const editorState = accessPrivate<CrossBlockSelection['Editor']>(crossBlockSelection, 'Editor');
+      const blockManager = editorState.BlockManager;
+
+      crossBlockSelection.watchSelection({
+        button: _.mouseButtons.RIGHT,
+        target: blocks[2].holder,
+      } as unknown as MouseEvent);
+
+      expect(blockManager.getBlock).not.toHaveBeenCalled();
+      expect(onSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('isCrossBlockSelectionStarted', () => {
+    it('returns true when selection spans multiple blocks', () => {
+      setPrivate(crossBlockSelection, 'firstSelectedBlock', blocks[0]);
+      setPrivate(crossBlockSelection, 'lastSelectedBlock', blocks[2]);
+
+      expect(crossBlockSelection.isCrossBlockSelectionStarted).toBe(true);
+    });
+
+    it('returns false when selection does not span multiple blocks', () => {
+      setPrivate(crossBlockSelection, 'firstSelectedBlock', blocks[1]);
+      setPrivate(crossBlockSelection, 'lastSelectedBlock', blocks[1]);
+
+      expect(crossBlockSelection.isCrossBlockSelectionStarted).toBe(false);
+
+      setPrivate(crossBlockSelection, 'firstSelectedBlock', null);
+      setPrivate(crossBlockSelection, 'lastSelectedBlock', blocks[1]);
+
+      expect(crossBlockSelection.isCrossBlockSelectionStarted).toBe(false);
+    });
+  });
+
+  describe('toggleBlockSelectedState', () => {
+    it('selects the next block and closes toolbars when extending selection forward', () => {
+      selectionMock.removeAllRanges.mockClear();
+
+      crossBlockSelection.toggleBlockSelectedState(true);
+
+      expect(blocks[0].selected).toBe(true);
+      expect(blocks[1].selected).toBe(true);
+      expect(blockSelectionClearCache).toHaveBeenCalled();
+      expect(selectionMock.removeAllRanges).toHaveBeenCalled();
+      expect(toolbarClose).toHaveBeenCalled();
+      expect(inlineToolbarClose).toHaveBeenCalled();
+      expect(blocks[1].holder.scrollIntoView).toHaveBeenCalledWith({ block: 'nearest' });
+    });
+
+    it('deselects the previous block when shrinking the selection', () => {
+      setPrivate(crossBlockSelection, 'firstSelectedBlock', blocks[1]);
+      setPrivate(crossBlockSelection, 'lastSelectedBlock', blocks[1]);
+      blocks[1].selected = true;
+      blocks[2].selected = true;
+
+      crossBlockSelection.toggleBlockSelectedState(true);
+
+      expect(blocks[1].selected).toBe(false);
+      expect(blocks[2].selected).toBe(true);
+      expect(blockSelectionClearCache).toHaveBeenCalled();
+      expect(toolbarClose).toHaveBeenCalled();
+    });
+  });
+
+  describe('clear', () => {
+    const createKeyboardEventWithKey = (key: string): KeyboardEvent => {
+      return new KeyboardEvent('keydown', { key });
+    };
+
+    it('restores caret position at the end when clearing with ArrowDown', () => {
+      const editorState = accessPrivate<CrossBlockSelection['Editor']>(crossBlockSelection, 'Editor');
+
+      (editorState.BlockSelection as { anyBlockSelected: boolean }).anyBlockSelected = true;
+      setPrivate(crossBlockSelection, 'firstSelectedBlock', blocks[0]);
+      setPrivate(crossBlockSelection, 'lastSelectedBlock', blocks[2]);
+
+      crossBlockSelection.clear(createKeyboardEventWithKey('ArrowDown'));
+
+      expect(caretSetToBlock).toHaveBeenCalledWith(blocks[2], editorState.Caret.positions.END);
+      expect(accessPrivate<Block | null>(crossBlockSelection, 'firstSelectedBlock')).toBeNull();
+      expect(accessPrivate<Block | null>(crossBlockSelection, 'lastSelectedBlock')).toBeNull();
+    });
+
+    it('restores caret at the start when clearing with ArrowUp', () => {
+      const editorState = accessPrivate<CrossBlockSelection['Editor']>(crossBlockSelection, 'Editor');
+
+      (editorState.BlockSelection as { anyBlockSelected: boolean }).anyBlockSelected = true;
+      setPrivate(crossBlockSelection, 'firstSelectedBlock', blocks[0]);
+      setPrivate(crossBlockSelection, 'lastSelectedBlock', blocks[2]);
+
+      crossBlockSelection.clear(createKeyboardEventWithKey('ArrowUp'));
+
+      expect(caretSetToBlock).toHaveBeenCalledWith(blocks[0], editorState.Caret.positions.START);
+    });
+
+    it('skips caret restoration when nothing is selected', () => {
+      const editorState = accessPrivate<CrossBlockSelection['Editor']>(crossBlockSelection, 'Editor');
+
+      (editorState.BlockSelection as { anyBlockSelected: boolean }).anyBlockSelected = false;
+      setPrivate(crossBlockSelection, 'firstSelectedBlock', blocks[0]);
+      setPrivate(crossBlockSelection, 'lastSelectedBlock', blocks[2]);
+
+      crossBlockSelection.clear();
+
+      expect(caretSetToBlock).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('enableCrossBlockSelection', () => {
+    let enableCrossBlockSelection: (event: MouseEvent) => void;
+
+    beforeEach(() => {
+      enableCrossBlockSelection = accessPrivate(crossBlockSelection, 'enableCrossBlockSelection');
+    });
+
+    it('clears block selection when there is an active DOM selection', () => {
+      selectionMock.isCollapsed = false;
+
+      const event = new MouseEvent('mousedown');
+
+      enableCrossBlockSelection.call(crossBlockSelection, event);
+
+      expect(blockSelectionClearSelection).toHaveBeenCalledWith(event);
+    });
+
+    it('starts watching selection when mousedown occurs within the redactor', () => {
+      selectionMock.isCollapsed = true;
+      const watchSpy = vi.spyOn(crossBlockSelection, 'watchSelection');
+      const event = {
+        target: blocks[1].holder,
+      } as unknown as MouseEvent;
+
+      enableCrossBlockSelection.call(crossBlockSelection, event);
+
+      expect(watchSpy).toHaveBeenCalledWith(event);
+      expect(blockSelectionClearSelection).not.toHaveBeenCalled();
+    });
+
+    it('clears selection when mousedown happens outside the redactor', () => {
+      selectionMock.isCollapsed = true;
+      const watchSpy = vi.spyOn(crossBlockSelection, 'watchSelection');
+      const event = {
+        target: document.body,
+      } as unknown as MouseEvent;
+
+      enableCrossBlockSelection.call(crossBlockSelection, event);
+
+      expect(watchSpy).not.toHaveBeenCalled();
+      expect(blockSelectionClearSelection).toHaveBeenCalledWith(event);
+    });
+  });
+
+  describe('onMouseUp', () => {
+    it('removes temporary listeners', () => {
+      const listeners = accessPrivate<Listeners>(crossBlockSelection, 'listeners');
+      const offSpy = vi.spyOn(listeners, 'off');
+
+      accessPrivate<() => void>(crossBlockSelection, 'onMouseUp')();
+
+      expect(offSpy).toHaveBeenCalledWith(document, 'mouseover', accessPrivate(crossBlockSelection, 'onMouseOver'));
+      expect(offSpy).toHaveBeenCalledWith(document, 'mouseup', accessPrivate(crossBlockSelection, 'onMouseUp'));
+    });
+  });
+
+  describe('onMouseOver', () => {
+    it('selects both edges when extending from the first selected block', () => {
+      const event = {
+        relatedTarget: blocks[0].holder,
+        target: blocks[1].holder,
+      } as unknown as MouseEvent;
+
+      blocks[0].selected = false;
+      blocks[1].selected = false;
+
+      accessPrivate<(event: MouseEvent) => void>(crossBlockSelection, 'onMouseOver')(event);
+
+      expect(selectionMock.removeAllRanges).toHaveBeenCalled();
+      expect(blocks[0].selected).toBe(true);
+      expect(blocks[1].selected).toBe(true);
+      expect(blockSelectionClearCache).toHaveBeenCalled();
+    });
+
+    it('deselects blocks when returning to the first selected block', () => {
+      const event = {
+        relatedTarget: blocks[1].holder,
+        target: blocks[0].holder,
+      } as unknown as MouseEvent;
+
+      blocks[0].selected = true;
+      blocks[1].selected = true;
+
+      accessPrivate<(event: MouseEvent) => void>(crossBlockSelection, 'onMouseOver')(event);
+
+      expect(blocks[0].selected).toBe(false);
+      expect(blocks[1].selected).toBe(false);
+      expect(blockSelectionClearCache).toHaveBeenCalled();
+    });
+
+    it('delegates range toggling to toggleBlocksSelectedState for intermediate blocks', () => {
+      const toggleSpy = vi.spyOn(
+        crossBlockSelection as unknown as {
+          toggleBlocksSelectedState: (firstBlock: Block, lastBlock: Block) => void;
+        },
+        'toggleBlocksSelectedState'
+      );
+
+      const event = {
+        relatedTarget: blocks[1].holder,
+        target: blocks[2].holder,
+      } as unknown as MouseEvent;
+
+      accessPrivate<(event: MouseEvent) => void>(crossBlockSelection, 'onMouseOver')(event);
+
+      expect(inlineToolbarClose).toHaveBeenCalled();
+      expect(toggleSpy).toHaveBeenCalledWith(blocks[1], blocks[2]);
+      expect(accessPrivate<Block>(crossBlockSelection, 'lastSelectedBlock')).toBe(blocks[2]);
+    });
+  });
+
+  describe('toggleBlocksSelectedState', () => {
+    it('toggles intermediate blocks when edges have different selection state', () => {
+      setPrivate(crossBlockSelection, 'firstSelectedBlock', blocks[0]);
+
+      blocks[1].selected = false;
+      blocks[2].selected = false;
+      blocks[3].selected = true;
+
+      const toggleBlocksSelectedState = accessPrivate<
+        (firstBlock: Block, lastBlock: Block) => void
+          >(crossBlockSelection, 'toggleBlocksSelectedState');
+
+      toggleBlocksSelectedState.call(crossBlockSelection, blocks[1], blocks[3]);
+
+      expect(blocks[1].selected).toBe(false);
+      expect(blocks[2].selected).toBe(true);
+      expect(blocks[3].selected).toBe(false);
+      expect(blockSelectionClearCache).toHaveBeenCalledTimes(2);
+      expect(toolbarClose).toHaveBeenCalled();
+    });
+
+    it('does not toggle the last block when edges have identical selection state', () => {
+      setPrivate(crossBlockSelection, 'firstSelectedBlock', blocks[0]);
+
+      blocks[1].selected = false;
+      blocks[2].selected = false;
+
+      const toggleBlocksSelectedState = accessPrivate<
+        (firstBlock: Block, lastBlock: Block) => void
+          >(crossBlockSelection, 'toggleBlocksSelectedState');
+
+      toggleBlocksSelectedState.call(crossBlockSelection, blocks[1], blocks[2]);
+
+      expect(blocks[1].selected).toBe(true);
+      expect(blocks[2].selected).toBe(false);
+      expect(blockSelectionClearCache).toHaveBeenCalledTimes(1);
+      expect(toolbarClose).toHaveBeenCalled();
+    });
+  });
+});
+
diff --git a/test/unit/components/modules/dragNDrop.test.ts b/test/unit/components/modules/dragNDrop.test.ts
new file mode 100644
index 000000000..22a92302f
--- /dev/null
+++ b/test/unit/components/modules/dragNDrop.test.ts
@@ -0,0 +1,270 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import DragNDrop from '../../../../src/components/modules/dragNDrop';
+import SelectionUtils from '../../../../src/components/selection';
+import EventsDispatcher from '../../../../src/components/utils/events';
+import type { EditorEventMap } from '../../../../src/components/events';
+import type { EditorModules } from '../../../../src/types-internal/editor-modules';
+import type { EditorConfig } from '../../../../types';
+import type Block from '../../../../src/components/block';
+
+type TestModules = {
+  UI: {
+    nodes: {
+      holder: HTMLElement;
+    };
+  };
+  BlockManager: {
+    blocks: Block[];
+    setCurrentBlockByChildNode: ReturnType<typeof vi.fn>;
+    lastBlock: Block | { holder: HTMLElement };
+  };
+  Paste: {
+    processDataTransfer: ReturnType<typeof vi.fn>;
+  };
+  Caret: {
+    setToBlock: ReturnType<typeof vi.fn>;
+    positions: {
+      START: string;
+      END: string;
+    };
+  };
+  InlineToolbar: {
+    close: ReturnType<typeof vi.fn>;
+  };
+};
+type PartialModules = Partial<TestModules>;
+type DragNDropTestContext = {
+  dragNDrop: DragNDrop;
+  modules: TestModules;
+};
+type InternalDragNDrop = {
+  readOnlyMutableListeners: {
+    on: (element: EventTarget, event: string, handler: (event: Event) => void, options?: boolean | AddEventListenerOptions) => void;
+    clearAll: () => void;
+  };
+  processDrop: (event: DragEvent) => Promise<void>;
+  processDragStart: () => void;
+  processDragOver: (event: DragEvent) => void;
+  isStartedAtEditor: boolean;
+};
+
+const createDragNDrop = (overrides: PartialModules = {}): DragNDropTestContext => {
+  const dragNDrop = new DragNDrop({
+    config: {} as EditorConfig,
+    eventsDispatcher: new EventsDispatcher<EditorEventMap>(),
+  });
+
+  const holder = document.createElement('div');
+  const lastBlockHolder = document.createElement('div');
+
+  const defaults: TestModules = {
+    UI: {
+      nodes: {
+        holder,
+      },
+    },
+    BlockManager: {
+      blocks: [],
+      setCurrentBlockByChildNode: vi.fn(),
+      lastBlock: {
+        holder: lastBlockHolder,
+      },
+    },
+    Paste: {
+      processDataTransfer: vi.fn().mockResolvedValue(undefined),
+    },
+    Caret: {
+      setToBlock: vi.fn(),
+      positions: {
+        START: 'start-position',
+        END: 'end-position',
+      },
+    },
+    InlineToolbar: {
+      close: vi.fn(),
+    },
+  };
+
+  const mergedState: TestModules = {
+    ...defaults,
+    ...overrides,
+  };
+
+  dragNDrop.state = mergedState as unknown as EditorModules;
+
+  return {
+    dragNDrop,
+    modules: mergedState,
+  };
+};
+
+describe('DragNDrop', () => {
+  let dragNDrop: DragNDrop;
+  let modules: TestModules;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    ({
+      dragNDrop,
+      modules,
+    } = createDragNDrop());
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const getInternal = (): InternalDragNDrop => {
+    return dragNDrop as unknown as InternalDragNDrop;
+  };
+
+  it('clears listeners when toggled to read-only mode', () => {
+    const internal = getInternal();
+    const clearSpy = vi.spyOn(internal.readOnlyMutableListeners, 'clearAll');
+
+    dragNDrop.toggleReadOnly(true);
+
+    expect(clearSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('attaches drag-and-drop listeners when read-only mode is disabled', () => {
+    const internal = getInternal();
+    const onSpy = vi.spyOn(internal.readOnlyMutableListeners, 'on');
+    const holder = modules.UI.nodes.holder;
+
+    dragNDrop.toggleReadOnly(false);
+
+    expect(onSpy).toHaveBeenNthCalledWith(1, holder, 'drop', expect.any(Function), true);
+    expect(onSpy).toHaveBeenNthCalledWith(2, holder, 'dragstart', expect.any(Function));
+    expect(onSpy).toHaveBeenNthCalledWith(3, holder, 'dragover', expect.any(Function), true);
+  });
+
+  it('marks drag start when selection exists in editor and closes inline toolbar', () => {
+    const internal = getInternal();
+    const { close } = modules.InlineToolbar;
+
+    vi.spyOn(SelectionUtils, 'isAtEditor', 'get').mockReturnValue(true);
+    vi.spyOn(SelectionUtils, 'isCollapsed', 'get').mockReturnValue(false);
+
+    internal.isStartedAtEditor = false;
+    internal.processDragStart();
+
+    expect(internal.isStartedAtEditor).toBe(true);
+    expect(close).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not mark drag start when selection is collapsed', () => {
+    const internal = getInternal();
+    const { close } = modules.InlineToolbar;
+
+    vi.spyOn(SelectionUtils, 'isAtEditor', 'get').mockReturnValue(true);
+    vi.spyOn(SelectionUtils, 'isCollapsed', 'get').mockReturnValue(true);
+
+    internal.isStartedAtEditor = false;
+    internal.processDragStart();
+
+    expect(internal.isStartedAtEditor).toBe(false);
+    expect(close).toHaveBeenCalledTimes(1);
+  });
+
+  it('resets blocks drop target and positions caret on found block after drop', async () => {
+    const internal = getInternal();
+    const blockA = { dropTarget: true } as unknown as Block;
+    const blockB = { dropTarget: true } as unknown as Block;
+    const targetBlock = { id: 'target-block' } as unknown as Block;
+    const blocksManager = modules.BlockManager;
+
+    blocksManager.blocks = [
+      blockA,
+      blockB,
+    ];
+    blocksManager.setCurrentBlockByChildNode = vi.fn().mockReturnValue(targetBlock);
+
+    const caret = modules.Caret;
+    const processDataTransfer = modules.Paste.processDataTransfer;
+
+    const dropEvent = {
+      preventDefault: vi.fn(),
+      target: document.createElement('div'),
+      dataTransfer: {} as DataTransfer,
+    } as unknown as DragEvent;
+
+    await internal.processDrop(dropEvent);
+
+    expect(dropEvent.preventDefault).toHaveBeenCalledTimes(1);
+    expect(blockA.dropTarget).toBe(false);
+    expect(blockB.dropTarget).toBe(false);
+    expect(caret.setToBlock).toHaveBeenCalledWith(targetBlock, caret.positions.END);
+    expect(processDataTransfer).toHaveBeenCalledWith(dropEvent.dataTransfer, true);
+    expect(internal.isStartedAtEditor).toBe(false);
+  });
+
+  it('falls back to the last block when drop target block is not found', async () => {
+    const internal = getInternal();
+    const lastBlock = { id: 'last',
+      holder: document.createElement('div') } as unknown as Block;
+    const blocksManager = modules.BlockManager;
+
+    blocksManager.lastBlock = lastBlock;
+    blocksManager.setCurrentBlockByChildNode = vi.fn()
+      .mockReturnValueOnce(undefined)
+      .mockReturnValueOnce(lastBlock);
+
+    const caret = modules.Caret;
+
+    const dropEvent = {
+      preventDefault: vi.fn(),
+      target: document.createElement('div'),
+      dataTransfer: {} as DataTransfer,
+    } as unknown as DragEvent;
+
+    await internal.processDrop(dropEvent);
+
+    expect(blocksManager.setCurrentBlockByChildNode).toHaveBeenNthCalledWith(1, dropEvent.target);
+    expect(blocksManager.setCurrentBlockByChildNode).toHaveBeenNthCalledWith(2, lastBlock.holder);
+    expect(caret.setToBlock).toHaveBeenCalledWith(lastBlock, caret.positions.END);
+  });
+
+  it('deletes selection when drop starts inside editor with non-collapsed selection', async () => {
+    const internal = getInternal();
+    const blocksManager = modules.BlockManager;
+
+    blocksManager.blocks = [];
+    blocksManager.setCurrentBlockByChildNode = vi.fn().mockReturnValue(undefined);
+
+    internal.isStartedAtEditor = true;
+
+    vi.spyOn(SelectionUtils, 'isAtEditor', 'get').mockReturnValue(true);
+    vi.spyOn(SelectionUtils, 'isCollapsed', 'get').mockReturnValue(false);
+
+    const execCommandMock = vi.fn().mockReturnValue(true);
+
+    (document as Document & { execCommand: (commandId: string) => boolean }).execCommand = execCommandMock;
+
+    const dropEvent = {
+      preventDefault: vi.fn(),
+      target: document.createElement('div'),
+      dataTransfer: {} as DataTransfer,
+    } as unknown as DragEvent;
+
+    await internal.processDrop(dropEvent);
+
+    expect(execCommandMock).toHaveBeenCalledWith('delete');
+    expect(internal.isStartedAtEditor).toBe(false);
+  });
+
+  it('prevents default behavior on drag over', () => {
+    const internal = getInternal();
+    const preventDefault = vi.fn();
+
+    internal.processDragOver({
+      preventDefault,
+    } as unknown as DragEvent);
+
+    expect(preventDefault).toHaveBeenCalledTimes(1);
+  });
+});
+
+
diff --git a/test/unit/components/modules/modificationsObserver.test.ts b/test/unit/components/modules/modificationsObserver.test.ts
new file mode 100644
index 000000000..6ef135b7f
--- /dev/null
+++ b/test/unit/components/modules/modificationsObserver.test.ts
@@ -0,0 +1,226 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+import ModificationsObserver from '../../../../src/components/modules/modificationsObserver';
+import { modificationsObserverBatchTimeout } from '../../../../src/components/constants';
+import {
+  BlockChanged,
+  FakeCursorAboutToBeToggled,
+  FakeCursorHaveBeenSet,
+  RedactorDomChanged
+} from '../../../../src/components/events';
+import EventsDispatcher from '../../../../src/components/utils/events';
+import type { EditorEventMap } from '../../../../src/components/events';
+import type { EditorConfig } from '../../../../types';
+import type { BlockMutationEvent, BlockMutationType } from '../../../../types/events/block';
+import type { EditorModules } from '../../../../src/types-internal/editor-modules';
+
+/**
+ * Stub implementation of MutationObserver used to capture and trigger callbacks in tests.
+ */
+class MutationObserverStub {
+  public static lastInstance: MutationObserverStub | null = null;
+
+  private readonly callback: MutationCallback;
+
+  public observe = vi.fn();
+
+  public disconnect = vi.fn();
+
+  public takeRecords = vi.fn(() => []);
+
+  /**
+   * Creates a stub that records the provided observer callback for later manual triggering.
+   *
+   * @param callback Mutation observer callback that should run when `trigger` is invoked.
+   */
+  constructor(callback: MutationCallback) {
+    this.callback = callback;
+    MutationObserverStub.lastInstance = this;
+  }
+
+  /**
+   * Invokes the stored callback with the supplied mutation records.
+   *
+   * @param mutations Mutation records that simulate DOM changes.
+   */
+  public trigger(mutations: MutationRecord[]): void {
+    this.callback(mutations, this as unknown as MutationObserver);
+  }
+}
+
+const createBlockMutationEvent = (
+  id: string,
+  type: BlockMutationType = 'block-changed'
+): BlockMutationEvent => new CustomEvent(type, {
+  detail: {
+    target: { id } as unknown,
+  },
+}) as BlockMutationEvent;
+
+const observeOptions = {
+  childList: true,
+  subtree: true,
+  characterData: true,
+  attributes: true,
+} as const;
+
+describe('ModificationsObserver', () => {
+  let originalMutationObserver: typeof MutationObserver | undefined;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    originalMutationObserver = globalThis.MutationObserver;
+    globalThis.MutationObserver = MutationObserverStub as unknown as typeof MutationObserver;
+    MutationObserverStub.lastInstance = null;
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    if (originalMutationObserver) {
+      globalThis.MutationObserver = originalMutationObserver;
+
+      return;
+    }
+    delete (globalThis as { MutationObserver?: typeof MutationObserver }).MutationObserver;
+  });
+
+  const createObserver = (
+    configOverrides?: Partial<EditorConfig>
+  ): {
+    observer: ModificationsObserver;
+    eventsDispatcher: EventsDispatcher<EditorEventMap>;
+    config: EditorConfig;
+    redactor: HTMLDivElement;
+    apiMethods: Record<string, never>;
+    onChange: ReturnType<typeof vi.fn>;
+  } => {
+    const eventsDispatcher = new EventsDispatcher<EditorEventMap>();
+    const onChange = vi.fn();
+    const config = {
+      onChange,
+      ...configOverrides,
+    } as unknown as EditorConfig;
+
+    const observer = new ModificationsObserver({
+      config,
+      eventsDispatcher,
+    });
+
+    const redactor = document.createElement('div');
+    const apiMethods = {} as Record<string, never>;
+
+    observer.state = {
+      UI: {
+        nodes: {
+          redactor,
+        },
+      },
+      API: {
+        methods: apiMethods,
+      },
+    } as unknown as EditorModules;
+
+    return {
+      observer,
+      eventsDispatcher,
+      config,
+      redactor,
+      apiMethods,
+      onChange,
+    };
+  };
+
+  it('observes the redactor element when enabled', () => {
+    const { observer, redactor } = createObserver();
+
+    observer.enable();
+
+    const instance = MutationObserverStub.lastInstance;
+
+    expect(instance).not.toBeNull();
+    expect(instance?.observe).toHaveBeenCalledWith(redactor, observeOptions);
+  });
+
+  it('disconnects the observer and prevents onChange while disabled', () => {
+    const { observer, eventsDispatcher, onChange } = createObserver();
+
+    observer.disable();
+
+    const instance = MutationObserverStub.lastInstance;
+
+    expect(instance).not.toBeNull();
+    expect(instance?.disconnect).toHaveBeenCalledTimes(1);
+
+    const blockEvent = createBlockMutationEvent('block-1');
+
+    eventsDispatcher.emit(BlockChanged, { event: blockEvent });
+    vi.advanceTimersByTime(modificationsObserverBatchTimeout + 1);
+
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('emits onChange with the latest single event after batching time', () => {
+    const { eventsDispatcher, onChange, apiMethods } = createObserver();
+
+    const firstEvent = createBlockMutationEvent('block-1');
+    const latestEvent = createBlockMutationEvent('block-1');
+
+    eventsDispatcher.emit(BlockChanged, { event: firstEvent });
+    eventsDispatcher.emit(BlockChanged, { event: latestEvent });
+
+    vi.advanceTimersByTime(modificationsObserverBatchTimeout);
+
+    expect(onChange).toHaveBeenCalledTimes(1);
+    expect(onChange).toHaveBeenCalledWith(apiMethods, latestEvent);
+  });
+
+  it('emits an array when batching multiple distinct events', () => {
+    const { eventsDispatcher, onChange, apiMethods } = createObserver();
+
+    const firstEvent = createBlockMutationEvent('block-1');
+    const secondEvent = createBlockMutationEvent('block-2');
+
+    eventsDispatcher.emit(BlockChanged, { event: firstEvent });
+    eventsDispatcher.emit(BlockChanged, { event: secondEvent });
+
+    vi.advanceTimersByTime(modificationsObserverBatchTimeout);
+
+    expect(onChange).toHaveBeenCalledTimes(1);
+    expect(onChange).toHaveBeenCalledWith(apiMethods, [firstEvent, secondEvent]);
+  });
+
+  it('emits RedactorDomChanged when mutations are observed', () => {
+    const { observer, eventsDispatcher } = createObserver();
+    const listener = vi.fn();
+
+    eventsDispatcher.on(RedactorDomChanged, listener);
+    observer.enable();
+
+    const instance = MutationObserverStub.lastInstance;
+    const mutations: MutationRecord[] = [];
+
+    instance?.trigger(mutations);
+
+    expect(listener).toHaveBeenCalledWith({ mutations });
+  });
+
+  it('reacts to fake cursor events by toggling observation', () => {
+    const { observer, eventsDispatcher, redactor } = createObserver();
+
+    observer.enable();
+
+    const instance = MutationObserverStub.lastInstance;
+
+    expect(instance).not.toBeNull();
+    expect(instance?.observe).toHaveBeenCalledWith(redactor, observeOptions);
+
+    eventsDispatcher.emit(FakeCursorAboutToBeToggled, { state: true });
+    expect(instance?.disconnect).toHaveBeenCalledTimes(1);
+
+    eventsDispatcher.emit(FakeCursorHaveBeenSet, { state: true });
+    expect(instance?.observe).toHaveBeenCalledTimes(2);
+  });
+});
+
+
diff --git a/test/unit/components/modules/paste.test.ts b/test/unit/components/modules/paste.test.ts
new file mode 100644
index 000000000..5d051d7be
--- /dev/null
+++ b/test/unit/components/modules/paste.test.ts
@@ -0,0 +1,767 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { SpyInstance } from 'vitest';
+
+import Paste from '../../../../src/components/modules/paste';
+import type BlockToolAdapter from '../../../../src/components/tools/block';
+import type { SanitizerConfig } from '../../../../types';
+import * as sanitizer from '../../../../src/components/utils/sanitizer';
+import Listeners from '../../../../src/components/utils/listeners';
+import * as utils from '../../../../src/components/utils';
+
+interface CreatePasteOptions {
+  defaultBlock?: string;
+  sanitizer?: SanitizerConfig;
+  defaultTool?: BlockToolAdapter;
+}
+
+type ListenersMock = {
+  instance: Listeners;
+  on: SpyInstance<
+    Parameters<Listeners['on']> extends Array<unknown> ? Parameters<Listeners['on']> : never,
+    ReturnType<Listeners['on']>
+  >;
+  off: SpyInstance<
+    Parameters<Listeners['off']> extends Array<unknown> ? Parameters<Listeners['off']> : never,
+    ReturnType<Listeners['off']>
+  >;
+};
+
+type BlockManagerMock = {
+  currentBlock: {
+    tool: {
+      isDefault: boolean;
+      baseSanitizeConfig?: SanitizerConfig;
+    };
+    isEmpty: boolean;
+    name?: string;
+    currentInput?: HTMLElement | null;
+  } | null;
+  paste: ReturnType<typeof vi.fn<[string, CustomEvent, boolean?], unknown>>;
+  insert: ReturnType<typeof vi.fn<[{ tool: string; data: unknown; replace: boolean }], unknown>>;
+  setCurrentBlockByChildNode: ReturnType<typeof vi.fn<[HTMLElement], unknown>>;
+};
+
+type CaretMock = {
+  positions: {
+    END: string;
+  };
+  setToBlock: ReturnType<typeof vi.fn<[unknown, string], void>>;
+  insertContentAtCaretPosition: ReturnType<typeof vi.fn<[string], void>>;
+};
+
+type ToolsMock = {
+  blockTools: Map<string, BlockToolAdapter>;
+  defaultTool: BlockToolAdapter;
+  getAllInlineToolsSanitizeConfig: ReturnType<typeof vi.fn<[], SanitizerConfig>>;
+};
+
+type ToolbarMock = {
+  close: ReturnType<typeof vi.fn<[], void>>;
+};
+
+type PasteMocks = {
+  listeners: ListenersMock;
+  BlockManager: BlockManagerMock;
+  Caret: CaretMock;
+  Tools: ToolsMock;
+  Toolbar: ToolbarMock;
+  holder: HTMLElement;
+};
+
+const createPaste = (options?: CreatePasteOptions): { paste: Paste; mocks: PasteMocks } => {
+  const holder = document.createElement('div');
+  const defaultBlockName = options?.defaultBlock ?? 'paragraph';
+  const defaultTool = options?.defaultTool ?? ({
+    name: defaultBlockName,
+    pasteConfig: {},
+    baseSanitizeConfig: {},
+  } as unknown as BlockToolAdapter);
+
+  const listenersInstance = new Listeners();
+  const listeners: ListenersMock = {
+    instance: listenersInstance,
+    on: vi.spyOn(listenersInstance, 'on'),
+    off: vi.spyOn(listenersInstance, 'off'),
+  };
+
+  const blockManager: BlockManagerMock = {
+    currentBlock: null,
+    paste: vi.fn<[string, CustomEvent, boolean?], unknown>(),
+    insert: vi.fn<[{ tool: string; data: unknown; replace: boolean }], unknown>(),
+    setCurrentBlockByChildNode: vi.fn<[HTMLElement], unknown>(),
+  };
+
+  const caret: CaretMock = {
+    positions: {
+      END: 'end',
+    },
+    setToBlock: vi.fn<[unknown, string], void>(),
+    insertContentAtCaretPosition: vi.fn<[string], void>(),
+  };
+
+  const tools: ToolsMock = {
+    blockTools: new Map<string, BlockToolAdapter>(),
+    defaultTool,
+    getAllInlineToolsSanitizeConfig: vi.fn<[], SanitizerConfig>(() => ({})),
+  };
+
+  const toolbar: ToolbarMock = {
+    close: vi.fn<[], void>(),
+  };
+
+  const paste = new Paste({
+    config: {
+      defaultBlock: options?.defaultBlock ?? 'paragraph',
+      sanitizer: options?.sanitizer ?? {},
+    },
+    eventsDispatcher: {
+      on: vi.fn(),
+      off: vi.fn(),
+    } as unknown as Paste['eventsDispatcher'],
+  });
+
+  const pasteWithInternals = paste as unknown as { listeners: Listeners; state: Paste['Editor'] };
+
+  pasteWithInternals.listeners = listeners.instance;
+
+  const editorState = {
+    BlockManager: blockManager,
+    Caret: caret,
+    Tools: tools,
+    Toolbar: toolbar,
+    UI: {
+      nodes: {
+        holder,
+      },
+    },
+  };
+
+  pasteWithInternals.state = editorState as unknown as Paste['Editor'];
+
+  return {
+    paste,
+    mocks: {
+      listeners,
+      BlockManager: blockManager,
+      Caret: caret,
+      Tools: tools,
+      Toolbar: toolbar,
+      holder,
+    },
+  };
+};
+
+describe('Paste module', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('collects tool configurations during prepare', async () => {
+    const { paste } = createPaste();
+    const processToolsSpy = vi.spyOn(paste as unknown as { processTools(): void }, 'processTools');
+
+    await paste.prepare();
+
+    expect(processToolsSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('processes every tool registered in Tools collection', () => {
+    const { paste, mocks } = createPaste();
+    const firstTool = {
+      name: 'first',
+      create: vi.fn(() => ({ onPaste: vi.fn() })),
+      pasteConfig: {},
+      baseSanitizeConfig: {},
+    } as unknown as BlockToolAdapter;
+    const secondTool = {
+      name: 'second',
+      create: vi.fn(() => ({ onPaste: vi.fn() })),
+      pasteConfig: {},
+      baseSanitizeConfig: {},
+    } as unknown as BlockToolAdapter;
+
+    mocks.Tools.blockTools.set('first', firstTool);
+    mocks.Tools.blockTools.set('second', secondTool);
+
+    const processToolSpy = vi.spyOn(paste as unknown as { processTool(tool: BlockToolAdapter): void }, 'processTool');
+
+    (paste as unknown as { processTools(): void }).processTools();
+
+    expect(processToolSpy).toHaveBeenCalledTimes(2);
+    expect(processToolSpy.mock.calls.map((args) => args[0])).toEqual([firstTool, secondTool]);
+  });
+
+  it('adds tools with disabled paste config to exception list and skips config collection', () => {
+    const { paste } = createPaste();
+    const tool = {
+      name: 'skip-tool',
+      create: vi.fn(() => ({ onPaste: vi.fn() })),
+      pasteConfig: false,
+      baseSanitizeConfig: {},
+    } as unknown as BlockToolAdapter;
+
+    const getTagsSpy = vi.spyOn(paste as unknown as { getTagsConfig(tool: BlockToolAdapter): void }, 'getTagsConfig');
+    const getFilesSpy = vi.spyOn(paste as unknown as { getFilesConfig(tool: BlockToolAdapter): void }, 'getFilesConfig');
+    const getPatternsSpy = vi.spyOn(paste as unknown as { getPatternsConfig(tool: BlockToolAdapter): void }, 'getPatternsConfig');
+
+    (paste as unknown as { processTool(tool: BlockToolAdapter): void }).processTool(tool);
+
+    const exceptionList = (paste as unknown as { exceptionList: string[] }).exceptionList;
+
+    expect(exceptionList).toContain('skip-tool');
+    expect(getTagsSpy).not.toHaveBeenCalled();
+    expect(getFilesSpy).not.toHaveBeenCalled();
+    expect(getPatternsSpy).not.toHaveBeenCalled();
+  });
+
+  it('skips tools without onPaste handler when processing paste config', () => {
+    const { paste } = createPaste();
+    const tool = {
+      name: 'incompatible',
+      create: vi.fn(() => ({})),
+      pasteConfig: {},
+      baseSanitizeConfig: {},
+    } as unknown as BlockToolAdapter;
+
+    const getTagsSpy = vi.spyOn(paste as unknown as { getTagsConfig(tool: BlockToolAdapter): void }, 'getTagsConfig');
+
+    (paste as unknown as { processTool(tool: BlockToolAdapter): void }).processTool(tool);
+
+    expect(getTagsSpy).not.toHaveBeenCalled();
+  });
+
+  it('collects tag, file and pattern configs for eligible tools', () => {
+    const { paste } = createPaste();
+    const tool = {
+      name: 'handler',
+      create: vi.fn(() => ({ onPaste: vi.fn() })),
+      pasteConfig: {
+        tags: [ 'P' ],
+        files: {
+          extensions: [ 'jpg' ],
+          mimeTypes: [ 'image/png' ],
+        },
+        patterns: {
+          link: /example/,
+        },
+      },
+      baseSanitizeConfig: {},
+    } as unknown as BlockToolAdapter;
+
+    const getTagsSpy = vi.spyOn(paste as unknown as { getTagsConfig(tool: BlockToolAdapter): void }, 'getTagsConfig');
+    const getFilesSpy = vi.spyOn(paste as unknown as { getFilesConfig(tool: BlockToolAdapter): void }, 'getFilesConfig');
+    const getPatternsSpy = vi.spyOn(paste as unknown as { getPatternsConfig(tool: BlockToolAdapter): void }, 'getPatternsConfig');
+
+    (paste as unknown as { processTool(tool: BlockToolAdapter): void }).processTool(tool);
+
+    expect(getTagsSpy).toHaveBeenCalledWith(tool);
+    expect(getFilesSpy).toHaveBeenCalledWith(tool);
+    expect(getPatternsSpy).toHaveBeenCalledWith(tool);
+  });
+
+  it('registers and removes paste listener when toggling read-only state', () => {
+    const { paste, mocks } = createPaste();
+
+    paste.toggleReadOnly(false);
+
+    expect(mocks.listeners.on).toHaveBeenCalledTimes(1);
+    expect(mocks.listeners.on).toHaveBeenNthCalledWith(
+      1,
+      mocks.holder,
+      'paste',
+      expect.any(Function)
+    );
+
+    const [, , handler] = mocks.listeners.on.mock.calls[0];
+
+    mocks.listeners.on.mockClear();
+
+    paste.toggleReadOnly(true);
+
+    expect(mocks.listeners.off).toHaveBeenCalledTimes(1);
+    expect(mocks.listeners.off).toHaveBeenCalledWith(
+      mocks.holder,
+      'paste',
+      handler
+    );
+    expect(mocks.listeners.on).not.toHaveBeenCalled();
+  });
+
+  it('processes matched files via BlockManager and replaces current default block', async () => {
+    const { paste, mocks } = createPaste();
+
+    mocks.BlockManager.currentBlock = {
+      tool: {
+        isDefault: true,
+      },
+      isEmpty: true,
+    };
+
+    (paste as unknown as { toolsFiles: Record<string, { extensions: string[]; mimeTypes: string[] }> }).toolsFiles = {
+      imageTool: {
+        extensions: [ 'png' ],
+        mimeTypes: [ 'image/*' ],
+      },
+    };
+
+    const file = new File([ 'content' ], 'example.png', { type: 'image/png' });
+    const fileList = {
+      length: 1,
+      item(index: number): File | null {
+        return index === 0 ? file : null;
+      },
+      [0]: file,
+    } as unknown as FileList;
+
+    await (paste as unknown as { processFiles(items: FileList): Promise<void> }).processFiles(fileList);
+
+    expect(mocks.BlockManager.paste).toHaveBeenCalledTimes(1);
+
+    const [tool, event, shouldReplace] = mocks.BlockManager.paste.mock.calls[0];
+
+    expect(tool).toBe('imageTool');
+    expect(event).toBeInstanceOf(CustomEvent);
+    expect(event.type).toBe('file');
+    expect(event.detail.file).toBe(file);
+    expect(shouldReplace).toBe(true);
+  });
+
+  it('collects tags from paste config and prevents duplicates', () => {
+    const { paste } = createPaste();
+    const logSpy = vi.spyOn(utils, 'log').mockImplementation(() => undefined);
+
+    const firstTool = {
+      name: 'first',
+      pasteConfig: {
+        tags: ['DIV', { table: { tr: {} } } ],
+      },
+    } as unknown as BlockToolAdapter;
+
+    const secondTool = {
+      name: 'second',
+      pasteConfig: {
+        tags: [ 'DIV' ],
+      },
+    } as unknown as BlockToolAdapter;
+
+    (paste as unknown as { getTagsConfig(tool: BlockToolAdapter): void }).getTagsConfig(firstTool);
+    (paste as unknown as { getTagsConfig(tool: BlockToolAdapter): void }).getTagsConfig(secondTool);
+
+    const toolsTags = (paste as unknown as { toolsTags: Record<string, { tool: BlockToolAdapter }> }).toolsTags;
+    const tagsByTool = (paste as unknown as { tagsByTool: Record<string, string[]> }).tagsByTool;
+
+    expect(toolsTags.DIV.tool).toBe(firstTool);
+    expect(toolsTags.TABLE.tool).toBe(firstTool);
+    expect(tagsByTool[firstTool.name]).toEqual(['DIV', 'TABLE']);
+    expect(tagsByTool[secondTool.name]).toEqual([ 'DIV' ]);
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Paste handler for «second» Tool on «DIV» tag is skipped because it is already used by «first» Tool.'),
+      'warn'
+    );
+  });
+
+  it('normalizes file configurations and warns for invalid values', () => {
+    const { paste } = createPaste();
+    const logSpy = vi.spyOn(utils, 'log').mockImplementation(() => undefined);
+    const tool = {
+      name: 'files',
+      pasteConfig: {
+        files: {
+          extensions: 'jpg' as unknown as string[],
+          mimeTypes: ['image/png', 'invalid'],
+        },
+      },
+    } as unknown as BlockToolAdapter;
+
+    (paste as unknown as { getFilesConfig(tool: BlockToolAdapter): void }).getFilesConfig(tool);
+
+    const filesConfig = (paste as unknown as {
+      toolsFiles: Record<string, { extensions: string[]; mimeTypes: string[] }>;
+    }).toolsFiles;
+
+    expect(filesConfig[tool.name]).toEqual({
+      extensions: [],
+      mimeTypes: [ 'image/png' ],
+    });
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('«extensions» property of the onDrop config for «files» Tool should be an array')
+    );
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('MIME type value «invalid» for the «files» Tool is not a valid MIME type'),
+      'warn'
+    );
+  });
+
+  it('stores valid patterns and warns when non-RegExp values are provided', () => {
+    const { paste } = createPaste();
+    const logSpy = vi.spyOn(utils, 'log').mockImplementation(() => undefined);
+    const tool = {
+      name: 'patterns',
+      pasteConfig: {
+        patterns: {
+          link: /example/,
+          invalid: 'string' as unknown as RegExp,
+        },
+      },
+    } as unknown as BlockToolAdapter;
+
+    (paste as unknown as { getPatternsConfig(tool: BlockToolAdapter): void }).getPatternsConfig(tool);
+
+    const registeredPatterns = (paste as unknown as {
+      toolsPatterns: Array<{ key: string; pattern: RegExp; tool: BlockToolAdapter }>;
+    }).toolsPatterns;
+
+    expect(registeredPatterns).toHaveLength(2);
+    expect(registeredPatterns[0]).toMatchObject({ key: 'link',
+      tool });
+    expect(registeredPatterns[1]).toMatchObject({ key: 'invalid',
+      tool });
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Pattern string for «patterns» Tool is skipped because it should be a Regexp instance.'),
+      'warn'
+    );
+  });
+
+  it('substitutes pattern matches on inline paste and replaces current default block', async () => {
+    const { paste, mocks } = createPaste();
+
+    const patternTool = {
+      name: 'link',
+      pasteConfig: {},
+      baseSanitizeConfig: {},
+    } as unknown as BlockToolAdapter;
+
+    (paste as unknown as {
+      toolsPatterns: Array<{
+        key: string;
+        pattern: RegExp;
+        tool: BlockToolAdapter;
+      }>;
+    }).toolsPatterns = [
+      {
+        key: 'link',
+        pattern: /^https:\/\/example\.com$/,
+        tool: patternTool,
+      },
+    ];
+
+    mocks.BlockManager.currentBlock = {
+      tool: {
+        isDefault: true,
+        baseSanitizeConfig: {},
+      },
+      isEmpty: true,
+      name: 'paragraph',
+      currentInput: document.createElement('div'),
+    };
+
+    const content = document.createElement('div');
+
+    content.textContent = 'https://example.com';
+
+    mocks.BlockManager.paste.mockImplementation((_tool, _event, replace) => {
+      expect(replace).toBe(true);
+
+      return { id: 'link-block' };
+    });
+
+    await (paste as unknown as {
+      processInlinePaste(data: {
+        content: HTMLElement;
+        tool: string;
+        isBlock: boolean;
+        event: CustomEvent;
+      }): Promise<void>;
+    }).processInlinePaste({
+      content,
+      tool: 'paragraph',
+      isBlock: false,
+      event: new CustomEvent('pattern'),
+    });
+
+    expect(mocks.BlockManager.paste).toHaveBeenCalledTimes(1);
+
+    const [tool, event] = mocks.BlockManager.paste.mock.calls[0];
+
+    expect(tool).toBe('link');
+    expect(event).toBeInstanceOf(CustomEvent);
+    expect(event.type).toBe('pattern');
+    expect(event.detail.data).toBe('https://example.com');
+    expect(event.detail.key).toBe('link');
+    expect(mocks.Caret.setToBlock).toHaveBeenCalledWith({ id: 'link-block' }, mocks.Caret.positions.END);
+    expect(mocks.Caret.insertContentAtCaretPosition).not.toHaveBeenCalled();
+  });
+
+  it('inserts sanitized inline content when no pattern matches and current input exists', async () => {
+    const { paste, mocks } = createPaste();
+
+    const cleanSpy = vi.spyOn(sanitizer, 'clean').mockReturnValue('sanitized-content');
+
+    mocks.BlockManager.currentBlock = {
+      tool: {
+        isDefault: false,
+        baseSanitizeConfig: {
+          b: {},
+        },
+      },
+      isEmpty: false,
+      name: 'paragraph',
+      currentInput: document.createElement('div'),
+    };
+
+    const content = document.createElement('div');
+
+    content.innerHTML = '<b>Example</b>';
+
+    await (paste as unknown as {
+      processInlinePaste(data: {
+        content: HTMLElement;
+        tool: string;
+        isBlock: boolean;
+        event: CustomEvent;
+      }): Promise<void>;
+    }).processInlinePaste({
+      content,
+      tool: 'paragraph',
+      isBlock: false,
+      event: new CustomEvent('tag'),
+    });
+
+    expect(cleanSpy).toHaveBeenCalledWith(
+      '<b>Example</b>',
+      {
+        b: {},
+      }
+    );
+    expect(mocks.Caret.insertContentAtCaretPosition).toHaveBeenCalledWith('sanitized-content');
+    expect(mocks.BlockManager.paste).not.toHaveBeenCalled();
+  });
+
+  it('inserts sanitized EditorJS data and updates caret position', () => {
+    const { paste, mocks } = createPaste();
+
+    const sanitizeBlocksSpy = vi.spyOn(sanitizer, 'sanitizeBlocks').mockReturnValue([
+      {
+        tool: 'image',
+        data: { src: 'image.png' },
+      },
+      {
+        tool: 'paragraph',
+        data: { text: 'Hello' },
+      },
+    ]);
+
+    mocks.BlockManager.currentBlock = {
+      tool: {
+        isDefault: true,
+      },
+      isEmpty: true,
+    };
+
+    const insertedBlocks: Array<{ tool: string; data: unknown; replace: boolean }> = [];
+
+    mocks.BlockManager.insert.mockImplementation((payload) => {
+      insertedBlocks.push(payload);
+
+      return { id: `${payload.tool}-id` };
+    });
+
+    (paste as unknown as {
+      insertEditorJSData(blocks: Array<{ id: string; tool: string; data: unknown }>): void;
+    }).insertEditorJSData([
+      {
+        id: '1',
+        tool: 'image',
+        data: { src: 'image.png' },
+      },
+      {
+        id: '2',
+        tool: 'paragraph',
+        data: { text: 'Hello' },
+      },
+    ]);
+
+    expect(sanitizeBlocksSpy).toHaveBeenCalledTimes(1);
+    expect(insertedBlocks).toEqual([
+      {
+        tool: 'image',
+        data: { src: 'image.png' },
+        replace: true,
+      },
+      {
+        tool: 'paragraph',
+        data: { text: 'Hello' },
+        replace: false,
+      },
+    ]);
+    expect(mocks.Caret.setToBlock).toHaveBeenNthCalledWith(1, { id: 'image-id' }, mocks.Caret.positions.END);
+    expect(mocks.Caret.setToBlock).toHaveBeenNthCalledWith(2, { id: 'paragraph-id' }, mocks.Caret.positions.END);
+  });
+
+  it('splits plain text by new lines and creates PasteData entries', () => {
+    const { paste } = createPaste({ defaultBlock: 'paragraph' });
+
+    const result = (paste as unknown as {
+      processPlain(data: string): Array<{ tool: string; content: HTMLElement; event: CustomEvent; isBlock: boolean }>;
+    }).processPlain('First\n\nSecond');
+
+    expect(result).toHaveLength(2);
+    expect(result[0].tool).toBe('paragraph');
+    expect(result[0].content.textContent).toBe('First');
+    expect(result[0].event.type).toBe('tag');
+    expect(result[1].content.textContent).toBe('Second');
+  });
+
+  it('inserts a new block when pasted tool differs from current block', async () => {
+    const { paste, mocks } = createPaste();
+    const insertBlockSpy = vi.spyOn(paste as unknown as { insertBlock(data: unknown, replace?: boolean): void }, 'insertBlock').mockImplementation(() => undefined);
+
+    mocks.BlockManager.currentBlock = {
+      tool: {
+        isDefault: true,
+      },
+      isEmpty: true,
+      name: 'paragraph',
+    };
+
+    const content = document.createElement('div');
+
+    await (paste as unknown as {
+      processSingleBlock(data: { content: HTMLElement; tool: string; isBlock: boolean; event: CustomEvent }): Promise<void>;
+    }).processSingleBlock({
+      content,
+      tool: 'quote',
+      isBlock: true,
+      event: new CustomEvent('tag'),
+    });
+
+    expect(insertBlockSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ tool: 'quote' }),
+      true
+    );
+    expect(mocks.Caret.insertContentAtCaretPosition).not.toHaveBeenCalled();
+  });
+
+  it('merges pasted single block content into the current block when possible', async () => {
+    const { paste, mocks } = createPaste();
+
+    mocks.BlockManager.currentBlock = {
+      tool: {
+        isDefault: false,
+      },
+      isEmpty: false,
+      name: 'paragraph',
+    };
+
+    const content = document.createElement('div');
+
+    content.innerHTML = '<span>Inline</span>';
+
+    await (paste as unknown as {
+      processSingleBlock(data: { content: HTMLElement; tool: string; isBlock: boolean; event: CustomEvent }): Promise<void>;
+    }).processSingleBlock({
+      content,
+      tool: 'paragraph',
+      isBlock: true,
+      event: new CustomEvent('tag'),
+    });
+
+    expect(mocks.Caret.insertContentAtCaretPosition).toHaveBeenCalledWith('<span>Inline</span>');
+    expect(mocks.BlockManager.paste).not.toHaveBeenCalled();
+  });
+
+  it('processes HTML fragments, default block content and substituted tags', () => {
+    const defaultTool = {
+      name: 'paragraph',
+      pasteConfig: {},
+      baseSanitizeConfig: {},
+    } as unknown as BlockToolAdapter;
+    const { paste } = createPaste({ defaultBlock: 'paragraph',
+      defaultTool });
+    const headingTool = {
+      name: 'header',
+      pasteConfig: {
+        tags: [ 'h1' ],
+      },
+      baseSanitizeConfig: {},
+    } as unknown as BlockToolAdapter;
+
+    (paste as unknown as { getTagsConfig(tool: BlockToolAdapter): void }).getTagsConfig(headingTool);
+
+    const cleanSpy = vi.spyOn(sanitizer, 'clean').mockImplementation((html: string) => html.replace(/<script>.*?<\/script>/g, ''));
+    const html = '<span>Inline</span><div>Content</div><h1><script>bad()</script>Heading</h1>';
+
+    const result = (paste as unknown as {
+      processHTML(innerHTML: string): Array<{ content: HTMLElement; isBlock: boolean; tool: string; event: CustomEvent }>;
+    }).processHTML(html);
+
+    expect(result).toHaveLength(3);
+
+    expect(result[0]).toMatchObject({
+      isBlock: false,
+      tool: 'paragraph',
+    });
+    expect(result[1]).toMatchObject({
+      isBlock: true,
+      tool: 'paragraph',
+    });
+    expect(result[2]).toMatchObject({
+      isBlock: true,
+      tool: 'header',
+    });
+    expect(result[2].content.tagName).toBe('H1');
+    expect(result[2].event.type).toBe('tag');
+    expect(cleanSpy).toHaveBeenCalled();
+  });
+
+  it('flattens nested block elements when fetching nodes', () => {
+    const { paste } = createPaste();
+    const wrapper = document.createElement('div');
+
+    wrapper.innerHTML = '<div><p>Paragraph</p></div>';
+
+    const nodes = (paste as unknown as { getNodes(wrapper: Node): Node[] }).getNodes(wrapper);
+
+    expect(nodes).toHaveLength(2);
+    expect(nodes[0]).toBeInstanceOf(DocumentFragment);
+    expect(nodes[1]).toBeInstanceOf(HTMLElement);
+    expect((nodes[1] as HTMLElement).tagName).toBe('P');
+  });
+
+  it('appends inline elements to document fragments when processing element nodes', () => {
+    const { paste } = createPaste();
+    const fragment = document.createDocumentFragment();
+    const span = document.createElement('span');
+    const nodes: Node[] = [];
+
+    span.textContent = 'inline';
+
+    const processed = (paste as unknown as {
+      processElementNode(node: Node, nodes: Node[], destNode: Node): Node[] | void;
+    }).processElementNode(span, nodes, fragment);
+
+    expect(processed).toEqual([ fragment ]);
+    expect(fragment.childNodes[0]).toBe(span);
+  });
+
+  it('returns block elements separately when processing element nodes', () => {
+    const { paste } = createPaste();
+    const fragment = document.createDocumentFragment();
+    const paragraph = document.createElement('p');
+
+    const processed = (paste as unknown as {
+      processElementNode(node: Node, nodes: Node[], destNode: Node): Node[] | void;
+    }).processElementNode(paragraph, [], fragment);
+
+    expect(processed).toEqual([fragment, paragraph]);
+  });
+
+  it('detects native inputs when checking for native behaviour', () => {
+    const { paste } = createPaste();
+    const input = document.createElement('input');
+    const div = document.createElement('div');
+
+    expect((paste as unknown as { isNativeBehaviour(element: EventTarget): boolean }).isNativeBehaviour(input)).toBe(true);
+    expect((paste as unknown as { isNativeBehaviour(element: EventTarget): boolean }).isNativeBehaviour(div)).toBe(false);
+  });
+});
diff --git a/test/unit/components/modules/readonly.test.ts b/test/unit/components/modules/readonly.test.ts
new file mode 100644
index 000000000..4d2653265
--- /dev/null
+++ b/test/unit/components/modules/readonly.test.ts
@@ -0,0 +1,217 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import type { MockInstance } from 'vitest';
+
+import ReadOnly from '../../../../src/components/modules/readonly';
+import { CriticalError } from '../../../../src/components/errors/critical';
+import type { EditorConfig } from '../../../../types';
+
+interface CreateReadOnlyOptions {
+  config?: EditorConfig;
+  blockTools?: Array<[string, { isReadOnlySupported?: boolean }]>;
+  saverBlocks?: unknown[];
+}
+
+type ReadOnlyMocks = {
+  modificationsObserver: {
+    disable: MockInstance<[], void>;
+    enable: MockInstance<[], void>;
+  };
+  saver: {
+    save: MockInstance<[], Promise<{ blocks: unknown[] }>>;
+  };
+  blockManager: {
+    clear: MockInstance<[], Promise<void>>;
+    toggleReadOnly: MockInstance<[boolean], void>;
+  };
+  renderer: {
+    render: MockInstance<[unknown[]], Promise<void>>;
+  };
+  toolbar: {
+    toggleReadOnly: MockInstance<[boolean], void>;
+  };
+  inlineToolbar: {
+    toggleReadOnly: MockInstance<[boolean], void>;
+  };
+};
+
+type CreateReadOnlyResult = {
+  readOnly: ReadOnly;
+  mocks: ReadOnlyMocks;
+};
+
+const createReadOnly = (options?: CreateReadOnlyOptions): CreateReadOnlyResult => {
+  const blockToolsEntries = options?.blockTools ?? [];
+  const blockTools = new Map<string, { isReadOnlySupported?: boolean }>(blockToolsEntries);
+
+  const readOnly = new ReadOnly({
+    config: options?.config ?? {},
+    eventsDispatcher: {
+      on: vi.fn(),
+      off: vi.fn(),
+    } as unknown as ReadOnly['eventsDispatcher'],
+  });
+
+  const modificationsObserver = {
+    disable: vi.fn(() => undefined) as MockInstance<[], void>,
+    enable: vi.fn(() => undefined) as MockInstance<[], void>,
+  };
+
+  const saver = {
+    save: vi.fn(async () => ({
+      blocks: options?.saverBlocks ?? [],
+    })) as MockInstance<[], Promise<{ blocks: unknown[] }>>,
+  };
+
+  const blockManager = {
+    clear: vi.fn(async () => undefined) as MockInstance<[], Promise<void>>,
+    toggleReadOnly: vi.fn((_state: boolean) => undefined) as MockInstance<[boolean], void>,
+  };
+
+  const renderer = {
+    render: vi.fn(async (_blocks: unknown[]) => undefined) as MockInstance<[unknown[]], Promise<void>>,
+  };
+
+  const toolbar = {
+    toggleReadOnly: vi.fn((_state: boolean) => undefined) as MockInstance<[boolean], void>,
+  };
+
+  const inlineToolbar = {
+    toggleReadOnly: vi.fn((_state: boolean) => undefined) as MockInstance<[boolean], void>,
+  };
+
+  const modules = {
+    ModificationsObserver: modificationsObserver,
+    Saver: saver,
+    BlockManager: blockManager,
+    Renderer: renderer,
+    Toolbar: toolbar,
+    InlineToolbar: inlineToolbar,
+    Tools: {
+      blockTools,
+    },
+  };
+
+  readOnly.state = modules as unknown as ReadOnly['Editor'];
+
+  return {
+    readOnly,
+    mocks: {
+      modificationsObserver,
+      saver,
+      blockManager,
+      renderer,
+      toolbar,
+      inlineToolbar,
+    },
+  };
+};
+
+describe('ReadOnly module', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('collects tools that do not support read-only and toggles initial state during prepare', async () => {
+    const { readOnly } = createReadOnly({
+      config: {
+        readOnly: false,
+      },
+      blockTools: [
+        ['paragraph', { isReadOnlySupported: true } ],
+        ['legacy', { isReadOnlySupported: false } ],
+      ],
+    });
+
+    const toggleSpy = vi.spyOn(readOnly, 'toggle').mockResolvedValue(false);
+
+    await readOnly.prepare();
+
+    expect(toggleSpy).toHaveBeenCalledWith(false, true);
+
+    const unsupportedTools =
+      (readOnly as unknown as { toolsDontSupportReadOnly: string[] }).toolsDontSupportReadOnly;
+
+    expect(unsupportedTools).toEqual([ 'legacy' ]);
+  });
+
+  it('throws a critical error when initializing read-only mode with unsupported tools', async () => {
+    const { readOnly } = createReadOnly({
+      config: {
+        readOnly: true,
+      },
+      blockTools: [
+        ['unsupported', { isReadOnlySupported: false } ],
+      ],
+    });
+
+    await expect(readOnly.prepare()).rejects.toThrow(CriticalError);
+  });
+
+  it('propagates toggle state to modules and re-renders saved blocks', async () => {
+    const savedBlocks = [ { id: 'block-1' } ];
+    const { readOnly, mocks } = createReadOnly({
+      saverBlocks: savedBlocks,
+    });
+
+    const result = await readOnly.toggle(true);
+
+    expect(result).toBe(true);
+    expect(mocks.blockManager.toggleReadOnly).toHaveBeenCalledWith(true);
+    expect(mocks.toolbar.toggleReadOnly).toHaveBeenCalledWith(true);
+    expect(mocks.inlineToolbar.toggleReadOnly).toHaveBeenCalledWith(true);
+    expect(mocks.modificationsObserver.disable).toHaveBeenCalledTimes(1);
+    expect(mocks.saver.save).toHaveBeenCalledTimes(1);
+    expect(mocks.blockManager.clear).toHaveBeenCalledTimes(1);
+    expect(mocks.renderer.render).toHaveBeenCalledWith(savedBlocks);
+    expect(mocks.modificationsObserver.enable).toHaveBeenCalledTimes(1);
+  });
+
+  it('prevents enabling read-only mode when unsupported tools are registered', async () => {
+    const { readOnly } = createReadOnly();
+
+    (readOnly as unknown as { toolsDontSupportReadOnly: string[] }).toolsDontSupportReadOnly = [
+      'legacy',
+    ];
+
+    await expect(readOnly.toggle(true)).rejects.toThrow(CriticalError);
+  });
+
+  it('skips re-render when the requested state matches the current state', async () => {
+    const { readOnly, mocks } = createReadOnly();
+
+    await readOnly.toggle(true);
+
+    mocks.modificationsObserver.disable.mockClear();
+    mocks.saver.save.mockClear();
+    mocks.blockManager.clear.mockClear();
+    mocks.renderer.render.mockClear();
+    mocks.modificationsObserver.enable.mockClear();
+
+    const result = await readOnly.toggle(true);
+
+    expect(result).toBe(true);
+    expect(mocks.saver.save).not.toHaveBeenCalled();
+    expect(mocks.blockManager.clear).not.toHaveBeenCalled();
+    expect(mocks.renderer.render).not.toHaveBeenCalled();
+    expect(mocks.modificationsObserver.disable).not.toHaveBeenCalled();
+    expect(mocks.modificationsObserver.enable).not.toHaveBeenCalled();
+  });
+
+  it('skips re-render during the initial toggle', async () => {
+    const { readOnly, mocks } = createReadOnly();
+
+    const result = await readOnly.toggle(true, true);
+
+    expect(result).toBe(true);
+    expect(mocks.saver.save).not.toHaveBeenCalled();
+    expect(mocks.blockManager.clear).not.toHaveBeenCalled();
+    expect(mocks.renderer.render).not.toHaveBeenCalled();
+    expect(mocks.modificationsObserver.disable).not.toHaveBeenCalled();
+    expect(mocks.modificationsObserver.enable).not.toHaveBeenCalled();
+    expect(mocks.blockManager.toggleReadOnly).toHaveBeenCalledWith(true);
+    expect(mocks.toolbar.toggleReadOnly).toHaveBeenCalledWith(true);
+    expect(mocks.inlineToolbar.toggleReadOnly).toHaveBeenCalledWith(true);
+  });
+});
+
+
diff --git a/test/unit/components/modules/rectangleSelection.test.ts b/test/unit/components/modules/rectangleSelection.test.ts
new file mode 100644
index 000000000..bbb0d525d
--- /dev/null
+++ b/test/unit/components/modules/rectangleSelection.test.ts
@@ -0,0 +1,849 @@
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi, type Mock } from 'vitest';
+
+import RectangleSelection from '../../../../src/components/modules/rectangleSelection';
+import Block from '../../../../src/components/block';
+import SelectionUtils from '../../../../src/components/selection';
+import EventsDispatcher from '../../../../src/components/utils/events';
+import type { EditorEventMap } from '../../../../src/components/events';
+import type { EditorModules } from '../../../../src/types-internal/editor-modules';
+import type { EditorConfig } from '../../../../types';
+import type BlockType from '../../../../src/components/block';
+
+type PartialModules = Partial<EditorModules>;
+
+type ToolbarModuleMock = {
+  CSS: { toolbar: string };
+  close: Mock<[], void>;
+};
+
+type InlineToolbarModuleMock = {
+  CSS: { inlineToolbar: string };
+  close: Mock<[], void>;
+};
+
+type BlockSelectionModuleMock = {
+  allBlocksSelected: boolean;
+  selectBlockByIndex: Mock<[number], void>;
+  unSelectBlockByIndex: Mock<[number], void>;
+};
+
+type BlockManagerModuleMock = {
+  blocks: BlockType[];
+  getBlockByChildNode: Mock<[Node], BlockType | undefined>;
+  getBlockByIndex: Mock<[number], BlockType | undefined>;
+  lastBlock: { holder: HTMLElement };
+};
+
+interface RectangleSelectionTestSetup {
+  rectangleSelection: RectangleSelection;
+  modules: PartialModules;
+  editorWrapper: HTMLDivElement;
+  holder: HTMLDivElement;
+  blockContent: HTMLDivElement;
+  toolbar: ToolbarModuleMock;
+  inlineToolbar: InlineToolbarModuleMock;
+  blockSelection: BlockSelectionModuleMock;
+  blockManager: BlockManagerModuleMock;
+}
+
+const createRectangleSelection = (overrides: PartialModules = {}): RectangleSelectionTestSetup => {
+  const rectangleSelection = new RectangleSelection({
+    config: {} as EditorConfig,
+    eventsDispatcher: new EventsDispatcher<EditorEventMap>(),
+  });
+
+  const holder = document.createElement('div');
+  const editorWrapper = document.createElement('div');
+  const editorWrapperClass = 'codex-editor__redactor';
+
+  editorWrapper.className = editorWrapperClass;
+  holder.appendChild(editorWrapper);
+  document.body.appendChild(holder);
+
+  const blockContent = document.createElement('div');
+
+  blockContent.className = Block.CSS.content;
+  blockContent.style.width = '400px';
+
+  const lastBlockHolder = document.createElement('div');
+
+  lastBlockHolder.appendChild(blockContent);
+
+  const blocks: BlockType[] = [];
+
+  const toolbarMock: ToolbarModuleMock = {
+    CSS: {
+      toolbar: 'codex-editor-toolbar',
+    },
+    close: vi.fn<[], void>(),
+  };
+
+  const inlineToolbarMock: InlineToolbarModuleMock = {
+    CSS: {
+      inlineToolbar: 'codex-editor-inline-toolbar',
+    },
+    close: vi.fn<[], void>(),
+  };
+
+  const blockSelectionMock: BlockSelectionModuleMock = {
+    allBlocksSelected: false,
+    selectBlockByIndex: vi.fn<[number], void>(),
+    unSelectBlockByIndex: vi.fn<[number], void>(),
+  };
+
+  const blockManagerMock: BlockManagerModuleMock = {
+    blocks,
+    getBlockByChildNode: vi.fn<[Node], BlockType | undefined>(),
+    getBlockByIndex: vi.fn<[number], BlockType | undefined>((index) => blocks[index]),
+    lastBlock: {
+      holder: lastBlockHolder,
+    },
+  };
+
+  const defaults: PartialModules = {
+    UI: {
+      nodes: {
+        holder,
+      },
+      CSS: {
+        editorWrapper: editorWrapperClass,
+      },
+    } as unknown as EditorModules['UI'],
+    Toolbar: toolbarMock as unknown as EditorModules['Toolbar'],
+    InlineToolbar: inlineToolbarMock as unknown as EditorModules['InlineToolbar'],
+    BlockSelection: blockSelectionMock as unknown as EditorModules['BlockSelection'],
+    BlockManager: blockManagerMock as unknown as EditorModules['BlockManager'],
+  };
+
+  const mergedState: PartialModules = { ...defaults };
+
+  for (const [moduleName, moduleOverrides] of Object.entries(overrides) as Array<[keyof EditorModules, unknown]>) {
+    if (moduleOverrides === undefined) {
+      continue;
+    }
+
+    const existingModule = mergedState[moduleName];
+
+    if (
+      existingModule !== undefined &&
+      existingModule !== null &&
+      typeof existingModule === 'object' &&
+      moduleOverrides !== null &&
+      typeof moduleOverrides === 'object'
+    ) {
+      Object.assign(
+        existingModule as unknown as Record<string, unknown>,
+        moduleOverrides as unknown as Record<string, unknown>
+      );
+    } else {
+      (mergedState as Record<keyof EditorModules, EditorModules[keyof EditorModules]>)[moduleName] = moduleOverrides as EditorModules[typeof moduleName];
+    }
+  }
+
+  rectangleSelection.state = mergedState as EditorModules;
+
+  return {
+    rectangleSelection,
+    modules: mergedState,
+    editorWrapper,
+    holder,
+    blockContent,
+    toolbar: toolbarMock,
+    inlineToolbar: inlineToolbarMock,
+    blockSelection: blockSelectionMock,
+    blockManager: blockManagerMock,
+  };
+};
+
+describe('RectangleSelection', () => {
+  beforeAll(() => {
+    if (typeof document.elementFromPoint !== 'function') {
+      Object.defineProperty(document, 'elementFromPoint', {
+        configurable: true,
+        writable: true,
+        value: () => document.createElement('div'),
+      });
+    }
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    document.body.innerHTML = '';
+    vi.restoreAllMocks();
+  });
+
+  it('creates overlay container on prepare', () => {
+    const {
+      rectangleSelection,
+      editorWrapper,
+    } = createRectangleSelection();
+
+    rectangleSelection.prepare();
+
+    const overlay = editorWrapper.querySelector(`.${RectangleSelection.CSS.overlay}`);
+    const rectangle = editorWrapper.querySelector(`.${RectangleSelection.CSS.rect}`);
+
+    expect(overlay).not.toBeNull();
+    expect(rectangle).not.toBeNull();
+  });
+
+  it('starts selection inside the editor and resets selection state', () => {
+    const {
+      rectangleSelection,
+      blockSelection,
+      editorWrapper,
+    } = createRectangleSelection();
+
+    const internal = rectangleSelection as unknown as {
+      stackOfSelected: number[];
+      isRectSelectionActivated: boolean;
+      mousedown: boolean;
+      startX: number;
+      startY: number;
+    };
+
+    internal.stackOfSelected.push(1, 2);
+    internal.isRectSelectionActivated = true;
+
+    blockSelection.allBlocksSelected = true;
+
+    const startTarget = document.createElement('div');
+
+    editorWrapper.appendChild(startTarget);
+
+    const elementFromPointSpy = vi.spyOn(document, 'elementFromPoint').mockReturnValue(startTarget);
+
+    rectangleSelection.startSelection(120, 240);
+
+    expect(blockSelection.allBlocksSelected).toBe(false);
+    expect(internal.stackOfSelected).toEqual([]);
+    expect(internal.isRectSelectionActivated).toBe(false);
+    expect(internal.mousedown).toBe(true);
+    expect(internal.startX).toBe(120);
+    expect(internal.startY).toBe(240);
+
+    elementFromPointSpy.mockRestore();
+  });
+
+  it('ignores selection start initiated from the toolbar', () => {
+    const {
+      rectangleSelection,
+      blockSelection,
+      toolbar,
+    } = createRectangleSelection();
+
+    blockSelection.allBlocksSelected = true;
+
+    const toolbarClass = toolbar.CSS.toolbar;
+    const toolbarElement = document.createElement('div');
+
+    toolbarElement.className = toolbarClass;
+    const toolbarChild = document.createElement('div');
+
+    toolbarElement.appendChild(toolbarChild);
+    document.body.appendChild(toolbarElement);
+
+    const elementFromPointSpy = vi.spyOn(document, 'elementFromPoint').mockReturnValue(toolbarChild);
+
+    const internal = rectangleSelection as unknown as { mousedown: boolean };
+
+    rectangleSelection.startSelection(10, 20);
+
+    expect(blockSelection.allBlocksSelected).toBe(true);
+    expect(internal.mousedown).toBe(false);
+
+    elementFromPointSpy.mockRestore();
+  });
+
+  it('ignores selection attempts outside of selectable area', () => {
+    const {
+      rectangleSelection,
+      editorWrapper,
+    } = createRectangleSelection();
+
+    const internal = rectangleSelection as unknown as { mousedown: boolean };
+
+    const outsideNode = document.createElement('div');
+
+    document.body.appendChild(outsideNode);
+
+    const elementFromPointSpy = vi.spyOn(document, 'elementFromPoint').mockReturnValue(outsideNode);
+
+    rectangleSelection.startSelection(10, 15);
+
+    expect(internal.mousedown).toBe(false);
+
+    const blockContent = document.createElement('div');
+
+    blockContent.className = Block.CSS.content;
+    editorWrapper.appendChild(blockContent);
+    elementFromPointSpy.mockReturnValue(blockContent);
+
+    rectangleSelection.startSelection(20, 25);
+
+    expect(internal.mousedown).toBe(false);
+
+    elementFromPointSpy.mockRestore();
+  });
+
+  it('clears selection activation flag when clearSelection is called', () => {
+    const { rectangleSelection } = createRectangleSelection();
+    const internal = rectangleSelection as unknown as { isRectSelectionActivated: boolean };
+
+    internal.isRectSelectionActivated = true;
+    rectangleSelection.clearSelection();
+
+    expect(internal.isRectSelectionActivated).toBe(false);
+  });
+
+  it('reports whether rectangle selection is active', () => {
+    const { rectangleSelection } = createRectangleSelection();
+    const internal = rectangleSelection as unknown as { isRectSelectionActivated: boolean };
+
+    internal.isRectSelectionActivated = false;
+    expect(rectangleSelection.isRectActivated()).toBe(false);
+
+    internal.isRectSelectionActivated = true;
+    expect(rectangleSelection.isRectActivated()).toBe(true);
+  });
+
+  it('resets selection parameters on endSelection', () => {
+    const {
+      rectangleSelection,
+      editorWrapper,
+    } = createRectangleSelection();
+
+    rectangleSelection.prepare();
+
+    const internal = rectangleSelection as unknown as {
+      mousedown: boolean;
+      startX: number;
+      startY: number;
+      overlayRectangle: HTMLDivElement;
+    };
+
+    internal.mousedown = true;
+    internal.startX = 50;
+    internal.startY = 60;
+    internal.overlayRectangle = editorWrapper.querySelector(`.${RectangleSelection.CSS.rect}`) as HTMLDivElement;
+    internal.overlayRectangle.style.display = 'block';
+
+    rectangleSelection.endSelection();
+
+    expect(internal.mousedown).toBe(false);
+    expect(internal.startX).toBe(0);
+    expect(internal.startY).toBe(0);
+    expect(internal.overlayRectangle.style.display).toBe('none');
+  });
+
+  it('starts selection only for the main mouse button', () => {
+    const {
+      rectangleSelection,
+    } = createRectangleSelection();
+
+    const startSelectionSpy = vi.spyOn(rectangleSelection, 'startSelection');
+
+    const internal = rectangleSelection as unknown as {
+      processMouseDown: (event: MouseEvent) => void;
+    };
+
+    const primaryEvent = {
+      button: 0,
+      pageX: 150,
+      pageY: 200,
+      target: document.createElement('div'),
+    } as unknown as MouseEvent;
+
+    internal.processMouseDown(primaryEvent);
+
+    expect(startSelectionSpy).toHaveBeenCalledWith(150, 200);
+
+    startSelectionSpy.mockClear();
+
+    const secondaryEvent = {
+      button: 1,
+      pageX: 150,
+      pageY: 200,
+      target: document.createElement('div'),
+    } as unknown as MouseEvent;
+
+    internal.processMouseDown(secondaryEvent);
+
+    expect(startSelectionSpy).not.toHaveBeenCalled();
+  });
+
+  it('delegates mouse move handling to rectangle updates and scroll zones', () => {
+    const {
+      rectangleSelection,
+    } = createRectangleSelection();
+
+    const internal = rectangleSelection as unknown as {
+      processMouseMove: (event: MouseEvent) => void;
+      changingRectangle: (event: MouseEvent) => void;
+      scrollByZones: (clientY: number) => void;
+    };
+
+    const changeSpy = vi.spyOn(internal, 'changingRectangle');
+    const scrollSpy = vi.spyOn(internal, 'scrollByZones');
+
+    const mouseEvent = {
+      clientY: 320,
+    } as unknown as MouseEvent;
+
+    internal.processMouseMove(mouseEvent);
+
+    expect(changeSpy).toHaveBeenCalledWith(mouseEvent);
+    expect(scrollSpy).toHaveBeenCalledWith(320);
+  });
+
+  it('updates rectangle on scroll events', () => {
+    const {
+      rectangleSelection,
+    } = createRectangleSelection();
+
+    const internal = rectangleSelection as unknown as {
+      processScroll: (event: MouseEvent) => void;
+      changingRectangle: (event: MouseEvent) => void;
+    };
+
+    const changeSpy = vi.spyOn(internal, 'changingRectangle');
+    const scrollEvent = { pageX: 50,
+      pageY: 75 } as unknown as MouseEvent;
+
+    internal.processScroll(scrollEvent);
+
+    expect(changeSpy).toHaveBeenCalledWith(scrollEvent);
+  });
+
+  it('stops scrolling when cursor leaves scroll zones', () => {
+    const { rectangleSelection } = createRectangleSelection();
+    const internal = rectangleSelection as unknown as {
+      scrollByZones: (clientY: number) => void;
+      isScrolling: boolean;
+      inScrollZone: number | null;
+    };
+
+    Object.defineProperty(document.documentElement, 'clientHeight', {
+      configurable: true,
+      value: 1000,
+    });
+
+    internal.isScrolling = true;
+    internal.scrollByZones(200);
+
+    expect(internal.isScrolling).toBe(false);
+    expect(internal.inScrollZone).toBeNull();
+  });
+
+  it('triggers vertical scrolling when mouse enters scroll zones', () => {
+    const {
+      rectangleSelection,
+    } = createRectangleSelection();
+
+    const internal = rectangleSelection as unknown as {
+      scrollByZones: (clientY: number) => void;
+      scrollVertical: (speed: number) => void;
+      isScrolling: boolean;
+    };
+
+    const scrollSpy = vi.spyOn(internal, 'scrollVertical').mockImplementation(() => undefined);
+
+    Object.defineProperty(document.documentElement, 'clientHeight', {
+      configurable: true,
+      value: 1000,
+    });
+
+    internal.isScrolling = false;
+    internal.scrollByZones(10);
+    expect(scrollSpy).toHaveBeenCalledWith(-3);
+
+    internal.isScrolling = false;
+    scrollSpy.mockClear();
+    internal.scrollByZones(995);
+    expect(scrollSpy).toHaveBeenCalledWith(3);
+  });
+
+  it('scrolls vertically while mouse button is pressed in a scroll zone', () => {
+    const { rectangleSelection } = createRectangleSelection();
+    const internal = rectangleSelection as unknown as {
+      scrollVertical: (speed: number) => void;
+      inScrollZone: number | null;
+      mousedown: boolean;
+      mouseY: number;
+    };
+
+    vi.useFakeTimers();
+
+    internal.inScrollZone = 1;
+    internal.mousedown = true;
+    internal.mouseY = 100;
+
+    let yOffset = 0;
+
+    const scrollYSpy = vi.spyOn(window, 'scrollY', 'get').mockImplementation(() => yOffset);
+
+    const scrollBySpy = vi.spyOn(window, 'scrollBy').mockImplementation((_x, y) => {
+      yOffset += y;
+    });
+
+    internal.scrollVertical(5);
+
+    internal.inScrollZone = null;
+    vi.runOnlyPendingTimers();
+    vi.useRealTimers();
+
+    expect(scrollBySpy).toHaveBeenCalledWith(0, 5);
+    expect(internal.mouseY).toBe(105);
+
+    scrollBySpy.mockRestore();
+    scrollYSpy.mockRestore();
+  });
+
+  it('shrinks overlay rectangle to the starting point', () => {
+    const {
+      rectangleSelection,
+      editorWrapper,
+    } = createRectangleSelection();
+
+    rectangleSelection.prepare();
+
+    const internal = rectangleSelection as unknown as {
+      shrinkRectangleToPoint: () => void;
+      overlayRectangle: HTMLDivElement;
+      startX: number;
+      startY: number;
+    };
+
+    internal.overlayRectangle = editorWrapper.querySelector(`.${RectangleSelection.CSS.rect}`) as HTMLDivElement;
+    internal.startX = 150;
+    internal.startY = 260;
+
+    const scrollXSpy = vi.spyOn(window, 'scrollX', 'get').mockReturnValue(10);
+    const scrollYSpy = vi.spyOn(window, 'scrollY', 'get').mockReturnValue(20);
+
+    internal.shrinkRectangleToPoint();
+
+    expect(internal.overlayRectangle.style.left).toBe('140px');
+    expect(internal.overlayRectangle.style.top).toBe('240px');
+    expect(internal.overlayRectangle.style.bottom).toBe('calc(100% - 240px)');
+    expect(internal.overlayRectangle.style.right).toBe('calc(100% - 140px)');
+
+    scrollXSpy.mockRestore();
+    scrollYSpy.mockRestore();
+  });
+
+  it('selects or unselects blocks based on rectangle overlap', () => {
+    const {
+      rectangleSelection,
+      blockSelection,
+      blockManager,
+    } = createRectangleSelection();
+
+    const selectedBlockState = { selected: false } as unknown as BlockType & { selected: boolean };
+
+    blockManager.getBlockByIndex.mockReturnValue(selectedBlockState);
+
+    const internal = rectangleSelection as unknown as {
+      stackOfSelected: number[];
+      rectCrossesBlocks: boolean;
+      inverseSelection: () => void;
+    };
+
+    internal.stackOfSelected.push(0, 1);
+    internal.rectCrossesBlocks = true;
+
+    internal.inverseSelection();
+
+    expect(blockSelection.selectBlockByIndex).toHaveBeenCalledWith(0);
+    expect(blockSelection.selectBlockByIndex).toHaveBeenCalledWith(1);
+    expect(blockSelection.unSelectBlockByIndex).not.toHaveBeenCalled();
+
+    blockSelection.selectBlockByIndex.mockClear();
+    selectedBlockState.selected = true;
+    internal.rectCrossesBlocks = false;
+
+    internal.inverseSelection();
+
+    expect(blockSelection.unSelectBlockByIndex).toHaveBeenCalledWith(0);
+    expect(blockSelection.unSelectBlockByIndex).toHaveBeenCalledWith(1);
+    expect(blockSelection.selectBlockByIndex).not.toHaveBeenCalled();
+  });
+
+  it('adds blocks to selection stack via addBlockInSelection', () => {
+    const {
+      rectangleSelection,
+      blockSelection,
+    } = createRectangleSelection();
+
+    const internal = rectangleSelection as unknown as {
+      rectCrossesBlocks: boolean;
+      stackOfSelected: number[];
+      addBlockInSelection: (index: number) => void;
+    };
+
+    internal.rectCrossesBlocks = true;
+    internal.addBlockInSelection(2);
+
+    expect(blockSelection.selectBlockByIndex).toHaveBeenCalledWith(2);
+    expect(internal.stackOfSelected).toEqual([ 2 ]);
+
+    blockSelection.selectBlockByIndex.mockClear();
+    internal.rectCrossesBlocks = false;
+    internal.addBlockInSelection(3);
+
+    expect(blockSelection.selectBlockByIndex).not.toHaveBeenCalled();
+    expect(internal.stackOfSelected).toEqual([2, 3]);
+  });
+
+  it('updates rectangle size based on cursor position', () => {
+    const {
+      rectangleSelection,
+      editorWrapper,
+    } = createRectangleSelection();
+
+    rectangleSelection.prepare();
+
+    const internal = rectangleSelection as unknown as {
+      overlayRectangle: HTMLDivElement;
+      startX: number;
+      startY: number;
+      mouseX: number;
+      mouseY: number;
+      updateRectangleSize: () => void;
+    };
+
+    internal.overlayRectangle = editorWrapper.querySelector(`.${RectangleSelection.CSS.rect}`) as HTMLDivElement;
+    internal.startX = 100;
+    internal.startY = 150;
+    internal.mouseX = 200;
+    internal.mouseY = 250;
+
+    internal.updateRectangleSize();
+
+    expect(internal.overlayRectangle.style.left).toBe('100px');
+    expect(internal.overlayRectangle.style.top).toBe('150px');
+    expect(internal.overlayRectangle.style.right).toBe('calc(100% - 200px)');
+    expect(internal.overlayRectangle.style.bottom).toBe('calc(100% - 250px)');
+  });
+
+  it('computes block information for current cursor position', () => {
+    const {
+      rectangleSelection,
+      blockManager,
+      blockContent,
+    } = createRectangleSelection();
+
+    const blockHolder = document.createElement('div');
+
+    blockHolder.appendChild(blockContent);
+
+    const block = {
+      holder: blockHolder,
+    } as unknown as BlockType;
+
+    blockManager.blocks.push(block);
+    blockManager.lastBlock = {
+      holder: blockHolder,
+    };
+
+    blockManager.getBlockByChildNode.mockReturnValue(block);
+
+    Object.defineProperty(document.body, 'offsetWidth', {
+      configurable: true,
+      value: 800,
+    });
+
+    const internal = rectangleSelection as unknown as {
+      mouseY: number;
+      genInfoForMouseSelection: () => { index: number; leftPos: number; rightPos: number };
+    };
+
+    internal.mouseY = 300;
+
+    const elementFromPointSpy = vi.spyOn(document, 'elementFromPoint').mockReturnValue(blockHolder);
+
+    const result = internal.genInfoForMouseSelection();
+
+    expect(result.index).toBe(0);
+    expect(result.leftPos).toBe(200);
+    expect(result.rightPos).toBe(600);
+
+    elementFromPointSpy.mockRestore();
+  });
+
+  it('activates rectangle selection and updates state when cursor moves with pressed mouse', () => {
+    const {
+      rectangleSelection,
+      toolbar,
+      editorWrapper,
+    } = createRectangleSelection();
+
+    rectangleSelection.prepare();
+
+    const internal = rectangleSelection as unknown as {
+      changingRectangle: (event: MouseEvent) => void;
+      mousedown: boolean;
+      isRectSelectionActivated: boolean;
+      overlayRectangle: HTMLDivElement;
+    };
+
+    internal.mousedown = true;
+    internal.isRectSelectionActivated = false;
+    internal.overlayRectangle = editorWrapper.querySelector(`.${RectangleSelection.CSS.rect}`) as HTMLDivElement;
+
+    const genInfoSpy = vi.spyOn(
+      rectangleSelection as unknown as { genInfoForMouseSelection: () => { rightPos: number; leftPos: number; index: number } },
+      'genInfoForMouseSelection'
+    ).mockReturnValue({
+      leftPos: 0,
+      rightPos: 500,
+      index: 1,
+    });
+    const trySelectSpy = vi.spyOn(
+      rectangleSelection as unknown as { trySelectNextBlock: (index: number) => void },
+      'trySelectNextBlock'
+    );
+    const inverseSpy = vi.spyOn(
+      rectangleSelection as unknown as { inverseSelection: () => void },
+      'inverseSelection'
+    );
+    const selectionRemove = vi.fn();
+    const selectionSpy = vi.spyOn(SelectionUtils, 'get').mockReturnValue({
+      removeAllRanges: selectionRemove,
+    } as unknown as Selection);
+
+    internal.changingRectangle({
+      pageX: 200,
+      pageY: 220,
+    } as MouseEvent);
+
+    expect(internal.isRectSelectionActivated).toBe(true);
+    expect(internal.overlayRectangle.style.display).toBe('block');
+    expect(toolbar.close).toHaveBeenCalled();
+    expect(trySelectSpy).toHaveBeenCalledWith(1);
+    expect(inverseSpy).toHaveBeenCalled();
+    expect(selectionRemove).toHaveBeenCalled();
+
+    genInfoSpy.mockRestore();
+    selectionSpy.mockRestore();
+  });
+
+  it('does not attempt block selection when no block is detected under cursor', () => {
+    const {
+      rectangleSelection,
+      toolbar,
+      editorWrapper,
+    } = createRectangleSelection();
+
+    rectangleSelection.prepare();
+
+    const internal = rectangleSelection as unknown as {
+      changingRectangle: (event: MouseEvent) => void;
+      mousedown: boolean;
+      isRectSelectionActivated: boolean;
+      overlayRectangle: HTMLDivElement;
+    };
+
+    internal.mousedown = true;
+    internal.isRectSelectionActivated = true;
+    internal.overlayRectangle = editorWrapper.querySelector(`.${RectangleSelection.CSS.rect}`) as HTMLDivElement;
+
+    const genInfoSpy = vi.spyOn(
+      rectangleSelection as unknown as { genInfoForMouseSelection: () => { rightPos: number; leftPos: number; index: number | undefined } },
+      'genInfoForMouseSelection'
+    ).mockReturnValue({
+      leftPos: 0,
+      rightPos: 500,
+      index: undefined,
+    });
+    const trySelectSpy = vi.spyOn(
+      rectangleSelection as unknown as { trySelectNextBlock: (index: number) => void },
+      'trySelectNextBlock'
+    );
+    const selectionSpy = vi.spyOn(SelectionUtils, 'get');
+
+    internal.changingRectangle({
+      pageX: 120,
+      pageY: 140,
+    } as MouseEvent);
+
+    expect(toolbar.close).toHaveBeenCalled();
+    expect(trySelectSpy).not.toHaveBeenCalled();
+    expect(selectionSpy).not.toHaveBeenCalled();
+
+    genInfoSpy.mockRestore();
+    selectionSpy.mockRestore();
+  });
+
+  it('clears selection state on mouse leave and mouse up events', () => {
+    const {
+      rectangleSelection,
+    } = createRectangleSelection();
+
+    rectangleSelection.prepare();
+
+    const internal = rectangleSelection as unknown as {
+      processMouseLeave: () => void;
+      processMouseUp: () => void;
+      clearSelection: () => void;
+      endSelection: () => void;
+    };
+
+    const clearSpy = vi.spyOn(internal, 'clearSelection');
+    const endSpy = vi.spyOn(internal, 'endSelection');
+
+    internal.processMouseLeave();
+    internal.processMouseUp();
+
+    expect(clearSpy).toHaveBeenCalledTimes(2);
+    expect(endSpy).toHaveBeenCalledTimes(2);
+  });
+
+  it('extends selection to skipped blocks in downward direction', () => {
+    const {
+      rectangleSelection,
+      blockSelection,
+    } = createRectangleSelection();
+
+    const internal = rectangleSelection as unknown as {
+      stackOfSelected: number[];
+      rectCrossesBlocks: boolean;
+      trySelectNextBlock: (index: number) => void;
+    };
+
+    internal.stackOfSelected.push(0, 1);
+    internal.rectCrossesBlocks = true;
+
+    internal.trySelectNextBlock(4);
+
+    expect(internal.stackOfSelected).toEqual([0, 1, 2, 3, 4]);
+    expect(blockSelection.selectBlockByIndex).toHaveBeenCalledWith(2);
+    expect(blockSelection.selectBlockByIndex).toHaveBeenCalledWith(3);
+    expect(blockSelection.selectBlockByIndex).toHaveBeenCalledWith(4);
+  });
+
+  it('shrinks selection stack when cursor moves backwards', () => {
+    const {
+      rectangleSelection,
+      blockSelection,
+    } = createRectangleSelection();
+
+    const internal = rectangleSelection as unknown as {
+      stackOfSelected: number[];
+      rectCrossesBlocks: boolean;
+      trySelectNextBlock: (index: number) => void;
+    };
+
+    internal.stackOfSelected.push(0, 1, 2, 3);
+    internal.rectCrossesBlocks = true;
+
+    internal.trySelectNextBlock(1);
+
+    expect(internal.stackOfSelected).toEqual([0, 1]);
+    expect(blockSelection.unSelectBlockByIndex).toHaveBeenCalledWith(3);
+    expect(blockSelection.unSelectBlockByIndex).toHaveBeenCalledWith(2);
+  });
+});
diff --git a/test/unit/components/modules/renderer.test.ts b/test/unit/components/modules/renderer.test.ts
new file mode 100644
index 000000000..7909118b1
--- /dev/null
+++ b/test/unit/components/modules/renderer.test.ts
@@ -0,0 +1,361 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { MockInstance } from 'vitest';
+
+import Renderer from '../../../../src/components/modules/renderer';
+import type { OutputBlockData } from '../../../../types';
+import type { StubData } from '../../../../src/tools/stub';
+import * as utils from '../../../../src/components/utils';
+
+type RendererEditor = Renderer['Editor'];
+type RendererBlockManager = RendererEditor['BlockManager'];
+type BlockManagerInsert = RendererBlockManager['insert'];
+type BlockManagerInsertMany = RendererBlockManager['insertMany'];
+type BlockManagerComposeBlock = RendererBlockManager['composeBlock'];
+type ComposeBlockArgs = Parameters<BlockManagerComposeBlock>[0];
+type ComposeBlockReturn = ReturnType<BlockManagerComposeBlock>;
+type IdleCallback = (deadline: { didTimeout: boolean; timeRemaining: () => number }) => void;
+
+interface MockBlockManager {
+  insert: MockInstance<Parameters<BlockManagerInsert>, ReturnType<BlockManagerInsert>>;
+  insertMany: MockInstance<Parameters<BlockManagerInsertMany>, ReturnType<BlockManagerInsertMany>>;
+  composeBlock: MockInstance<Parameters<BlockManagerComposeBlock>, ComposeBlockReturn>;
+}
+
+interface MockTools {
+  available: Map<string, unknown>;
+  unavailable: Map<string, { toolbox?: Array<{ title?: string }> }>;
+  stubTool: string;
+}
+
+interface RendererTestContext {
+  renderer: Renderer;
+  blockManager: MockBlockManager;
+  tools: MockTools;
+}
+
+const createMockBlock = ({ id, tool, marker }: { id?: string; tool: string; marker?: string }): ComposeBlockReturn => {
+  return {
+    id,
+    tool,
+    marker,
+  } as unknown as ComposeBlockReturn;
+};
+
+const createRenderer = (
+  options?: {
+    blockManager?: Partial<MockBlockManager>;
+    tools?: Partial<MockTools>;
+  }
+): RendererTestContext => {
+  const defaultBlockManager: MockBlockManager = {
+    insert: vi.fn<Parameters<BlockManagerInsert>, ReturnType<BlockManagerInsert>>(({ id, tool = 'default' } = {}) => {
+      return createMockBlock({
+        id,
+        tool,
+      });
+    }),
+    insertMany: vi.fn<Parameters<BlockManagerInsertMany>, ReturnType<BlockManagerInsertMany>>(() => undefined),
+    composeBlock: vi.fn<Parameters<BlockManagerComposeBlock>, ComposeBlockReturn>(({ id, tool }) => {
+      return createMockBlock({
+        id,
+        tool,
+      });
+    }),
+  };
+
+  const blockManager: MockBlockManager = {
+    ...defaultBlockManager,
+    ...options?.blockManager,
+  };
+
+  const defaultTools: MockTools = {
+    available: new Map<string, unknown>(),
+    unavailable: new Map<string, { toolbox?: Array<{ title?: string }> }>(),
+    stubTool: 'stub-tool',
+  };
+
+  const tools: MockTools = {
+    ...defaultTools,
+    ...options?.tools,
+  };
+
+  const renderer = new Renderer({
+    config: {},
+    eventsDispatcher: {
+      on: vi.fn(),
+      off: vi.fn(),
+    } as unknown as Renderer['eventsDispatcher'],
+  });
+
+  const editorState = {
+    BlockManager: blockManager,
+    Tools: tools,
+  };
+
+  renderer.state = editorState as unknown as RendererEditor;
+
+  return {
+    renderer,
+    blockManager,
+    tools,
+  };
+};
+
+let originalRequestIdleCallback: typeof window.requestIdleCallback;
+
+type RequestIdleCallbackMock = MockInstance<[IdleCallback], number>;
+let requestIdleCallbackMock: RequestIdleCallbackMock;
+
+beforeAll(() => {
+  originalRequestIdleCallback = window.requestIdleCallback;
+});
+
+beforeEach(() => {
+  requestIdleCallbackMock = vi.fn<[IdleCallback], number>((callback) => {
+    callback({
+      didTimeout: false,
+      timeRemaining: () => 0,
+    });
+
+    return 0;
+  });
+
+  Object.defineProperty(window, 'requestIdleCallback', {
+    configurable: true,
+    writable: true,
+    value: requestIdleCallbackMock,
+  });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+
+  Object.defineProperty(window, 'requestIdleCallback', {
+    configurable: true,
+    writable: true,
+    value: originalRequestIdleCallback,
+  });
+});
+
+afterAll(() => {
+  Object.defineProperty(window, 'requestIdleCallback', {
+    configurable: true,
+    writable: true,
+    value: originalRequestIdleCallback,
+  });
+});
+
+describe('Renderer module', () => {
+  it('inserts a default block when render receives an empty array', async () => {
+    const { renderer, blockManager } = createRenderer();
+
+    await renderer.render([]);
+
+    expect(blockManager.insert).toHaveBeenCalledTimes(1);
+    expect(blockManager.insertMany).not.toHaveBeenCalled();
+  });
+
+  it('composes and inserts blocks when tools are available', async () => {
+    const { renderer, blockManager, tools } = createRenderer();
+
+    tools.available.set('paragraph', {});
+
+    const composeBlock: MockBlockManager['composeBlock'] = vi.fn<
+      Parameters<BlockManagerComposeBlock>,
+      ComposeBlockReturn
+    >(({ id, tool }) => {
+      return createMockBlock({
+        id,
+        tool,
+        marker: 'block-instance',
+      });
+    });
+
+    blockManager.composeBlock = composeBlock;
+
+    const blockData: OutputBlockData = {
+      id: 'block-1',
+      type: 'paragraph',
+      data: { text: 'Hello' },
+      tunes: { alignment: 'left' },
+    };
+
+    await renderer.render([ blockData ]);
+
+    expect(composeBlock).toHaveBeenCalledTimes(1);
+    expect(composeBlock).toHaveBeenCalledWith({
+      id: 'block-1',
+      tool: 'paragraph',
+      data: blockData.data,
+      tunes: blockData.tunes,
+    });
+    expect(blockManager.insertMany).toHaveBeenCalledWith([
+      expect.objectContaining({
+        id: 'block-1',
+        tool: 'paragraph',
+        marker: 'block-instance',
+      }),
+    ]);
+    expect(blockManager.insert).not.toHaveBeenCalled();
+  });
+
+  it('replaces missing tools with stub blocks and logs a warning', async () => {
+    const { renderer, blockManager, tools } = createRenderer({
+      tools: {
+        stubTool: 'stub-tool',
+      },
+    });
+
+    const logLabeledSpy = vi.spyOn(utils, 'logLabeled').mockImplementation(() => {});
+
+    const blockData: OutputBlockData = {
+      id: 'missing-tool-block',
+      type: 'unsupported',
+      data: { payload: true },
+    };
+
+    await renderer.render([ blockData ]);
+
+    expect(logLabeledSpy).toHaveBeenCalledTimes(1);
+    const [message, level] = logLabeledSpy.mock.calls[0];
+
+    expect(level).toBe('warn');
+    expect(message).toContain('Tool «unsupported» is not found');
+
+    expect(blockManager.composeBlock).toHaveBeenCalledTimes(1);
+    const [ composeArgs ] = blockManager.composeBlock.mock.calls[0];
+
+    expect(composeArgs.tool).toBe(tools.stubTool);
+
+    const stubData = composeArgs.data as StubData;
+
+    expect(stubData.title).toBe('unsupported');
+    expect(stubData.savedData).toEqual({
+      id: 'missing-tool-block',
+      type: 'unsupported',
+      data: blockData.data,
+    });
+  });
+
+  it('renders stub blocks when a tool throws during composition', async () => {
+    const failingTool = 'unstable';
+
+    const composeBlock: MockBlockManager['composeBlock'] = vi.fn<
+      Parameters<BlockManagerComposeBlock>,
+      ComposeBlockReturn
+    >(() => {
+      throw new Error('Tool error');
+    });
+
+    composeBlock.mockImplementationOnce(() => {
+      throw new Error('Tool error');
+    });
+
+    composeBlock.mockImplementation((options: ComposeBlockArgs) => {
+      return createMockBlock({
+        id: options.id,
+        tool: options.tool,
+      });
+    });
+
+    const { renderer, tools } = createRenderer({
+      blockManager: {
+        composeBlock,
+      },
+    });
+
+    tools.available.set(failingTool, {});
+    tools.stubTool = 'stub-tool';
+
+    const logSpy = vi.spyOn(utils, 'log').mockImplementation(() => {});
+
+    const blockData: OutputBlockData = {
+      id: 'failing-tool-block',
+      type: failingTool,
+      data: { payload: true },
+    };
+
+    await renderer.render([ blockData ]);
+
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    const [message, level, details] = logSpy.mock.calls[0];
+
+    expect(level).toBe('error');
+    expect(message).toContain(`Block «${failingTool}» skipped because of plugins error`);
+    expect(details).toEqual({
+      data: blockData.data,
+      error: expect.any(Error),
+    });
+
+    expect(composeBlock).toHaveBeenCalledTimes(2);
+    const secondCall = composeBlock.mock.calls[1];
+
+    expect(secondCall).toBeDefined();
+
+    if (secondCall === undefined) {
+      throw new Error('Expected composeBlock to be called twice with arguments.');
+    }
+
+    const [ secondCallArgs ] = secondCall;
+
+    expect(secondCallArgs).toBeDefined();
+
+    if (secondCallArgs === undefined) {
+      throw new Error('Expected composeBlock second call to receive arguments.');
+    }
+
+    expect(secondCallArgs.tool).toBe(tools.stubTool);
+
+
+    const stubData = secondCallArgs.data as StubData;
+
+    expect(stubData.savedData.type).toBe(failingTool);
+  });
+
+  it('derives stub title from the unavailable tools registry when available', () => {
+    const customTitle = 'Custom tool title';
+
+    const toolsOverrides: Partial<MockTools> = {
+      unavailable: new Map<string, { toolbox?: Array<{ title?: string }> }>([
+        ['missing', { toolbox: [ { title: customTitle } ] } ],
+      ]),
+    };
+
+    const { renderer, tools } = createRenderer({
+      tools: toolsOverrides,
+    });
+
+    const composeStubDataForTool = (renderer as unknown as {
+      composeStubDataForTool: (tool: string, data: OutputBlockData['data'], id?: string) => StubData;
+    }).composeStubDataForTool.bind(renderer);
+
+    const stubData = composeStubDataForTool('missing', { payload: true }, 'id-1');
+
+    expect(stubData.title).toBe(customTitle);
+    expect(stubData.savedData).toEqual({
+      id: 'id-1',
+      type: 'missing',
+      data: { payload: true },
+    });
+
+    expect(tools.unavailable.has('missing')).toBe(true);
+  });
+
+  it('falls back to the tool name when toolbox metadata is missing', () => {
+    const { renderer } = createRenderer();
+
+    const composeStubDataForTool = (renderer as unknown as {
+      composeStubDataForTool: (tool: string, data: OutputBlockData['data'], id?: string) => StubData;
+    }).composeStubDataForTool.bind(renderer);
+
+    const stubData = composeStubDataForTool('fallback', { value: 1 }, 'block-id');
+
+    expect(stubData.title).toBe('fallback');
+    expect(stubData.savedData).toEqual({
+      id: 'block-id',
+      type: 'fallback',
+      data: { value: 1 },
+    });
+  });
+});
+
diff --git a/test/unit/components/modules/saver.test.ts b/test/unit/components/modules/saver.test.ts
new file mode 100644
index 000000000..2f7fcba2f
--- /dev/null
+++ b/test/unit/components/modules/saver.test.ts
@@ -0,0 +1,277 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { Mock } from 'vitest';
+
+import Saver from '../../../../src/components/modules/saver';
+import type Block from '../../../../src/components/block';
+import type { EditorConfig, SanitizerConfig } from '../../../../types';
+import type { SavedData } from '../../../../types/data-formats';
+import * as sanitizer from '../../../../src/components/utils/sanitizer';
+import * as utils from '../../../../src/components/utils';
+
+type BlockSaveResult = SavedData & { tunes?: Record<string, unknown> };
+
+interface BlockMock {
+  block: Block;
+  savedData: BlockSaveResult;
+  saveMock: Mock<[], Promise<BlockSaveResult>>;
+  validateMock: Mock<[BlockSaveResult['data']], Promise<boolean>>;
+}
+
+interface BlockMockOptions {
+  id: string;
+  tool: string;
+  data: SavedData['data'];
+  tunes?: Record<string, unknown>;
+  isValid?: boolean;
+}
+
+interface CreateSaverOptions {
+  blocks?: Block[];
+  sanitizer?: SanitizerConfig;
+  stubTool?: string;
+  toolSanitizeConfigs?: Record<string, SanitizerConfig>;
+}
+
+const createBlockMock = (options: BlockMockOptions): BlockMock => {
+  const savedData: BlockSaveResult = {
+    id: options.id,
+    tool: options.tool,
+    data: options.data,
+    time: 0,
+    ...(options.tunes ? { tunes: options.tunes } : {}),
+  };
+
+  const saveMock = vi.fn<[], Promise<BlockSaveResult>>().mockResolvedValue(savedData);
+  const validateMock = vi.fn<[BlockSaveResult['data']], Promise<boolean>>()
+    .mockResolvedValue(options.isValid ?? true);
+
+  const block = {
+    save: saveMock,
+    validate: validateMock,
+  } as unknown as Block;
+
+  return {
+    block,
+    savedData,
+    saveMock,
+    validateMock,
+  };
+};
+
+const createSaver = (options: CreateSaverOptions = {}): { saver: Saver } => {
+  const config: EditorConfig = {
+    sanitizer: options.sanitizer ?? ({} as SanitizerConfig),
+  };
+
+  const eventsDispatcher = {
+    on: vi.fn(),
+    off: vi.fn(),
+    emit: vi.fn(),
+  } as unknown as Saver['eventsDispatcher'];
+
+  const saver = new Saver({
+    config,
+    eventsDispatcher,
+  });
+
+  const stubTool = options.stubTool ?? 'stub';
+  const toolConfigs: Record<string, SanitizerConfig> = {
+    ...(options.toolSanitizeConfigs ?? {}),
+  };
+
+  if (!toolConfigs[stubTool]) {
+    toolConfigs[stubTool] = {} as SanitizerConfig;
+  }
+
+  const blockTools = new Map<string, { sanitizeConfig?: SanitizerConfig }>(
+    Object.entries(toolConfigs).map(([name, sanitizeConfig]) => [name, { sanitizeConfig } ])
+  );
+
+  const editorState = {
+    BlockManager: {
+      blocks: options.blocks ?? [],
+    },
+    Tools: {
+      blockTools,
+      stubTool,
+    },
+  };
+
+  (saver as unknown as { state: Saver['Editor'] }).state = editorState as unknown as Saver['Editor'];
+
+  return { saver };
+};
+
+describe('Saver module', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  it('saves valid blocks, sanitizes data, and preserves stub data', async () => {
+    vi.useFakeTimers();
+    const frozenDate = new Date('2024-05-01T10:00:00Z');
+
+    vi.setSystemTime(frozenDate);
+
+    const version = 'test-version';
+
+    vi.spyOn(utils, 'getEditorVersion').mockReturnValue(version);
+
+    const paragraphBlock = createBlockMock({
+      id: 'block-1',
+      tool: 'paragraph',
+      data: { text: '<b>Hello</b>' },
+      tunes: {
+        alignment: 'left',
+      },
+    });
+
+    const preservedData = {
+      type: 'legacy-tool',
+      data: { text: 'Keep me intact' },
+    };
+
+    const stubToolName = 'stub-tool';
+
+    const stubBlock = createBlockMock({
+      id: 'block-2',
+      tool: stubToolName,
+      data: preservedData,
+    });
+
+    const sanitizeBlocksSpy = vi.spyOn(sanitizer, 'sanitizeBlocks').mockImplementation((blocks, getConfig, globalSanitizer) => {
+      expect(typeof getConfig).toBe('function');
+
+      if (typeof getConfig !== 'function') {
+        throw new Error('Expected sanitize config resolver to be a function');
+      }
+
+      expect(getConfig('paragraph')).toEqual({ paragraph: { b: true } });
+      expect(globalSanitizer).toEqual({ common: true });
+
+      return blocks.map((block) => {
+        if (block.tool === 'paragraph') {
+          return {
+            ...block,
+            data: { text: 'Hello' },
+          };
+        }
+
+        return block;
+      });
+    });
+
+    const { saver } = createSaver({
+      blocks: [paragraphBlock.block, stubBlock.block],
+      sanitizer: { common: true },
+      stubTool: stubToolName,
+      toolSanitizeConfigs: {
+        paragraph: { paragraph: { b: true } },
+        [stubToolName]: {},
+      },
+    });
+
+    const result = await saver.save();
+
+    expect(paragraphBlock.saveMock).toHaveBeenCalledTimes(1);
+    expect(paragraphBlock.validateMock).toHaveBeenCalledWith(paragraphBlock.savedData.data);
+    expect(stubBlock.saveMock).toHaveBeenCalledTimes(1);
+    expect(sanitizeBlocksSpy).toHaveBeenCalledTimes(1);
+
+    const [ blocksBeforeSanitize ] = sanitizeBlocksSpy.mock.calls[0];
+
+    expect(blocksBeforeSanitize).toEqual([
+      expect.objectContaining({
+        id: paragraphBlock.savedData.id,
+        tool: 'paragraph',
+        data: paragraphBlock.savedData.data,
+        tunes: paragraphBlock.savedData.tunes,
+        isValid: true,
+      }),
+      expect.objectContaining({
+        id: stubBlock.savedData.id,
+        tool: 'stub-tool',
+        data: preservedData,
+        isValid: true,
+      }),
+    ]);
+
+    expect(result).toEqual({
+      time: frozenDate.valueOf(),
+      version,
+      blocks: [
+        {
+          id: paragraphBlock.savedData.id,
+          type: 'paragraph',
+          data: { text: 'Hello' },
+          tunes: paragraphBlock.savedData.tunes,
+        },
+        preservedData,
+      ],
+    });
+  });
+
+  it('skips invalid blocks and logs the reason', async () => {
+    const logSpy = vi.spyOn(utils, 'log').mockImplementation(() => undefined);
+
+    const invalidBlock = createBlockMock({
+      id: 'invalid',
+      tool: 'quote',
+      data: { text: 'Invalid' },
+      isValid: false,
+    });
+
+    const validBlock = createBlockMock({
+      id: 'valid',
+      tool: 'paragraph',
+      data: { text: 'Valid' },
+    });
+
+    const sanitizeBlocksSpy = vi.spyOn(sanitizer, 'sanitizeBlocks').mockImplementation((blocks) => blocks);
+
+    const { saver } = createSaver({
+      blocks: [invalidBlock.block, validBlock.block],
+      toolSanitizeConfigs: {
+        quote: {},
+        paragraph: {},
+      },
+    });
+
+    const result = await saver.save();
+
+    expect(result?.blocks).toEqual([
+      {
+        id: 'valid',
+        type: 'paragraph',
+        data: { text: 'Valid' },
+      },
+    ]);
+
+    expect(sanitizeBlocksSpy).toHaveBeenCalledTimes(1);
+    expect(logSpy).toHaveBeenCalledWith('Block «quote» skipped because saved data is invalid');
+  });
+
+  it('logs a labeled error when saving fails', async () => {
+    const error = new Error('save failed');
+    const logLabeledSpy = vi.spyOn(utils, 'logLabeled').mockImplementation(() => undefined);
+    const sanitizeBlocksSpy = vi.spyOn(sanitizer, 'sanitizeBlocks');
+
+    const failingBlock = {
+      save: vi.fn().mockRejectedValue(error),
+      validate: vi.fn(),
+    } as unknown as Block;
+
+    const { saver } = createSaver({
+      blocks: [ failingBlock ],
+      toolSanitizeConfigs: {
+        paragraph: {},
+      },
+    });
+
+    await expect(saver.save()).resolves.toBeUndefined();
+    expect(logLabeledSpy).toHaveBeenCalledWith('Saving failed due to the Error %o', 'error', error);
+    expect(sanitizeBlocksSpy).not.toHaveBeenCalled();
+  });
+});
+
diff --git a/test/unit/components/modules/toolbar/index.test.ts b/test/unit/components/modules/toolbar/index.test.ts
new file mode 100644
index 000000000..9d8573f43
--- /dev/null
+++ b/test/unit/components/modules/toolbar/index.test.ts
@@ -0,0 +1,164 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import Toolbar from '../../../../../src/components/modules/toolbar/index';
+import type * as UtilsModule from '../../../../../src/components/utils';
+import { BlockHovered } from '../../../../../src/components/events/BlockHovered';
+import type { EditorModules } from '../../../../../src/types-internal/editor-modules';
+
+vi.mock('@codexteam/icons', () => ({
+  IconMenu: '<svg></svg>',
+  IconPlus: '<svg></svg>',
+}));
+
+vi.mock('../../../../../src/components/utils/tooltip', () => ({
+  hide: vi.fn(),
+  onHover: vi.fn(),
+}));
+
+vi.mock('../../../../../src/components/dom', () => ({
+  default: {
+    make: vi.fn((tag: string) => document.createElement(tag)),
+    append: vi.fn((parent: HTMLElement, child: HTMLElement) => {
+      parent.appendChild(child);
+    }),
+  },
+  calculateBaseline: vi.fn(() => 0),
+}));
+
+vi.mock('../../../../../src/components/utils', async () => {
+  const actual = await vi.importActual<typeof UtilsModule>(
+    '../../../../../src/components/utils'
+  );
+
+  return {
+    ...actual,
+    isMobileScreen: vi.fn(() => false),
+    log: vi.fn(),
+  };
+});
+
+vi.mock('../../../../../src/components/i18n', () => ({
+  default: {
+    ui: vi.fn(() => ''),
+    t: vi.fn(() => ''),
+  },
+}));
+
+describe('Toolbar module interactions', () => {
+  let toolbar: Toolbar;
+  let blockHoveredHandler: ((data: { block: unknown }) => void) | undefined;
+
+  type MutableListeners = {
+    on: (
+      element: EventTarget,
+      eventType: string,
+      handler: (event: Event) => void,
+      options?: boolean | AddEventListenerOptions
+    ) => void;
+    clearAll: () => void;
+  };
+  const getEditor = (): EditorModules =>
+    (toolbar as unknown as { Editor: EditorModules }).Editor;
+
+  beforeEach(() => {
+    const eventsDispatcher = {
+      on: vi.fn((event, callback) => {
+        if (event === BlockHovered) {
+          blockHoveredHandler = callback as (data: { block: unknown }) => void;
+        }
+      }),
+      off: vi.fn(),
+    };
+
+    toolbar = new Toolbar({
+      config: {},
+      eventsDispatcher: eventsDispatcher as unknown as typeof toolbar['eventsDispatcher'],
+    });
+
+    toolbar.state = {
+      BlockSettings: {
+        opened: false,
+        close: vi.fn(),
+        getElement: vi.fn(() => document.createElement('div')),
+      },
+      UI: {
+        nodes: {
+          wrapper: document.createElement('div'),
+        },
+      },
+      BlockManager: {
+        currentBlock: null,
+        blocks: [],
+        length: 0,
+      },
+      BlockSelection: {
+        clearSelection: vi.fn(),
+      },
+      InlineToolbar: {
+        opened: false,
+      },
+      ReadOnly: {
+        isEnabled: false,
+      },
+    } as unknown as Toolbar['Editor'];
+
+    (toolbar as unknown as { nodes: typeof toolbar['nodes'] }).nodes = {
+      wrapper: document.createElement('div'),
+      content: document.createElement('div'),
+      actions: document.createElement('div'),
+      plusButton: document.createElement('button'),
+      settingsToggler: document.createElement('button'),
+    };
+
+    const readOnlyMutableListeners: MutableListeners = {
+      on: vi.fn(),
+      clearAll: vi.fn(),
+    };
+
+    (toolbar as unknown as { readOnlyMutableListeners: MutableListeners }).readOnlyMutableListeners =
+      readOnlyMutableListeners;
+  });
+
+  afterEach(() => {
+    blockHoveredHandler = undefined;
+    vi.clearAllMocks();
+  });
+
+  const enableBindings = (): void => {
+    (toolbar as unknown as { enableModuleBindings: () => void }).enableModuleBindings();
+
+    if (!blockHoveredHandler) {
+      throw new Error('BlockHovered handler was not registered');
+    }
+  };
+
+  it('does not move when Block Settings are opened during block hover', () => {
+    enableBindings();
+
+    getEditor().BlockSettings.opened = true;
+    const moveSpy = vi.spyOn(toolbar as unknown as { moveAndOpen: (block: unknown) => void }, 'moveAndOpen');
+
+    blockHoveredHandler?.({ block: {} });
+
+    expect(moveSpy).not.toHaveBeenCalled();
+  });
+
+  it('does not move when Toolbox is opened during block hover', () => {
+    enableBindings();
+
+    getEditor().BlockSettings.opened = false;
+    (toolbar as unknown as { toolboxInstance: { opened: boolean; close: () => void; open: () => void; toggle: () => void; hasFocus: () => boolean } }).toolboxInstance = {
+      opened: true,
+      close: vi.fn(),
+      open: vi.fn(),
+      toggle: vi.fn(),
+      hasFocus: vi.fn(),
+    };
+
+    const moveSpy = vi.spyOn(toolbar as unknown as { moveAndOpen: (block: unknown) => void }, 'moveAndOpen');
+
+    blockHoveredHandler?.({ block: {} });
+
+    expect(moveSpy).not.toHaveBeenCalled();
+  });
+});
+
diff --git a/test/unit/components/modules/tools.test.ts b/test/unit/components/modules/tools.test.ts
new file mode 100644
index 000000000..1d66de85f
--- /dev/null
+++ b/test/unit/components/modules/tools.test.ts
@@ -0,0 +1,545 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import Tools from '../../../../src/components/modules/tools';
+import BlockToolAdapter from '../../../../src/components/tools/block';
+import EventsDispatcher from '../../../../src/components/utils/events';
+import type { EditorModules } from '../../../../src/types-internal/editor-modules';
+import type { ModuleConfig } from '../../../../src/types-internal/module-config';
+import type { EditorConfig } from '../../../../types';
+import type { ToolConstructable } from '../../../../types/tools';
+import type { EditorEventMap } from '../../../../src/components/events';
+
+/**
+ * Creates a Tools module instance with provided editor config.
+ *
+ * @param config - optional editor configuration
+ */
+const createModule = (config?: EditorConfig): Tools => {
+  const editorConfig: EditorConfig = config ?? {
+    tools: {},
+  };
+
+  const moduleConfig: ModuleConfig = {
+    config: editorConfig,
+    eventsDispatcher: new EventsDispatcher<EditorEventMap>(),
+  };
+
+  const module = new Tools(moduleConfig);
+
+  const APIMethods = {
+    method(): void {},
+  };
+
+  const editorModules = {
+    API: {
+      getMethodsForTool(): typeof APIMethods {
+        return APIMethods;
+      },
+    },
+  } as unknown as EditorModules;
+
+  module.state = editorModules;
+
+  return module;
+};
+
+describe('tools module', () => {
+  describe('.prepare()', () => {
+    it('resolves without errors when tools config is valid', async () => {
+      const module = createModule();
+
+      await expect(module.prepare()).resolves.toBeUndefined();
+    });
+
+    it('throws when tool configuration is corrupted', async () => {
+      const module = createModule({
+        tools: {
+          corruptedTool: 'value' as unknown as ToolConstructable,
+        },
+      });
+
+      await expect(module.prepare()).rejects.toThrowError(Error);
+    });
+
+    it('calls a tool prepare method with user config', async () => {
+      /**
+       *
+       */
+      class WithSuccessfulPrepare {
+        public static calls: Array<{ toolName: string; config: unknown }> = [];
+
+        /**
+         * Forwards tool name and config to tool-level prepare handler.
+         *
+         * @param data object containing tool identifier and its configuration
+         */
+        public static prepare(data: { toolName: string; config: unknown }): void {
+          this.calls.push(data);
+        }
+      }
+
+      const config = {
+        property: 'value',
+      };
+
+      const module = createModule({
+        defaultBlock: 'withSuccessfulPrepare',
+        tools: {
+          withSuccessfulPrepare: {
+            class: WithSuccessfulPrepare as unknown as ToolConstructable,
+            config,
+          },
+        },
+      });
+
+      WithSuccessfulPrepare.calls = [];
+
+      await module.prepare();
+
+      expect(WithSuccessfulPrepare.calls).toStrictEqual([
+        {
+          toolName: 'withSuccessfulPrepare',
+          config,
+        },
+      ]);
+    });
+  });
+
+  describe('collection accessors', () => {
+    let module: Tools;
+
+    beforeEach(async () => {
+      /**
+       *
+       */
+      class InlineTool {
+        public static isInline = true;
+
+        /**
+         *
+         */
+        public render(): void {}
+
+        /**
+         *
+         */
+        public surround(): void {}
+
+        /**
+         *
+         */
+        public checkState(): void {}
+      }
+
+      /**
+       *
+       */
+      class InlineTool2 {
+        public static isInline = true;
+
+        /**
+         *
+         */
+        public render(): void {}
+
+        /**
+         *
+         */
+        public surround(): void {}
+
+        /**
+         *
+         */
+        public checkState(): void {}
+      }
+
+      /**
+       *
+       */
+      class UnavailableInlineTool {
+        public static isInline = true;
+      }
+
+      /**
+       *
+       */
+      class WithSuccessfulPrepare {
+        /**
+         *
+         */
+        public static prepare(): void {}
+      }
+
+      /**
+       *
+       */
+      class WithFailedPrepare {
+        /**
+         *
+         */
+        public static prepare(): void {
+          throw new Error();
+        }
+      }
+
+      /**
+       *
+       */
+      class UnavailableBlockTune {
+        public static isTune = true;
+
+        /**
+         *
+         */
+        public static prepare(): void {
+          throw new Error();
+        }
+      }
+
+      /**
+       *
+       */
+      class BasicBlockTool {
+        /**
+         *
+         */
+        public render(): HTMLElement {
+          const element = document.createElement('div');
+
+          element.contentEditable = 'true';
+
+          return element;
+        }
+
+        /**
+         *
+         */
+        public save(): void {}
+      }
+
+      /**
+       *
+       */
+      class BlockToolWithoutSettings extends BasicBlockTool {}
+
+      /**
+       *
+       */
+      class BlockToolWithInline extends BasicBlockTool {}
+
+      const moduleInstance = createModule({
+        defaultBlock: 'withoutPrepare',
+        tools: {
+          withSuccessfulPrepare: {
+            class: WithSuccessfulPrepare as unknown as ToolConstructable,
+            inlineToolbar: [ 'inlineTool2' ],
+            tunes: [ 'blockTune2' ],
+          },
+          withFailedPrepare: WithFailedPrepare as unknown as ToolConstructable,
+          withoutPrepare: {
+            class: BlockToolWithoutSettings as unknown as ToolConstructable,
+            inlineToolbar: false,
+            tunes: false,
+          },
+          blockTool: {
+            class: BlockToolWithInline as unknown as ToolConstructable,
+            inlineToolbar: true,
+          },
+          blockToolWithoutSettings: BlockToolWithoutSettings as unknown as ToolConstructable,
+          inlineTool: InlineTool as unknown as ToolConstructable,
+          inlineTool2: InlineTool2 as unknown as ToolConstructable,
+          unavailableInlineTool: UnavailableInlineTool as unknown as ToolConstructable,
+          blockTune: class {
+            public static isTune = true;
+          } as unknown as ToolConstructable,
+          blockTune2: class {
+            public static isTune = true;
+          } as unknown as ToolConstructable,
+          unavailableBlockTune: UnavailableBlockTune as unknown as ToolConstructable,
+        },
+        inlineToolbar: ['inlineTool2', 'inlineTool'],
+        tunes: ['blockTune2', 'blockTune'],
+      });
+
+      await moduleInstance.prepare();
+
+      module = moduleInstance;
+    });
+
+    it('.available returns only ready to use tools', () => {
+      expect(module.available).toBeInstanceOf(Map);
+      expect(module.available.has('withSuccessfulPrepare')).toBe(true);
+      expect(module.available.has('withoutPrepare')).toBe(true);
+      expect(module.available.has('withFailedPrepare')).toBe(false);
+      expect(module.available.has('unavailableInlineTool')).toBe(false);
+    });
+
+    it('.unavailable returns tools that failed preparation', () => {
+      expect(module.unavailable).toBeInstanceOf(Map);
+      expect(module.unavailable.has('withSuccessfulPrepare')).toBe(false);
+      expect(module.unavailable.has('withoutPrepare')).toBe(false);
+      expect(module.unavailable.has('withFailedPrepare')).toBe(true);
+      expect(module.unavailable.has('unavailableInlineTool')).toBe(true);
+    });
+
+    it('.inlineTools contains only available inline tools', () => {
+      expect(module.inlineTools).toBeInstanceOf(Map);
+      expect(module.inlineTools.has('inlineTool')).toBe(true);
+      expect(module.inlineTools.has('unavailableInlineTool')).toBe(false);
+      expect(Array.from(module.inlineTools.values()).every(tool => tool.isInline())).toBe(true);
+    });
+
+    it('.blockTools contains only available block tools', () => {
+      expect(module.blockTools).toBeInstanceOf(Map);
+      expect(module.blockTools.has('withSuccessfulPrepare')).toBe(true);
+      expect(module.blockTools.has('withoutPrepare')).toBe(true);
+      expect(module.blockTools.has('withFailedPrepare')).toBe(false);
+      expect(Array.from(module.blockTools.values()).every(tool => tool.isBlock())).toBe(true);
+    });
+
+    it('block tools without settings contain default tunes', () => {
+      const tool = module.blockTools.get('blockToolWithoutSettings');
+
+      expect(tool?.tunes.has('delete')).toBe(true);
+      expect(tool?.tunes.has('moveUp')).toBe(true);
+      expect(tool?.tunes.has('moveDown')).toBe(true);
+    });
+
+    it('block tools contain default tunes', () => {
+      const tool = module.blockTools.get('blockTool');
+
+      expect(tool?.tunes.has('delete')).toBe(true);
+      expect(tool?.tunes.has('moveUp')).toBe(true);
+      expect(tool?.tunes.has('moveDown')).toBe(true);
+    });
+
+    it('block tools include tunes in the correct order', () => {
+      const toolWithInline = module.blockTools.get('blockTool');
+      const tunesOrder = Array.from(toolWithInline?.tunes.keys() ?? []);
+
+      expect(toolWithInline?.tunes.has('blockTune')).toBe(true);
+      expect(toolWithInline?.tunes.has('blockTune2')).toBe(true);
+      expect(tunesOrder).toStrictEqual(['blockTune2', 'blockTune', 'moveUp', 'delete', 'moveDown']);
+
+      const toolWithSuccessfulPrepare = module.blockTools.get('withSuccessfulPrepare');
+
+      expect(toolWithSuccessfulPrepare?.tunes.has('blockTune')).toBe(false);
+      expect(toolWithSuccessfulPrepare?.tunes.has('blockTune2')).toBe(true);
+
+      const toolWithoutPrepare = module.blockTools.get('withoutPrepare');
+
+      expect(toolWithoutPrepare?.tunes.has('blockTune')).toBe(false);
+      expect(toolWithoutPrepare?.tunes.has('blockTune2')).toBe(false);
+    });
+
+    it('block tools include inline tools in the correct order', () => {
+      const toolWithInline = module.blockTools.get('blockTool');
+      const inlineToolsOrder = Array.from(toolWithInline?.inlineTools.keys() ?? []);
+
+      expect(toolWithInline?.inlineTools.has('inlineTool')).toBe(true);
+      expect(toolWithInline?.inlineTools.has('inlineTool2')).toBe(true);
+      expect(inlineToolsOrder).toStrictEqual(['inlineTool2', 'inlineTool']);
+
+      const toolWithSuccessfulPrepare = module.blockTools.get('withSuccessfulPrepare');
+
+      expect(toolWithSuccessfulPrepare?.inlineTools.has('inlineTool')).toBe(false);
+      expect(toolWithSuccessfulPrepare?.inlineTools.has('inlineTool2')).toBe(true);
+
+      const toolWithoutPrepare = module.blockTools.get('withoutPrepare');
+
+      expect(toolWithoutPrepare?.inlineTools.has('inlineTool')).toBe(false);
+      expect(toolWithoutPrepare?.inlineTools.has('inlineTool2')).toBe(false);
+    });
+
+    it('.blockTunes contains only available block tunes', () => {
+      expect(module.blockTunes).toBeInstanceOf(Map);
+      expect(module.blockTunes.has('blockTune')).toBe(true);
+      expect(module.blockTunes.has('unavailableBlockTune')).toBe(false);
+      expect(Array.from(module.blockTunes.values()).every(tool => tool.isTune())).toBe(true);
+    });
+
+    it('.internal contains only internal tools', () => {
+      expect(module.internal).toBeInstanceOf(Map);
+      expect(Array.from(module.internal.values()).every(tool => tool.isInternal)).toBe(true);
+    });
+
+    it('.defaultTool returns a block tool adapter for the default tool', () => {
+      expect(module.defaultTool).toBeInstanceOf(BlockToolAdapter);
+      expect(module.defaultTool.isDefault).toBe(true);
+    });
+  });
+
+  describe('.getAllInlineToolsSanitizeConfig()', () => {
+    it('returns merged inline tool sanitize configuration', async () => {
+      /**
+       *
+       */
+      class InlineToolWithSanitize {
+        public static isInline = true;
+
+        public static sanitize = {
+          span: {
+            class: true,
+          },
+        };
+
+        /**
+         *
+         */
+        public render(): void {}
+
+        /**
+         *
+         */
+        public surround(): void {}
+
+        /**
+         *
+         */
+        public checkState(): void {}
+      }
+
+      /**
+       *
+       */
+      class AnotherInlineToolWithSanitize {
+        public static isInline = true;
+
+        public static sanitize = {
+          mark: {
+            style: true,
+          },
+        };
+
+        /**
+         *
+         */
+        public render(): void {}
+
+        /**
+         *
+         */
+        public surround(): void {}
+
+        /**
+         *
+         */
+        public checkState(): void {}
+      }
+
+      const module = createModule({
+        tools: {
+          inlineToolOne: InlineToolWithSanitize as unknown as ToolConstructable,
+          inlineToolTwo: AnotherInlineToolWithSanitize as unknown as ToolConstructable,
+        },
+        inlineToolbar: ['inlineToolOne', 'inlineToolTwo'],
+      });
+
+      await module.prepare();
+
+      const sanitizeConfig = module.getAllInlineToolsSanitizeConfig();
+
+      expect(sanitizeConfig).toMatchObject({
+        span: {
+          class: true,
+        },
+        mark: {
+          style: true,
+        },
+      });
+
+      expect(module.getAllInlineToolsSanitizeConfig()).toBe(sanitizeConfig);
+    });
+  });
+
+  describe('.destroy()', () => {
+    it('calls reset on all available tools', async () => {
+      /**
+       *
+       */
+      class AsyncResetBlockTool {
+        public static calls = 0;
+
+        /**
+         *
+         */
+        public static reset(): Promise<void> {
+          this.calls += 1;
+
+          return Promise.resolve();
+        }
+      }
+
+      const module = createModule({
+        tools: {
+          asyncResetTool: AsyncResetBlockTool as unknown as ToolConstructable,
+        },
+      });
+
+      await module.prepare();
+
+      AsyncResetBlockTool.calls = 0;
+
+      module.destroy();
+
+      expect(AsyncResetBlockTool.calls).toBe(1);
+    });
+
+    it('handles errors raised during tool reset', async () => {
+      /**
+       *
+       */
+      class ThrowingBlockTool {
+        public static wasResetCalled = false;
+
+        /**
+         *
+         */
+        public static reset(): void {
+          this.wasResetCalled = true;
+
+          throw new Error('reset failure');
+        }
+      }
+
+      /**
+       *
+       */
+      class RejectingBlockTool {
+        /**
+         *
+         */
+        public static reset(): Promise<void> {
+          return Promise.reject(new Error('async reset failure'));
+        }
+      }
+
+      const module = createModule({
+        tools: {
+          throwing: ThrowingBlockTool as unknown as ToolConstructable,
+          rejecting: RejectingBlockTool as unknown as ToolConstructable,
+        },
+      });
+
+      await module.prepare();
+
+      let unhandledRejection: unknown;
+      const handleUnhandledRejection = (reason: unknown): void => {
+        unhandledRejection = reason;
+      };
+
+      process.on('unhandledRejection', handleUnhandledRejection);
+
+      expect(() => module.destroy()).not.toThrow();
+
+      await new Promise(resolve => {
+        setTimeout(resolve, 0);
+      });
+
+      process.off('unhandledRejection', handleUnhandledRejection);
+
+      expect(unhandledRejection).toBeUndefined();
+      expect(ThrowingBlockTool.wasResetCalled).toBe(true);
+    });
+  });
+});
+
diff --git a/test/unit/components/modules/ui.test.ts b/test/unit/components/modules/ui.test.ts
new file mode 100644
index 000000000..d26dd42c4
--- /dev/null
+++ b/test/unit/components/modules/ui.test.ts
@@ -0,0 +1,751 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import UI from '../../../../src/components/modules/ui';
+import SelectionUtils from '../../../../src/components/selection';
+import Flipper from '../../../../src/components/flipper';
+import { DATA_INTERFACE_ATTRIBUTE, EDITOR_INTERFACE_VALUE } from '../../../../src/components/constants';
+import { BlockHovered } from '../../../../src/components/events/BlockHovered';
+import { EditorMobileLayoutToggled } from '../../../../src/components/events';
+import * as Dom from '../../../../src/components/dom';
+import { mobileScreenBreakpoint } from '../../../../src/components/utils';
+import type { EditorConfig } from '../../../../types';
+
+const fakeCssContent = '.mock-style{}';
+
+vi.mock('../../../../src/components/styles/main.css?inline', () => fakeCssContent);
+
+const createEditorStub = (): UI['Editor'] => {
+  const blockSettingsWrapper = document.createElement('div');
+  const toolbarWrapper = document.createElement('div');
+  const toolbarSettingsToggler = document.createElement('button');
+
+  return {
+    BlockManager: {
+      isEditorEmpty: false,
+      currentBlock: null,
+      currentBlockIndex: -1,
+      lastBlock: null,
+      insert: vi.fn(() => ({})),
+      insertAtEnd: vi.fn(),
+      insertDefaultBlockAtIndex: vi.fn(),
+      unsetCurrentBlock: vi.fn(),
+      setCurrentBlockByChildNode: vi.fn(),
+      getBlockByChildNode: vi.fn(),
+      getBlockByIndex: vi.fn(() => ({
+        holder: document.createElement('div'),
+      })),
+      removeSelectedBlocks: vi.fn(),
+    },
+    BlockSelection: {
+      anyBlockSelected: false,
+      clearSelection: vi.fn(),
+    },
+    CrossBlockSelection: {
+      isCrossBlockSelectionStarted: false,
+    },
+    RectangleSelection: {
+      isRectActivated: vi.fn(() => false),
+    },
+    InlineToolbar: {
+      opened: false,
+      close: vi.fn(),
+      tryToShow: vi.fn(() => Promise.resolve()),
+      containsNode: vi.fn(() => false),
+    },
+    BlockSettings: {
+      opened: false,
+      close: vi.fn(),
+      nodes: {
+        wrapper: blockSettingsWrapper,
+      },
+    },
+    Toolbar: {
+      moveAndOpen: vi.fn(),
+      close: vi.fn(),
+      nodes: {
+        wrapper: toolbarWrapper,
+        settingsToggler: toolbarSettingsToggler,
+      },
+      toolbox: {
+        opened: false,
+        close: vi.fn(),
+        hasFocus: vi.fn(() => false),
+      },
+    },
+    BlockEvents: {
+      keydown: vi.fn(),
+    },
+    Caret: {
+      setToBlock: vi.fn(),
+      positions: {
+        START: 'start',
+        END: 'end',
+      },
+    },
+    ReadOnly: {
+      isEnabled: false,
+    },
+    InlineToolbarAPI: {},
+    BlockSettingsAPI: {},
+    BlockSelectionAPI: {},
+    BlockEventsAPI: {},
+  } as unknown as UI['Editor'];
+};
+
+interface CreateUIOptions {
+  attachNodes?: boolean;
+  configOverrides?: Partial<EditorConfig>;
+  editorOverrides?: Partial<ReturnType<typeof createEditorStub>>;
+  holderWidth?: number;
+}
+
+type EventsDispatcherMock = {
+  on: ReturnType<typeof vi.fn>;
+  off: ReturnType<typeof vi.fn>;
+  emit: ReturnType<typeof vi.fn>;
+};
+
+interface CreateUIResult {
+  ui: UI;
+  editor: UI['Editor'];
+  holder: HTMLDivElement;
+  wrapper: HTMLDivElement;
+  redactor: HTMLDivElement;
+  eventsDispatcher: EventsDispatcherMock;
+}
+
+const createUI = (options: CreateUIOptions = {}): CreateUIResult => {
+  const holder = document.createElement('div');
+  const wrapper = document.createElement('div');
+  const redactor = document.createElement('div');
+
+  holder.appendChild(wrapper);
+  wrapper.appendChild(redactor);
+  document.body.appendChild(holder);
+
+  Object.defineProperty(holder, 'offsetWidth', {
+    value: options.holderWidth ?? 400,
+    configurable: true,
+  });
+
+  const eventsDispatcher: EventsDispatcherMock = {
+    on: vi.fn(),
+    off: vi.fn(),
+    emit: vi.fn(),
+  };
+
+  const ui = new UI({
+    config: {
+      holder,
+      minHeight: 50,
+      ...options.configOverrides,
+    } as EditorConfig,
+    eventsDispatcher: eventsDispatcher as unknown as UI['eventsDispatcher'],
+  });
+
+  const editor = createEditorStub();
+
+  if (options.editorOverrides) {
+    Object.assign(editor, options.editorOverrides);
+  }
+
+  ui.state = editor;
+
+  if (options.attachNodes !== false) {
+    (ui as { nodes: UI['nodes'] }).nodes = {
+      holder,
+      wrapper,
+      redactor,
+    };
+  }
+
+  return {
+    ui,
+    editor,
+    holder,
+    wrapper,
+    redactor,
+    eventsDispatcher,
+  };
+};
+
+const mockSelectionExists = (value: boolean): ReturnType<typeof vi.spyOn> => {
+  return vi.spyOn(SelectionUtils, 'isSelectionExists', 'get').mockReturnValue(value) as unknown as ReturnType<typeof vi.spyOn>;
+};
+
+const mockSelectionCollapsed = (value: boolean | null): ReturnType<typeof vi.spyOn> => {
+  return vi.spyOn(SelectionUtils, 'isCollapsed', 'get').mockReturnValue(value) as unknown as ReturnType<typeof vi.spyOn>;
+};
+
+const mockSelectionAnchor = (value: Element | null): ReturnType<typeof vi.spyOn> => {
+  return vi.spyOn(SelectionUtils, 'anchorElement', 'get').mockReturnValue(value) as unknown as ReturnType<typeof vi.spyOn>;
+};
+
+const mockSelectionRange = (value: Range | null): ReturnType<typeof vi.spyOn> => {
+  return vi.spyOn(SelectionUtils, 'range', 'get').mockReturnValue(value) as unknown as ReturnType<typeof vi.spyOn>;
+};
+
+const mockSelection = (selection: Partial<Selection> | null): ReturnType<typeof vi.spyOn> => {
+  return vi.spyOn(SelectionUtils, 'get').mockReturnValue(selection as Selection | null) as unknown as ReturnType<typeof vi.spyOn>;
+};
+
+describe('UI module', () => {
+  afterEach(() => {
+    document.body.innerHTML = '';
+    document.head.innerHTML = '';
+    vi.restoreAllMocks();
+    delete (window as Partial<Window>).requestIdleCallback;
+  });
+
+  describe('initialization', () => {
+    it('runs preparation steps sequentially', async () => {
+      const { ui } = createUI({ attachNodes: false });
+      const setIsMobileSpy = vi.spyOn(ui as unknown as { setIsMobile: () => void }, 'setIsMobile');
+      const makeSpy = vi.spyOn(ui as unknown as { make: () => void }, 'make');
+      const loadStylesSpy = vi.spyOn(ui as unknown as { loadStyles: () => void }, 'loadStyles');
+
+      await ui.prepare();
+
+      expect(setIsMobileSpy).toHaveBeenCalledTimes(1);
+      expect(makeSpy).toHaveBeenCalledTimes(1);
+      expect(loadStylesSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('throws when holder is missing', () => {
+      const holderLessUI = new UI({
+        config: {} as EditorConfig,
+        eventsDispatcher: {
+          on: vi.fn(),
+          off: vi.fn(),
+          emit: vi.fn(),
+        } as unknown as UI['eventsDispatcher'],
+      });
+
+      expect(() => (holderLessUI as unknown as { make: () => void }).make()).toThrowError(
+        'Editor holder is not specified in the configuration.'
+      );
+    });
+
+    it('creates wrapper/redactor nodes and attaches listeners', () => {
+      const { ui, holder } = createUI({ attachNodes: false,
+        holderWidth: 200 });
+      const bindSpy = vi.spyOn(ui as unknown as { bindReadOnlyInsensitiveListeners: () => void }, 'bindReadOnlyInsensitiveListeners');
+
+      (ui as unknown as { make: () => void }).make();
+
+      const nodes = (ui as { nodes: UI['nodes'] }).nodes;
+
+      expect(nodes.wrapper).toBeInstanceOf(HTMLElement);
+      expect(nodes.wrapper?.classList.contains(ui.CSS.editorWrapper)).toBe(true);
+      expect(nodes.wrapper?.classList.contains(ui.CSS.editorWrapperNarrow)).toBe(true);
+      expect(nodes.wrapper?.getAttribute(DATA_INTERFACE_ATTRIBUTE)).toBe(EDITOR_INTERFACE_VALUE);
+
+      expect(nodes.redactor).toBeInstanceOf(HTMLElement);
+      expect(nodes.redactor?.classList.contains(ui.CSS.editorZone)).toBe(true);
+      expect(nodes.redactor?.style.paddingBottom).toBe(`${ui['config'].minHeight}px`);
+
+      expect(holder.contains(nodes.wrapper as HTMLElement)).toBe(true);
+      expect(bindSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('appends styles with nonce only once', () => {
+      const { ui } = createUI();
+
+      (ui as unknown as { config: EditorConfig }).config.style = {
+        nonce: 'nonce-value',
+      };
+
+      (ui as unknown as { loadStyles: () => void }).loadStyles();
+
+      const styleTag = document.getElementById('editor-js-styles');
+
+      expect(styleTag).toBeTruthy();
+      expect(styleTag?.getAttribute('nonce')).toBe('nonce-value');
+      expect(document.head.firstChild).toBe(styleTag);
+
+      (ui as unknown as { loadStyles: () => void }).loadStyles();
+
+      expect(document.querySelectorAll('#editor-js-styles')).toHaveLength(1);
+    });
+  });
+
+  describe('read-only state management', () => {
+    it('unbinds sensitive listeners when read-only mode enabled', () => {
+      const { ui } = createUI();
+      const unbindSpy = vi.spyOn(ui as unknown as { unbindReadOnlySensitiveListeners: () => void }, 'unbindReadOnlySensitiveListeners');
+      const bindSpy = vi.spyOn(ui as unknown as { bindReadOnlySensitiveListeners: () => void }, 'bindReadOnlySensitiveListeners');
+
+      ui.toggleReadOnly(true);
+
+      expect(unbindSpy).toHaveBeenCalledTimes(1);
+      expect(bindSpy).not.toHaveBeenCalled();
+    });
+
+    it('binds listeners immediately and on idle callback in read-write mode', () => {
+      const { ui } = createUI();
+      const bindSpy = vi.spyOn(ui as unknown as { bindReadOnlySensitiveListeners: () => void }, 'bindReadOnlySensitiveListeners');
+      const idleCallback = vi.fn();
+
+      (window as Partial<Window>).requestIdleCallback = idleCallback as unknown as typeof window.requestIdleCallback;
+
+      ui.toggleReadOnly(false);
+
+      expect(bindSpy).toHaveBeenCalledTimes(1);
+      expect(idleCallback).toHaveBeenCalledWith(expect.any(Function), { timeout: 2000 });
+      const scheduled = idleCallback.mock.calls[0][0];
+
+      bindSpy.mockClear();
+      scheduled();
+
+      expect(bindSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('state updates and getters', () => {
+    it('toggles empty class based on BlockManager state', () => {
+      const { ui, editor, wrapper } = createUI();
+
+      Object.assign(editor.BlockManager, { isEditorEmpty: true });
+      ui.checkEmptiness();
+      expect(wrapper.classList.contains(ui.CSS.editorEmpty)).toBe(true);
+
+      Object.assign(editor.BlockManager, { isEditorEmpty: false });
+      ui.checkEmptiness();
+      expect(wrapper.classList.contains(ui.CSS.editorEmpty)).toBe(false);
+    });
+
+    it('invalidates cached content rect on resize and recalculates mobile state', () => {
+      const { ui } = createUI();
+      const cache = { width: 100 } as DOMRect;
+
+      (ui as unknown as { contentRectCache: DOMRect | null }).contentRectCache = cache;
+      const setIsMobileSpy = vi.spyOn(ui as unknown as { setIsMobile: () => void }, 'setIsMobile');
+
+      (ui as unknown as { windowResize: () => void }).windowResize();
+
+      expect((ui as unknown as { contentRectCache: DOMRect | null }).contentRectCache).toBeNull();
+      expect(setIsMobileSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('provides cached content rect when available', () => {
+      const { ui } = createUI();
+      const cache = { width: 321 } as DOMRect;
+
+      (ui as unknown as { contentRectCache: DOMRect | null }).contentRectCache = cache;
+
+      const querySpy = vi.spyOn((ui as { nodes: UI['nodes'] }).nodes.wrapper, 'querySelector');
+
+      expect(ui.contentRect).toBe(cache);
+      expect(querySpy).not.toHaveBeenCalled();
+    });
+
+    it('returns default rect when no blocks rendered', () => {
+      const { ui, wrapper } = createUI();
+
+      // Ensure wrapper has no content blocks
+      wrapper.innerHTML = '';
+
+      const rect = ui.contentRect;
+
+      expect(rect.width).toBe(650);
+      expect(rect.left).toBe(0);
+      expect(rect.right).toBe(0);
+    });
+
+    it('caches computed rect when block exists', () => {
+      const { ui, wrapper } = createUI();
+      const blockContent = document.createElement('div');
+
+      blockContent.classList.add('ce-block__content');
+      const measuredRect = { width: 777 } as DOMRect;
+
+      vi.spyOn(blockContent, 'getBoundingClientRect').mockReturnValue(measuredRect);
+      wrapper.appendChild(blockContent);
+
+      const firstCall = ui.contentRect;
+      const secondCall = ui.contentRect;
+
+      expect(firstCall).toBe(measuredRect);
+      expect(secondCall).toBe(measuredRect);
+      expect(blockContent.getBoundingClientRect).toHaveBeenCalledTimes(1);
+    });
+
+    it('detects open toolbars and flipper focus', () => {
+      const { ui, editor } = createUI();
+
+      editor.BlockSettings.opened = true;
+      expect(ui.someToolbarOpened).toBe(true);
+
+      editor.BlockSettings.opened = false;
+      editor.InlineToolbar.opened = true;
+      expect(ui.someToolbarOpened).toBe(true);
+
+      editor.InlineToolbar.opened = false;
+      editor.Toolbar.toolbox.opened = true;
+      expect(ui.someToolbarOpened).toBe(true);
+
+      editor.Toolbar.toolbox.opened = false;
+
+      vi.mocked(editor.Toolbar.toolbox.hasFocus).mockReturnValue(true);
+      expect(ui.someFlipperButtonFocused).toBe(true);
+
+      vi.mocked(editor.Toolbar.toolbox.hasFocus).mockReturnValue(false);
+      const flipper = new Flipper({ items: [] });
+
+      flipper.hasFocus = vi.fn(() => true);
+
+      (editor as unknown as Record<string, unknown>).MockModule = {
+        flipper,
+      };
+
+      expect(ui.someFlipperButtonFocused).toBe(true);
+    });
+
+    it('updates mobile flag and emits layout toggle when breakpoint changes', () => {
+      const { ui, eventsDispatcher } = createUI();
+
+      window.innerWidth = mobileScreenBreakpoint - 1;
+      (ui as unknown as { setIsMobile: () => void }).setIsMobile();
+
+      expect(ui.isMobile).toBe(true);
+      expect(eventsDispatcher.emit).toHaveBeenCalledWith(EditorMobileLayoutToggled, {
+        isEnabled: false,
+      });
+
+      eventsDispatcher.emit.mockClear();
+      window.innerWidth = mobileScreenBreakpoint + 1;
+      (ui as unknown as { setIsMobile: () => void }).setIsMobile();
+
+      expect(ui.isMobile).toBe(false);
+      expect(eventsDispatcher.emit).toHaveBeenCalledWith(EditorMobileLayoutToggled, {
+        isEnabled: true,
+      });
+    });
+
+    it('closes all toolbars at once', () => {
+      const { ui, editor } = createUI();
+
+      ui.closeAllToolbars();
+
+      expect(editor.BlockSettings.close).toHaveBeenCalledTimes(1);
+      expect(editor.InlineToolbar.close).toHaveBeenCalledTimes(1);
+      expect(editor.Toolbar.toolbox.close).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('keyboard handling', () => {
+    it('skips enter handling when any toolbar opened', () => {
+      const { ui, editor } = createUI();
+
+      editor.InlineToolbar.opened = true;
+
+      (ui as unknown as { enterPressed: (event: KeyboardEvent) => void }).enterPressed(new KeyboardEvent('keydown'));
+
+      expect(editor.BlockManager.insert).not.toHaveBeenCalled();
+    });
+
+    it('clears selected blocks on enter when selection absent', () => {
+      const { ui, editor } = createUI();
+
+      Object.assign(editor.BlockSelection, { anyBlockSelected: true });
+      mockSelectionExists(false);
+      mockSelectionCollapsed(true);
+
+      const event = {
+        preventDefault: vi.fn(),
+        stopImmediatePropagation: vi.fn(),
+        stopPropagation: vi.fn(),
+        target: document.body,
+      } as unknown as KeyboardEvent;
+
+      (ui as unknown as { enterPressed: (event: KeyboardEvent) => void }).enterPressed(event);
+
+      expect(editor.BlockSelection.clearSelection).toHaveBeenCalledWith(event);
+      expect(event.preventDefault).toHaveBeenCalled();
+    });
+
+    it('inserts new block when enter pressed on body without selection', () => {
+      const { ui, editor } = createUI();
+      const newBlock = { id: 'new' } as unknown as ReturnType<typeof editor.BlockManager.insert>;
+
+      Object.assign(editor.BlockSelection, { anyBlockSelected: false });
+      editor.BlockManager.currentBlockIndex = 1;
+      vi.mocked(editor.BlockManager.insert).mockReturnValue(newBlock);
+      mockSelectionExists(true);
+      mockSelectionCollapsed(false);
+
+      const event = {
+        preventDefault: vi.fn(),
+        stopImmediatePropagation: vi.fn(),
+        stopPropagation: vi.fn(),
+        target: document.body,
+      } as unknown as KeyboardEvent;
+
+      (ui as unknown as { enterPressed: (event: KeyboardEvent) => void }).enterPressed(event);
+
+      expect(editor.BlockManager.insert).toHaveBeenCalledTimes(1);
+      expect(editor.Caret.setToBlock).toHaveBeenCalledWith(newBlock);
+      expect(editor.Toolbar.moveAndOpen).toHaveBeenCalledWith(newBlock);
+      expect(editor.BlockSelection.clearSelection).toHaveBeenCalledWith(event);
+    });
+
+    it('handles escape priority order', () => {
+      const { ui, editor } = createUI();
+      const event = new KeyboardEvent('keydown');
+
+      editor.Toolbar.toolbox.opened = true;
+      editor.BlockManager.currentBlock = {
+        id: 'test',
+        name: 'paragraph',
+        holder: document.createElement('div'),
+      } as unknown as typeof editor.BlockManager.currentBlock;
+
+      (ui as unknown as { escapePressed: (event: KeyboardEvent) => void }).escapePressed(event);
+
+      expect(editor.Toolbar.toolbox.close).toHaveBeenCalledTimes(1);
+      expect(editor.Caret.setToBlock).toHaveBeenCalledWith(editor.BlockManager.currentBlock, editor.Caret.positions.END);
+
+      editor.Toolbar.toolbox.opened = false;
+      editor.BlockSettings.opened = true;
+      (ui as unknown as { escapePressed: (event: KeyboardEvent) => void }).escapePressed(event);
+      expect(editor.BlockSettings.close).toHaveBeenCalledTimes(1);
+
+      editor.BlockSettings.opened = false;
+      editor.InlineToolbar.opened = true;
+      (ui as unknown as { escapePressed: (event: KeyboardEvent) => void }).escapePressed(event);
+      expect(editor.InlineToolbar.close).toHaveBeenCalledTimes(1);
+
+      editor.InlineToolbar.opened = false;
+      (ui as unknown as { escapePressed: (event: KeyboardEvent) => void }).escapePressed(event);
+      expect(editor.Toolbar.close).toHaveBeenCalledTimes(1);
+    });
+
+    it('sends keydown to block events or clears caret on default handler', () => {
+      const { ui, editor, holder } = createUI();
+
+      const outsideTarget = document.createElement('div');
+
+      document.body.appendChild(outsideTarget);
+      editor.BlockManager.currentBlock = {
+        id: 'test',
+        name: 'paragraph',
+        holder: document.createElement('div'),
+      } as unknown as typeof editor.BlockManager.currentBlock;
+
+      (ui as unknown as { defaultBehaviour: (event: KeyboardEvent) => void }).defaultBehaviour({
+        target: outsideTarget,
+        altKey: false,
+        ctrlKey: false,
+        metaKey: false,
+        shiftKey: false,
+      } as unknown as KeyboardEvent);
+
+      expect(editor.BlockEvents.keydown).toHaveBeenCalledTimes(1);
+
+      Object.assign(editor.BlockManager, { currentBlock: undefined });
+      (ui as unknown as { defaultBehaviour: (event: KeyboardEvent) => void }).defaultBehaviour({
+        target: outsideTarget,
+        altKey: false,
+        ctrlKey: false,
+        metaKey: false,
+        shiftKey: false,
+      } as unknown as KeyboardEvent);
+
+      expect(editor.BlockManager.unsetCurrentBlock).toHaveBeenCalledTimes(1);
+      expect(editor.Toolbar.close).toHaveBeenCalledTimes(1);
+
+      holder.classList.add(ui.CSS.editorWrapper);
+      (ui as unknown as { defaultBehaviour: (event: KeyboardEvent) => void }).defaultBehaviour({
+        target: holder,
+        altKey: false,
+        ctrlKey: false,
+        metaKey: false,
+        shiftKey: false,
+      } as unknown as KeyboardEvent);
+
+      expect(editor.BlockManager.unsetCurrentBlock).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('selection handling', () => {
+    it('responds to selection changes and clears cross block ranges', () => {
+      const { ui, editor } = createUI();
+
+      Object.assign(editor.CrossBlockSelection, { isCrossBlockSelectionStarted: true });
+      Object.assign(editor.BlockSelection, { anyBlockSelected: true });
+
+      const removeRanges = vi.fn();
+
+      mockSelection({ removeAllRanges: removeRanges });
+      mockSelectionAnchor(null);
+      mockSelectionRange(null);
+
+      (ui as unknown as { selectionChanged: () => void }).selectionChanged();
+
+      expect(removeRanges).toHaveBeenCalledTimes(1);
+      expect(editor.InlineToolbar.close).toHaveBeenCalledTimes(1);
+    });
+
+    it('closes inline toolbar when selection outside block content', () => {
+      const { ui, editor, holder } = createUI();
+      const externalElement = document.createElement('div');
+
+      holder.appendChild(externalElement);
+
+      mockSelectionAnchor(externalElement);
+
+      (ui as unknown as { selectionChanged: () => void }).selectionChanged();
+
+      expect(editor.InlineToolbar.close).toHaveBeenCalledTimes(1);
+    });
+
+    it('skips closing when inline toolbar enabled for external element and opens toolbar for block content', async () => {
+      const { ui, editor, wrapper } = createUI();
+      const blockContent = document.createElement('div');
+
+      blockContent.classList.add('ce-block__content');
+      wrapper.classList.add(SelectionUtils.CSS.editorWrapper);
+      const external = document.createElement('div');
+
+      wrapper.appendChild(blockContent);
+      wrapper.parentElement?.appendChild(external);
+      external.dataset.inlineToolbar = 'true';
+
+      const anchorSpy = vi.spyOn(SelectionUtils, 'anchorElement', 'get');
+
+      anchorSpy.mockReturnValue(external);
+
+      (ui as unknown as { selectionChanged: () => void }).selectionChanged();
+      expect(editor.InlineToolbar.close).toHaveBeenCalledTimes(1);
+
+      editor.BlockManager.currentBlock = undefined;
+      anchorSpy.mockReturnValue(blockContent);
+
+      await (ui as unknown as { selectionChanged: () => Promise<void> }).selectionChanged();
+
+      expect(editor.BlockManager.setCurrentBlockByChildNode).toHaveBeenLastCalledWith(blockContent);
+      expect(editor.InlineToolbar.tryToShow).toHaveBeenCalledWith(true);
+    });
+  });
+
+  describe('DOM interactions', () => {
+    it('moves toolbar on document touch when block selected', () => {
+      const { ui, editor, redactor } = createUI();
+      const block = document.createElement('div');
+
+      redactor.appendChild(block);
+
+      (ui as unknown as { documentTouched: (event: Event) => void }).documentTouched({
+        target: block,
+      } as unknown as Event);
+
+      expect(editor.BlockManager.setCurrentBlockByChildNode).toHaveBeenCalledWith(block);
+      expect(editor.Toolbar.moveAndOpen).toHaveBeenCalledTimes(1);
+    });
+
+    it('clears current block when clicking outside of editor', () => {
+      const { ui, editor } = createUI();
+      const outside = document.createElement('div');
+
+      document.body.appendChild(outside);
+
+      vi.spyOn(SelectionUtils, 'isAtEditor', 'get').mockReturnValue(false);
+
+      (ui as unknown as { documentClicked: (event: MouseEvent) => void }).documentClicked({
+        target: outside,
+        isTrusted: true,
+      } as unknown as MouseEvent);
+
+      expect(editor.BlockManager.unsetCurrentBlock).toHaveBeenCalledTimes(1);
+      expect(editor.Toolbar.close).toHaveBeenCalledTimes(1);
+      expect(editor.BlockSelection.clearSelection).toHaveBeenCalledTimes(1);
+    });
+
+    it('closes block settings when clicking inside redactor', () => {
+      const { ui, editor, redactor } = createUI();
+
+      editor.BlockSettings.opened = true;
+      const blockElement = document.createElement('div');
+
+      redactor.appendChild(blockElement);
+      const blockStub = {
+        id: 'test',
+        name: 'paragraph',
+        holder: document.createElement('div'),
+      } as unknown as ReturnType<typeof editor.BlockManager.getBlockByChildNode>;
+
+      vi.mocked(editor.BlockManager.getBlockByChildNode).mockReturnValue(blockStub);
+
+      (ui as unknown as { documentClicked: (event: MouseEvent) => void }).documentClicked({
+        target: blockElement,
+        isTrusted: true,
+      } as unknown as MouseEvent);
+
+      expect(editor.BlockSettings.close).toHaveBeenCalledTimes(1);
+      expect(editor.Toolbar.moveAndOpen).toHaveBeenCalledWith(blockStub);
+    });
+  });
+
+  describe('hover and placeholder helpers', () => {
+    it('emits block-hovered events for unique hovered blocks', () => {
+      const { ui, editor, redactor, eventsDispatcher } = createUI();
+      const blockElement = document.createElement('div');
+
+      blockElement.classList.add('ce-block');
+      redactor.appendChild(blockElement);
+
+      const blockStub = {
+        id: 'hovered',
+        name: 'paragraph',
+        holder: document.createElement('div'),
+      } as unknown as ReturnType<typeof editor.BlockManager.getBlockByChildNode>;
+
+      vi.mocked(editor.BlockManager.getBlockByChildNode).mockReturnValue(blockStub);
+      Object.assign(editor.BlockSelection, { anyBlockSelected: false });
+
+      (ui as unknown as { watchBlockHoveredEvents: () => void }).watchBlockHoveredEvents();
+
+      const event = new MouseEvent('mousemove', { bubbles: true });
+
+      Object.defineProperty(event, 'target', { value: blockElement });
+      redactor.dispatchEvent(event);
+
+      expect(eventsDispatcher.emit).toHaveBeenCalledWith(BlockHovered, { block: blockStub });
+      eventsDispatcher.emit.mockClear();
+
+      redactor.dispatchEvent(event);
+      expect(eventsDispatcher.emit).not.toHaveBeenCalled();
+    });
+
+    it('marks inputs as empty on focus and input events', () => {
+      const { ui, wrapper } = createUI();
+      const toggleSpy = vi.spyOn(Dom, 'toggleEmptyMark');
+
+      (ui as unknown as { enableInputsEmptyMark: () => void }).enableInputsEmptyMark();
+
+      const input = document.createElement('div');
+
+      wrapper.appendChild(input);
+
+      input.dispatchEvent(new Event('input', { bubbles: true }));
+      input.dispatchEvent(new Event('focusin', { bubbles: true }));
+      input.dispatchEvent(new Event('focusout', { bubbles: true }));
+
+      expect(toggleSpy).toHaveBeenCalledTimes(3);
+      expect(toggleSpy).toHaveBeenCalledWith(input);
+    });
+  });
+
+  describe('cleanup', () => {
+    it('closes toolbars and removes listeners on destroy', () => {
+      const { ui, holder } = createUI();
+
+      holder.innerHTML = '<div>content</div>';
+      const unbindSpy = vi.spyOn(ui as unknown as { unbindReadOnlyInsensitiveListeners: () => void }, 'unbindReadOnlyInsensitiveListeners');
+
+      ui.destroy();
+
+      expect(holder.innerHTML).toBe('');
+      expect(unbindSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+});
diff --git a/test/unit/components/selection.test.ts b/test/unit/components/selection.test.ts
new file mode 100644
index 000000000..85c33cc65
--- /dev/null
+++ b/test/unit/components/selection.test.ts
@@ -0,0 +1,505 @@
+import { describe, it, expect, beforeEach, afterEach, beforeAll, vi } from 'vitest';
+import SelectionUtils from '../../../src/components/selection';
+import * as utils from '../../../src/components/utils';
+
+const ensureSelection = (): Selection => {
+  const selection = window.getSelection();
+
+  if (!selection) {
+    throw new Error('Selection API is not available in the current environment');
+  }
+
+  return selection;
+};
+
+const updateSelectionProperties = (
+  selection: Selection,
+  state: {
+    anchorNode: Node | null;
+    focusNode: Node | null;
+    anchorOffset: number;
+    focusOffset: number;
+    isCollapsed: boolean;
+  }
+): void => {
+  Object.defineProperty(selection, 'anchorNode', {
+    value: state.anchorNode,
+    configurable: true,
+  });
+
+  Object.defineProperty(selection, 'focusNode', {
+    value: state.focusNode,
+    configurable: true,
+  });
+
+  Object.defineProperty(selection, 'anchorOffset', {
+    value: state.anchorOffset,
+    configurable: true,
+  });
+
+  Object.defineProperty(selection, 'focusOffset', {
+    value: state.focusOffset,
+    configurable: true,
+  });
+
+  Object.defineProperty(selection, 'isCollapsed', {
+    value: state.isCollapsed,
+    configurable: true,
+  });
+};
+
+const setSelectionRange = (node: Node, startOffset: number, endOffset: number = startOffset): Range => {
+  const selection = ensureSelection();
+  const range = document.createRange();
+
+  range.setStart(node, startOffset);
+  range.setEnd(node, endOffset);
+  selection.removeAllRanges();
+  selection.addRange(range);
+
+  updateSelectionProperties(selection, {
+    anchorNode: node,
+    focusNode: node,
+    anchorOffset: startOffset,
+    focusOffset: endOffset,
+    isCollapsed: startOffset === endOffset,
+  });
+
+  return range;
+};
+
+const createContentEditable = (text = 'Hello world'): { element: HTMLDivElement; textNode: Text } => {
+  const element = document.createElement('div');
+
+  element.contentEditable = 'true';
+  element.textContent = text;
+  document.body.appendChild(element);
+
+  const textNode = element.firstChild;
+
+  if (!(textNode instanceof Text)) {
+    throw new Error('Failed to create text node for contenteditable element');
+  }
+
+  return { element,
+    textNode };
+};
+
+const createEditorZone = (text = 'Hello world'): {
+  wrapper: HTMLDivElement;
+  zone: HTMLDivElement;
+  paragraph: HTMLParagraphElement;
+  textNode: Text;
+} => {
+  const wrapper = document.createElement('div');
+  const zone = document.createElement('div');
+  const paragraph = document.createElement('p');
+
+  wrapper.className = 'codex-editor';
+  zone.className = 'codex-editor__redactor';
+  paragraph.textContent = text;
+
+  zone.appendChild(paragraph);
+  wrapper.appendChild(zone);
+  document.body.appendChild(wrapper);
+
+  const textNode = paragraph.firstChild;
+
+  if (!(textNode instanceof Text)) {
+    throw new Error('Failed to create text node inside editor zone');
+  }
+
+  return { wrapper,
+    zone,
+    paragraph,
+    textNode };
+};
+
+describe('SelectionUtils', () => {
+  beforeAll(() => {
+    const prototype = Range.prototype as Range & {
+      getBoundingClientRect?: () => DOMRect;
+    };
+
+    if (typeof prototype.getBoundingClientRect !== 'function') {
+      prototype.getBoundingClientRect = () => new DOMRect(0, 0, 0, 0);
+    }
+  });
+
+  const clearSelectionState = (): void => {
+    const selection = ensureSelection();
+
+    selection.removeAllRanges();
+    updateSelectionProperties(selection, {
+      anchorNode: null,
+      focusNode: null,
+      anchorOffset: 0,
+      focusOffset: 0,
+      isCollapsed: true,
+    });
+  };
+
+  beforeEach(() => {
+    document.body.innerHTML = '';
+    clearSelectionState();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    clearSelectionState();
+    document.body.innerHTML = '';
+  });
+
+  it('returns anchor node of the current selection', () => {
+    const { textNode } = createContentEditable();
+
+    setSelectionRange(textNode, 1);
+
+    expect(SelectionUtils.anchorNode).toBe(textNode);
+  });
+
+  it('returns parent element when anchor is a text node', () => {
+    const { element, textNode } = createContentEditable();
+
+    setSelectionRange(textNode, 0);
+
+    expect(SelectionUtils.anchorElement).toBe(element);
+  });
+
+  it('returns the element itself when anchor node is an element', () => {
+    const { element } = createContentEditable();
+    const selection = ensureSelection();
+    const range = document.createRange();
+
+    range.selectNodeContents(element);
+    selection.removeAllRanges();
+    selection.addRange(range);
+
+    updateSelectionProperties(selection, {
+      anchorNode: element,
+      focusNode: element,
+      anchorOffset: 0,
+      focusOffset: element.childNodes.length,
+      isCollapsed: element.childNodes.length === 0,
+    });
+
+    expect(SelectionUtils.anchorElement).toBe(element);
+  });
+
+  it('detects collapsed selection state', () => {
+    const { textNode } = createContentEditable();
+
+    setSelectionRange(textNode, 2);
+    expect(SelectionUtils.isCollapsed).toBe(true);
+
+    setSelectionRange(textNode, 0, 4);
+    expect(SelectionUtils.isCollapsed).toBe(false);
+  });
+
+  it('checks whether selection is inside the editor zone', () => {
+    const { textNode } = createEditorZone();
+
+    setSelectionRange(textNode, 0, textNode.textContent?.length ?? 0);
+    expect(SelectionUtils.isAtEditor).toBe(true);
+
+    const outside = document.createElement('p');
+
+    outside.textContent = 'Outside';
+    document.body.appendChild(outside);
+
+    const outsideText = outside.firstChild;
+
+    if (!(outsideText instanceof Text)) {
+      throw new Error('Outside element is missing text node');
+    }
+
+    setSelectionRange(outsideText, 0, 3);
+    expect(SelectionUtils.isAtEditor).toBe(false);
+  });
+
+  it('validates whether a specific range belongs to the editor zone', () => {
+    const { textNode } = createEditorZone();
+    const insideRange = document.createRange();
+
+    insideRange.setStart(textNode, 0);
+    insideRange.setEnd(textNode, 2);
+
+    expect(SelectionUtils.isRangeAtEditor(insideRange)).toBe(true);
+
+    const outsideParagraph = document.createElement('p');
+
+    outsideParagraph.textContent = 'Outer text';
+    document.body.appendChild(outsideParagraph);
+
+    const outsideText = outsideParagraph.firstChild;
+
+    if (!(outsideText instanceof Text)) {
+      throw new Error('Missing text node for outside range');
+    }
+
+    const outsideRange = document.createRange();
+
+    outsideRange.setStart(outsideText, 0);
+    outsideRange.setEnd(outsideText, 5);
+
+    expect(SelectionUtils.isRangeAtEditor(outsideRange)).toBe(false);
+  });
+
+  it('reports whether any selection exists', () => {
+    const { textNode } = createContentEditable();
+
+    setSelectionRange(textNode, 1, 3);
+    expect(SelectionUtils.isSelectionExists).toBe(true);
+
+    clearSelectionState();
+    expect(SelectionUtils.isSelectionExists).toBe(false);
+  });
+
+  it('returns the current selection range', () => {
+    const { textNode } = createContentEditable();
+
+    const range = setSelectionRange(textNode, 0, 5);
+
+    expect(SelectionUtils.range).toBeDefined();
+    expect(SelectionUtils.range?.startContainer).toBe(range.startContainer);
+    expect(SelectionUtils.range?.startOffset).toBe(range.startOffset);
+  });
+
+  it('returns range from provided selection object', () => {
+    const { textNode } = createContentEditable();
+
+    setSelectionRange(textNode, 0, 4);
+
+    const selection = ensureSelection();
+
+    expect(SelectionUtils.getRangeFromSelection(selection)).toEqual(selection.getRangeAt(0));
+    expect(SelectionUtils.getRangeFromSelection(null)).toBeNull();
+  });
+
+  it('returns selected text value', () => {
+    const { textNode } = createContentEditable('Sample');
+
+    setSelectionRange(textNode, 0, 3);
+
+    expect(SelectionUtils.text).toBe('Sam');
+  });
+
+  it('provides access to window selection object', () => {
+    expect(SelectionUtils.get()).toBe(window.getSelection());
+  });
+
+  it('sets cursor inside a contenteditable element', () => {
+    const { element } = createContentEditable();
+
+    SelectionUtils.setCursor(element, 0);
+
+    const range = SelectionUtils.range;
+
+    expect(range).not.toBeNull();
+    expect(range?.startContainer).toBe(element);
+    expect(range?.startOffset).toBe(0);
+  });
+
+  it('sets cursor inside a native input element', () => {
+    const input = document.createElement('input');
+
+    input.type = 'text';
+    input.value = 'Hello';
+    document.body.appendChild(input);
+
+    SelectionUtils.setCursor(input, 2);
+
+    expect(input.selectionStart).toBe(2);
+    expect(input.selectionEnd).toBe(2);
+  });
+
+  it('checks whether current range is inside a container', () => {
+    const { element, textNode } = createContentEditable();
+
+    setSelectionRange(textNode, 0, 1);
+
+    expect(SelectionUtils.isRangeInsideContainer(element)).toBe(true);
+
+    const otherContainer = document.createElement('div');
+
+    document.body.appendChild(otherContainer);
+
+    expect(SelectionUtils.isRangeInsideContainer(otherContainer)).toBe(false);
+  });
+
+  it('adds and removes a fake cursor', () => {
+    const { element } = createContentEditable();
+
+    SelectionUtils.setCursor(element, 0);
+    SelectionUtils.addFakeCursor();
+
+    expect(SelectionUtils.isFakeCursorInsideContainer(element)).toBe(true);
+    expect(element.querySelector('.codex-editor__fake-cursor')).not.toBeNull();
+
+    SelectionUtils.removeFakeCursor(element);
+
+    expect(SelectionUtils.isFakeCursorInsideContainer(element)).toBe(false);
+  });
+
+  it('manages fake background wrappers around selection', () => {
+    const utilsInstance = new SelectionUtils();
+    const { zone, paragraph } = createEditorZone('Highlighted text');
+    const selection = ensureSelection();
+    const range = document.createRange();
+
+    range.setStart(paragraph, 0);
+    range.setEnd(paragraph, paragraph.childNodes.length);
+    selection.removeAllRanges();
+    selection.addRange(range);
+
+    updateSelectionProperties(selection, {
+      anchorNode: paragraph,
+      focusNode: paragraph,
+      anchorOffset: 0,
+      focusOffset: paragraph.childNodes.length,
+      isCollapsed: false,
+    });
+
+    utilsInstance.setFakeBackground();
+
+    const wrappers = zone.querySelectorAll('.codex-editor__fake-background');
+
+    expect(wrappers.length).toBeGreaterThan(0);
+    wrappers.forEach((wrapper) => {
+      expect((wrapper as HTMLElement).dataset.fakeBackground).toBe('true');
+    });
+    expect(utilsInstance.isFakeBackgroundEnabled).toBe(true);
+
+    utilsInstance.removeFakeBackground();
+
+    expect(utilsInstance.isFakeBackgroundEnabled).toBe(false);
+    expect(paragraph.querySelector('.codex-editor__fake-background')).toBeNull();
+    expect(paragraph.textContent).toBe('Highlighted text');
+  });
+
+  it('does not enable fake background when selection is collapsed', () => {
+    const utilsInstance = new SelectionUtils();
+    const { paragraph } = createEditorZone('Single word');
+    const selection = ensureSelection();
+    const range = document.createRange();
+
+    range.setStart(paragraph, 0);
+    range.setEnd(paragraph, 0);
+    selection.removeAllRanges();
+    selection.addRange(range);
+
+    updateSelectionProperties(selection, {
+      anchorNode: paragraph,
+      focusNode: paragraph,
+      anchorOffset: 0,
+      focusOffset: 0,
+      isCollapsed: true,
+    });
+
+    utilsInstance.setFakeBackground();
+
+    expect(utilsInstance.isFakeBackgroundEnabled).toBe(false);
+    expect(document.querySelector('.codex-editor__fake-background')).toBeNull();
+  });
+
+  it('saves, restores, and clears selection ranges', () => {
+    const utilsInstance = new SelectionUtils();
+    const { textNode } = createContentEditable('Saved range example');
+
+    setSelectionRange(textNode, 0, 5);
+    const savedText = SelectionUtils.text;
+
+    utilsInstance.save();
+
+    const other = document.createElement('p');
+
+    other.textContent = 'Other content';
+    document.body.appendChild(other);
+
+    const otherText = other.firstChild;
+
+    if (!(otherText instanceof Text)) {
+      throw new Error('Missing text node in other element');
+    }
+
+    setSelectionRange(otherText, 0, 5);
+    expect(SelectionUtils.text).toBe('Other');
+
+    utilsInstance.restore();
+    expect(SelectionUtils.text).toBe(savedText);
+
+    utilsInstance.clearSaved();
+    expect(utilsInstance.savedSelectionRange).toBeNull();
+  });
+
+  it('collapses selection to the end of focus node', () => {
+    const utilsInstance = new SelectionUtils();
+    const { textNode } = createContentEditable('Collapse');
+
+    setSelectionRange(textNode, 0, 3);
+    utilsInstance.collapseToEnd();
+
+    const range = SelectionUtils.range;
+
+    expect(range?.collapsed).toBe(true);
+    expect(range?.startContainer).toBe(textNode);
+    expect(range?.startOffset).toBe(textNode.length);
+  });
+
+  it('finds parent tag by name and optional class', () => {
+    const utilsInstance = new SelectionUtils();
+    const container = document.createElement('div');
+
+    container.innerHTML = '<p><strong class="highlight">Nested text</strong></p>';
+    document.body.appendChild(container);
+
+    const strong = container.querySelector('strong');
+
+    if (!(strong instanceof HTMLElement) || !(strong.firstChild instanceof Text)) {
+      throw new Error('Expected strong element with a text node');
+    }
+
+    setSelectionRange(strong.firstChild, 0, strong.firstChild.length);
+
+    expect(utilsInstance.findParentTag('STRONG')).toBe(strong);
+    expect(utilsInstance.findParentTag('STRONG', 'highlight')).toBe(strong);
+    expect(utilsInstance.findParentTag('STRONG', 'missing')).toBeNull();
+  });
+
+  it('expands selection to cover an entire element', () => {
+    const utilsInstance = new SelectionUtils();
+    const container = document.createElement('div');
+
+    container.innerHTML = '<p><em>Expanded text</em></p>';
+    document.body.appendChild(container);
+
+    const emphasis = container.querySelector('em');
+
+    if (!(emphasis instanceof HTMLElement) || !(emphasis.firstChild instanceof Text)) {
+      throw new Error('Expected em element with a text node');
+    }
+
+    setSelectionRange(emphasis.firstChild, 0, 4);
+    utilsInstance.expandToTag(emphasis);
+
+    expect(SelectionUtils.text).toBe(emphasis.textContent);
+  });
+
+  it('returns zero rect when selection is unavailable', () => {
+    const getSelectionSpy = vi.spyOn(window, 'getSelection').mockReturnValue(null as unknown as Selection);
+    const logSpy = vi.spyOn(utils, 'log').mockImplementation(() => undefined);
+
+    const rect = SelectionUtils.rect;
+
+    expect(rect.x).toBe(0);
+    expect(rect.y).toBe(0);
+    expect(rect.width).toBe(0);
+    expect(rect.height).toBe(0);
+    expect(logSpy).toHaveBeenCalled();
+
+    getSelectionSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+});
+
+
diff --git a/test/unit/components/utils/events.test.ts b/test/unit/components/utils/events.test.ts
new file mode 100644
index 000000000..3a9c15a17
--- /dev/null
+++ b/test/unit/components/utils/events.test.ts
@@ -0,0 +1,123 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import EventsDispatcher from '../../../../src/components/utils/events';
+
+type TestEventMap = {
+  simple: string;
+  numeric: number;
+};
+
+describe('EventsDispatcher', () => {
+  let dispatcher: EventsDispatcher<TestEventMap>;
+
+  beforeEach(() => {
+    dispatcher = new EventsDispatcher<TestEventMap>();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('on & emit', () => {
+    it('calls all subscribers with emitted data', () => {
+      const firstHandler = vi.fn();
+      const secondHandler = vi.fn();
+
+      dispatcher.on('simple', firstHandler);
+      dispatcher.on('simple', secondHandler);
+
+      dispatcher.emit('simple', 'payload');
+
+      expect(firstHandler).toHaveBeenCalledTimes(1);
+      expect(firstHandler).toHaveBeenCalledWith('payload');
+      expect(secondHandler).toHaveBeenCalledTimes(1);
+      expect(secondHandler).toHaveBeenCalledWith('payload');
+    });
+
+    it('pipes returned data between listeners', () => {
+      const firstHandler = vi.fn((value: string) => `${value} -> first`);
+      const secondHandler = vi.fn((value: string) => `${value} -> second`);
+
+      dispatcher.on('simple', firstHandler);
+      dispatcher.on('simple', secondHandler);
+
+      dispatcher.emit('simple', 'start');
+
+      expect(firstHandler).toHaveBeenCalledWith('start');
+      expect(secondHandler).toHaveBeenCalledWith('start -> first');
+    });
+
+    it('retains previous data when listener returns undefined', () => {
+      const firstHandler = vi.fn(() => undefined);
+      const secondHandler = vi.fn();
+
+      dispatcher.on('simple', firstHandler);
+      dispatcher.on('simple', secondHandler);
+
+      dispatcher.emit('simple', 'initial');
+
+      expect(firstHandler).toHaveBeenCalledWith('initial');
+      expect(secondHandler).toHaveBeenCalledWith('initial');
+    });
+  });
+
+  describe('once', () => {
+    it('removes listener after first invocation', () => {
+      const handler = vi.fn();
+
+      dispatcher.once('simple', handler);
+
+      dispatcher.emit('simple', 'first');
+      dispatcher.emit('simple', 'second');
+
+      expect(handler).toHaveBeenCalledTimes(1);
+      expect(handler).toHaveBeenCalledWith('first');
+    });
+  });
+
+  describe('off', () => {
+    it('removes a specific listener', () => {
+      const handlerToRemove = vi.fn();
+      const remainingHandler = vi.fn();
+
+      dispatcher.on('simple', handlerToRemove);
+      dispatcher.on('simple', remainingHandler);
+
+      dispatcher.off('simple', handlerToRemove);
+
+      dispatcher.emit('simple', 'payload');
+
+      expect(handlerToRemove).not.toHaveBeenCalled();
+      expect(remainingHandler).toHaveBeenCalledTimes(1);
+      expect(remainingHandler).toHaveBeenCalledWith('payload');
+    });
+
+    it('warns when trying to remove listener from unknown event', () => {
+      const handler = vi.fn();
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+
+      dispatcher.off('simple', handler);
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        'EventDispatcher .off(): there is no subscribers for event "simple". Probably, .off() called before .on()'
+      );
+    });
+  });
+
+  describe('destroy', () => {
+    it('clears all subscribers', () => {
+      const handler = vi.fn();
+
+      dispatcher.on('simple', handler);
+      dispatcher.on('numeric', vi.fn());
+
+      dispatcher.destroy();
+
+      dispatcher.emit('simple', 'payload');
+      dispatcher.emit('numeric', 42);
+
+      expect(handler).not.toHaveBeenCalled();
+    });
+  });
+});
+
diff --git a/test/unit/components/utils/mutations.test.ts b/test/unit/components/utils/mutations.test.ts
new file mode 100644
index 000000000..de9cc99c0
--- /dev/null
+++ b/test/unit/components/utils/mutations.test.ts
@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest';
+
+import { isMutationBelongsToElement } from '../../../../src/components/utils/mutations';
+
+const toNodeList = (nodes: Node[]): NodeList => nodes as unknown as NodeList;
+
+const createMutation = (overrides: Partial<MutationRecord> = {}): MutationRecord => {
+  const defaultTarget = document.createElement('div');
+
+  return {
+    addedNodes: toNodeList([]),
+    attributeName: null,
+    attributeNamespace: null,
+    nextSibling: null,
+    oldValue: null,
+    previousSibling: null,
+    removedNodes: toNodeList([]),
+    target: defaultTarget,
+    type: 'childList',
+    ...overrides,
+  };
+};
+
+describe('isMutationBelongsToElement', () => {
+  it('ignores internal data-empty attribute updates', () => {
+    const element = document.createElement('div');
+    const mutation = createMutation({
+      type: 'attributes',
+      attributeName: 'data-empty',
+      target: element,
+    });
+
+    expect(isMutationBelongsToElement(mutation, element)).toBe(false);
+  });
+
+  it('returns true when mutation affects the element or its descendants', () => {
+    const element = document.createElement('div');
+    const child = document.createElement('span');
+
+    element.appendChild(child);
+
+    const mutation = createMutation({
+      type: 'attributes',
+      attributeName: 'class',
+      target: child,
+    });
+
+    expect(isMutationBelongsToElement(mutation, element)).toBe(true);
+  });
+
+  it('returns false for mutations outside of the element tree when not a childList change', () => {
+    const element = document.createElement('div');
+    const otherElement = document.createElement('div');
+    const mutation = createMutation({
+      type: 'attributes',
+      attributeName: 'data-test',
+      target: otherElement,
+    });
+
+    expect(isMutationBelongsToElement(mutation, element)).toBe(false);
+  });
+
+  it('returns true when the element itself is added', () => {
+    const element = document.createElement('div');
+    const parent = document.createElement('div');
+
+    const mutation = createMutation({
+      type: 'childList',
+      target: parent,
+      addedNodes: toNodeList([ element ]),
+    });
+
+    expect(isMutationBelongsToElement(mutation, element)).toBe(true);
+  });
+
+  it('returns true when the element itself is removed', () => {
+    const element = document.createElement('div');
+    const parent = document.createElement('div');
+
+    const mutation = createMutation({
+      type: 'childList',
+      target: parent,
+      removedNodes: toNodeList([ element ]),
+    });
+
+    expect(isMutationBelongsToElement(mutation, element)).toBe(true);
+  });
+
+  it('returns false when childList mutation does not reference the element', () => {
+    const element = document.createElement('div');
+    const parent = document.createElement('div');
+    const unrelatedChild = document.createElement('span');
+
+    const mutation = createMutation({
+      type: 'childList',
+      target: parent,
+      addedNodes: toNodeList([ unrelatedChild ]),
+      removedNodes: toNodeList([]),
+    });
+
+    expect(isMutationBelongsToElement(mutation, element)).toBe(false);
+  });
+});
diff --git a/test/unit/components/utils/scroll-locker.test.ts b/test/unit/components/utils/scroll-locker.test.ts
new file mode 100644
index 000000000..f766d5113
--- /dev/null
+++ b/test/unit/components/utils/scroll-locker.test.ts
@@ -0,0 +1,100 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import ScrollLocker from '../../../../src/components/utils/scroll-locker';
+
+const { getIsIosDeviceValue, setIsIosDeviceValue } = vi.hoisted(() => {
+  let value = false;
+
+  return {
+    getIsIosDeviceValue: () => value,
+    setIsIosDeviceValue: (nextValue: boolean) => {
+      value = nextValue;
+    },
+  };
+});
+
+vi.mock('../../../../src/components/utils', async () => {
+  const actual = await vi.importActual('../../../../src/components/utils');
+
+  return {
+    ...actual,
+    get isIosDevice() {
+      return getIsIosDeviceValue();
+    },
+  };
+});
+
+const originalScrollTo = window.scrollTo;
+
+describe('ScrollLocker', () => {
+  beforeEach(() => {
+    document.body.className = '';
+    document.body.innerHTML = '';
+    document.documentElement?.style.removeProperty('--window-scroll-offset');
+    setIsIosDeviceValue(false);
+    delete (window as { pageYOffset?: number }).pageYOffset;
+  });
+
+  afterEach(() => {
+    if (originalScrollTo) {
+      window.scrollTo = originalScrollTo;
+    } else {
+      delete (window as { scrollTo?: typeof window.scrollTo }).scrollTo;
+    }
+    document.body.className = '';
+    document.documentElement?.style.removeProperty('--window-scroll-offset');
+    setIsIosDeviceValue(false);
+    delete (window as { pageYOffset?: number }).pageYOffset;
+  });
+
+  it('adds and removes body class on non-iOS devices', () => {
+    setIsIosDeviceValue(false);
+    const locker = new ScrollLocker();
+
+    locker.lock();
+
+    expect(document.body.classList.contains('ce-scroll-locked')).toBe(true);
+
+    locker.unlock();
+
+    expect(document.body.classList.contains('ce-scroll-locked')).toBe(false);
+  });
+
+  it('performs hard lock on iOS devices and restores scroll position', () => {
+    const storedScroll = 160;
+
+    setIsIosDeviceValue(true);
+    Object.defineProperty(window, 'pageYOffset', {
+      configurable: true,
+      value: storedScroll,
+    });
+
+    const scrollTo = vi.fn();
+
+    window.scrollTo = scrollTo;
+
+    const locker = new ScrollLocker();
+
+    locker.lock();
+
+    expect(document.body.classList.contains('ce-scroll-locked--hard')).toBe(true);
+    expect(document.documentElement?.style.getPropertyValue('--window-scroll-offset')).toBe(`${storedScroll}px`);
+
+    locker.unlock();
+
+    expect(document.body.classList.contains('ce-scroll-locked--hard')).toBe(false);
+    expect(scrollTo).toHaveBeenCalledWith(0, storedScroll);
+  });
+
+  it('does not restore scroll when hard lock was never applied', () => {
+    setIsIosDeviceValue(true);
+    const scrollTo = vi.fn();
+
+    window.scrollTo = scrollTo;
+
+    const locker = new ScrollLocker();
+
+    locker.unlock();
+
+    expect(scrollTo).not.toHaveBeenCalled();
+  });
+});
diff --git a/test/unit/components/utils/tooltip.test.ts b/test/unit/components/utils/tooltip.test.ts
new file mode 100644
index 000000000..486117d97
--- /dev/null
+++ b/test/unit/components/utils/tooltip.test.ts
@@ -0,0 +1,356 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { DATA_INTERFACE_ATTRIBUTE, TOOLTIP_INTERFACE_VALUE } from '../../../../src/components/constants';
+import { destroy, hide, onHover, show } from '../../../../src/components/utils/tooltip';
+import type { TooltipContent } from '../../../../src/components/utils/tooltip';
+
+const { fakeCssContent } = vi.hoisted(() => ({
+  fakeCssContent: '.tooltip{ color: #000; }',
+}));
+
+vi.mock('../../../../src/styles/tooltip.css?inline', () => ({
+  default: fakeCssContent,
+}));
+
+const tooltipSelector = `[${DATA_INTERFACE_ATTRIBUTE}="${TOOLTIP_INTERFACE_VALUE}"]`;
+
+const getTooltipWrapper = (): HTMLElement | null => {
+  return document.querySelector(tooltipSelector);
+};
+
+const createTargetElement = (rectOverrides: Partial<DOMRect> = {}): HTMLElement => {
+  const element = document.createElement('button');
+
+  const left = rectOverrides.left ?? 10;
+  const width = rectOverrides.width ?? 100;
+  const top = rectOverrides.top ?? 20;
+  const height = rectOverrides.height ?? 40;
+  const right = rectOverrides.right ?? left + width;
+  const bottom = rectOverrides.bottom ?? top + height;
+  const rect = {
+    left,
+    right,
+    top,
+    bottom,
+    width,
+    height,
+    x: left,
+    y: top,
+  };
+
+  Object.defineProperty(element, 'clientWidth', {
+    configurable: true,
+    value: rect.width,
+  });
+  Object.defineProperty(element, 'clientHeight', {
+    configurable: true,
+    value: rect.height,
+  });
+
+  element.getBoundingClientRect = vi.fn(() => ({
+    ...rect,
+    toJSON: () => rect,
+  }));
+
+  document.body.appendChild(element);
+
+  return element;
+};
+
+const setWrapperSize = (wrapper: HTMLElement, width: number, height: number): void => {
+  Object.defineProperty(wrapper, 'offsetWidth', {
+    configurable: true,
+    value: width,
+  });
+  Object.defineProperty(wrapper, 'offsetHeight', {
+    configurable: true,
+    value: height,
+  });
+  Object.defineProperty(wrapper, 'clientWidth', {
+    configurable: true,
+    value: width,
+  });
+  Object.defineProperty(wrapper, 'clientHeight', {
+    configurable: true,
+    value: height,
+  });
+};
+
+const setWindowScrollY = (value?: number): void => {
+  if (typeof value === 'number') {
+    Object.defineProperty(window, 'scrollY', {
+      configurable: true,
+      value,
+    });
+
+    return;
+  }
+
+  delete (window as unknown as { scrollY?: number }).scrollY;
+};
+
+describe('Tooltip utility', () => {
+  afterEach(() => {
+    const wrapper = getTooltipWrapper();
+
+    if (wrapper) {
+      destroy();
+    }
+
+    document.getElementById('codex-tooltips-style')?.remove();
+    document.body.innerHTML = '';
+    if (document.documentElement) {
+      document.documentElement.scrollTop = 0;
+    }
+    document.body.scrollTop = 0;
+    setWindowScrollY(undefined);
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  it('renders tooltip content, accessible attributes, and injects CSS only once', () => {
+    const target = createTargetElement();
+
+    show(target, 'Tooltip text', { delay: 0 });
+
+    const wrapper = getTooltipWrapper();
+
+    expect(wrapper).not.toBeNull();
+    expect(wrapper?.textContent).toBe('Tooltip text');
+    expect(wrapper?.classList.contains('ct--shown')).toBe(true);
+    expect(wrapper?.getAttribute(DATA_INTERFACE_ATTRIBUTE)).toBe(TOOLTIP_INTERFACE_VALUE);
+    expect(wrapper?.getAttribute('role')).toBe('tooltip');
+    expect(wrapper?.getAttribute('aria-hidden')).toBe('false');
+    expect(wrapper?.style.visibility).toBe('visible');
+
+    show(target, 'New text', { delay: 0 });
+
+    expect(wrapper?.textContent).toBe('New text');
+
+    const styles = document.querySelectorAll('#codex-tooltips-style');
+
+    expect(styles).toHaveLength(1);
+    expect(styles[0]?.textContent).toBe(fakeCssContent);
+  });
+
+  it('accepts DOM nodes as content without cloning them', () => {
+    const target = createTargetElement();
+    const customContent = document.createElement('div');
+
+    customContent.dataset.testid = 'content';
+    customContent.textContent = 'node content';
+
+    show(target, customContent, { delay: 0 });
+
+    const wrapper = getTooltipWrapper();
+    const contentHolder = wrapper?.querySelector('.ct__content');
+
+    expect(contentHolder?.contains(customContent)).toBe(true);
+  });
+
+  it('throws when content is not a string or Node', () => {
+    const target = createTargetElement();
+
+    expect(() => {
+      show(target, 123 as unknown as TooltipContent, { delay: 0 });
+    }).toThrow('[CodeX Tooltip] Wrong type of «content» passed. It should be an instance of Node or String. But number given.');
+  });
+
+  it('places tooltip below the element taking margins and scroll into account', () => {
+    const target = createTargetElement({
+      left: 15,
+      bottom: 75,
+      width: 120,
+    });
+
+    show(target, 'bottom', { delay: 0 });
+
+    const wrapper = getTooltipWrapper();
+
+    expect(wrapper).not.toBeNull();
+
+    setWrapperSize(wrapper!, 80, 30);
+    setWindowScrollY(5);
+
+    show(target, 'bottom', { placement: 'bottom',
+      marginTop: 8,
+      delay: 0 });
+
+    expect(wrapper?.style.left).toBe('35px');
+    expect(wrapper?.style.top).toBe('98px');
+    expect(wrapper?.classList.contains('ct--bottom')).toBe(true);
+  });
+
+  it('places tooltip to the left of the element and respects marginLeft', () => {
+    const target = createTargetElement({
+      left: 220,
+      top: 100,
+      width: 60,
+      height: 50,
+    });
+
+    show(target, 'left', { delay: 0 });
+
+    const wrapper = getTooltipWrapper();
+
+    expect(wrapper).not.toBeNull();
+
+    setWrapperSize(wrapper!, 50, 30);
+    setWindowScrollY(0);
+
+    show(target, 'left', { placement: 'left',
+      marginLeft: 15,
+      delay: 0 });
+
+    expect(wrapper?.style.left).toBe('145px');
+    expect(wrapper?.style.top).toBe('110px');
+    expect(wrapper?.classList.contains('ct--left')).toBe(true);
+    expect(wrapper?.classList.contains('ct--right')).toBe(false);
+  });
+
+  it('places tooltip to the right of the element with marginRight taken into account', () => {
+    const target = createTargetElement({
+      right: 260,
+      top: 40,
+      height: 30,
+      width: 40,
+      left: 220,
+    });
+
+    show(target, 'right', { delay: 0 });
+
+    const wrapper = getTooltipWrapper();
+
+    expect(wrapper).not.toBeNull();
+
+    setWrapperSize(wrapper!, 40, 20);
+
+    show(target, 'right', { placement: 'right',
+      marginRight: 6,
+      delay: 0 });
+
+    expect(wrapper?.style.left).toBe('276px');
+    expect(wrapper?.style.top).toBe('45px');
+    expect(wrapper?.classList.contains('ct--right')).toBe(true);
+    expect(wrapper?.classList.contains('ct--left')).toBe(false);
+  });
+
+  it('places tooltip above the element using document scroll fallback', () => {
+    const target = createTargetElement({
+      top: 120,
+      left: 40,
+      width: 80,
+      height: 20,
+    });
+
+    show(target, 'top', { delay: 0 });
+
+    const wrapper = getTooltipWrapper();
+
+    expect(wrapper).not.toBeNull();
+
+    setWrapperSize(wrapper!, 60, 24);
+    setWindowScrollY(undefined);
+    document.documentElement!.scrollTop = 30;
+
+    show(target, 'top', { placement: 'top',
+      delay: 0 });
+
+    expect(wrapper?.style.left).toBe('50px');
+    expect(wrapper?.style.top).toBe('116px');
+    expect(wrapper?.classList.contains('ct--top')).toBe(true);
+  });
+
+  it('delays hiding when hidingDelay is set but respects skip flag', () => {
+    const target = createTargetElement();
+    const wrapperText = 'delayed';
+
+    vi.useFakeTimers();
+
+    show(target, wrapperText, { delay: 0,
+      hidingDelay: 50 });
+
+    const wrapper = getTooltipWrapper();
+
+    expect(wrapper?.classList.contains('ct--shown')).toBe(true);
+
+    hide();
+
+    expect(wrapper?.classList.contains('ct--shown')).toBe(true);
+
+    vi.advanceTimersByTime(49);
+    expect(wrapper?.classList.contains('ct--shown')).toBe(true);
+
+    vi.advanceTimersByTime(1);
+    expect(wrapper?.classList.contains('ct--shown')).toBe(false);
+
+    show(target, wrapperText, { delay: 0,
+      hidingDelay: 50 });
+    hide(true);
+    expect(wrapper?.classList.contains('ct--shown')).toBe(false);
+  });
+
+  it('responds to hover events by showing and hiding the tooltip', () => {
+    const target = createTargetElement();
+
+    onHover(target, 'hover text', { delay: 0 });
+
+    target.dispatchEvent(new Event('mouseenter'));
+
+    const wrapper = getTooltipWrapper();
+
+    expect(wrapper?.classList.contains('ct--shown')).toBe(true);
+
+    target.dispatchEvent(new Event('mouseleave'));
+
+    expect(wrapper?.classList.contains('ct--shown')).toBe(false);
+  });
+
+  it('keeps aria-hidden synchronized with CSS class changes', async () => {
+    const target = createTargetElement();
+
+    show(target, 'visible', { delay: 0 });
+
+    const wrapper = getTooltipWrapper();
+
+    expect(wrapper?.getAttribute('aria-hidden')).toBe('false');
+
+    wrapper?.classList.remove('ct--shown');
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(wrapper?.getAttribute('aria-hidden')).toBe('true');
+    expect(wrapper?.style.visibility).toBe('hidden');
+  });
+
+  it('hides the tooltip automatically when the page scrolls', () => {
+    const target = createTargetElement();
+
+    show(target, 'scroll', { delay: 0 });
+
+    const wrapper = getTooltipWrapper();
+
+    expect(wrapper?.classList.contains('ct--shown')).toBe(true);
+
+    window.dispatchEvent(new Event('scroll'));
+
+    expect(wrapper?.classList.contains('ct--shown')).toBe(false);
+  });
+
+  it('destroy removes DOM nodes and allows reinitialization', () => {
+    const target = createTargetElement();
+
+    show(target, 'first', { delay: 0 });
+
+    expect(getTooltipWrapper()).not.toBeNull();
+
+    destroy();
+
+    expect(getTooltipWrapper()).toBeNull();
+
+    const secondTarget = createTargetElement();
+
+    show(secondTarget, 'second', { delay: 0 });
+
+    expect(getTooltipWrapper()).not.toBeNull();
+  });
+});
diff --git a/test/unit/modules/toolbar/inline.test.ts b/test/unit/modules/toolbar/inline.test.ts
new file mode 100644
index 000000000..cfc813e53
--- /dev/null
+++ b/test/unit/modules/toolbar/inline.test.ts
@@ -0,0 +1,988 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import InlineToolbar from '../../../../src/components/modules/toolbar/inline';
+import type InlineToolAdapter from '../../../../src/components/tools/inline';
+import SelectionUtils from '../../../../src/components/selection';
+import type { Popover } from '../../../../src/components/utils/popover';
+import Shortcuts from '../../../../src/components/utils/shortcuts';
+import type { InlineTool } from '../../../../types';
+
+// Mock dependencies at module level
+const mockPopoverInstance = {
+  show: vi.fn(),
+  hide: vi.fn(),
+  destroy: vi.fn(),
+  getElement: vi.fn(() => document.createElement('div')),
+  activateItemByName: vi.fn(),
+  size: {
+    width: 200,
+    height: 40,
+  },
+};
+
+vi.mock('../../../../src/components/utils/popover/popover-inline', () => ({
+  PopoverInline: vi.fn().mockImplementation(() => mockPopoverInstance),
+}));
+
+vi.mock('../../../../src/components/utils/shortcuts', () => ({
+  default: {
+    add: vi.fn(),
+    remove: vi.fn(),
+  },
+}));
+
+vi.mock('../../../../src/components/utils', async () => {
+  const actual = await vi.importActual('../../../../src/components/utils');
+
+  return {
+    ...actual,
+    isMobileScreen: vi.fn(() => false),
+    beautifyShortcut: vi.fn((shortcut: string) => shortcut),
+    capitalize: vi.fn((str: string) => str.charAt(0).toUpperCase() + str.slice(1)),
+    isFunction: vi.fn((fn: unknown) => typeof fn === 'function'),
+    keyCodes: {
+      DOWN: 40,
+      UP: 38,
+    },
+  };
+});
+
+// Mock SelectionUtils - we'll use Object.defineProperty in tests to override getters
+// This mock just ensures the module can be imported
+vi.mock('../../../../src/components/selection', async () => {
+  const actual = await vi.importActual('../../../../src/components/selection');
+
+  return actual;
+});
+
+vi.mock('../../../../src/components/i18n', () => ({
+  default: {
+    ui: vi.fn((namespace: string, key: string) => key),
+    t: vi.fn((namespace: string, key: string) => key),
+  },
+}));
+
+vi.mock('../../../../src/components/dom', () => ({
+  default: {
+    make: vi.fn((tag: string, className: string | string[]) => {
+      const el = document.createElement(tag);
+
+      if (Array.isArray(className)) {
+        el.className = className.join(' ');
+      } else {
+        el.className = className;
+      }
+
+      return el;
+    }),
+    append: vi.fn((parent: HTMLElement, child: HTMLElement) => {
+      parent.appendChild(child);
+    }),
+    isElement: vi.fn((node: unknown) => node instanceof HTMLElement),
+  },
+}));
+
+/**
+ * Unit tests for InlineToolbar class
+ *
+ * Tests internal functionality and edge cases not covered by E2E tests
+ */
+describe('InlineToolbar', () => {
+  const TOOLBAR_WIDTH = 200;
+  const CONTENT_RECT_RIGHT = 1000;
+  const OVERFLOW_ADJUSTMENT = 800;
+
+  // eslint-disable-next-line no-restricted-syntax -- Test setup variables need to be reassigned in beforeEach
+  let inlineToolbar: InlineToolbar;
+  // eslint-disable-next-line no-restricted-syntax -- Test setup variables need to be reassigned in beforeEach
+  let mockEditor: {
+    BlockManager: {
+      getBlock: ReturnType<typeof vi.fn>;
+      currentBlock: {
+        tool: {
+          inlineTools: Map<string, InlineToolAdapter>;
+          enabledInlineTools: boolean;
+        };
+      } | null;
+    };
+    Tools: {
+      inlineTools: Map<string, InlineToolAdapter>;
+      internal: {
+        inlineTools: Map<string, unknown>;
+      };
+    };
+    ReadOnly: {
+      isEnabled: boolean;
+    };
+    UI: {
+      nodes: {
+        wrapper: HTMLElement;
+        redactor: HTMLElement;
+      };
+      contentRect: {
+        right: number;
+      };
+      CSS: {
+        editorRtlFix: string;
+      };
+    };
+    Toolbar: {
+      close: ReturnType<typeof vi.fn>;
+    };
+  };
+
+  const createMockInlineTool = (name: string, options: {
+    title?: string;
+    shortcut?: string;
+    isReadOnlySupported?: boolean;
+    render?: () => HTMLElement | { type: string; [key: string]: unknown };
+    checkState?: (selection: Selection) => boolean;
+    surround?: (range: Range) => void;
+    clear?: () => void;
+  } = {}): InlineTool => {
+    return {
+      render: options.render || (() => document.createElement('button')),
+      checkState: options.checkState,
+      surround: options.surround,
+      clear: options.clear,
+    } as InlineTool;
+  };
+
+  const createMockInlineToolAdapter = (name: string, options: {
+    title?: string;
+    shortcut?: string;
+    isReadOnlySupported?: boolean;
+    create?: () => InlineTool;
+  } = {}): InlineToolAdapter => {
+    return {
+      name,
+      title: options.title || name,
+      shortcut: options.shortcut,
+      isReadOnlySupported: options.isReadOnlySupported,
+      create: options.create || (() => createMockInlineTool(name)),
+    } as InlineToolAdapter;
+  };
+
+  const createMockBlock = (): {
+    tool: {
+      inlineTools: Map<string, InlineToolAdapter>;
+      enabledInlineTools: boolean;
+    };
+    holder: HTMLElement;
+  } => {
+    const blockElement = document.createElement('div');
+
+    blockElement.className = 'ce-block';
+    blockElement.setAttribute('contenteditable', 'true');
+
+    const toolAdapter = createMockInlineToolAdapter('bold', {
+      title: 'Bold',
+      shortcut: 'CMD+B',
+    });
+
+    return {
+      tool: {
+        inlineTools: new Map([ ['bold', toolAdapter] ]),
+        enabledInlineTools: true,
+      },
+      holder: blockElement,
+    };
+  };
+
+  const createMockSelection = (text: string = 'test'): Selection => {
+    const range = document.createRange();
+    const textNode = document.createTextNode(text);
+
+    document.body.appendChild(textNode);
+    range.setStart(textNode, 0);
+    range.setEnd(textNode, text.length);
+
+    return {
+      anchorNode: textNode,
+      isCollapsed: false,
+      rangeCount: 1,
+      getRangeAt: () => range,
+    } as unknown as Selection;
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Reset SelectionUtils spies if they exist
+    vi.restoreAllMocks();
+
+    // Mock requestIdleCallback to execute immediately
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (global as any).requestIdleCallback = vi.fn((callback: () => void) => {
+      callback();
+
+      return 1;
+    });
+
+    // Create mock UI nodes
+    const wrapper = document.createElement('div');
+
+    wrapper.className = 'codex-editor';
+    document.body.appendChild(wrapper);
+
+    const redactor = document.createElement('div');
+
+    redactor.className = 'codex-editor__redactor';
+    wrapper.appendChild(redactor);
+
+    // Create mock Editor
+    mockEditor = {
+      BlockManager: {
+        getBlock: vi.fn(),
+        currentBlock: null,
+      },
+      Tools: {
+        inlineTools: new Map(),
+        internal: {
+          inlineTools: new Map(),
+        },
+      },
+      ReadOnly: {
+        isEnabled: false,
+      },
+      UI: {
+        nodes: {
+          wrapper,
+          redactor,
+        },
+        contentRect: {
+          right: CONTENT_RECT_RIGHT,
+        },
+        CSS: {
+          editorRtlFix: 'ce-editor--rtl',
+        },
+      },
+      Toolbar: {
+        close: vi.fn(),
+      },
+    };
+
+    // Create InlineToolbar instance
+    inlineToolbar = new InlineToolbar({
+      config: {},
+      eventsDispatcher: {
+        on: vi.fn(),
+        off: vi.fn(),
+      } as unknown as typeof InlineToolbar.prototype['eventsDispatcher'],
+    });
+
+    // Set Editor modules
+    (inlineToolbar as unknown as { Editor: typeof mockEditor }).Editor = mockEditor;
+  });
+
+  afterEach(() => {
+    // Clean up DOM
+    if (mockEditor?.UI?.nodes?.wrapper) {
+      const wrapper = mockEditor.UI.nodes.wrapper;
+
+      if (wrapper.parentNode) {
+        wrapper.parentNode.removeChild(wrapper);
+      }
+    }
+  });
+
+  describe('constructor', () => {
+    it('should initialize with opened = false', () => {
+      expect(inlineToolbar.opened).toBe(false);
+    });
+
+    it('should register keydown listener for shift+arrow keys', () => {
+      // Create new instance to trigger constructor
+      const newToolbar = new InlineToolbar({
+        config: {},
+        eventsDispatcher: {
+          on: vi.fn(),
+          off: vi.fn(),
+        } as unknown as typeof InlineToolbar.prototype['eventsDispatcher'],
+      });
+
+      (newToolbar as unknown as { Editor: typeof mockEditor }).Editor = mockEditor;
+
+      // The listener is registered via this.listeners.on, not directly
+      // So we check that the toolbar was created successfully
+      expect(newToolbar).toBeInstanceOf(InlineToolbar);
+    });
+
+    it('should schedule make() and registerInitialShortcuts() via requestIdleCallback', () => {
+      const requestIdleCallbackSpy = vi.fn((callback: () => void) => {
+        callback();
+
+        return 1;
+      });
+
+      (global as unknown as { requestIdleCallback: typeof requestIdleCallbackSpy }).requestIdleCallback = requestIdleCallbackSpy;
+
+      new InlineToolbar({
+        config: {},
+        eventsDispatcher: {
+          on: vi.fn(),
+          off: vi.fn(),
+        } as unknown as typeof InlineToolbar.prototype['eventsDispatcher'],
+      });
+
+      expect(requestIdleCallbackSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('tryToShow', () => {
+    beforeEach(() => {
+      // Setup valid selection
+      const selection = createMockSelection();
+
+      vi.spyOn(SelectionUtils, 'get').mockReturnValue(selection);
+      vi.spyOn(SelectionUtils, 'text', 'get').mockReturnValue('test');
+      vi.spyOn(SelectionUtils, 'rect', 'get').mockReturnValue({
+        x: 100,
+        y: 100,
+        width: 50,
+        height: 20,
+      } as DOMRect);
+      vi.spyOn(SelectionUtils, 'range', 'get').mockReturnValue(selection.getRangeAt(0));
+
+      mockEditor.BlockManager.currentBlock = createMockBlock() as unknown as typeof mockEditor.BlockManager.currentBlock;
+    });
+
+    it('should close toolbar when needToClose is true', async () => {
+      inlineToolbar.opened = true;
+      const closeSpy = vi.spyOn(inlineToolbar, 'close');
+
+      await inlineToolbar.tryToShow(true);
+
+      expect(closeSpy).toHaveBeenCalled();
+    });
+
+    it('should not open toolbar when not allowed to show', async () => {
+      // Make selection invalid
+      vi.spyOn(SelectionUtils, 'get').mockReturnValue(null);
+      vi.spyOn(SelectionUtils, 'text', 'get').mockReturnValue('');
+
+      await inlineToolbar.tryToShow();
+
+      expect(inlineToolbar.opened).toBe(false);
+    });
+
+    it('should open toolbar and close main toolbar when allowed', async () => {
+      // Mock the open method
+      const openSpy = vi.spyOn(inlineToolbar as unknown as { open: () => Promise<void> }, 'open').mockResolvedValue();
+
+      await inlineToolbar.tryToShow();
+
+      expect(openSpy).toHaveBeenCalled();
+      expect(mockEditor.Toolbar.close).toHaveBeenCalled();
+    });
+  });
+
+  describe('close', () => {
+    it('should do nothing when toolbar is already closed', () => {
+      inlineToolbar.opened = false;
+      const hideSpy = vi.spyOn(mockPopoverInstance, 'hide');
+
+      inlineToolbar.close();
+
+      expect(hideSpy).not.toHaveBeenCalled();
+    });
+
+    it('should clear tool instances and reset state when closing', () => {
+      inlineToolbar.opened = true;
+      const toolInstance = createMockInlineTool('bold', {
+        clear: vi.fn(),
+      });
+
+      (inlineToolbar as unknown as { tools: Map<InlineToolAdapter, InlineTool> }).tools = new Map([
+        [createMockInlineToolAdapter('bold'), toolInstance],
+      ]);
+
+      (inlineToolbar as unknown as { popover: Popover | null }).popover = mockPopoverInstance as unknown as Popover;
+
+      inlineToolbar.close();
+
+      expect(toolInstance.clear).toHaveBeenCalled();
+      expect(inlineToolbar.opened).toBe(false);
+      expect(mockPopoverInstance.hide).toHaveBeenCalled();
+      expect(mockPopoverInstance.destroy).toHaveBeenCalled();
+    });
+
+    it('should reset wrapper position', () => {
+      inlineToolbar.opened = true;
+      const wrapper = document.createElement('div');
+
+      wrapper.style.left = '100px';
+      wrapper.style.top = '200px';
+      (inlineToolbar as unknown as { nodes: { wrapper: HTMLElement } }).nodes.wrapper = wrapper;
+
+      inlineToolbar.close();
+
+      expect(wrapper.style.left).toBe('0px');
+      expect(wrapper.style.top).toBe('0px');
+    });
+  });
+
+  describe('containsNode', () => {
+    it('should return false when wrapper is undefined', () => {
+      (inlineToolbar as unknown as { nodes: { wrapper: HTMLElement | undefined } }).nodes.wrapper = undefined;
+
+      const node = document.createElement('div');
+      const result = inlineToolbar.containsNode(node);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true when node is contained in wrapper', () => {
+      const wrapper = document.createElement('div');
+      const child = document.createElement('div');
+
+      wrapper.appendChild(child);
+      (inlineToolbar as unknown as { nodes: { wrapper: HTMLElement } }).nodes.wrapper = wrapper;
+
+      const result = inlineToolbar.containsNode(child);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false when node is not contained in wrapper', () => {
+      const wrapper = document.createElement('div');
+      const otherNode = document.createElement('div');
+
+      (inlineToolbar as unknown as { nodes: { wrapper: HTMLElement } }).nodes.wrapper = wrapper;
+
+      const result = inlineToolbar.containsNode(otherNode);
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('destroy', () => {
+    it('should destroy popover and remove nodes', () => {
+      inlineToolbar.opened = true;
+      (inlineToolbar as unknown as { popover: Popover | null }).popover = mockPopoverInstance as unknown as Popover;
+
+      inlineToolbar.destroy();
+
+      expect(mockPopoverInstance.destroy).toHaveBeenCalled();
+    });
+  });
+
+  describe('allowedToShow', () => {
+    it('should return false when selection is null', () => {
+      Object.defineProperty(SelectionUtils, 'instance', {
+        value: null,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'selection', {
+        value: null,
+        writable: true,
+        configurable: true,
+      });
+
+      const result = (inlineToolbar as unknown as { allowedToShow: () => boolean }).allowedToShow();
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false when selection is collapsed', () => {
+      const selection = createMockSelection();
+
+      (selection as unknown as { isCollapsed: boolean }).isCollapsed = true;
+      Object.defineProperty(SelectionUtils, 'instance', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'selection', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+
+      const result = (inlineToolbar as unknown as { allowedToShow: () => boolean }).allowedToShow();
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false when selected text is empty', () => {
+      const selection = createMockSelection('');
+
+      Object.defineProperty(SelectionUtils, 'instance', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'selection', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'text', {
+        value: '',
+        writable: true,
+        configurable: true,
+      });
+
+      const result = (inlineToolbar as unknown as { allowedToShow: () => boolean }).allowedToShow();
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false when target is IMG or INPUT tag', () => {
+      const img = document.createElement('img');
+      const selection = {
+        anchorNode: img,
+        isCollapsed: false,
+      } as unknown as Selection;
+
+      Object.defineProperty(SelectionUtils, 'instance', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'selection', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'text', {
+        value: 'test',
+        writable: true,
+        configurable: true,
+      });
+
+      mockEditor.BlockManager.getBlock = vi.fn(() => createMockBlock() as unknown as typeof mockEditor.BlockManager.currentBlock) as typeof mockEditor.BlockManager.getBlock;
+
+      const result = (inlineToolbar as unknown as { allowedToShow: () => boolean }).allowedToShow();
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false when current block is null', () => {
+      const selection = createMockSelection();
+
+      Object.defineProperty(SelectionUtils, 'instance', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'selection', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'text', {
+        value: 'test',
+        writable: true,
+        configurable: true,
+      });
+
+      mockEditor.BlockManager.currentBlock = null;
+      mockEditor.BlockManager.getBlock = vi.fn(() => null) as typeof mockEditor.BlockManager.getBlock;
+
+      const result = (inlineToolbar as unknown as { allowedToShow: () => boolean }).allowedToShow();
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false when no inline tools are available for block', () => {
+      const selection = createMockSelection();
+
+      Object.defineProperty(SelectionUtils, 'instance', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'selection', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'text', {
+        value: 'test',
+        writable: true,
+        configurable: true,
+      });
+
+      const block = createMockBlock();
+
+      block.tool.inlineTools = new Map();
+      mockEditor.BlockManager.currentBlock = block as unknown as typeof mockEditor.BlockManager.currentBlock;
+      mockEditor.BlockManager.getBlock = vi.fn(() => block as unknown as typeof mockEditor.BlockManager.currentBlock) as typeof mockEditor.BlockManager.getBlock;
+
+      const result = (inlineToolbar as unknown as { allowedToShow: () => boolean }).allowedToShow();
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false when target is not contenteditable', () => {
+      const selection = createMockSelection();
+
+      Object.defineProperty(SelectionUtils, 'instance', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'selection', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'text', {
+        value: 'test',
+        writable: true,
+        configurable: true,
+      });
+
+      const block = createMockBlock();
+
+      block.holder.removeAttribute('contenteditable');
+      mockEditor.BlockManager.currentBlock = block as unknown as typeof mockEditor.BlockManager.currentBlock;
+      mockEditor.BlockManager.getBlock = vi.fn(() => block as unknown as typeof mockEditor.BlockManager.currentBlock) as typeof mockEditor.BlockManager.getBlock;
+
+      const result = (inlineToolbar as unknown as { allowedToShow: () => boolean }).allowedToShow();
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true when all conditions are met', () => {
+      const selection = createMockSelection();
+
+      Object.defineProperty(SelectionUtils, 'instance', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'selection', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'text', {
+        value: 'test',
+        writable: true,
+        configurable: true,
+      });
+
+      const block = createMockBlock();
+
+      mockEditor.BlockManager.currentBlock = block as unknown as typeof mockEditor.BlockManager.currentBlock;
+      mockEditor.BlockManager.getBlock = vi.fn(() => block as unknown as typeof mockEditor.BlockManager.currentBlock) as typeof mockEditor.BlockManager.getBlock;
+
+      const result = (inlineToolbar as unknown as { allowedToShow: () => boolean }).allowedToShow();
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('getTools', () => {
+    it('should return empty array when current block is null', () => {
+      mockEditor.BlockManager.currentBlock = null;
+
+      const result = (inlineToolbar as unknown as { getTools: () => InlineToolAdapter[] }).getTools();
+
+      expect(result).toEqual([]);
+    });
+
+    it('should filter out tools not supported in read-only mode', () => {
+      const block = createMockBlock();
+      const readOnlyTool = createMockInlineToolAdapter('readonly-tool', {
+        isReadOnlySupported: true,
+      });
+      const normalTool = createMockInlineToolAdapter('normal-tool', {
+        isReadOnlySupported: false,
+      });
+
+      block.tool.inlineTools = new Map([
+        ['readonly-tool', readOnlyTool],
+        ['normal-tool', normalTool],
+      ]);
+
+      mockEditor.BlockManager.currentBlock = block as unknown as typeof mockEditor.BlockManager.currentBlock;
+      mockEditor.ReadOnly.isEnabled = true;
+
+      const result = (inlineToolbar as unknown as { getTools: () => InlineToolAdapter[] }).getTools();
+
+      expect(result).toHaveLength(1);
+      expect(result[0].name).toBe('readonly-tool');
+    });
+
+    it('should return all tools when not in read-only mode', () => {
+      const block = createMockBlock();
+      const tool1 = createMockInlineToolAdapter('tool1');
+      const tool2 = createMockInlineToolAdapter('tool2');
+
+      block.tool.inlineTools = new Map([
+        ['tool1', tool1],
+        ['tool2', tool2],
+      ]);
+
+      mockEditor.BlockManager.currentBlock = block as unknown as typeof mockEditor.BlockManager.currentBlock;
+      mockEditor.ReadOnly.isEnabled = false;
+
+      const result = (inlineToolbar as unknown as { getTools: () => InlineToolAdapter[] }).getTools();
+
+      expect(result).toHaveLength(2);
+    });
+  });
+
+  describe('toolClicked', () => {
+    it('should call surround on tool with range', () => {
+      const range = document.createRange();
+      const tool = createMockInlineTool('bold', {
+        surround: vi.fn(),
+      });
+
+      Object.defineProperty(SelectionUtils, 'range', {
+        value: range,
+        writable: true,
+      });
+
+      (inlineToolbar as unknown as { toolClicked: (tool: InlineTool) => void }).toolClicked(tool);
+
+      expect(tool.surround).toHaveBeenCalledWith(range);
+    });
+
+    it('should check tools state after clicking', () => {
+      const tool = createMockInlineTool('bold', {
+        surround: vi.fn(),
+      });
+
+      const checkToolsStateSpy = vi.spyOn(inlineToolbar as unknown as { checkToolsState: () => void }, 'checkToolsState');
+
+      Object.defineProperty(SelectionUtils, 'range', {
+        value: document.createRange(),
+        writable: true,
+      });
+
+      (inlineToolbar as unknown as { toolClicked: (tool: InlineTool) => void }).toolClicked(tool);
+
+      expect(checkToolsStateSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('activateToolByShortcut', () => {
+    beforeEach(() => {
+      const selection = createMockSelection();
+
+      Object.defineProperty(SelectionUtils, 'instance', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'selection', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+    });
+
+    it('should try to show toolbar when not opened', async () => {
+      inlineToolbar.opened = false;
+      const tryToShowSpy = vi.spyOn(inlineToolbar, 'tryToShow').mockResolvedValue();
+
+      (inlineToolbar as unknown as { popover: Popover | null }).popover = mockPopoverInstance as unknown as Popover;
+
+      await (inlineToolbar as unknown as { activateToolByShortcut: (toolName: string) => Promise<void> }).activateToolByShortcut('bold');
+
+      expect(tryToShowSpy).toHaveBeenCalled();
+    });
+
+    it('should activate item by name when selection is null', async () => {
+      inlineToolbar.opened = true;
+      Object.defineProperty(SelectionUtils, 'instance', {
+        value: null,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'selection', {
+        value: null,
+        writable: true,
+        configurable: true,
+      });
+
+      (inlineToolbar as unknown as { popover: Popover | null }).popover = mockPopoverInstance as unknown as Popover;
+
+      await (inlineToolbar as unknown as { activateToolByShortcut: (toolName: string) => Promise<void> }).activateToolByShortcut('bold');
+
+      expect(mockPopoverInstance.activateItemByName).toHaveBeenCalledWith('bold');
+    });
+
+    it('should not activate tool when tool is already active', async () => {
+      inlineToolbar.opened = true;
+      const toolInstance = createMockInlineTool('bold', {
+        checkState: vi.fn(() => true),
+      });
+      const toolAdapter = createMockInlineToolAdapter('bold');
+
+      (inlineToolbar as unknown as { tools: Map<InlineToolAdapter, InlineTool> }).tools = new Map([
+        [toolAdapter, toolInstance],
+      ]);
+
+      (inlineToolbar as unknown as { popover: Popover | null }).popover = mockPopoverInstance as unknown as Popover;
+
+      await (inlineToolbar as unknown as { activateToolByShortcut: (toolName: string) => Promise<void> }).activateToolByShortcut('bold');
+
+      expect(mockPopoverInstance.activateItemByName).not.toHaveBeenCalled();
+    });
+
+    it('should activate tool when tool is not active', async () => {
+      inlineToolbar.opened = true;
+      const toolInstance = createMockInlineTool('bold', {
+        checkState: vi.fn(() => false),
+      });
+      const toolAdapter = createMockInlineToolAdapter('bold');
+
+      (inlineToolbar as unknown as { tools: Map<InlineToolAdapter, InlineTool> }).tools = new Map([
+        [toolAdapter, toolInstance],
+      ]);
+
+      (inlineToolbar as unknown as { popover: Popover | null }).popover = mockPopoverInstance as unknown as Popover;
+
+      await (inlineToolbar as unknown as { activateToolByShortcut: (toolName: string) => Promise<void> }).activateToolByShortcut('bold');
+
+      expect(mockPopoverInstance.activateItemByName).toHaveBeenCalledWith('bold');
+    });
+  });
+
+  describe('checkToolsState', () => {
+    it('should do nothing when selection is null', () => {
+      Object.defineProperty(SelectionUtils, 'instance', {
+        value: null,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'selection', {
+        value: null,
+        writable: true,
+        configurable: true,
+      });
+
+      const toolInstance = createMockInlineTool('bold', {
+        checkState: vi.fn(),
+      });
+
+      (inlineToolbar as unknown as { tools: Map<InlineToolAdapter, InlineTool> }).tools = new Map([
+        [createMockInlineToolAdapter('bold'), toolInstance],
+      ]);
+
+      (inlineToolbar as unknown as { checkToolsState: () => void }).checkToolsState();
+
+      expect(toolInstance.checkState).not.toHaveBeenCalled();
+    });
+
+    it('should call checkState on all tool instances', () => {
+      const selection = createMockSelection();
+      const tool1 = createMockInlineTool('bold', {
+        checkState: vi.fn(),
+      });
+      const tool2 = createMockInlineTool('italic', {
+        checkState: vi.fn(),
+      });
+
+      Object.defineProperty(SelectionUtils, 'instance', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+      Object.defineProperty(SelectionUtils, 'selection', {
+        value: selection,
+        writable: true,
+        configurable: true,
+      });
+
+      (inlineToolbar as unknown as { tools: Map<InlineToolAdapter, InlineTool> }).tools = new Map([
+        [createMockInlineToolAdapter('bold'), tool1],
+        [createMockInlineToolAdapter('italic'), tool2],
+      ]);
+
+      (inlineToolbar as unknown as { checkToolsState: () => void }).checkToolsState();
+
+      expect(tool1.checkState).toHaveBeenCalledWith(selection);
+      expect(tool2.checkState).toHaveBeenCalledWith(selection);
+    });
+  });
+
+  describe('shortcut registration', () => {
+    it('should register shortcuts for tools with shortcuts', () => {
+      const toolAdapter = createMockInlineToolAdapter('bold', {
+        shortcut: 'CMD+B',
+      });
+
+      mockEditor.Tools.inlineTools.set('bold', toolAdapter);
+
+      (inlineToolbar as unknown as { registerInitialShortcuts: () => void }).registerInitialShortcuts();
+
+      expect(Shortcuts.add).toHaveBeenCalled();
+    });
+
+    it('should handle errors when enabling shortcuts', () => {
+      const toolAdapter = createMockInlineToolAdapter('bold', {
+        shortcut: 'CMD+B',
+      });
+
+      mockEditor.Tools.inlineTools.set('bold', toolAdapter);
+      vi.mocked(Shortcuts.add).mockImplementation(() => {
+        throw new Error('Shortcut error');
+      });
+
+      // Should not throw
+      expect(() => {
+        (inlineToolbar as unknown as { registerInitialShortcuts: () => void }).registerInitialShortcuts();
+      }).not.toThrow();
+    });
+  });
+
+  describe('move', () => {
+    beforeEach(() => {
+      Object.defineProperty(SelectionUtils, 'rect', {
+        value: {
+          x: 100,
+          y: 100,
+          width: 50,
+          height: 20,
+        } as DOMRect,
+        writable: true,
+        configurable: true,
+      });
+
+      const wrapper = document.createElement('div');
+
+      wrapper.style.position = 'absolute';
+      (inlineToolbar as unknown as { nodes: { wrapper: HTMLElement } }).nodes.wrapper = wrapper;
+    });
+
+    it('should position toolbar below selection', () => {
+      const wrapper = (inlineToolbar as unknown as { nodes: { wrapper: HTMLElement } }).nodes.wrapper;
+
+      (inlineToolbar as unknown as { move: (popoverWidth: number) => void }).move(TOOLBAR_WIDTH);
+
+      expect(wrapper.style.left).toBeTruthy();
+      expect(wrapper.style.top).toBeTruthy();
+    });
+
+    it('should adjust position when toolbar would overflow right edge', () => {
+      const wrapper = (inlineToolbar as unknown as { nodes: { wrapper: HTMLElement } }).nodes.wrapper;
+
+      Object.defineProperty(SelectionUtils, 'rect', {
+        value: {
+          x: 900,
+          y: 100,
+          width: 50,
+          height: 20,
+        } as DOMRect,
+        writable: true,
+        configurable: true,
+      });
+
+      mockEditor.UI.contentRect.right = CONTENT_RECT_RIGHT;
+
+      (inlineToolbar as unknown as { move: (popoverWidth: number) => void }).move(TOOLBAR_WIDTH);
+
+      const left = parseInt(wrapper.style.left, 10);
+
+      expect(left).toBeLessThanOrEqual(OVERFLOW_ADJUSTMENT); // Should be adjusted to fit
+    });
+  });
+});
+
diff --git a/test/unit/polyfills.test.ts b/test/unit/polyfills.test.ts
new file mode 100644
index 000000000..f3a0f35bd
--- /dev/null
+++ b/test/unit/polyfills.test.ts
@@ -0,0 +1,255 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const POLYFILLS_PATH = '../../src/components/polyfills';
+
+const importPolyfills = async (): Promise<void> => {
+  vi.resetModules();
+  await import(POLYFILLS_PATH);
+};
+
+describe('polyfills', () => {
+  describe('Element.scrollIntoViewIfNeeded', () => {
+    type MutableScrollPrototype = Omit<Element, 'scrollIntoViewIfNeeded'> & {
+      scrollIntoViewIfNeeded: ((centerIfNeeded?: boolean) => void) | undefined;
+    };
+
+    const prototype = Element.prototype as MutableScrollPrototype;
+    let originalScrollIntoViewIfNeeded: ((centerIfNeeded?: boolean) => void) | undefined;
+
+    beforeEach(() => {
+      originalScrollIntoViewIfNeeded = prototype.scrollIntoViewIfNeeded;
+      prototype.scrollIntoViewIfNeeded = undefined;
+    });
+
+    afterEach(() => {
+      prototype.scrollIntoViewIfNeeded = originalScrollIntoViewIfNeeded;
+    });
+
+    it('centers the element inside the scrollable parent when out of view', async () => {
+      await importPolyfills();
+
+      const parent = document.createElement('div');
+      const child = document.createElement('div');
+
+      Object.defineProperties(parent, {
+        clientHeight: {
+          configurable: true,
+          get: () => 100,
+        },
+        clientWidth: {
+          configurable: true,
+          get: () => 120,
+        },
+        offsetTop: {
+          configurable: true,
+          get: () => 0,
+        },
+        offsetLeft: {
+          configurable: true,
+          get: () => 0,
+        },
+      });
+
+      let scrollTop = 0;
+      let scrollLeft = 0;
+
+      Object.defineProperties(parent, {
+        scrollTop: {
+          configurable: true,
+          get: () => scrollTop,
+          set: (value: number) => {
+            scrollTop = value;
+          },
+        },
+        scrollLeft: {
+          configurable: true,
+          get: () => scrollLeft,
+          set: (value: number) => {
+            scrollLeft = value;
+          },
+        },
+      });
+
+      Object.defineProperties(child, {
+        offsetTop: {
+          configurable: true,
+          get: () => 150,
+        },
+        offsetLeft: {
+          configurable: true,
+          get: () => 200,
+        },
+        clientHeight: {
+          configurable: true,
+          get: () => 20,
+        },
+        clientWidth: {
+          configurable: true,
+          get: () => 30,
+        },
+      });
+
+      parent.appendChild(child);
+      document.body.appendChild(parent);
+
+      const getComputedStyleSpy = vi.spyOn(window, 'getComputedStyle').mockImplementation(
+        () =>
+          ({
+            getPropertyValue: () => '0',
+          } as unknown as CSSStyleDeclaration)
+      );
+
+      child.scrollIntoViewIfNeeded();
+
+      expect(scrollTop).toBe(110);
+      expect(scrollLeft).toBe(155);
+
+      parent.remove();
+      getComputedStyleSpy.mockRestore();
+    });
+
+    it('aligns using scrollIntoView when centering not requested', async () => {
+      await importPolyfills();
+
+      const parent = document.createElement('div');
+      const child = document.createElement('div');
+      const scrollIntoViewMock = vi.fn((_alignToTop?: boolean) => undefined);
+
+      Object.defineProperties(parent, {
+        clientHeight: {
+          configurable: true,
+          get: () => 200,
+        },
+        offsetTop: {
+          configurable: true,
+          get: () => 0,
+        },
+      });
+
+      let scrollTop = 120;
+
+      Object.defineProperty(parent, 'scrollTop', {
+        configurable: true,
+        get: () => scrollTop,
+        set: (value: number) => {
+          scrollTop = value;
+        },
+      });
+
+      Object.defineProperties(child, {
+        offsetTop: {
+          configurable: true,
+          get: () => 50,
+        },
+        clientHeight: {
+          configurable: true,
+          get: () => 40,
+        },
+      });
+
+      Object.defineProperty(child, 'scrollIntoView', {
+        configurable: true,
+        writable: true,
+        value: (alignToTop?: boolean) => {
+          scrollIntoViewMock(alignToTop);
+        },
+      });
+
+      parent.appendChild(child);
+      document.body.appendChild(parent);
+
+      const getComputedStyleSpy = vi.spyOn(window, 'getComputedStyle').mockImplementation(
+        () =>
+          ({
+            getPropertyValue: () => '0',
+          } as unknown as CSSStyleDeclaration)
+      );
+
+      child.scrollIntoViewIfNeeded(false);
+
+      expect(scrollIntoViewMock).toHaveBeenCalledTimes(1);
+      expect(scrollIntoViewMock).toHaveBeenCalledWith(true);
+
+      parent.remove();
+      getComputedStyleSpy.mockRestore();
+    });
+  });
+
+  describe('requestIdleCallback', () => {
+    type GlobalWithIdle = Omit<typeof globalThis, 'requestIdleCallback' | 'cancelIdleCallback'> & {
+      requestIdleCallback: (typeof window)['requestIdleCallback'] | undefined;
+      cancelIdleCallback: (typeof window)['cancelIdleCallback'] | undefined;
+    };
+
+    const globalWithIdle = globalThis as GlobalWithIdle;
+    let originalRequestIdleCallback: typeof window.requestIdleCallback | undefined;
+    let originalCancelIdleCallback: typeof window.cancelIdleCallback | undefined;
+
+    beforeEach(() => {
+      originalRequestIdleCallback = globalWithIdle.requestIdleCallback;
+      originalCancelIdleCallback = globalWithIdle.cancelIdleCallback;
+
+      globalWithIdle.requestIdleCallback = undefined;
+      globalWithIdle.cancelIdleCallback = undefined;
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+      globalWithIdle.requestIdleCallback = originalRequestIdleCallback;
+      globalWithIdle.cancelIdleCallback = originalCancelIdleCallback;
+    });
+
+    it('schedules callback using setTimeout when browser API missing', async () => {
+      vi.useFakeTimers();
+
+      await importPolyfills();
+
+      const callback = vi.fn((_deadline: IdleDeadline) => undefined);
+      const idleCallback: IdleRequestCallback = (deadline) => {
+        callback(deadline);
+      };
+      const id = globalWithIdle.requestIdleCallback?.(idleCallback);
+
+      expect(id).toBeDefined();
+      expect(callback).not.toHaveBeenCalled();
+
+      vi.advanceTimersByTime(1);
+
+      expect(callback).toHaveBeenCalledTimes(1);
+
+      const recordedCalls = callback.mock.calls;
+      const deadlineCall = recordedCalls[0];
+
+      if (!deadlineCall) {
+        throw new Error('Expected requestIdleCallback to invoke the provided callback');
+      }
+
+      const [ deadline ] = deadlineCall;
+
+      expect(deadline.didTimeout).toBe(false);
+      expect(deadline.timeRemaining()).toBeGreaterThanOrEqual(0);
+      expect(deadline.timeRemaining()).toBeLessThanOrEqual(50);
+    });
+
+    it('cancels scheduled callback using clearTimeout', async () => {
+      vi.useFakeTimers();
+
+      await importPolyfills();
+
+      const noopCallback: IdleRequestCallback = (_deadline: IdleDeadline) => undefined;
+      const timeoutId = globalWithIdle.requestIdleCallback?.(noopCallback);
+      const clearTimeoutSpy = vi.spyOn(globalThis, 'clearTimeout');
+
+      if (typeof timeoutId !== 'number') {
+        throw new Error('Expected cancelIdleCallback to receive a numeric handle');
+      }
+
+      globalWithIdle.cancelIdleCallback?.(timeoutId);
+
+      expect(clearTimeoutSpy).toHaveBeenCalledWith(timeoutId);
+
+      clearTimeoutSpy.mockRestore();
+    });
+  });
+});
+
diff --git a/test/unit/tools/base.test.ts b/test/unit/tools/base.test.ts
new file mode 100644
index 000000000..980660148
--- /dev/null
+++ b/test/unit/tools/base.test.ts
@@ -0,0 +1,273 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { Tool, ToolConstructable } from '@/types/tools';
+import type { API } from '@/types';
+import type { ToolOptions } from '../../../src/components/tools/base';
+import BaseToolAdapter, { CommonInternalSettings, UserSettings } from '../../../src/components/tools/base';
+import { ToolType } from '@/types/tools/adapters/tool-type';
+
+interface AdapterOptions {
+  name: string;
+  constructable: ToolConstructable;
+  config: ToolOptions;
+  api: API;
+  isDefault: boolean;
+  isInternal: boolean;
+  defaultPlaceholder?: string | false;
+}
+
+interface TestToolAdapterOptions extends AdapterOptions {
+  toolType?: ToolType;
+}
+
+/**
+ * Test-friendly adapter that lets specs interact with the base implementation.
+ */
+class TestToolAdapter extends BaseToolAdapter<ToolType, Tool> {
+  public type: ToolType;
+
+  /**
+   * Creates a tool adapter instance preloaded with the supplied test options.
+   *
+   * @param options configuration bundle used to build the adapter for a spec
+   */
+  constructor(options: TestToolAdapterOptions) {
+    super(options);
+    this.type = options.toolType ?? ToolType.Block;
+  }
+
+  /**
+   *
+   */
+  public create(): Tool {
+    return {} as Tool;
+  }
+}
+
+const createConstructable = (
+  overrides: Record<string, unknown> = {}
+): ToolConstructable & Record<string, unknown> => {
+  /**
+   *
+   */
+  class Constructable {}
+
+  Object.assign(Constructable, overrides);
+
+  return Constructable as unknown as ToolConstructable & Record<string, unknown>;
+};
+
+const createToolOptions = (overrides: Partial<ToolOptions> = {}): ToolOptions => {
+  return {
+    [UserSettings.Config]: {
+      option1: 'value1',
+    },
+    [UserSettings.Shortcut]: 'CTRL+SHIFT+B',
+    ...overrides,
+  };
+};
+
+const createTool = (
+  overrides: Partial<TestToolAdapterOptions> = {}
+): {
+  tool: TestToolAdapter;
+  options: TestToolAdapterOptions;
+} => {
+  const options: TestToolAdapterOptions = {
+    name: overrides.name ?? 'baseTool',
+    constructable: overrides.constructable ?? createConstructable(),
+    config: overrides.config ?? createToolOptions(),
+    api: overrides.api ?? {} as API,
+    isDefault: overrides.isDefault ?? false,
+    isInternal: overrides.isInternal ?? false,
+    defaultPlaceholder: overrides.defaultPlaceholder ?? 'Default placeholder',
+    toolType: overrides.toolType ?? ToolType.Block,
+  };
+
+  return {
+    tool: new TestToolAdapter(options),
+    options,
+  };
+};
+
+describe('BaseToolAdapter', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('settings', () => {
+    it('returns user configuration as-is', () => {
+      const customConfig: ToolOptions = {
+        [UserSettings.Config]: {
+          foo: 'bar',
+        },
+        [UserSettings.Shortcut]: 'CMD+ALT+1',
+      };
+      const { tool } = createTool({
+        config: customConfig,
+      });
+
+      expect(tool.settings).toStrictEqual(customConfig[UserSettings.Config]);
+    });
+
+    it('adds default placeholder when default tool lacks placeholder', () => {
+      const { tool } = createTool({
+        isDefault: true,
+        config: {
+          [UserSettings.Shortcut]: 'CMD+ALT+2',
+        } as ToolOptions,
+      });
+
+      expect(tool.settings).toStrictEqual({
+        placeholder: 'Default placeholder',
+      });
+    });
+
+    it('does not override user-defined placeholder', () => {
+      const placeholder = 'Custom placeholder';
+      const { tool } = createTool({
+        isDefault: true,
+        config: {
+          [UserSettings.Config]: {
+            placeholder,
+          },
+          [UserSettings.Shortcut]: 'CMD+ALT+3',
+        } as ToolOptions,
+      });
+
+      expect(tool.settings).toStrictEqual({
+        placeholder,
+      });
+    });
+  });
+
+  describe('lifecycle hooks', () => {
+    it('delegates prepare to constructable with tool context', async () => {
+      const prepare = vi.fn();
+      const { tool } = createTool({
+        constructable: createConstructable({
+          prepare,
+        }),
+      });
+
+      await tool.prepare();
+
+      expect(prepare).toHaveBeenCalledWith({
+        toolName: 'baseTool',
+        config: tool.settings,
+      });
+    });
+
+    it('skips prepare when constructable method is absent', async () => {
+      const { tool } = createTool({
+        constructable: createConstructable(),
+      });
+
+      const result = await tool.prepare();
+
+      expect(result).toBeUndefined();
+    });
+
+    it('delegates reset to constructable when available', async () => {
+      const reset = vi.fn();
+      const { tool } = createTool({
+        constructable: createConstructable({
+          reset,
+        }),
+      });
+
+      await tool.reset();
+
+      expect(reset).toHaveBeenCalledTimes(1);
+    });
+
+    it('skips reset when constructable method is absent', async () => {
+      const { tool } = createTool({
+        constructable: createConstructable(),
+      });
+
+      const result = await tool.reset();
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('shortcut', () => {
+    it('prefers user-defined shortcut value', () => {
+      const config: ToolOptions = {
+        [UserSettings.Config]: {},
+        [UserSettings.Shortcut]: 'CMD+ALT+4',
+      };
+      const { tool } = createTool({
+        config,
+      });
+
+      expect(tool.shortcut).toBe(config[UserSettings.Shortcut]);
+    });
+
+    it('falls back to constructable shortcut', () => {
+      const constructableShortcut = 'CTRL+K';
+      const { tool } = createTool({
+        config: {
+          [UserSettings.Config]: {},
+        } as ToolOptions,
+        constructable: createConstructable({
+          [CommonInternalSettings.Shortcut]: constructableShortcut,
+        }),
+      });
+
+      expect(tool.shortcut).toBe(constructableShortcut);
+    });
+  });
+
+  describe('sanitizeConfig', () => {
+    it('returns constructable sanitize configuration when provided', () => {
+      const sanitizeConfig = {
+        paragraph: {
+          b: true,
+        },
+      };
+      const { tool } = createTool({
+        constructable: createConstructable({
+          [CommonInternalSettings.SanitizeConfig]: sanitizeConfig,
+        }),
+      });
+
+      expect(tool.sanitizeConfig).toBe(sanitizeConfig);
+    });
+
+    it('returns empty object when sanitize configuration is missing', () => {
+      const { tool } = createTool({
+        constructable: createConstructable(),
+      });
+
+      expect(tool.sanitizeConfig).toEqual({});
+    });
+  });
+
+  describe('type guards', () => {
+    it('identifies tool type correctly', () => {
+      const blockTool = createTool({
+        toolType: ToolType.Block,
+      }).tool;
+      const inlineTool = createTool({
+        toolType: ToolType.Inline,
+      }).tool;
+      const tuneTool = createTool({
+        toolType: ToolType.Tune,
+      }).tool;
+
+      expect(blockTool.isBlock()).toBe(true);
+      expect(blockTool.isInline()).toBe(false);
+      expect(blockTool.isTune()).toBe(false);
+
+      expect(inlineTool.isInline()).toBe(true);
+      expect(inlineTool.isBlock()).toBe(false);
+      expect(inlineTool.isTune()).toBe(false);
+
+      expect(tuneTool.isTune()).toBe(true);
+      expect(tuneTool.isBlock()).toBe(false);
+      expect(tuneTool.isInline()).toBe(false);
+    });
+  });
+});
+
diff --git a/test/unit/tools/block.test.ts b/test/unit/tools/block.test.ts
new file mode 100644
index 000000000..b13f294f9
--- /dev/null
+++ b/test/unit/tools/block.test.ts
@@ -0,0 +1,577 @@
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import type { BlockAPI, BlockToolData, ToolSettings, BlockToolConstructable, API } from '@/types';
+import { ToolType } from '@/types/tools/adapters/tool-type';
+import BlockToolAdapter from '../../../src/components/tools/block';
+import InlineToolAdapter from '../../../src/components/tools/inline';
+import ToolsCollection from '../../../src/components/tools/collection';
+import { InternalBlockToolSettings } from '../../../src/components/tools/base';
+
+type BlockToolAdapterOptions = ConstructorParameters<typeof BlockToolAdapter>[0];
+
+interface ToolConstructorArgs {
+  data: BlockToolData;
+  block: BlockAPI;
+  readOnly: boolean;
+  api: object;
+  config?: ToolSettings;
+}
+
+type ConstructableClass = new (args: ToolConstructorArgs) => {
+  data: BlockToolData;
+  block: BlockAPI;
+  readonly: boolean;
+  api: object;
+  config: ToolSettings;
+};
+
+const createConstructable = (overrides: Record<string, unknown> = {}): ConstructableClass => {
+  /**
+   *
+   */
+  class Constructable {
+    public static sanitize = {
+      rule1: {
+        div: true,
+      },
+    };
+
+    public static toolbox = {
+      icon: 'Tool icon',
+      title: 'Tool title',
+    };
+
+    public static enableLineBreaks = true;
+
+    public static pasteConfig = {
+      tags: [ 'div' ],
+    };
+
+    public static conversionConfig = {
+      import: 'import',
+      export: 'export',
+    };
+
+    public static isReadOnlySupported = true;
+
+    public static shortcut = 'CTRL+N';
+
+    public data: BlockToolData;
+    public block: BlockAPI;
+    public readonly: boolean;
+    public api: object;
+    public config: ToolSettings;
+
+    /**
+     *
+     * @param root0 - The constructor arguments object
+     */
+    constructor({ data, block, readOnly, api, config }: ToolConstructorArgs) {
+      this.data = data;
+      this.block = block;
+      this.readonly = readOnly;
+      this.api = api;
+      this.config = config ?? {};
+    }
+  }
+
+  Object.assign(Constructable, overrides);
+
+  return Constructable;
+};
+
+const createBaseOptions = (): BlockToolAdapterOptions => {
+  const constructable = createConstructable();
+
+  return {
+    name: 'blockTool',
+    constructable: constructable as unknown as BlockToolConstructable,
+    config: {
+      config: {
+        option1: 'option1',
+        option2: 'option2',
+      },
+      inlineToolbar: ['link', 'bold'],
+      tunes: ['anchor', 'favorites'],
+      shortcut: 'CMD+SHIFT+B',
+      toolbox: {
+        title: 'User Block Tool',
+        icon: 'User icon',
+      },
+    },
+    api: {
+      prop1: 'prop1',
+      prop2: 'prop2',
+    } as unknown as API,
+    isDefault: false,
+    isInternal: false,
+    defaultPlaceholder: 'Default placeholder',
+  };
+};
+
+const mergeOptions = (overrides: Partial<BlockToolAdapterOptions> = {}): BlockToolAdapterOptions => {
+  const baseOptions = createBaseOptions();
+  const configOverrides = overrides.config;
+
+  const mergedConfig = {
+    ...baseOptions.config,
+    ...configOverrides,
+    config: configOverrides && 'config' in configOverrides
+      ? {
+        ...baseOptions.config.config,
+        ...configOverrides.config,
+      }
+      : baseOptions.config.config,
+  };
+
+  return {
+    ...baseOptions,
+    ...overrides,
+    config: mergedConfig,
+  };
+};
+
+const createBlockTool = (overrides?: Partial<BlockToolAdapterOptions>): { tool: BlockToolAdapter; options: BlockToolAdapterOptions } => {
+  const options = mergeOptions(overrides);
+  const tool = new BlockToolAdapter(options as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+  return { tool,
+    options };
+};
+
+const createInlineTool = (sanitize: Record<string, unknown>): InlineToolAdapter => {
+  return new InlineToolAdapter({
+    name: `inline-${Math.random()}`,
+    constructable: class {
+      public static sanitize = sanitize;
+    },
+    config: {
+      config: {},
+    },
+    api: {},
+    isDefault: false,
+    isInternal: false,
+  } as unknown as ConstructorParameters<typeof InlineToolAdapter>[0]);
+};
+
+describe('BlockToolAdapter', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('basic metadata', () => {
+    it('returns Block tool type', () => {
+      const { tool } = createBlockTool();
+
+      expect(tool.type).toBe(ToolType.Block);
+    });
+
+    it('exposes tool name', () => {
+      const { tool, options } = createBlockTool();
+
+      expect(tool.name).toBe(options.name);
+    });
+
+    it('reflects default tool flag', () => {
+      const { tool: regularTool } = createBlockTool();
+      const { tool: defaultTool } = createBlockTool({ isDefault: true });
+
+      expect(regularTool.isDefault).toBe(false);
+      expect(defaultTool.isDefault).toBe(true);
+    });
+
+    it('reflects internal tool flag', () => {
+      const { tool: externalTool } = createBlockTool();
+      const { tool: internalTool } = createBlockTool({ isInternal: true });
+
+      expect(externalTool.isInternal).toBe(false);
+      expect(internalTool.isInternal).toBe(true);
+    });
+  });
+
+  describe('settings', () => {
+    it('returns user configuration', () => {
+      const { tool, options } = createBlockTool();
+
+      expect(tool.settings).toEqual(options.config.config);
+    });
+
+    it('adds default placeholder for default tools', () => {
+      const { tool } = createBlockTool({ isDefault: true });
+
+      expect(tool.settings).toHaveProperty('placeholder', 'Default placeholder');
+    });
+  });
+
+  describe('sanitize configuration', () => {
+    it('returns constructable sanitize config by default', () => {
+      const { tool, options } = createBlockTool();
+
+      expect(tool.sanitizeConfig).toEqual(options.constructable.sanitize);
+    });
+
+    it('merges inline tool sanitize config when provided', () => {
+      const { tool, options } = createBlockTool();
+      const inlineTool = createInlineTool({ b: true });
+
+      tool.inlineTools = new ToolsCollection([ ['inlineTool', inlineTool] ]);
+
+      const expected = Object.fromEntries(
+        Object.entries(options.constructable.sanitize as Record<string, Record<string, boolean>>)
+          .map(([field, rule]) => [
+            field,
+            {
+              ...(rule ?? {}),
+              ...(inlineTool.sanitizeConfig as Record<string, boolean>),
+            },
+          ])
+      );
+
+      expect(tool.sanitizeConfig).toEqual(expected);
+    });
+
+    it('falls back to inline tools config when constructable sanitize config is empty', () => {
+      const { options } = createBlockTool();
+      const inlineTool = createInlineTool({ strong: true });
+      const inlineTool2 = createInlineTool({ em: true });
+      const tool = new BlockToolAdapter({
+        ...options,
+        constructable: class {},
+      } as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+      tool.inlineTools = new ToolsCollection([
+        ['inlineTool', inlineTool],
+        ['inlineTool2', inlineTool2],
+      ]);
+
+      expect(tool.sanitizeConfig).toEqual({
+        ...inlineTool.sanitizeConfig,
+        ...inlineTool2.sanitizeConfig,
+      });
+    });
+
+    it('returns empty object when no sanitize configuration is provided', () => {
+      const { options } = createBlockTool();
+      const tool = new BlockToolAdapter({
+        ...options,
+        constructable: class {},
+      } as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+      expect(tool.sanitizeConfig).toEqual({});
+    });
+  });
+
+  describe('type helpers', () => {
+    it('identifies block tool type correctly', () => {
+      const { tool } = createBlockTool();
+
+      expect(tool.isBlock()).toBe(true);
+      expect(tool.isInline()).toBe(false);
+      expect(tool.isTune()).toBe(false);
+    });
+  });
+
+  describe('capabilities', () => {
+    it('reports read-only support', () => {
+      const { tool, options } = createBlockTool();
+
+      expect(tool.isReadOnlySupported).toBe((options.constructable as BlockToolConstructable).isReadOnlySupported);
+    });
+
+    it('reports line breaks support', () => {
+      const { tool, options } = createBlockTool();
+
+      expect(tool.isLineBreaksEnabled).toBe((options.constructable as unknown as Record<string, boolean | undefined>)[InternalBlockToolSettings.IsEnabledLineBreaks]);
+    });
+  });
+
+  describe('configuration getters', () => {
+    it('exposes conversion config', () => {
+      const { tool, options } = createBlockTool();
+
+      expect(tool.conversionConfig).toEqual((options.constructable as BlockToolConstructable).conversionConfig);
+    });
+
+    it('exposes paste config from constructable', () => {
+      const { tool, options } = createBlockTool();
+
+      expect(tool.pasteConfig).toEqual((options.constructable as BlockToolConstructable).pasteConfig);
+    });
+
+    it('returns constructable paste config when set to false', () => {
+      const { options } = createBlockTool();
+      const tool = new BlockToolAdapter({
+        ...options,
+        constructable: class extends (options.constructable as typeof options.constructable) {
+          public static pasteConfig = false;
+        },
+      } as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+      expect(tool.pasteConfig).toBe(false);
+    });
+
+    it('returns empty object when paste config is not provided', () => {
+      const { options } = createBlockTool();
+      const tool = new BlockToolAdapter({
+        ...options,
+        constructable: class extends (options.constructable as typeof options.constructable) {
+          public static pasteConfig = undefined;
+        },
+      } as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+      expect(tool.pasteConfig).toEqual({});
+    });
+
+    it('returns enabled inline tools or false by default', () => {
+      const { tool, options } = createBlockTool();
+
+      expect(tool.enabledInlineTools).toEqual(options.config.inlineToolbar);
+
+      const { tool: fallbackTool } = createBlockTool({
+        config: {
+          inlineToolbar: undefined,
+        },
+      });
+
+      expect(fallbackTool.enabledInlineTools).toBe(false);
+    });
+
+    it('returns enabled block tunes from config', () => {
+      const { tool, options } = createBlockTool();
+
+      expect(tool.enabledBlockTunes).toEqual(options.config.tunes);
+    });
+  });
+
+  describe('toolbox configuration', () => {
+    it('returns user defined toolbox config wrapped in array', () => {
+      const { tool, options } = createBlockTool();
+
+      expect(tool.toolbox).toEqual([ options.config.toolbox ]);
+    });
+
+    it('falls back to constructable toolbox config when user config is not provided', () => {
+      const { options } = createBlockTool();
+      const tool = new BlockToolAdapter({
+        ...options,
+        config: {
+          ...options.config,
+          toolbox: undefined,
+        },
+      } as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+      expect(tool.toolbox).toEqual([ (options.constructable as BlockToolConstructable).toolbox ]);
+    });
+
+    it('merges constructable and user toolbox configs when both are objects', () => {
+      const { options } = createBlockTool();
+      const tool = new BlockToolAdapter({
+        ...options,
+        config: {
+          ...options.config,
+          toolbox: {
+            title: 'Custom title',
+          },
+        },
+      } as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+      expect(tool.toolbox).toEqual([
+        {
+          ...(options.constructable as BlockToolConstructable).toolbox,
+          title: 'Custom title',
+        },
+      ]);
+    });
+
+    it('replaces constructable toolbox array with user object', () => {
+      const { options } = createBlockTool();
+      const toolboxEntries = [
+        { title: 'Toolbox entry 1' },
+        { title: 'Toolbox entry 2' },
+      ];
+      const userConfig = {
+        title: 'User title',
+        icon: typeof options.config.toolbox === 'object' && !Array.isArray(options.config.toolbox) ? options.config.toolbox.icon : undefined,
+      };
+      const tool = new BlockToolAdapter({
+        ...options,
+        constructable: class extends (options.constructable as typeof options.constructable) {
+          public static toolbox = toolboxEntries;
+        },
+        config: {
+          ...options.config,
+          toolbox: userConfig,
+        },
+      } as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+      expect(tool.toolbox).toEqual([ userConfig ]);
+    });
+
+    it('uses user provided toolbox array when constructable config is object', () => {
+      const { options } = createBlockTool();
+      const userConfig = [
+        { title: 'Toolbox entry 1' },
+        { title: 'Toolbox entry 2' },
+      ];
+      const tool = new BlockToolAdapter({
+        ...options,
+        config: {
+          ...options.config,
+          toolbox: userConfig,
+        },
+      } as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+      expect(tool.toolbox).toEqual(userConfig);
+    });
+
+    it('merges toolbox arrays by index', () => {
+      const { options } = createBlockTool();
+      const toolboxEntries = [
+        { title: 'Toolbox entry 1' },
+      ];
+      const userConfig = [
+        { icon: 'Icon 1' },
+        { icon: 'Icon 2',
+          title: 'Toolbox entry 2' },
+      ];
+      const tool = new BlockToolAdapter({
+        ...options,
+        constructable: class extends (options.constructable as typeof options.constructable) {
+          public static toolbox = toolboxEntries;
+        },
+        config: {
+          ...options.config,
+          toolbox: userConfig,
+        },
+      } as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+      expect(tool.toolbox).toEqual([
+        {
+          ...toolboxEntries[0],
+          ...userConfig[0],
+        },
+        userConfig[1],
+      ]);
+    });
+
+    it('returns undefined when user disables toolbox', () => {
+      const { options } = createBlockTool();
+      const tool = new BlockToolAdapter({
+        ...options,
+        config: {
+          ...options.config,
+          toolbox: false,
+        },
+      } as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+      expect(tool.toolbox).toBeUndefined();
+    });
+
+    it('returns undefined when constructable toolbox config is false', () => {
+      const { options } = createBlockTool();
+      const tool = new BlockToolAdapter({
+        ...options,
+        constructable: class {
+          public static toolbox = false;
+        },
+      } as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+      expect(tool.toolbox).toBeUndefined();
+    });
+
+    it('returns undefined when constructable toolbox config is empty', () => {
+      const { options } = createBlockTool();
+      const tool = new BlockToolAdapter({
+        ...options,
+        constructable: class {
+          public static toolbox = {};
+        },
+      } as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+      expect(tool.toolbox).toBeUndefined();
+    });
+  });
+
+  describe('lifecycle hooks', () => {
+    it('calls constructable prepare when defined', async () => {
+      const { tool, options } = createBlockTool();
+      const prepare = vi.fn();
+
+      options.constructable.prepare = prepare;
+      await tool.prepare();
+
+      expect(prepare).toHaveBeenCalledWith({
+        toolName: options.name,
+        config: tool.settings,
+      });
+    });
+
+    it('gracefully skips prepare when missing', () => {
+      const { tool, options } = createBlockTool();
+
+      options.constructable.prepare = undefined;
+
+      expect(tool.prepare()).toBeUndefined();
+    });
+
+    it('calls constructable reset when defined', async () => {
+      const { tool, options } = createBlockTool();
+      const reset = vi.fn();
+
+      options.constructable.reset = reset;
+      await tool.reset();
+
+      expect(reset).toHaveBeenCalledTimes(1);
+    });
+
+    it('gracefully skips reset when missing', () => {
+      const { tool, options } = createBlockTool();
+
+      options.constructable.reset = undefined;
+
+      expect(tool.reset()).toBeUndefined();
+    });
+  });
+
+  describe('keyboard shortcut', () => {
+    it('prefers user defined shortcut', () => {
+      const { tool, options } = createBlockTool();
+
+      expect(tool.shortcut).toBe(options.config.shortcut);
+    });
+
+    it('falls back to constructable shortcut', () => {
+      const { options } = createBlockTool();
+      const tool = new BlockToolAdapter({
+        ...options,
+        config: {
+          ...options.config,
+          shortcut: undefined,
+        },
+      } as unknown as ConstructorParameters<typeof BlockToolAdapter>[0]);
+
+      expect(tool.shortcut).toBe(options.constructable.shortcut);
+    });
+  });
+
+  describe('instance creation', () => {
+    it('creates tool instances with provided arguments', () => {
+      const { tool, options } = createBlockTool();
+      const data = { text: 'text' };
+      const blockAPI = {
+        method(): void {
+          // noop
+        },
+      } as unknown as BlockAPI;
+
+      const instance = tool.create(data as BlockToolData, blockAPI, false);
+
+      expect(instance).toBeInstanceOf(options.constructable as unknown as { new(...args: unknown[]): object });
+      expect((instance as unknown as { data: unknown }).data).toEqual(data);
+      expect((instance as unknown as { block: unknown }).block).toEqual(blockAPI);
+      expect((instance as unknown as { readonly: boolean }).readonly).toBe(false);
+      expect((instance as unknown as { api: unknown }).api).toEqual(options.api);
+      expect((instance as unknown as { config: unknown }).config).toEqual(options.config.config);
+    });
+  });
+});
+
diff --git a/test/unit/tools/inline.test.ts b/test/unit/tools/inline.test.ts
new file mode 100644
index 000000000..35ba17033
--- /dev/null
+++ b/test/unit/tools/inline.test.ts
@@ -0,0 +1,334 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { ToolSettings, API } from '@/types';
+import { ToolType } from '@/types/tools/adapters/tool-type';
+import InlineToolAdapter from '../../../src/components/tools/inline';
+
+type InlineToolAdapterOptions = ConstructorParameters<typeof InlineToolAdapter>[0];
+
+type InlineToolInstance = {
+  api: object;
+  config: ToolSettings;
+};
+
+const createInlineToolOptions = (): InlineToolAdapterOptions => {
+  /**
+   *
+   */
+  class Constructable {
+    public static sanitize = {
+      rule1: 'rule1',
+    };
+
+    public static title = 'Title';
+
+    public static shortcut = 'CTRL+N';
+
+    public static isReadOnlySupported = true;
+
+    public api: object;
+
+    public config: ToolSettings;
+
+    /**
+     *
+     * @param root0 - The constructor arguments object
+     */
+    constructor({ api, config }: { api: object; config: ToolSettings }) {
+      this.api = api;
+      this.config = config;
+    }
+  }
+
+  return {
+    name: 'inlineTool',
+    constructable: Constructable as unknown as InlineToolAdapterOptions['constructable'],
+    config: {
+      config: {
+        option1: 'option1',
+        option2: 'option2',
+      },
+      shortcut: 'CMD+SHIFT+B',
+    },
+    api: {
+      prop1: 'prop1',
+      prop2: 'prop2',
+    } as unknown as API,
+    isDefault: false,
+    isInternal: false,
+    defaultPlaceholder: 'Default placeholder',
+  } as InlineToolAdapterOptions;
+};
+
+describe('InlineToolAdapter', () => {
+  describe('.type', () => {
+    it('returns ToolType.Inline', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter(options);
+
+      expect(tool.type).toBe(ToolType.Inline);
+    });
+  });
+
+  describe('.name', () => {
+    it('returns provided tool name', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter(options);
+
+      expect(tool.name).toBe(options.name);
+    });
+  });
+
+  describe('.title', () => {
+    it('returns constructable title', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter(options);
+      const constructable = options.constructable as { title?: string };
+
+      expect(tool.title).toBe(constructable.title);
+    });
+
+    it('returns empty string when constructable is undefined', () => {
+      const tool = new InlineToolAdapter({
+        ...createInlineToolOptions(),
+        constructable: undefined as unknown as InlineToolAdapterOptions['constructable'],
+      });
+
+      expect(tool.title).toBe('');
+    });
+
+    it('returns empty string when constructable title is undefined', () => {
+      const tool = new InlineToolAdapter({
+        ...createInlineToolOptions(),
+        constructable: {} as InlineToolAdapterOptions['constructable'],
+      });
+
+      expect(tool.title).toBe('');
+    });
+  });
+
+  describe('.isInternal', () => {
+    it('reflects provided value', () => {
+      const tool = new InlineToolAdapter(createInlineToolOptions());
+      const internalTool = new InlineToolAdapter({
+        ...createInlineToolOptions(),
+        isInternal: true,
+      });
+
+      expect(tool.isInternal).toBe(false);
+      expect(internalTool.isInternal).toBe(true);
+    });
+  });
+
+  describe('.settings', () => {
+    it('returns user configuration', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter(options);
+
+      expect(tool.settings).toStrictEqual(options.config.config);
+    });
+
+    it('includes default placeholder when tool is default', () => {
+      const options = {
+        ...createInlineToolOptions(),
+        isDefault: true,
+      } as InlineToolAdapterOptions;
+      const tool = new InlineToolAdapter(options);
+
+      expect(tool.settings).toStrictEqual({
+        ...options.config.config,
+        placeholder: options.defaultPlaceholder,
+      });
+    });
+  });
+
+  describe('.sanitizeConfig', () => {
+    it('returns constructable sanitize config', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter(options);
+
+      expect(tool.sanitizeConfig).toStrictEqual(options.constructable.sanitize);
+    });
+  });
+
+  describe('type guards', () => {
+    it('identify tool type correctly', () => {
+      const tool = new InlineToolAdapter(createInlineToolOptions());
+
+      expect(tool.isBlock()).toBe(false);
+      expect(tool.isInline()).toBe(true);
+      expect(tool.isTune()).toBe(false);
+    });
+  });
+
+  describe('.prepare', () => {
+    it('invokes constructable prepare with tool context', async () => {
+      const options = createInlineToolOptions();
+      const prepare = vi.fn();
+
+      options.constructable.prepare = prepare;
+      const tool = new InlineToolAdapter(options);
+
+      await tool.prepare();
+
+      expect(prepare).toHaveBeenCalledWith({
+        toolName: tool.name,
+        config: tool.settings,
+      });
+    });
+
+    it('does nothing when constructable prepare is absent', async () => {
+      const tool = new InlineToolAdapter({
+        ...createInlineToolOptions(),
+        constructable: {} as InlineToolAdapterOptions['constructable'],
+      });
+
+      const result = await tool.prepare();
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('.reset', () => {
+    it('invokes constructable reset', async () => {
+      const options = createInlineToolOptions();
+      const reset = vi.fn();
+
+      options.constructable.reset = reset;
+      const tool = new InlineToolAdapter(options);
+
+      await tool.reset();
+
+      expect(reset).toHaveBeenCalledTimes(1);
+    });
+
+    it('does nothing when constructable reset is absent', async () => {
+      const tool = new InlineToolAdapter({
+        ...createInlineToolOptions(),
+        constructable: {} as InlineToolAdapterOptions['constructable'],
+      });
+
+      const result = await tool.reset();
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('.getMissingMethods', () => {
+    it('returns all required methods when constructable prototype is missing', () => {
+      const tool = new InlineToolAdapter({
+        ...createInlineToolOptions(),
+        constructable: {} as InlineToolAdapterOptions['constructable'],
+      });
+      const requiredMethods = ['render', 'surround'];
+
+      expect(tool.getMissingMethods(requiredMethods)).toStrictEqual(requiredMethods);
+    });
+
+    it('returns methods missing on the prototype', () => {
+      const options = createInlineToolOptions();
+
+      /**
+       *
+       */
+      class ConstructableWithRender extends (options.constructable as unknown as { new (args: { api: object; config: ToolSettings }): InlineToolInstance }) {
+        /**
+         *
+         */
+        public render(): void {}
+      }
+
+      const tool = new InlineToolAdapter({
+        ...options,
+        constructable: ConstructableWithRender as unknown as InlineToolAdapterOptions['constructable'],
+      });
+      const requiredMethods = ['render', 'surround'];
+
+      expect(tool.getMissingMethods(requiredMethods)).toStrictEqual([ 'surround' ]);
+    });
+
+    it('returns empty array when all methods are implemented', () => {
+      const options = createInlineToolOptions();
+
+      /**
+       *
+       */
+      class ConstructableWithAllMethods extends (options.constructable as unknown as { new (args: { api: object; config: ToolSettings }): InlineToolInstance }) {
+        /**
+         *
+         */
+        public render(): void {}
+
+        /**
+         *
+         */
+        public surround(): void {}
+      }
+
+      const tool = new InlineToolAdapter({
+        ...options,
+        constructable: ConstructableWithAllMethods as unknown as InlineToolAdapterOptions['constructable'],
+      });
+      const requiredMethods = ['render', 'surround'];
+
+      expect(tool.getMissingMethods(requiredMethods)).toStrictEqual([]);
+    });
+  });
+
+  describe('.shortcut', () => {
+    it('prefers user shortcut over constructable shortcut', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter(options);
+
+      expect(tool.shortcut).toBe(options.config.shortcut);
+    });
+
+    it('falls back to constructable shortcut', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter({
+        ...options,
+        config: {
+          ...options.config,
+          shortcut: undefined,
+        },
+      });
+
+      expect(tool.shortcut).toBe(options.constructable.shortcut);
+    });
+  });
+
+  describe('.create', () => {
+    it('returns instance of constructable class', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter(options);
+
+      expect(tool.create()).toBeInstanceOf(options.constructable as unknown as { new (): InlineToolInstance });
+    });
+
+    it('passes api and config to constructable instance', () => {
+      const options = createInlineToolOptions();
+      const tool = new InlineToolAdapter(options);
+
+      const instance = tool.create() as unknown as InlineToolInstance & { api: InlineToolAdapterOptions['api']; config: ToolSettings };
+
+      expect(instance.api).toBe(options.api);
+      expect(instance.config).toStrictEqual(options.config.config);
+    });
+  });
+
+  describe('.isReadOnlySupported', () => {
+    it('returns constructable flag when present', () => {
+      const tool = new InlineToolAdapter(createInlineToolOptions());
+
+      expect(tool.isReadOnlySupported).toBe(true);
+    });
+
+    it('returns false when constructable flag is absent', () => {
+      const tool = new InlineToolAdapter({
+        ...createInlineToolOptions(),
+        constructable: {} as InlineToolAdapterOptions['constructable'],
+      });
+
+      expect(tool.isReadOnlySupported).toBe(false);
+    });
+  });
+});
diff --git a/test/unit/ui/toolbox.test.ts b/test/unit/ui/toolbox.test.ts
new file mode 100644
index 000000000..ba2a59c3f
--- /dev/null
+++ b/test/unit/ui/toolbox.test.ts
@@ -0,0 +1,755 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import Toolbox, { ToolboxEvent } from '../../../src/components/ui/toolbox';
+import type { API, BlockToolData, ToolboxConfigEntry, BlockAPI } from '@/types';
+import type BlockToolAdapter from '../../../src/components/tools/block';
+import type ToolsCollection from '../../../src/components/tools/collection';
+import type { Popover } from '../../../src/components/utils/popover';
+import { PopoverEvent } from '@/types/utils/popover/popover-event';
+import { EditorMobileLayoutToggled } from '../../../src/components/events';
+import Shortcuts from '../../../src/components/utils/shortcuts';
+
+// Mock dependencies at module level
+const mockPopoverInstance = {
+  show: vi.fn(),
+  hide: vi.fn(),
+  destroy: vi.fn(),
+  getElement: vi.fn(() => document.createElement('div')),
+  on: vi.fn(),
+  off: vi.fn(),
+  hasFocus: vi.fn(() => false),
+};
+
+vi.mock('../../../src/components/dom', () => ({
+  default: {
+    make: vi.fn((tag: string, className: string) => {
+      const el = document.createElement(tag);
+
+      el.className = className;
+
+      return el;
+    }),
+  },
+}));
+
+vi.mock('../../../src/components/utils/popover', () => ({
+  PopoverDesktop: vi.fn().mockImplementation(() => mockPopoverInstance),
+  PopoverMobile: vi.fn().mockImplementation(() => mockPopoverInstance),
+}));
+
+vi.mock('../../../src/components/utils/shortcuts', () => ({
+  default: {
+    add: vi.fn(),
+    remove: vi.fn(),
+  },
+}));
+
+vi.mock('../../../src/components/utils', async () => {
+  const actual = await vi.importActual('../../../src/components/utils');
+
+  return {
+    ...actual,
+    isMobileScreen: vi.fn(() => false),
+    cacheable: (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => descriptor,
+  };
+});
+
+vi.mock('../../../src/components/i18n', () => ({
+  default: {
+    t: vi.fn((namespace: string, key: string) => key),
+  },
+}));
+
+/**
+ * Unit tests for toolbox.ts
+ *
+ * Tests internal functionality and edge cases not covered by E2E tests
+ */
+describe('Toolbox', () => {
+  const i18nLabels: Record<'filter' | 'nothingFound', string> = {
+    filter: 'Filter',
+    nothingFound: 'Nothing found',
+  };
+
+  const mocks = {
+    api: undefined as unknown as API,
+    tools: undefined as unknown as ToolsCollection<BlockToolAdapter>,
+    blockToolAdapter: undefined as unknown as BlockToolAdapter,
+    blockAPI: undefined as unknown as BlockAPI,
+  };
+
+  beforeEach(() => {
+    // Reset all mocks
+    vi.clearAllMocks();
+
+    // Mock BlockAPI
+    const blockAPI = {
+      id: 'test-block-id',
+      isEmpty: true,
+      call: vi.fn(),
+    } as unknown as BlockAPI;
+
+    // Mock BlockToolAdapter
+    const blockToolAdapter = {
+      name: 'testTool',
+      toolbox: {
+        title: 'Test Tool',
+        icon: '<svg>test</svg>',
+      },
+      shortcut: 'CMD+T',
+    } as unknown as BlockToolAdapter;
+
+    // Mock ToolsCollection
+    const tools = new Map() as unknown as ToolsCollection<BlockToolAdapter>;
+
+    tools.set('testTool', blockToolAdapter);
+    tools.forEach = Map.prototype.forEach.bind(tools);
+
+    // Mock API
+    const api = {
+      blocks: {
+        getCurrentBlockIndex: vi.fn(() => 0),
+        getBlockByIndex: vi.fn(() => blockAPI),
+        convert: vi.fn(),
+        composeBlockData: vi.fn(async () => ({})),
+        insert: vi.fn(() => blockAPI),
+      },
+      caret: {
+        setToBlock: vi.fn(),
+      },
+      toolbar: {
+        close: vi.fn(),
+      },
+      ui: {
+        nodes: {
+          redactor: document.createElement('div'),
+        },
+      },
+      events: {
+        on: vi.fn(),
+        off: vi.fn(),
+      },
+    } as unknown as API;
+
+    // Update mocks object (mutation instead of reassignment)
+    mocks.blockAPI = blockAPI;
+    mocks.blockToolAdapter = blockToolAdapter;
+    mocks.tools = tools;
+    mocks.api = api;
+  });
+
+  describe('constructor', () => {
+    it('should initialize toolbox with correct structure', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      const element = toolbox.getElement();
+
+      expect(element).not.toBeNull();
+      expect(element?.classList.contains('ce-toolbox')).toBe(true);
+    });
+
+    it('should set data-cy attribute in test mode', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      const element = toolbox.getElement();
+
+      expect(element?.getAttribute('data-cy')).toBe('toolbox');
+    });
+
+    it('should initialize with opened = false', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      expect(toolbox.opened).toBe(false);
+    });
+
+    it('should register EditorMobileLayoutToggled event listener', () => {
+      new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      expect(mocks.api.events.on).toHaveBeenCalledWith(
+        EditorMobileLayoutToggled,
+        expect.any(Function)
+      );
+    });
+  });
+
+  describe('isEmpty', () => {
+    it('should return true when no tools have toolbox configuration', () => {
+      const emptyTools = new Map() as unknown as ToolsCollection<BlockToolAdapter>;
+
+      emptyTools.forEach = Map.prototype.forEach.bind(emptyTools);
+
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: emptyTools,
+        i18nLabels,
+      });
+
+      expect(toolbox.isEmpty).toBe(true);
+    });
+
+    it('should return false when tools have toolbox configuration', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      expect(toolbox.isEmpty).toBe(false);
+    });
+
+    it('should return true when tool has toolbox set to undefined', () => {
+      const toolWithoutToolbox = {
+        name: 'noToolboxTool',
+        toolbox: undefined,
+      } as unknown as BlockToolAdapter;
+
+      const tools = new Map() as unknown as ToolsCollection<BlockToolAdapter>;
+
+      tools.set('noToolboxTool', toolWithoutToolbox);
+      tools.forEach = Map.prototype.forEach.bind(tools);
+
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools,
+        i18nLabels,
+      });
+
+      expect(toolbox.isEmpty).toBe(true);
+    });
+  });
+
+  describe('getElement', () => {
+    it('should return the toolbox element', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      const element = toolbox.getElement();
+
+      expect(element).not.toBeNull();
+      expect(element?.tagName).toBe('DIV');
+    });
+  });
+
+  describe('hasFocus', () => {
+    it('should return undefined when popover is not initialized', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      // Access private popover and set to null
+      (toolbox as unknown as { popover: Popover | null }).popover = null;
+
+      expect(toolbox.hasFocus()).toBeUndefined();
+    });
+
+    it('should return popover hasFocus result when popover exists', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      mockPopoverInstance.hasFocus.mockReturnValue(true);
+
+      expect(toolbox.hasFocus()).toBe(true);
+    });
+  });
+
+  describe('open', () => {
+    it('should open popover and set opened to true', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      const emitSpy = vi.spyOn(toolbox, 'emit');
+
+      toolbox.open();
+
+      expect(mockPopoverInstance.show).toHaveBeenCalled();
+      expect(toolbox.opened).toBe(true);
+      expect(emitSpy).toHaveBeenCalledWith(ToolboxEvent.Opened);
+    });
+
+    it('should not open when toolbox is empty', () => {
+      const emptyTools = new Map() as unknown as ToolsCollection<BlockToolAdapter>;
+
+      emptyTools.forEach = Map.prototype.forEach.bind(emptyTools);
+
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: emptyTools,
+        i18nLabels,
+      });
+
+      const emitSpy = vi.spyOn(toolbox, 'emit');
+
+      toolbox.open();
+
+      expect(mockPopoverInstance.show).not.toHaveBeenCalled();
+      expect(toolbox.opened).toBe(false);
+      expect(emitSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('close', () => {
+    it('should close popover and set opened to false', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      toolbox.opened = true;
+      const emitSpy = vi.spyOn(toolbox, 'emit');
+
+      toolbox.close();
+
+      expect(mockPopoverInstance.hide).toHaveBeenCalled();
+      expect(toolbox.opened).toBe(false);
+      expect(emitSpy).toHaveBeenCalledWith(ToolboxEvent.Closed);
+    });
+  });
+
+  describe('toggle', () => {
+    it('should open when closed', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      toolbox.opened = false;
+      const openSpy = vi.spyOn(toolbox, 'open');
+
+      toolbox.toggle();
+
+      expect(openSpy).toHaveBeenCalled();
+    });
+
+    it('should close when opened', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      toolbox.opened = true;
+      const closeSpy = vi.spyOn(toolbox, 'close');
+
+      toolbox.toggle();
+
+      expect(closeSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('toolButtonActivated', () => {
+    it('should call insertNewBlock with tool name and data overrides', async () => {
+      // Ensure mocks return valid values before creating toolbox
+      vi.mocked(mocks.api.blocks.getCurrentBlockIndex).mockReturnValue(0);
+      vi.mocked(mocks.api.blocks.getBlockByIndex).mockReturnValue(mocks.blockAPI);
+
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      const blockDataOverrides: BlockToolData = { test: 'data' };
+
+      await toolbox.toolButtonActivated('testTool', blockDataOverrides);
+
+      expect(mocks.api.blocks.insert).toHaveBeenCalled();
+    });
+
+    it('should insert block with overridden data', async () => {
+      // Ensure mocks return valid values before creating toolbox
+      vi.mocked(mocks.api.blocks.getCurrentBlockIndex).mockReturnValue(0);
+      vi.mocked(mocks.api.blocks.getBlockByIndex).mockReturnValue(mocks.blockAPI);
+
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      const blockDataOverrides: BlockToolData = { customProp: 'value' };
+
+      await toolbox.toolButtonActivated('testTool', blockDataOverrides);
+
+      expect(mocks.api.blocks.composeBlockData).toHaveBeenCalledWith('testTool');
+    });
+  });
+
+  describe('handleMobileLayoutToggle', () => {
+    it('should destroy and reinitialize popover', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      toolbox.handleMobileLayoutToggle();
+
+      expect(mockPopoverInstance.hide).toHaveBeenCalled();
+      expect(mockPopoverInstance.destroy).toHaveBeenCalled();
+    });
+  });
+
+  describe('destroy', () => {
+    it('should remove toolbox element from DOM', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      const element = toolbox.getElement();
+
+      document.body.appendChild(element!);
+
+      expect(document.body.contains(element!)).toBe(true);
+
+      toolbox.destroy();
+
+      expect(document.body.contains(element!)).toBe(false);
+    });
+
+    it('should remove popover event listener', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      toolbox.destroy();
+
+      expect(mockPopoverInstance.off).toHaveBeenCalledWith(
+        PopoverEvent.Closed,
+        expect.any(Function)
+      );
+    });
+
+    it('should remove EditorMobileLayoutToggled event listener', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      toolbox.destroy();
+
+      expect(mocks.api.events.off).toHaveBeenCalledWith(
+        EditorMobileLayoutToggled,
+        expect.any(Function)
+      );
+    });
+
+    it('should call super.destroy()', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      const superDestroySpy = vi.spyOn(Object.getPrototypeOf(Object.getPrototypeOf(toolbox)), 'destroy');
+
+      toolbox.destroy();
+
+      expect(superDestroySpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('onPopoverClose', () => {
+    it('should set opened to false and emit Closed event when popover closes', () => {
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      toolbox.opened = true;
+      const emitSpy = vi.spyOn(toolbox, 'emit');
+
+      // Simulate popover close event
+      const closeHandler = (mockPopoverInstance.on as ReturnType<typeof vi.fn>).mock.calls.find(
+        (call) => call[0] === PopoverEvent.Closed
+      )?.[1];
+
+      if (closeHandler) {
+        closeHandler();
+      }
+
+      expect(toolbox.opened).toBe(false);
+      expect(emitSpy).toHaveBeenCalledWith(ToolboxEvent.Closed);
+    });
+  });
+
+  describe('toolbox items with multiple entries', () => {
+    it('should handle tool with array toolbox config', () => {
+      const toolWithMultipleEntries = {
+        name: 'multiTool',
+        toolbox: [
+          {
+            title: 'Entry 1',
+            icon: '<svg>1</svg>',
+          },
+          {
+            title: 'Entry 2',
+            icon: '<svg>2</svg>',
+          },
+        ] as ToolboxConfigEntry[],
+      } as unknown as BlockToolAdapter;
+
+      const tools = new Map() as unknown as ToolsCollection<BlockToolAdapter>;
+
+      tools.set('multiTool', toolWithMultipleEntries);
+      tools.forEach = Map.prototype.forEach.bind(tools);
+
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools,
+        i18nLabels,
+      });
+
+      expect(toolbox.isEmpty).toBe(false);
+    });
+  });
+
+  describe('shortcuts', () => {
+    it('should enable shortcuts for tools with shortcut configuration', () => {
+      new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      expect(Shortcuts.add).toHaveBeenCalled();
+    });
+
+    it('should not enable shortcuts for tools without shortcut', () => {
+      const toolWithoutShortcut = {
+        name: 'noShortcutTool',
+        toolbox: {
+          title: 'Tool',
+          icon: '<svg></svg>',
+        },
+        shortcut: undefined,
+      } as unknown as BlockToolAdapter;
+
+      const tools = new Map() as unknown as ToolsCollection<BlockToolAdapter>;
+
+      tools.set('noShortcutTool', toolWithoutShortcut);
+      tools.forEach = Map.prototype.forEach.bind(tools);
+
+      vi.clearAllMocks();
+
+      new Toolbox({
+        api: mocks.api,
+        tools,
+        i18nLabels,
+      });
+
+      // Should not be called for tools without shortcuts
+      expect(Shortcuts.add).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('insertNewBlock', () => {
+    it('should insert block at current index when block is empty', async () => {
+      const emptyBlock = {
+        ...mocks.blockAPI,
+        isEmpty: true,
+      };
+
+      vi.mocked(mocks.api.blocks.getCurrentBlockIndex).mockReturnValue(0);
+      vi.mocked(mocks.api.blocks.getBlockByIndex).mockReturnValue(emptyBlock as BlockAPI);
+
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      await toolbox.toolButtonActivated('testTool', {});
+
+      expect(mocks.api.blocks.insert).toHaveBeenCalledWith(
+        'testTool',
+        undefined,
+        undefined,
+        0,
+        undefined,
+        true
+      );
+    });
+
+    it('should insert block at next index when block is not empty', async () => {
+      const nonEmptyBlock = {
+        ...mocks.blockAPI,
+        isEmpty: false,
+      };
+
+      vi.mocked(mocks.api.blocks.getCurrentBlockIndex).mockReturnValue(0);
+      vi.mocked(mocks.api.blocks.getBlockByIndex).mockReturnValue(nonEmptyBlock as BlockAPI);
+
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      await toolbox.toolButtonActivated('testTool', {});
+
+      expect(mocks.api.blocks.insert).toHaveBeenCalledWith(
+        'testTool',
+        undefined,
+        undefined,
+        1,
+        undefined,
+        false
+      );
+    });
+
+    it('should emit BlockAdded event after inserting block', async () => {
+      vi.mocked(mocks.api.blocks.getCurrentBlockIndex).mockReturnValue(0);
+      vi.mocked(mocks.api.blocks.getBlockByIndex).mockReturnValue(mocks.blockAPI);
+
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      const emitSpy = vi.spyOn(toolbox, 'emit');
+
+      await toolbox.toolButtonActivated('testTool', {});
+
+      expect(emitSpy).toHaveBeenCalledWith(ToolboxEvent.BlockAdded, {
+        block: mocks.blockAPI,
+      });
+    });
+
+    it('should close toolbar after inserting block', async () => {
+      vi.mocked(mocks.api.blocks.getCurrentBlockIndex).mockReturnValue(0);
+      vi.mocked(mocks.api.blocks.getBlockByIndex).mockReturnValue(mocks.blockAPI);
+
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      await toolbox.toolButtonActivated('testTool', {});
+
+      expect(mocks.api.toolbar.close).toHaveBeenCalled();
+    });
+
+    it('should not insert block when current block is null', async () => {
+      vi.mocked(mocks.api.blocks.getCurrentBlockIndex).mockReturnValue(0);
+      vi.mocked(mocks.api.blocks.getBlockByIndex).mockReturnValue(undefined);
+
+      const toolbox = new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      await toolbox.toolButtonActivated('testTool', {});
+
+      expect(mocks.api.blocks.insert).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('shortcut handler', () => {
+    it('should convert block when conversion is possible', async () => {
+      new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      const convertedBlock = { id: 'converted-block' } as BlockAPI;
+
+      vi.mocked(mocks.api.blocks.convert).mockResolvedValue(convertedBlock);
+
+      const addCalls = vi.mocked(Shortcuts.add).mock.calls;
+      const addCall = addCalls[0]?.[0];
+
+      if (addCall && addCall.handler) {
+        const event = { preventDefault: vi.fn() } as unknown as KeyboardEvent;
+
+        await addCall.handler(event);
+
+        expect(event.preventDefault).toHaveBeenCalled();
+        expect(mocks.api.blocks.convert).toHaveBeenCalled();
+        expect(mocks.api.caret.setToBlock).toHaveBeenCalledWith(convertedBlock, 'end');
+      }
+    });
+
+    it('should insert new block when conversion fails', async () => {
+      new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      vi.mocked(mocks.api.blocks.convert).mockRejectedValue(new Error('Conversion failed'));
+
+      const addCalls = vi.mocked(Shortcuts.add).mock.calls;
+      const addCall = addCalls[0]?.[0];
+
+      if (addCall && addCall.handler) {
+        const event = { preventDefault: vi.fn() } as unknown as KeyboardEvent;
+
+        await addCall.handler(event);
+
+        expect(mocks.api.blocks.insert).toHaveBeenCalled();
+      }
+    });
+
+    it('should call insertNewBlock when current block is null but it returns early', async () => {
+      new Toolbox({
+        api: mocks.api,
+        tools: mocks.tools,
+        i18nLabels,
+      });
+
+      vi.mocked(mocks.api.blocks.getCurrentBlockIndex).mockReturnValue(0);
+      vi.mocked(mocks.api.blocks.getBlockByIndex).mockReturnValue(undefined);
+
+      const addCalls = vi.mocked(Shortcuts.add).mock.calls;
+      const addCall = addCalls[0]?.[0];
+
+      if (addCall && addCall.handler) {
+        const event = { preventDefault: vi.fn() } as unknown as KeyboardEvent;
+
+        await addCall.handler(event);
+
+        // insertNewBlock is called but returns early when currentBlock is null
+        // so blocks.insert should not be called
+        expect(mocks.api.blocks.insert).not.toHaveBeenCalled();
+      }
+    });
+  });
+});
diff --git a/test/unit/utils/bem.test.ts b/test/unit/utils/bem.test.ts
new file mode 100644
index 000000000..3911d26c3
--- /dev/null
+++ b/test/unit/utils/bem.test.ts
@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+
+import { bem } from '../../../src/components/utils/bem';
+
+describe('bem', () => {
+  it('returns block class when no element or modifier is provided', () => {
+    const className = bem('ce-popover');
+
+    expect(className()).toBe('ce-popover');
+  });
+
+  it('appends element to block when element is provided', () => {
+    const className = bem('ce-popover');
+
+    expect(className('container')).toBe('ce-popover__container');
+  });
+
+  it('appends modifier to element when modifier is provided', () => {
+    const className = bem('ce-popover');
+
+    expect(className('container', 'hidden')).toBe('ce-popover__container--hidden');
+  });
+
+  it('appends modifier to block when element is not provided', () => {
+    const className = bem('ce-popover');
+
+    expect(className(null, 'hidden')).toBe('ce-popover--hidden');
+    expect(className(undefined, 'hidden')).toBe('ce-popover--hidden');
+  });
+
+  it('omits falsy element or modifier values', () => {
+    const className = bem('ce-popover');
+
+    expect(className('')).toBe('ce-popover');
+    expect(className('container', '')).toBe('ce-popover__container');
+  });
+});
+
diff --git a/test/unit/utils/blocks.test.ts b/test/unit/utils/blocks.test.ts
new file mode 100644
index 000000000..66be7128c
--- /dev/null
+++ b/test/unit/utils/blocks.test.ts
@@ -0,0 +1,995 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { BlockAPI, ToolConfig } from '../../../types';
+import type { ConversionConfig } from '../../../types/configs/conversion-config';
+import type { SavedData } from '../../../types/data-formats';
+import type { BlockToolData } from '../../../types/tools/block-tool-data';
+import type Block from '../../../src/components/block';
+import type BlockToolAdapter from '../../../src/components/tools/block';
+import {
+  isBlockConvertable,
+  isSameBlockData,
+  getConvertibleToolsForBlock,
+  areBlocksMergeable,
+  convertBlockDataToString,
+  convertStringToBlockData
+} from '../../../src/components/utils/blocks';
+
+// Mock VERSION global variable
+declare global {
+  // eslint-disable-next-line no-var
+  var VERSION: string;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-undef
+(globalThis as { VERSION?: string }).VERSION = 'test-version';
+
+/**
+ * Unit tests for blocks.ts utility functions
+ *
+ * Tests edge cases and internal functionality not covered by E2E tests
+ */
+describe('blocks utilities', () => {
+  describe('isBlockConvertable', () => {
+    it('should return true when block tool has valid export conversion config (string)', () => {
+      const mockTool = {
+        conversionConfig: {
+          export: 'text',
+        },
+      } as unknown as BlockToolAdapter;
+
+      const mockBlock = {
+        tool: mockTool,
+      } as Block;
+
+      expect(isBlockConvertable(mockBlock, 'export')).toBe(true);
+    });
+
+    it('should return true when block tool has valid export conversion config (function)', () => {
+      const mockTool = {
+        conversionConfig: {
+          export: (data: BlockToolData) => String(data),
+        },
+      } as unknown as BlockToolAdapter;
+
+      const mockBlock = {
+        tool: mockTool,
+      } as Block;
+
+      expect(isBlockConvertable(mockBlock, 'export')).toBe(true);
+    });
+
+    it('should return true when block tool has valid import conversion config (string)', () => {
+      const mockTool = {
+        conversionConfig: {
+          import: 'text',
+        },
+      } as unknown as BlockToolAdapter;
+
+      const mockBlock = {
+        tool: mockTool,
+      } as Block;
+
+      expect(isBlockConvertable(mockBlock, 'import')).toBe(true);
+    });
+
+    it('should return true when block tool has valid import conversion config (function)', () => {
+      const mockTool = {
+        conversionConfig: {
+          import: (_data: string, _config?: ToolConfig) => ({}),
+        },
+      } as unknown as BlockToolAdapter;
+
+      const mockBlock = {
+        tool: mockTool,
+      } as Block;
+
+      expect(isBlockConvertable(mockBlock, 'import')).toBe(true);
+    });
+
+    it('should return false when block tool has no conversion config', () => {
+      const mockTool = {
+        conversionConfig: undefined,
+      } as unknown as BlockToolAdapter;
+
+      const mockBlock = {
+        tool: mockTool,
+      } as Block;
+
+      expect(isBlockConvertable(mockBlock, 'export')).toBe(false);
+      expect(isBlockConvertable(mockBlock, 'import')).toBe(false);
+    });
+
+    it('should return false when block tool has conversion config but missing export', () => {
+      const mockTool = {
+        conversionConfig: {
+          import: 'text',
+        },
+      } as unknown as BlockToolAdapter;
+
+      const mockBlock = {
+        tool: mockTool,
+      } as Block;
+
+      expect(isBlockConvertable(mockBlock, 'export')).toBe(false);
+    });
+
+    it('should return false when block tool has conversion config but missing import', () => {
+      const mockTool = {
+        conversionConfig: {
+          export: 'text',
+        },
+      } as unknown as BlockToolAdapter;
+
+      const mockBlock = {
+        tool: mockTool,
+      } as Block;
+
+      expect(isBlockConvertable(mockBlock, 'import')).toBe(false);
+    });
+
+    it('should return false when block tool has invalid export type', () => {
+      const mockTool = {
+        conversionConfig: {
+          export: 123, // Invalid type
+        },
+      } as unknown as BlockToolAdapter;
+
+      const mockBlock = {
+        tool: mockTool,
+      } as Block;
+
+      expect(isBlockConvertable(mockBlock, 'export')).toBe(false);
+    });
+  });
+
+  describe('isSameBlockData', () => {
+    it('should return true when all properties of data1 exist in data2 with same values', () => {
+      const data1: BlockToolData = { level: 1 };
+      const data2: BlockToolData = {
+        text: 'Heading text',
+        level: 1,
+      };
+
+      expect(isSameBlockData(data1, data2)).toBe(true);
+    });
+
+    it('should return true when data1 has multiple properties that match data2', () => {
+      const data1: BlockToolData = {
+        level: 1,
+        text: 'Heading',
+      };
+      const data2: BlockToolData = {
+        text: 'Heading',
+        level: 1,
+        extra: 'property',
+      };
+
+      expect(isSameBlockData(data1, data2)).toBe(true);
+    });
+
+    it('should return true when data1 has property that does not exist in data2 but other properties match', () => {
+      const data1: BlockToolData = {
+        level: 1,
+        text: 'Heading',
+      };
+      const data2: BlockToolData = {
+        level: 1,
+      };
+
+      // isSameBlockData uses .some(), so it returns true if ANY property matches
+      expect(isSameBlockData(data1, data2)).toBe(true);
+    });
+
+    it('should return false when data1 has property with different value in data2', () => {
+      const data1: BlockToolData = { level: 1 };
+      const data2: BlockToolData = {
+        text: 'Heading text',
+        level: 2,
+      };
+
+      expect(isSameBlockData(data1, data2)).toBe(false);
+    });
+
+    it('should return false when data1 has property that exists in data2 but value is undefined', () => {
+      const data1: BlockToolData = { level: 1 };
+      const data2: BlockToolData = {
+        text: 'Heading text',
+        level: undefined,
+      };
+
+      expect(isSameBlockData(data1, data2)).toBe(false);
+    });
+
+    it('should return true when data1 is empty object', () => {
+      const data1: BlockToolData = {};
+      const data2: BlockToolData = {
+        text: 'Heading text',
+        level: 1,
+      };
+
+      // Empty object has no entries, so some() returns false
+      expect(isSameBlockData(data1, data2)).toBe(false);
+    });
+
+    it('should handle nested objects correctly', () => {
+      const data1: BlockToolData = {
+        config: {
+          level: 1,
+        },
+      };
+      const data2: BlockToolData = {
+        text: 'Heading',
+        config: {
+          level: 1,
+        },
+      };
+
+      expect(isSameBlockData(data1, data2)).toBe(true);
+    });
+
+    it('should handle arrays correctly', () => {
+      const arrayLength = 3;
+      const data1: BlockToolData = {
+        items: [1, 2, arrayLength],
+      };
+      const data2: BlockToolData = {
+        text: 'Heading',
+        items: [1, 2, arrayLength],
+      };
+
+      expect(isSameBlockData(data1, data2)).toBe(true);
+    });
+
+    it('should return false when arrays have different values', () => {
+      const arrayLength = 3;
+      const differentValue = 4;
+      const data1: BlockToolData = {
+        items: [1, 2, arrayLength],
+      };
+      const data2: BlockToolData = {
+        text: 'Heading',
+        items: [1, 2, differentValue],
+      };
+
+      expect(isSameBlockData(data1, data2)).toBe(false);
+    });
+  });
+
+  describe('getConvertibleToolsForBlock', () => {
+    const mockSave = vi.fn();
+    const createMockBlock = (name: string): BlockAPI => ({
+      id: 'block-1',
+      name,
+      save: mockSave,
+    } as unknown as BlockAPI);
+
+    it('should return empty array when block tool has no export conversion config', async () => {
+      const mockTool = {
+        name: 'paragraph',
+        conversionConfig: {
+          import: 'text',
+        },
+      } as unknown as BlockToolAdapter;
+
+      const allBlockTools: BlockToolAdapter[] = [ mockTool ];
+      const mockBlock = createMockBlock('paragraph');
+
+      mockSave.mockResolvedValue({
+        tool: 'paragraph',
+        data: { text: 'Test' },
+      } as SavedData);
+
+      const result = await getConvertibleToolsForBlock(mockBlock, allBlockTools);
+
+      expect(result).toEqual([]);
+    });
+
+    it('should return tools with valid import conversion config and toolbox', async () => {
+      const mockTool1 = {
+        name: 'header',
+        conversionConfig: {
+          import: 'text',
+        },
+        toolbox: [
+          {
+            icon: 'H',
+            title: 'Header',
+          },
+        ],
+      } as unknown as BlockToolAdapter;
+
+      const mockTool2 = {
+        name: 'list',
+        conversionConfig: {
+          import: 'text',
+        },
+        toolbox: [
+          {
+            icon: '•',
+            title: 'List',
+          },
+        ],
+      } as unknown as BlockToolAdapter;
+
+      const allBlockTools: BlockToolAdapter[] = [mockTool1, mockTool2];
+      const mockBlock = createMockBlock('paragraph');
+
+      mockSave.mockResolvedValue({
+        tool: 'paragraph',
+        data: { text: 'Test' },
+      } as SavedData);
+
+      const result = await getConvertibleToolsForBlock(mockBlock, allBlockTools);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].name).toBe('header');
+      expect(result[1].name).toBe('list');
+    });
+
+    it('should filter out tools without import conversion config', async () => {
+      const mockTool1 = {
+        name: 'header',
+        conversionConfig: {
+          import: 'text',
+        },
+        toolbox: [
+          {
+            icon: 'H',
+            title: 'Header',
+          },
+        ],
+      } as unknown as BlockToolAdapter;
+
+      const mockTool2 = {
+        name: 'list',
+        conversionConfig: {
+          export: 'text', // Only export, no import
+        },
+        toolbox: [
+          {
+            icon: '•',
+            title: 'List',
+          },
+        ],
+      } as unknown as BlockToolAdapter;
+
+      const allBlockTools: BlockToolAdapter[] = [mockTool1, mockTool2];
+      const mockBlock = createMockBlock('paragraph');
+
+      mockSave.mockResolvedValue({
+        tool: 'paragraph',
+        data: { text: 'Test' },
+      } as SavedData);
+
+      const result = await getConvertibleToolsForBlock(mockBlock, allBlockTools);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].name).toBe('header');
+    });
+
+    it('should filter out tools without toolbox', async () => {
+      const mockTool1 = {
+        name: 'header',
+        conversionConfig: {
+          import: 'text',
+        },
+        toolbox: [
+          {
+            icon: 'H',
+            title: 'Header',
+          },
+        ],
+      } as unknown as BlockToolAdapter;
+
+      const mockTool2 = {
+        name: 'list',
+        conversionConfig: {
+          import: 'text',
+        },
+        toolbox: undefined,
+      } as unknown as BlockToolAdapter;
+
+      const allBlockTools: BlockToolAdapter[] = [mockTool1, mockTool2];
+      const mockBlock = createMockBlock('paragraph');
+
+      mockSave.mockResolvedValue({
+        tool: 'paragraph',
+        data: { text: 'Test' },
+      } as SavedData);
+
+      const result = await getConvertibleToolsForBlock(mockBlock, allBlockTools);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].name).toBe('header');
+    });
+
+    it('should filter out toolbox items without icon', async () => {
+      const mockTool = {
+        name: 'header',
+        conversionConfig: {
+          import: 'text',
+        },
+        toolbox: [
+          {
+            icon: 'H',
+            title: 'Header',
+          },
+          {
+            title: 'Header without icon',
+          },
+        ],
+      } as unknown as BlockToolAdapter;
+
+      const allBlockTools: BlockToolAdapter[] = [ mockTool ];
+      const mockBlock = createMockBlock('paragraph');
+
+      mockSave.mockResolvedValue({
+        tool: 'paragraph',
+        data: { text: 'Test' },
+      } as SavedData);
+
+      const result = await getConvertibleToolsForBlock(mockBlock, allBlockTools);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].toolbox).toHaveLength(1);
+      expect(result[0].toolbox?.[0].icon).toBe('H');
+    });
+
+    it('should filter out toolbox items with same data as block', async () => {
+      const mockTool = {
+        name: 'header',
+        conversionConfig: {
+          import: 'text',
+        },
+        toolbox: [
+          {
+            icon: 'H1',
+            title: 'Header 1',
+            data: {
+              level: 1,
+            },
+          },
+          {
+            icon: 'H2',
+            title: 'Header 2',
+            data: {
+              level: 2,
+            },
+          },
+        ],
+      } as unknown as BlockToolAdapter;
+
+      const allBlockTools: BlockToolAdapter[] = [ mockTool ];
+      const mockBlock = createMockBlock('paragraph');
+
+      mockSave.mockResolvedValue({
+        tool: 'paragraph',
+        data: { level: 1 },
+      } as SavedData);
+
+      const result = await getConvertibleToolsForBlock(mockBlock, allBlockTools);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].toolbox).toHaveLength(1);
+      expect(result[0].toolbox?.[0].icon).toBe('H2');
+    });
+
+    it('should filter out tool with same name as block when toolbox item has no data', async () => {
+      const mockTool = {
+        name: 'paragraph',
+        conversionConfig: {
+          import: 'text',
+        },
+        toolbox: [
+          {
+            icon: 'P',
+            title: 'Paragraph',
+          },
+        ],
+      } as unknown as BlockToolAdapter;
+
+      const allBlockTools: BlockToolAdapter[] = [ mockTool ];
+      const mockBlock = createMockBlock('paragraph');
+
+      mockSave.mockResolvedValue({
+        tool: 'paragraph',
+        data: { text: 'Test' },
+      } as SavedData);
+
+      const result = await getConvertibleToolsForBlock(mockBlock, allBlockTools);
+
+      expect(result).toHaveLength(0);
+    });
+
+    it('should include tool with same name if toolbox item has different data', async () => {
+      const mockTool = {
+        name: 'header',
+        conversionConfig: {
+          export: 'text', // Need export config for the block tool
+          import: 'text',
+        },
+        toolbox: [
+          {
+            icon: 'H1',
+            title: 'Header 1',
+            data: {
+              level: 1,
+            },
+          },
+          {
+            icon: 'H2',
+            title: 'Header 2',
+            data: {
+              level: 2,
+            },
+          },
+        ],
+      } as unknown as BlockToolAdapter;
+
+      const allBlockTools: BlockToolAdapter[] = [ mockTool ];
+      const mockBlock = createMockBlock('header');
+
+      mockSave.mockResolvedValue({
+        tool: 'header',
+        data: { level: 1 },
+      } as SavedData);
+
+      const result = await getConvertibleToolsForBlock(mockBlock, allBlockTools);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].toolbox).toHaveLength(1);
+      expect(result[0].toolbox?.[0].icon).toBe('H2');
+    });
+
+    it('should filter out empty toolbox items', async () => {
+      const mockTool = {
+        name: 'header',
+        conversionConfig: {
+          import: 'text',
+        },
+        toolbox: [
+          {
+            icon: 'H',
+            title: 'Header',
+          },
+          {},
+        ],
+      } as unknown as BlockToolAdapter;
+
+      const allBlockTools: BlockToolAdapter[] = [ mockTool ];
+      const mockBlock = createMockBlock('paragraph');
+
+      mockSave.mockResolvedValue({
+        tool: 'paragraph',
+        data: { text: 'Test' },
+      } as SavedData);
+
+      const result = await getConvertibleToolsForBlock(mockBlock, allBlockTools);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].toolbox).toHaveLength(1);
+    });
+
+    it('should return empty array when block tool is not found but has no export config', async () => {
+      const mockTool = {
+        name: 'header',
+        conversionConfig: {
+          import: 'text',
+        },
+        toolbox: [
+          {
+            icon: 'H',
+            title: 'Header',
+          },
+        ],
+      } as unknown as BlockToolAdapter;
+
+      const allBlockTools: BlockToolAdapter[] = [ mockTool ];
+      const mockBlock = createMockBlock('unknown-tool');
+
+      mockSave.mockResolvedValue({
+        tool: 'unknown-tool',
+        data: { text: 'Test' },
+      } as SavedData);
+
+      const result = await getConvertibleToolsForBlock(mockBlock, allBlockTools);
+
+      // Should still return tools since block tool is not found (undefined)
+      expect(result).toHaveLength(1);
+    });
+  });
+
+  describe('areBlocksMergeable', () => {
+    it('should return true when blocks have same name and target is mergeable', () => {
+      const mockTool = {
+        name: 'paragraph',
+      } as unknown as BlockToolAdapter;
+
+      const targetBlock = {
+        name: 'paragraph',
+        mergeable: true,
+        tool: mockTool,
+      } as Block;
+
+      const blockToMerge = {
+        name: 'paragraph',
+        tool: mockTool,
+      } as Block;
+
+      expect(areBlocksMergeable(targetBlock, blockToMerge)).toBe(true);
+    });
+
+    it('should return false when target block is not mergeable', () => {
+      const mockTool = {
+        name: 'paragraph',
+      } as unknown as BlockToolAdapter;
+
+      const targetBlock = {
+        name: 'paragraph',
+        mergeable: false,
+        tool: mockTool,
+      } as Block;
+
+      const blockToMerge = {
+        name: 'paragraph',
+        tool: mockTool,
+      } as Block;
+
+      expect(areBlocksMergeable(targetBlock, blockToMerge)).toBe(false);
+    });
+
+    it('should return true when blocks have different names but valid conversion configs', () => {
+      const mockTool1 = {
+        name: 'paragraph',
+        conversionConfig: {
+          export: 'text',
+        },
+      } as unknown as BlockToolAdapter;
+
+      const mockTool2 = {
+        name: 'header',
+        conversionConfig: {
+          import: 'text',
+        },
+      } as unknown as BlockToolAdapter;
+
+      const targetBlock = {
+        name: 'header',
+        mergeable: true,
+        tool: mockTool2,
+      } as Block;
+
+      const blockToMerge = {
+        name: 'paragraph',
+        tool: mockTool1,
+      } as Block;
+
+      expect(areBlocksMergeable(targetBlock, blockToMerge)).toBe(true);
+    });
+
+    it('should return false when blocks have different names and blockToMerge has no export config', () => {
+      const mockTool1 = {
+        name: 'paragraph',
+        conversionConfig: undefined,
+      } as unknown as BlockToolAdapter;
+
+      const mockTool2 = {
+        name: 'header',
+        conversionConfig: {
+          import: 'text',
+        },
+      } as unknown as BlockToolAdapter;
+
+      const targetBlock = {
+        name: 'header',
+        mergeable: true,
+        tool: mockTool2,
+      } as Block;
+
+      const blockToMerge = {
+        name: 'paragraph',
+        tool: mockTool1,
+      } as Block;
+
+      expect(areBlocksMergeable(targetBlock, blockToMerge)).toBe(false);
+    });
+
+    it('should return false when blocks have different names and target has no import config', () => {
+      const mockTool1 = {
+        name: 'paragraph',
+        conversionConfig: {
+          export: 'text',
+        },
+      } as unknown as BlockToolAdapter;
+
+      const mockTool2 = {
+        name: 'header',
+        conversionConfig: undefined,
+      } as unknown as BlockToolAdapter;
+
+      const targetBlock = {
+        name: 'header',
+        mergeable: true,
+        tool: mockTool2,
+      } as Block;
+
+      const blockToMerge = {
+        name: 'paragraph',
+        tool: mockTool1,
+      } as Block;
+
+      expect(areBlocksMergeable(targetBlock, blockToMerge)).toBe(false);
+    });
+
+    it('should return false when blocks have different names and both have invalid conversion configs', () => {
+      const mockTool1 = {
+        name: 'paragraph',
+        conversionConfig: {
+          export: 123, // Invalid type
+        },
+      } as unknown as BlockToolAdapter;
+
+      const mockTool2 = {
+        name: 'header',
+        conversionConfig: {
+          import: 123, // Invalid type
+        },
+      } as unknown as BlockToolAdapter;
+
+      const targetBlock = {
+        name: 'header',
+        mergeable: true,
+        tool: mockTool2,
+      } as Block;
+
+      const blockToMerge = {
+        name: 'paragraph',
+        tool: mockTool1,
+      } as Block;
+
+      expect(areBlocksMergeable(targetBlock, blockToMerge)).toBe(false);
+    });
+  });
+
+  describe('convertBlockDataToString', () => {
+    it('should convert block data to string using function export', () => {
+      const blockData: BlockToolData = {
+        text: 'Hello',
+        level: 1,
+      };
+
+      const conversionConfig: ConversionConfig = {
+        export: (data: BlockToolData) => {
+          return String(data.text);
+        },
+      };
+
+      const result = convertBlockDataToString(blockData, conversionConfig);
+
+      expect(result).toBe('Hello');
+    });
+
+    it('should convert block data to string using string export', () => {
+      const blockData: BlockToolData = {
+        text: 'Hello',
+        level: 1,
+      };
+
+      const conversionConfig: ConversionConfig = {
+        export: 'text',
+      };
+
+      const result = convertBlockDataToString(blockData, conversionConfig);
+
+      expect(result).toBe('Hello');
+    });
+
+    it('should return empty string when conversion config is undefined', () => {
+      const blockData: BlockToolData = {
+        text: 'Hello',
+      };
+
+      const result = convertBlockDataToString(blockData);
+
+      expect(result).toBe('');
+    });
+
+    it('should return empty string when export is undefined', () => {
+      const blockData: BlockToolData = {
+        text: 'Hello',
+      };
+
+      const conversionConfig: ConversionConfig = {
+        import: 'text',
+      };
+
+      const result = convertBlockDataToString(blockData, conversionConfig);
+
+      expect(result).toBe('');
+    });
+
+    it('should return empty string and log warning when export has invalid type', () => {
+      const blockData: BlockToolData = {
+        text: 'Hello',
+      };
+
+      const conversionConfig = {
+        export: 123, // Invalid type
+      } as unknown as ConversionConfig;
+
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      const result = convertBlockDataToString(blockData, conversionConfig);
+
+      expect(result).toBe('');
+      expect(logSpy).toHaveBeenCalled();
+
+      logSpy.mockRestore();
+    });
+
+    it('should handle function export with complex data', () => {
+      const itemCount = 3;
+      const blockData: BlockToolData = {
+        items: ['a', 'b', 'c'],
+        count: itemCount,
+      };
+
+      const conversionConfig: ConversionConfig = {
+        export: (data: BlockToolData) => {
+          const items = (data.items as string[]) || [];
+
+          return items.join(', ');
+        },
+      };
+
+      const result = convertBlockDataToString(blockData, conversionConfig);
+
+      expect(result).toBe('a, b, c');
+    });
+
+    it('should handle string export with nested property', () => {
+      const blockData: BlockToolData = {
+        content: {
+          text: 'Hello',
+        },
+      };
+
+      const conversionConfig: ConversionConfig = {
+        export: 'content',
+      };
+
+      const result = convertBlockDataToString(blockData, conversionConfig);
+
+      expect(result).toEqual({ text: 'Hello' });
+    });
+  });
+
+  describe('convertStringToBlockData', () => {
+    it('should convert string to block data using function import', () => {
+      const stringToImport = 'Hello';
+      const conversionConfig: ConversionConfig = {
+        import: (content: string) => {
+          return {
+            text: content,
+          };
+        },
+      };
+
+      const result = convertStringToBlockData(stringToImport, conversionConfig);
+
+      expect(result).toEqual({ text: 'Hello' });
+    });
+
+    it('should convert string to block data using function import with tool config', () => {
+      const stringToImport = 'Hello';
+      const toolConfig: ToolConfig = {
+        placeholder: 'Enter text',
+      };
+
+      const conversionConfig: ConversionConfig = {
+        import: (content: string, config?: ToolConfig) => {
+          return {
+            text: content,
+            placeholder: config?.placeholder,
+          };
+        },
+      };
+
+      const result = convertStringToBlockData(stringToImport, conversionConfig, toolConfig);
+
+      expect(result).toEqual({
+        text: 'Hello',
+        placeholder: 'Enter text',
+      });
+    });
+
+    it('should convert string to block data using string import', () => {
+      const stringToImport = 'Hello';
+      const conversionConfig: ConversionConfig = {
+        import: 'text',
+      };
+
+      const result = convertStringToBlockData(stringToImport, conversionConfig);
+
+      expect(result).toEqual({ text: 'Hello' });
+    });
+
+    it('should return empty object when conversion config is undefined', () => {
+      const stringToImport = 'Hello';
+
+      const result = convertStringToBlockData(stringToImport);
+
+      expect(result).toEqual({});
+    });
+
+    it('should return empty object when import is undefined', () => {
+      const stringToImport = 'Hello';
+
+      const conversionConfig: ConversionConfig = {
+        export: 'text',
+      };
+
+      const result = convertStringToBlockData(stringToImport, conversionConfig);
+
+      expect(result).toEqual({});
+    });
+
+    it('should return empty object and log warning when import has invalid type', () => {
+      const stringToImport = 'Hello';
+
+      const conversionConfig = {
+        import: 123, // Invalid type
+      } as unknown as ConversionConfig;
+
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      const result = convertStringToBlockData(stringToImport, conversionConfig);
+
+      expect(result).toEqual({});
+      expect(logSpy).toHaveBeenCalled();
+
+      logSpy.mockRestore();
+    });
+
+    it('should handle function import with complex transformation', () => {
+      const stringToImport = 'a, b, c';
+
+      const conversionConfig: ConversionConfig = {
+        import: (content: string) => {
+          return {
+            items: content.split(', '),
+            count: content.split(', ').length,
+          };
+        },
+      };
+
+      const result = convertStringToBlockData(stringToImport, conversionConfig);
+
+      expect(result).toEqual({
+        items: ['a', 'b', 'c'],
+        count: 3,
+      });
+    });
+
+    it('should handle function import without tool config', () => {
+      const stringToImport = 'Hello';
+
+      const conversionConfig: ConversionConfig = {
+        import: (content: string, config?: ToolConfig) => {
+          return {
+            text: content,
+            hasConfig: config !== undefined,
+          };
+        },
+      };
+
+      const result = convertStringToBlockData(stringToImport, conversionConfig);
+
+      expect(result).toEqual({
+        text: 'Hello',
+        hasConfig: false,
+      });
+    });
+  });
+});
+
diff --git a/test/unit/utils/caret.test.ts b/test/unit/utils/caret.test.ts
new file mode 100644
index 000000000..f31fd71ec
--- /dev/null
+++ b/test/unit/utils/caret.test.ts
@@ -0,0 +1,654 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  getCaretNodeAndOffset,
+  checkContenteditableSliceForEmptiness,
+  isCaretAtStartOfInput,
+  isCaretAtEndOfInput
+} from '../../../src/components/utils/caret';
+
+/**
+ * Unit tests for caret.ts utility functions
+ *
+ * Tests edge cases and internal functionality not covered by E2E tests
+ */
+describe('caret utilities', () => {
+  const containerState = { element: null as HTMLElement | null };
+
+  beforeEach(() => {
+    containerState.element = document.createElement('div');
+    document.body.appendChild(containerState.element);
+  });
+
+  afterEach(() => {
+    // Clear selection
+    window.getSelection()?.removeAllRanges();
+    if (containerState.element) {
+      containerState.element.remove();
+      containerState.element = null;
+    }
+  });
+
+  const getContainer = (): HTMLElement => {
+    if (!containerState.element) {
+      throw new Error('Container not initialized');
+    }
+
+    return containerState.element;
+  };
+
+  /**
+   * Helper function to set up selection in jsdom
+   * jsdom has limited Selection API support, so we need to manually set focusNode and focusOffset
+   *
+   * @param node - The node where the selection should be set
+   * @param offset - The offset within the node where the selection should be set
+   */
+  const setupSelection = (node: Node, offset: number): void => {
+    const range = document.createRange();
+
+    range.setStart(node, offset);
+    range.setEnd(node, offset);
+
+    const selection = window.getSelection();
+
+    if (!selection) {
+      return;
+    }
+
+    selection.removeAllRanges();
+    selection.addRange(range);
+
+    // jsdom doesn't properly set focusNode/focusOffset, so we need to set them manually
+    Object.defineProperty(selection, 'focusNode', {
+      value: node,
+      writable: true,
+      configurable: true,
+    });
+
+    Object.defineProperty(selection, 'focusOffset', {
+      value: offset,
+      writable: true,
+      configurable: true,
+    });
+
+    Object.defineProperty(selection, 'anchorNode', {
+      value: node,
+      writable: true,
+      configurable: true,
+    });
+
+    Object.defineProperty(selection, 'anchorOffset', {
+      value: offset,
+      writable: true,
+      configurable: true,
+    });
+
+    // Focus the element if it's an HTMLElement
+    if (node.nodeType === Node.ELEMENT_NODE) {
+      (node as HTMLElement).focus?.();
+    } else if (node.parentElement) {
+      node.parentElement.focus?.();
+    }
+  };
+
+  describe('getCaretNodeAndOffset', () => {
+    it('should return [null, 0] when selection is null', () => {
+      // Mock window.getSelection to return null
+      const originalGetSelection = window.getSelection;
+
+      window.getSelection = () => null;
+
+      const result = getCaretNodeAndOffset();
+
+      expect(result).toEqual([null, 0]);
+
+      window.getSelection = originalGetSelection;
+    });
+
+    it('should return [null, 0] when focusNode is null', () => {
+      const selection = window.getSelection();
+
+      if (!selection) {
+        return;
+      }
+
+      // Create a mock selection with null focusNode
+      const range = document.createRange();
+      const textNode = document.createTextNode('test');
+
+      getContainer().appendChild(textNode);
+      range.setStart(textNode, 0);
+      range.setEnd(textNode, 0);
+      selection.removeAllRanges();
+      selection.addRange(range);
+
+      // Manually set focusNode to null (simulating edge case)
+      Object.defineProperty(selection, 'focusNode', {
+        value: null,
+        writable: true,
+        configurable: true,
+      });
+
+      const result = getCaretNodeAndOffset();
+
+      expect(result).toEqual([null, 0]);
+    });
+
+    it('should return text node and offset when focusNode is a text node', () => {
+      const textNode = document.createTextNode('Hello world');
+
+      const CARET_OFFSET = 5;
+
+      getContainer().appendChild(textNode);
+      getContainer().focus();
+
+      setupSelection(textNode, CARET_OFFSET);
+
+      const [node, offset] = getCaretNodeAndOffset();
+
+      expect(node).toBe(textNode);
+      expect(offset).toBe(CARET_OFFSET);
+    });
+
+    it('should return child node when focusNode is an element with children', () => {
+      const div = document.createElement('div');
+      const textNode = document.createTextNode('Hello');
+
+      div.appendChild(textNode);
+      getContainer().appendChild(div);
+      div.focus();
+
+      setupSelection(div, 0);
+
+      const [node, offset] = getCaretNodeAndOffset();
+
+      expect(node).toBe(textNode);
+      expect(offset).toBe(0);
+    });
+
+    it('should handle Firefox edge case when focusOffset is 1 with single child', () => {
+      const div = document.createElement('div');
+      const textNode = document.createTextNode('Hello');
+
+      div.appendChild(textNode);
+      getContainer().appendChild(div);
+      div.focus();
+
+      setupSelection(div, 1);
+
+      const [node, offset] = getCaretNodeAndOffset();
+
+      expect(node).toBe(textNode);
+      expect(offset).toBe(textNode.textContent?.length ?? 0);
+    });
+
+    it('should return element and offset when element has no children', () => {
+      const div = document.createElement('div');
+
+      getContainer().appendChild(div);
+      div.focus();
+
+      setupSelection(div, 0);
+
+      const [node, offset] = getCaretNodeAndOffset();
+
+      expect(node).toBe(div);
+      expect(offset).toBe(0);
+    });
+  });
+
+  describe('checkContenteditableSliceForEmptiness', () => {
+    it('should return true for left direction when content is empty', () => {
+      const contenteditable = document.createElement('div');
+
+      contenteditable.contentEditable = 'true';
+      const textNode = document.createTextNode('Hello');
+
+      contenteditable.appendChild(textNode);
+      getContainer().appendChild(contenteditable);
+
+      const result = checkContenteditableSliceForEmptiness(contenteditable, textNode, 0, 'left');
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false for left direction when content has visible text', () => {
+      const contenteditable = document.createElement('div');
+
+      contenteditable.contentEditable = 'true';
+      const textNode1 = document.createTextNode('Hello');
+      const textNode2 = document.createTextNode(' World');
+
+      contenteditable.appendChild(textNode1);
+      contenteditable.appendChild(textNode2);
+      getContainer().appendChild(contenteditable);
+
+      const result = checkContenteditableSliceForEmptiness(contenteditable, textNode2, 0, 'left');
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true for left direction when content has only whitespace', () => {
+      const contenteditable = document.createElement('div');
+
+      contenteditable.contentEditable = 'true';
+      const textNode1 = document.createTextNode('   \t\n');
+      const textNode2 = document.createTextNode('Hello');
+
+      contenteditable.appendChild(textNode1);
+      contenteditable.appendChild(textNode2);
+      getContainer().appendChild(contenteditable);
+
+      const result = checkContenteditableSliceForEmptiness(contenteditable, textNode2, 0, 'left');
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true for left direction when content has only non-breaking spaces', () => {
+      const contenteditable = document.createElement('div');
+
+      contenteditable.contentEditable = 'true';
+      const textNode1 = document.createTextNode('\u00A0\u00A0\u00A0'); // Non-breaking spaces
+      const textNode2 = document.createTextNode('Hello');
+
+      contenteditable.appendChild(textNode1);
+      contenteditable.appendChild(textNode2);
+      getContainer().appendChild(contenteditable);
+
+      // Non-breaking spaces are visible, so should return false
+      const result = checkContenteditableSliceForEmptiness(contenteditable, textNode2, 0, 'left');
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true for right direction when content is empty', () => {
+      const contenteditable = document.createElement('div');
+
+      contenteditable.contentEditable = 'true';
+      const textNode = document.createTextNode('Hello');
+
+      contenteditable.appendChild(textNode);
+      getContainer().appendChild(contenteditable);
+
+      const result = checkContenteditableSliceForEmptiness(contenteditable, textNode, textNode.length, 'right');
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false for right direction when content has visible text', () => {
+      const contenteditable = document.createElement('div');
+
+      contenteditable.contentEditable = 'true';
+      const textNode1 = document.createTextNode('Hello');
+      const textNode2 = document.createTextNode(' World');
+
+      contenteditable.appendChild(textNode1);
+      contenteditable.appendChild(textNode2);
+      getContainer().appendChild(contenteditable);
+
+      const result = checkContenteditableSliceForEmptiness(contenteditable, textNode1, textNode1.length, 'right');
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true for right direction when content has only whitespace', () => {
+      const contenteditable = document.createElement('div');
+
+      contenteditable.contentEditable = 'true';
+      const textNode1 = document.createTextNode('Hello');
+      const textNode2 = document.createTextNode('   \t\n');
+
+      contenteditable.appendChild(textNode1);
+      contenteditable.appendChild(textNode2);
+      getContainer().appendChild(contenteditable);
+
+      const result = checkContenteditableSliceForEmptiness(contenteditable, textNode1, textNode1.length, 'right');
+
+      expect(result).toBe(true);
+    });
+
+    it('should handle nested elements correctly for left direction', () => {
+      const contenteditable = document.createElement('div');
+
+      contenteditable.contentEditable = 'true';
+      const span = document.createElement('span');
+      const textNode = document.createTextNode('Hello');
+
+      span.appendChild(textNode);
+      contenteditable.appendChild(span);
+      getContainer().appendChild(contenteditable);
+
+      const result = checkContenteditableSliceForEmptiness(contenteditable, textNode, 0, 'left');
+
+      expect(result).toBe(true);
+    });
+
+    it('should handle nested elements correctly for right direction', () => {
+      const contenteditable = document.createElement('div');
+
+      contenteditable.contentEditable = 'true';
+      const span = document.createElement('span');
+      const textNode = document.createTextNode('Hello');
+
+      span.appendChild(textNode);
+      contenteditable.appendChild(span);
+      getContainer().appendChild(contenteditable);
+
+      const result = checkContenteditableSliceForEmptiness(contenteditable, textNode, textNode.length, 'right');
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('isCaretAtStartOfInput', () => {
+    it('should return true for empty input', () => {
+      const input = document.createElement('div');
+
+      input.contentEditable = 'true';
+      getContainer().appendChild(input);
+
+      const result = isCaretAtStartOfInput(input);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true for native input at start', () => {
+      const input = document.createElement('input');
+
+      input.type = 'text';
+      input.value = 'Hello';
+      getContainer().appendChild(input);
+      input.focus();
+      input.setSelectionRange(0, 0);
+
+      const result = isCaretAtStartOfInput(input);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false for native input not at start', () => {
+      const input = document.createElement('input');
+      const CARET_POSITION = 3;
+
+      input.type = 'text';
+      input.value = 'Hello';
+      getContainer().appendChild(input);
+      input.focus();
+      input.setSelectionRange(CARET_POSITION, CARET_POSITION);
+
+      const result = isCaretAtStartOfInput(input);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true for contenteditable at start with offset 0', () => {
+      const input = document.createElement('div');
+
+      input.contentEditable = 'true';
+      const textNode = document.createTextNode('Hello');
+
+      input.appendChild(textNode);
+      getContainer().appendChild(input);
+      input.focus();
+
+      setupSelection(textNode, 0);
+
+      const result = isCaretAtStartOfInput(input);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false for contenteditable not at start', () => {
+      const input = document.createElement('div');
+      const CARET_POSITION = 3;
+
+      input.contentEditable = 'true';
+      const textNode = document.createTextNode('Hello');
+
+      input.appendChild(textNode);
+      getContainer().appendChild(input);
+      input.focus();
+
+      setupSelection(textNode, CARET_POSITION);
+
+      const result = isCaretAtStartOfInput(input);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false when there is no selection', () => {
+      const input = document.createElement('div');
+
+      input.contentEditable = 'true';
+      const textNode = document.createTextNode('Hello');
+
+      input.appendChild(textNode);
+      getContainer().appendChild(input);
+
+      const selection = window.getSelection();
+
+      if (selection) {
+        selection.removeAllRanges();
+        // Clear selection properties to simulate no selection
+        Object.defineProperty(selection, 'focusNode', {
+          value: null,
+          writable: true,
+          configurable: true,
+        });
+        Object.defineProperty(selection, 'focusOffset', {
+          value: 0,
+          writable: true,
+          configurable: true,
+        });
+      }
+
+      const result = isCaretAtStartOfInput(input);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true when caret is after whitespace-only content', () => {
+      const input = document.createElement('div');
+
+      input.contentEditable = 'true';
+      const textNode1 = document.createTextNode('   \t\n');
+      const textNode2 = document.createTextNode('Hello');
+
+      input.appendChild(textNode1);
+      input.appendChild(textNode2);
+      getContainer().appendChild(input);
+      input.focus();
+
+      setupSelection(textNode2, 0);
+
+      const result = isCaretAtStartOfInput(input);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false when caret is after visible content', () => {
+      const input = document.createElement('div');
+
+      input.contentEditable = 'true';
+      const textNode1 = document.createTextNode('Hello');
+      const textNode2 = document.createTextNode(' World');
+
+      input.appendChild(textNode1);
+      input.appendChild(textNode2);
+      getContainer().appendChild(input);
+      input.focus();
+
+      setupSelection(textNode2, 0);
+
+      const result = isCaretAtStartOfInput(input);
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('isCaretAtEndOfInput', () => {
+    it('should return true for empty input', () => {
+      const input = document.createElement('div');
+
+      input.contentEditable = 'true';
+      getContainer().appendChild(input);
+
+      const result = isCaretAtEndOfInput(input);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true for native input at end', () => {
+      const input = document.createElement('input');
+
+      input.type = 'text';
+      input.value = 'Hello';
+      getContainer().appendChild(input);
+      input.focus();
+      input.setSelectionRange(input.value.length, input.value.length);
+
+      const result = isCaretAtEndOfInput(input);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false for native input not at end', () => {
+      const input = document.createElement('input');
+      const CARET_POSITION = 3;
+
+      input.type = 'text';
+      input.value = 'Hello';
+      getContainer().appendChild(input);
+      input.focus();
+      input.setSelectionRange(CARET_POSITION, CARET_POSITION);
+
+      const result = isCaretAtEndOfInput(input);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true for contenteditable at end', () => {
+      const input = document.createElement('div');
+
+      input.contentEditable = 'true';
+      const textNode = document.createTextNode('Hello');
+
+      input.appendChild(textNode);
+      getContainer().appendChild(input);
+      input.focus();
+
+      setupSelection(textNode, textNode.length);
+
+      const result = isCaretAtEndOfInput(input);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false for contenteditable not at end', () => {
+      const input = document.createElement('div');
+      const CARET_POSITION = 3;
+
+      input.contentEditable = 'true';
+      const textNode = document.createTextNode('Hello');
+
+      input.appendChild(textNode);
+      getContainer().appendChild(input);
+      input.focus();
+
+      setupSelection(textNode, CARET_POSITION);
+
+      const result = isCaretAtEndOfInput(input);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false when there is no selection', () => {
+      const input = document.createElement('div');
+
+      input.contentEditable = 'true';
+      const textNode = document.createTextNode('Hello');
+
+      input.appendChild(textNode);
+      getContainer().appendChild(input);
+
+      const selection = window.getSelection();
+
+      if (selection) {
+        selection.removeAllRanges();
+        // Clear selection properties to simulate no selection
+        Object.defineProperty(selection, 'focusNode', {
+          value: null,
+          writable: true,
+          configurable: true,
+        });
+        Object.defineProperty(selection, 'focusOffset', {
+          value: 0,
+          writable: true,
+          configurable: true,
+        });
+      }
+
+      const result = isCaretAtEndOfInput(input);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true when caret is before whitespace-only content', () => {
+      const input = document.createElement('div');
+
+      input.contentEditable = 'true';
+      const textNode1 = document.createTextNode('Hello');
+      const textNode2 = document.createTextNode('   \t\n');
+
+      input.appendChild(textNode1);
+      input.appendChild(textNode2);
+      getContainer().appendChild(input);
+      input.focus();
+
+      setupSelection(textNode1, textNode1.length);
+
+      const result = isCaretAtEndOfInput(input);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false when caret is before visible content', () => {
+      const input = document.createElement('div');
+
+      input.contentEditable = 'true';
+      const textNode1 = document.createTextNode('Hello');
+      const textNode2 = document.createTextNode(' World');
+
+      input.appendChild(textNode1);
+      input.appendChild(textNode2);
+      getContainer().appendChild(input);
+      input.focus();
+
+      setupSelection(textNode1, textNode1.length);
+
+      const result = isCaretAtEndOfInput(input);
+
+      expect(result).toBe(false);
+    });
+
+    it('should handle nested elements correctly', () => {
+      const input = document.createElement('div');
+
+      input.contentEditable = 'true';
+      const span = document.createElement('span');
+      const textNode = document.createTextNode('Hello');
+
+      span.appendChild(textNode);
+      input.appendChild(span);
+      getContainer().appendChild(input);
+      input.focus();
+
+      setupSelection(textNode, textNode.length);
+
+      const result = isCaretAtEndOfInput(input);
+
+      expect(result).toBe(true);
+    });
+  });
+});
+
diff --git a/test/unit/utils/listeners.test.ts b/test/unit/utils/listeners.test.ts
new file mode 100644
index 000000000..6223ffeb7
--- /dev/null
+++ b/test/unit/utils/listeners.test.ts
@@ -0,0 +1,170 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import Listeners, { type ListenerData } from '../../../src/components/utils/listeners';
+import * as Utils from '../../../src/components/utils';
+
+const getStoredListeners = (instance: Listeners): ListenerData[] => {
+  return (instance as unknown as { allListeners: ListenerData[] }).allListeners;
+};
+
+describe('Listeners', () => {
+  let listeners: Listeners;
+  let element: HTMLDivElement;
+
+  beforeEach(() => {
+    listeners = new Listeners();
+    element = document.createElement('div');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('registers a listener and returns generated id', () => {
+    const generateIdSpy = vi.spyOn(Utils, 'generateId').mockReturnValue('l-test');
+    const addEventListenerSpy = vi.spyOn(element, 'addEventListener');
+    const handler = vi.fn<[Event], void>();
+
+    const id = listeners.on(element, 'click', handler);
+
+    expect(generateIdSpy).toHaveBeenCalledWith('l');
+    expect(id).toBe('l-test');
+    expect(addEventListenerSpy).toHaveBeenCalledTimes(1);
+    expect(addEventListenerSpy).toHaveBeenCalledWith('click', handler, false);
+
+    const storedListeners = getStoredListeners(listeners);
+
+    expect(storedListeners).toHaveLength(1);
+    const [ stored ] = storedListeners;
+
+    expect(stored.id).toBe('l-test');
+    expect(stored.element).toBe(element);
+    expect(stored.eventType).toBe('click');
+    expect(stored.handler).toBe(handler);
+    expect(stored.options).toBe(false);
+  });
+
+  it('does not register duplicate listeners for the same element, event and handler', () => {
+    vi.spyOn(Utils, 'generateId')
+      .mockReturnValueOnce('first-id')
+      .mockReturnValueOnce('second-id');
+    const addEventListenerSpy = vi.spyOn(element, 'addEventListener');
+    const handler = vi.fn<[Event], void>();
+
+    const firstId = listeners.on(element, 'click', handler);
+    const secondId = listeners.on(element, 'click', handler);
+
+    expect(firstId).toBe('first-id');
+    expect(secondId).toBeUndefined();
+    expect(addEventListenerSpy).toHaveBeenCalledTimes(1);
+    expect(getStoredListeners(listeners)).toHaveLength(1);
+  });
+
+  it('removes a specific listener with matching handler and event type', () => {
+    vi.spyOn(Utils, 'generateId').mockReturnValue('listener-id');
+    const addEventListenerSpy = vi.spyOn(element, 'addEventListener');
+    const removeEventListenerSpy = vi.spyOn(element, 'removeEventListener');
+    const handler = vi.fn<[Event], void>();
+    const options: AddEventListenerOptions = { capture: true,
+      once: true };
+
+    listeners.on(element, 'keydown', handler, options);
+
+    expect(addEventListenerSpy).toHaveBeenCalledWith('keydown', handler, options);
+
+    listeners.off(element, 'keydown', handler);
+
+    expect(removeEventListenerSpy).toHaveBeenCalledWith('keydown', handler, options);
+    expect(getStoredListeners(listeners)).toHaveLength(0);
+  });
+
+  it('removes all listeners for an element and event when handler is omitted', () => {
+    const handlerA = vi.fn<[Event], void>();
+    const handlerB = vi.fn<[Event], void>();
+
+    listeners.on(element, 'mousemove', handlerA);
+    listeners.on(element, 'mousemove', handlerB);
+    const removeEventListenerSpy = vi.spyOn(element, 'removeEventListener');
+
+    listeners.off(element, 'mousemove');
+
+    expect(removeEventListenerSpy).toHaveBeenCalledTimes(2);
+    expect(removeEventListenerSpy).toHaveBeenCalledWith('mousemove', handlerA, false);
+    expect(removeEventListenerSpy).toHaveBeenCalledWith('mousemove', handlerB, false);
+    expect(getStoredListeners(listeners)).toHaveLength(0);
+  });
+
+  it('removes a listener by its id', () => {
+    vi.spyOn(Utils, 'generateId').mockReturnValue('listener-id');
+    const handler = vi.fn<[Event], void>();
+    const removeEventListenerSpy = vi.spyOn(element, 'removeEventListener');
+
+    const id = listeners.on(element, 'wheel', handler);
+
+    if (!id) {
+      throw new Error('Listener id should be defined');
+    }
+
+    listeners.offById(id);
+
+    expect(removeEventListenerSpy).toHaveBeenCalledWith('wheel', handler, false);
+    expect(getStoredListeners(listeners)).toHaveLength(0);
+  });
+
+  it('finds the first matching listener', () => {
+    const handlerA = vi.fn<[Event], void>();
+    const handlerB = vi.fn<[Event], void>();
+
+    listeners.on(element, 'click', handlerA);
+    listeners.on(element, 'click', handlerB);
+
+    const found = listeners.findOne(element, 'click');
+
+    expect(found).not.toBeNull();
+    expect(found?.handler).toBe(handlerA);
+  });
+
+  it('returns null when listener is not found', () => {
+    const found = listeners.findOne(element, 'scroll');
+
+    expect(found).toBeNull();
+  });
+
+  it('returns all listeners for the provided element when event type is omitted', () => {
+    const secondHandler = vi.fn<[Event], void>();
+
+    listeners.on(element, 'click', vi.fn<[Event], void>());
+    listeners.on(element, 'keydown', secondHandler);
+
+    const found = listeners.findAll(element);
+
+    expect(found).toHaveLength(2);
+    expect(found.map((item) => item.eventType)).toEqual(expect.arrayContaining(['click', 'keydown']));
+  });
+
+  it('removes every registered listener on removeAll', () => {
+    const otherElement = document.createElement('button');
+    const clickHandler = vi.fn<[Event], void>();
+    const keydownHandler = vi.fn<[Event], void>();
+
+    listeners.on(element, 'click', clickHandler);
+    listeners.on(otherElement, 'keydown', keydownHandler);
+    const removeEventListenerSpyElement = vi.spyOn(element, 'removeEventListener');
+    const removeEventListenerSpyOther = vi.spyOn(otherElement, 'removeEventListener');
+
+    listeners.removeAll();
+
+    expect(removeEventListenerSpyElement).toHaveBeenCalledWith('click', clickHandler, false);
+    expect(removeEventListenerSpyOther).toHaveBeenCalledWith('keydown', keydownHandler, false);
+    expect(getStoredListeners(listeners)).toHaveLength(0);
+  });
+
+  it('invokes removeAll on destroy', () => {
+    const removeAllSpy = vi.spyOn(listeners, 'removeAll');
+
+    listeners.destroy();
+
+    expect(removeAllSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+
diff --git a/test/unit/utils/popover-abstract.test.ts b/test/unit/utils/popover-abstract.test.ts
new file mode 100644
index 000000000..ac9a13b94
--- /dev/null
+++ b/test/unit/utils/popover-abstract.test.ts
@@ -0,0 +1,481 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+vi.mock('@codexteam/icons', () => ({
+  IconDotCircle: '<svg data-testid="dot-circle"></svg>',
+  IconChevronRight: '<svg data-testid="chevron-right"></svg>',
+}));
+
+import { PopoverAbstract } from '../../../src/components/utils/popover/popover-abstract';
+import type { PopoverParams, PopoverNodes } from '@/types/utils/popover/popover';
+import { PopoverEvent } from '@/types/utils/popover/popover-event';
+import {
+  PopoverItemDefault,
+  PopoverItemSeparator,
+  type PopoverItem
+} from '../../../src/components/utils/popover/components/popover-item';
+import { PopoverItemHtml } from '../../../src/components/utils/popover/components/popover-item/popover-item-html/popover-item-html';
+import type {
+  PopoverItemParams,
+  PopoverItemRenderParamsMap
+} from '@/types/utils/popover/popover-item';
+import { PopoverItemType } from '@/types/utils/popover/popover-item-type';
+import type { SearchInput } from '../../../src/components/utils/popover/components/search-input';
+import { css } from '../../../src/components/utils/popover/popover.const';
+import { css as popoverItemCss } from '../../../src/components/utils/popover/components/popover-item/popover-item-default/popover-item-default.const';
+
+/**
+ * Test implementation of PopoverAbstract for unit testing
+ */
+class TestPopover extends PopoverAbstract {
+  public readonly showNestedItemsMock = vi.fn<[item: PopoverItemDefault | PopoverItemHtml], void>();
+
+  /**
+   * Override to track calls to showNestedItems
+   *
+   * @param item - The popover item to show nested items for
+   */
+  protected override showNestedItems(item: PopoverItemDefault | PopoverItemHtml): void {
+    this.showNestedItemsMock(item);
+  }
+
+  /**
+   * Exposes nodes for testing purposes
+   */
+  public getNodesForTests(): PopoverNodes {
+    return this.nodes;
+  }
+
+  /**
+   * Exposes items for testing purposes
+   */
+  public getItemsForTests(): Array<PopoverItem> {
+    return this.items;
+  }
+
+  /**
+   * Exposes getTargetItem for testing purposes
+   *
+   * @param event - The event to get the target item from
+   */
+  public invokeGetTargetItem(event: Event): PopoverItemDefault | PopoverItemHtml | undefined {
+    return this.getTargetItem(event);
+  }
+
+  /**
+   * Exposes handleItemClick for testing purposes
+   *
+   * @param item - The popover item to handle click for
+   */
+  public invokeHandleItemClick(item: PopoverItem): void {
+    this.handleItemClick(item);
+  }
+
+  /**
+   * Exposes buildItems for testing purposes
+   *
+   * @param items - The item parameters to build items from
+   */
+  public invokeBuildItems(items: PopoverItemParams[]): Array<PopoverItem> {
+    return this.buildItems(items);
+  }
+}
+
+const createDefaultItems = (): PopoverItemParams[] => [
+  {
+    title: 'First',
+    name: 'first',
+    onActivate: vi.fn(),
+  },
+  {
+    title: 'Second',
+    name: 'second',
+    onActivate: vi.fn(),
+  },
+];
+
+const createPopover = (
+  params: Partial<PopoverParams> = {},
+  itemsRenderParams?: PopoverItemRenderParamsMap
+): TestPopover => {
+  const resolvedParams: PopoverParams = {
+    items: params.items ?? createDefaultItems(),
+    ...params,
+  };
+
+  const popover = new TestPopover(resolvedParams, itemsRenderParams);
+
+  document.body.appendChild(popover.getElement());
+
+  return popover;
+};
+
+const patchComposedPath = <T extends Event>(event: T, path: EventTarget[]): T => {
+  Object.defineProperty(event, 'composedPath', {
+    configurable: true,
+    value: () => path,
+  });
+
+  return event;
+};
+
+describe('PopoverAbstract', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    document.body.innerHTML = '';
+  });
+
+  describe('constructor', () => {
+    it('creates DOM nodes and renders provided items/messages', () => {
+      const nothingFoundText = 'Custom message';
+      const popover = createPopover({
+        messages: { nothingFound: nothingFoundText },
+        class: 'custom-popover',
+      });
+
+      const nodes = popover.getNodesForTests();
+      const items = popover.getItemsForTests();
+
+      expect(popover.getElement()).toBe(nodes.popover);
+      expect(nodes.popover.classList.contains(css.popover)).toBe(true);
+      expect(nodes.popover.classList.contains('custom-popover')).toBe(true);
+      expect(nodes.nothingFoundMessage.textContent).toBe(nothingFoundText);
+      expect(nodes.popoverContainer.contains(nodes.items)).toBe(true);
+      expect(nodes.items.childElementCount).toBe(items.length);
+    });
+
+    it('respects popover item render params constructor argument', () => {
+      const popover = createPopover(
+        {
+          items: [
+            {
+              title: 'Button item',
+              name: 'button-item',
+              onActivate: vi.fn(),
+            },
+          ],
+        },
+        {
+          [PopoverItemType.Default]: {
+            wrapperTag: 'button',
+          },
+        }
+      );
+
+      const defaultItem = popover.getItemsForTests()[0] as PopoverItemDefault;
+      const element = defaultItem.getElement();
+
+      expect(element?.tagName).toBe('BUTTON');
+    });
+  });
+
+  describe('buildItems()', () => {
+    it('returns appropriate instances for different item types', () => {
+      const popover = createPopover();
+      const htmlElement = document.createElement('div');
+      const items = popover.invokeBuildItems([
+        { type: PopoverItemType.Separator },
+        { type: PopoverItemType.Html,
+          element: htmlElement,
+          name: 'html' },
+        { title: 'Default',
+          name: 'default',
+          onActivate: vi.fn() },
+      ]);
+
+      expect(items[0]).toBeInstanceOf(PopoverItemSeparator);
+      expect(items[1]).toBeInstanceOf(PopoverItemHtml);
+      expect(items[2]).toBeInstanceOf(PopoverItemDefault);
+    });
+  });
+
+  describe('getTargetItem()', () => {
+    it('returns PopoverItemDefault when event path contains its element', () => {
+      const popover = createPopover();
+      const defaultItem = popover.getItemsForTests()[0] as PopoverItemDefault;
+      const element = defaultItem.getElement();
+
+      if (element === null) {
+        throw new Error('Expected default item element to exist');
+      }
+
+      const event = patchComposedPath(new Event('click'), [ element as EventTarget ]);
+
+      expect(popover.invokeGetTargetItem(event)).toBe(defaultItem);
+    });
+
+    it('returns PopoverItemHtml when event path contains custom html element', () => {
+      const customElement = document.createElement('button');
+      const popover = createPopover({
+        items: [
+          ...createDefaultItems(),
+          {
+            type: PopoverItemType.Html,
+            element: customElement,
+            name: 'html',
+          },
+        ],
+      });
+      const htmlItem = popover.getItemsForTests().find((item): item is PopoverItemHtml => item instanceof PopoverItemHtml);
+
+      if (htmlItem === undefined) {
+        throw new Error('Expected html item to be created');
+      }
+
+      const htmlRoot = htmlItem.getElement();
+
+      const event = patchComposedPath(new Event('click'), [ htmlRoot ]);
+
+      expect(popover.invokeGetTargetItem(event)).toBe(htmlItem);
+    });
+  });
+
+  describe('public API', () => {
+    it('show() marks popover as opened and focuses search when available', () => {
+      const popover = createPopover();
+      const nodes = popover.getNodesForTests();
+      const focus = vi.fn();
+      const searchMock = {
+        focus,
+        clear: vi.fn(),
+        destroy: vi.fn(),
+      } as unknown as SearchInput;
+
+      (popover as unknown as { search?: SearchInput }).search = searchMock;
+
+      popover.show();
+
+      expect(nodes.popover.classList.contains(css.popoverOpened)).toBe(true);
+      expect(nodes.popover.getAttribute('data-popover-opened')).toBe('true');
+      expect(focus).toHaveBeenCalledTimes(1);
+    });
+
+    it('hide() clears classes, resets items, clears search and emits Closed event', () => {
+      const popover = createPopover();
+      const nodes = popover.getNodesForTests();
+      const defaultItem = popover.getItemsForTests().find((item): item is PopoverItemDefault => item instanceof PopoverItemDefault);
+
+      if (defaultItem === undefined) {
+        throw new Error('Expected default item to exist');
+      }
+
+      const resetSpy = vi.spyOn(defaultItem, 'reset');
+      const searchMock = {
+        focus: vi.fn(),
+        clear: vi.fn(),
+        destroy: vi.fn(),
+      } as unknown as SearchInput;
+      const closedHandler = vi.fn();
+
+      (popover as unknown as { search?: SearchInput }).search = searchMock;
+      popover.on(PopoverEvent.Closed, closedHandler);
+
+      nodes.popover.classList.add(css.popoverOpenTop, css.popoverOpenLeft);
+      popover.show();
+      popover.hide();
+
+      expect(nodes.popover.classList.contains(css.popoverOpened)).toBe(false);
+      expect(nodes.popover.classList.contains(css.popoverOpenTop)).toBe(false);
+      expect(nodes.popover.getAttribute('data-popover-opened')).toBeNull();
+      expect(resetSpy).toHaveBeenCalled();
+      expect(searchMock.clear).toHaveBeenCalledTimes(1);
+      expect(closedHandler).toHaveBeenCalledTimes(1);
+    });
+
+    it('destroy() tears down DOM nodes, listeners, items and search instance', () => {
+      const popover = createPopover();
+      const nodes = popover.getNodesForTests();
+      const items = popover.getItemsForTests();
+      const searchMock = {
+        focus: vi.fn(),
+        clear: vi.fn(),
+        destroy: vi.fn(),
+      } as unknown as SearchInput;
+      const removeAllSpy = vi.spyOn(popover['listeners'], 'removeAll');
+      const destroySpies = items.map(item => vi.spyOn(item, 'destroy'));
+
+      (popover as unknown as { search?: SearchInput }).search = searchMock;
+
+      popover.destroy();
+
+      expect(removeAllSpy).toHaveBeenCalledTimes(1);
+      destroySpies.forEach(spy => expect(spy).toHaveBeenCalled());
+      expect(searchMock.destroy).toHaveBeenCalledTimes(1);
+      expect(document.body.contains(nodes.popover)).toBe(false);
+    });
+
+    it('activateItemByName() triggers handleItemClick only for existing items', () => {
+      const popover = createPopover();
+      const handleItemClickSpy = vi.spyOn(
+        popover as unknown as { handleItemClick: (item: PopoverItem) => void },
+        'handleItemClick'
+      );
+
+      popover.activateItemByName('second');
+      popover.activateItemByName('missing');
+
+      expect(handleItemClickSpy).toHaveBeenCalledTimes(1);
+      const items = popover.getItemsForTests();
+
+      expect(handleItemClickSpy).toHaveBeenCalledWith(items[1]);
+    });
+  });
+
+  describe('handleItemClick()', () => {
+    it('ignores disabled items', () => {
+      const popover = createPopover({
+        items: [
+          {
+            title: 'Disabled',
+            name: 'disabled',
+            isDisabled: true,
+            onActivate: vi.fn(),
+          },
+        ],
+      });
+      const item = popover.getItemsForTests()[0] as PopoverItemDefault;
+      const handleSpy = vi.spyOn(item, 'handleClick');
+
+      popover.invokeHandleItemClick(item);
+
+      expect(handleSpy).not.toHaveBeenCalled();
+    });
+
+    it('opens nested items when an item with children is clicked', () => {
+      const popover = createPopover({
+        items: [
+          {
+            title: 'Parent',
+            name: 'parent',
+            children: {
+              items: [
+                {
+                  title: 'Child',
+                  name: 'child',
+                  onActivate: vi.fn(),
+                },
+              ],
+            },
+          },
+        ],
+      });
+      const parentItem = popover.getItemsForTests()[0] as PopoverItemDefault;
+      const handleSpy = vi.spyOn(parentItem, 'handleClick');
+
+      popover.invokeHandleItemClick(parentItem);
+
+      expect(popover.showNestedItemsMock).toHaveBeenCalledWith(parentItem);
+      expect(handleSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('toggles activeness when toggle=true', () => {
+      const popover = createPopover({
+        items: [
+          {
+            title: 'Toggle item',
+            name: 'toggle',
+            toggle: true,
+            onActivate: vi.fn(),
+          },
+        ],
+      });
+      const toggleItem = popover.getItemsForTests()[0] as PopoverItemDefault;
+      const element = toggleItem.getElement();
+
+      if (element === null) {
+        throw new Error('Expected toggle item element to exist');
+      }
+
+      popover.invokeHandleItemClick(toggleItem);
+      expect(element?.classList.contains(popoverItemCss.active)).toBe(true);
+
+      popover.invokeHandleItemClick(toggleItem);
+      expect(element?.classList.contains(popoverItemCss.active)).toBe(false);
+    });
+
+    it('applies radio-like behaviour when toggle is a string key', () => {
+      const popover = createPopover({
+        items: [
+          {
+            title: 'First',
+            name: 'first',
+            toggle: 'group',
+            onActivate: vi.fn(),
+          },
+          {
+            title: 'Second',
+            name: 'second',
+            toggle: 'group',
+            onActivate: vi.fn(),
+          },
+        ],
+      });
+      const [first, second] = popover.getItemsForTests() as PopoverItemDefault[];
+      const firstEl = first.getElement();
+      const secondEl = second.getElement();
+
+      if (firstEl === null || secondEl === null) {
+        throw new Error('Expected toggle items to have DOM nodes');
+      }
+
+      popover.invokeHandleItemClick(first);
+      expect(firstEl?.classList.contains(popoverItemCss.active)).toBe(true);
+      expect(secondEl?.classList.contains(popoverItemCss.active)).toBe(false);
+
+      popover.invokeHandleItemClick(second);
+      expect(secondEl?.classList.contains(popoverItemCss.active)).toBe(true);
+      expect(firstEl?.classList.contains(popoverItemCss.active)).toBe(false);
+    });
+
+    it('hides popover and emits ClosedOnActivate when item requires closing', () => {
+      const popover = createPopover({
+        items: [
+          {
+            title: 'Close on activate',
+            name: 'close',
+            closeOnActivate: true,
+            onActivate: vi.fn(),
+          },
+        ],
+      });
+      const item = popover.getItemsForTests()[0] as PopoverItemDefault;
+      const nodes = popover.getNodesForTests();
+      const closedOnActivateHandler = vi.fn();
+
+      popover.on(PopoverEvent.ClosedOnActivate, closedOnActivateHandler);
+      popover.show();
+      popover.invokeHandleItemClick(item);
+
+      expect(nodes.popover.classList.contains(css.popoverOpened)).toBe(false);
+      expect(closedOnActivateHandler).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('event listener wiring', () => {
+    it('translate DOM click events into handleItemClick calls', () => {
+      const popover = createPopover();
+      const handleItemClickSpy = vi.spyOn(
+        popover as unknown as { handleItemClick: (item: PopoverItem) => void },
+        'handleItemClick'
+      );
+      const nodes = popover.getNodesForTests();
+      const firstItem = popover.getItemsForTests()[0] as PopoverItemDefault;
+      const itemElement = firstItem.getElement();
+
+      if (itemElement === null) {
+        throw new Error('Expected item element to exist');
+      }
+      const event = patchComposedPath(
+        new Event('click', { bubbles: true }),
+        [itemElement as EventTarget, nodes.items, nodes.popoverContainer]
+      );
+
+      itemElement?.dispatchEvent(event);
+
+      expect(handleItemClickSpy).toHaveBeenCalledWith(firstItem);
+    });
+  });
+});
diff --git a/test/unit/utils/popover-desktop.test.ts b/test/unit/utils/popover-desktop.test.ts
new file mode 100644
index 000000000..dd4537b5b
--- /dev/null
+++ b/test/unit/utils/popover-desktop.test.ts
@@ -0,0 +1,790 @@
+import { describe, it, expect, beforeEach, afterEach, vi, type MockInstance } from 'vitest';
+
+/* eslint-disable jsdoc/require-jsdoc */
+
+type SearchPayload = { query: string; items: unknown[] };
+
+type MockFlipperShape = {
+  activate: ReturnType<typeof vi.fn>;
+  deactivate: ReturnType<typeof vi.fn>;
+  focusFirst: ReturnType<typeof vi.fn>;
+  onFlip: ReturnType<typeof vi.fn>;
+  removeOnFlip: ReturnType<typeof vi.fn>;
+  triggerFlip: () => void;
+  lastActivatedWith: HTMLElement[] | undefined;
+  readonly isActivated: boolean;
+  hasFocus: () => boolean;
+};
+
+type MockSearchInputShape = {
+  on: ReturnType<typeof vi.fn>;
+  getElement: ReturnType<typeof vi.fn>;
+  focus: ReturnType<typeof vi.fn>;
+  clear: ReturnType<typeof vi.fn>;
+  destroy: ReturnType<typeof vi.fn>;
+  emitSearch: (payload: SearchPayload) => void;
+  element: HTMLElement;
+  items: unknown[];
+  placeholder: string | undefined;
+};
+
+const flipperRegistry = vi.hoisted(() => ({
+  instances: [] as unknown[],
+  reset(): void {
+    this.instances.length = 0;
+  },
+}));
+
+vi.mock('../../../src/components/flipper', () => {
+  class MockFlipper {
+    public readonly onFlip = vi.fn((callback: () => void) => {
+      this.flipCallbacks.add(callback);
+    });
+
+    public readonly removeOnFlip = vi.fn((callback: () => void) => {
+      this.flipCallbacks.delete(callback);
+    });
+
+    public readonly activate = vi.fn((items?: HTMLElement[]) => {
+      this.activated = true;
+      this.lastActivatedWith = items;
+    });
+
+    public readonly deactivate = vi.fn(() => {
+      this.activated = false;
+    });
+
+    public readonly focusFirst = vi.fn(() => {});
+
+    public readonly hasFocus = vi.fn(() => this.activated);
+
+    public lastActivatedWith: HTMLElement[] | undefined;
+
+    private activated = false;
+
+    private readonly flipCallbacks = new Set<() => void>();
+
+    constructor(_options: unknown) {
+      flipperRegistry.instances.push(this);
+    }
+
+    public get isActivated(): boolean {
+      return this.activated;
+    }
+
+    public triggerFlip(): void {
+      this.flipCallbacks.forEach(callback => callback());
+    }
+  }
+
+  return {
+    ['__esModule']: true,
+    default: MockFlipper,
+  };
+});
+
+const searchInputRegistry = vi.hoisted(() => ({
+  instances: [] as unknown[],
+  reset(): void {
+    this.instances.length = 0;
+  },
+}));
+
+vi.mock('../../../src/components/utils/popover/components/search-input', () => {
+  const SearchInputEvent = {
+    Search: 'search' as const,
+  };
+
+  class MockSearchInput {
+    public readonly on = vi.fn((event: string, handler: (payload: SearchPayload) => void) => {
+      const handlers = this.handlers.get(event) ?? [];
+
+      handlers.push(handler);
+      this.handlers.set(event, handlers);
+    });
+
+    public readonly getElement = vi.fn(() => this.element);
+
+    public readonly focus = vi.fn(() => {});
+
+    public readonly clear = vi.fn(() => {});
+
+    public readonly destroy = vi.fn(() => {});
+
+    public readonly element: HTMLElement;
+
+    public readonly items: unknown[];
+
+    public readonly placeholder: string | undefined;
+
+    private readonly handlers = new Map<string, Array<(payload: SearchPayload) => void>>();
+
+    constructor({ items, placeholder }: { items: unknown[]; placeholder?: string }) {
+      this.items = items;
+      this.placeholder = placeholder;
+      this.element = document.createElement('div');
+      this.element.className = 'mock-search-input';
+
+      searchInputRegistry.instances.push(this);
+    }
+
+    public emitSearch(payload: SearchPayload): void {
+      this.handlers.get(SearchInputEvent.Search)?.forEach(handler => handler(payload));
+    }
+  }
+
+  return {
+    ['__esModule']: true,
+    SearchInput: MockSearchInput,
+    SearchInputEvent,
+  };
+});
+
+const getMockFlipper = (index = 0): MockFlipperShape => {
+  return flipperRegistry.instances[index] as MockFlipperShape;
+};
+
+const getMockSearchInput = (index = 0): MockSearchInputShape => {
+  return searchInputRegistry.instances[index] as MockSearchInputShape;
+};
+
+import { PopoverDesktop } from '../../../src/components/utils/popover/popover-desktop';
+import { PopoverItemType } from '@/types/utils/popover/popover-item-type';
+import type { PopoverParams } from '@/types/utils/popover/popover';
+import { PopoverEvent } from '@/types/utils/popover/popover-event';
+import { css, CSSVariables } from '../../../src/components/utils/popover/popover.const';
+import { css as popoverItemCss } from '../../../src/components/utils/popover/components/popover-item/popover-item-default/popover-item-default.const';
+import { css as separatorCss } from '../../../src/components/utils/popover/components/popover-item/popover-item-separator/popover-item-separator.const';
+import { PopoverItemDefault, PopoverItemSeparator } from '../../../src/components/utils/popover/components/popover-item';
+import Flipper from '../../../src/components/flipper';
+import { PopoverAbstract } from '../../../src/components/utils/popover/popover-abstract';
+
+type PopoverDesktopInternal = Omit<PopoverDesktop, 'shouldOpenBottom' | 'shouldOpenRight'> & {
+  flippableElements: HTMLElement[];
+  size: { height: number; width: number };
+  setTriggerItemPosition: (nestedPopoverEl: HTMLElement, item: PopoverItemDefault) => void;
+  showNestedPopoverForItem: (item: PopoverItemDefault) => PopoverDesktop;
+  destroyNestedPopoverIfExists: () => void;
+  handleHover: (event: Event) => void;
+  readonly itemsDefault: PopoverItemDefault[];
+  readonly items: Array<PopoverItemDefault | PopoverItemSeparator>;
+  nodes: {
+    popover: HTMLElement;
+    popoverContainer: HTMLElement;
+    items: HTMLElement;
+    nothingFoundMessage: HTMLElement;
+  };
+  nestedPopover: PopoverDesktop | null | undefined;
+  nestedPopoverTriggerItem: PopoverItemDefault | null;
+};
+
+const createRect = (overrides: Partial<DOMRect>): DOMRect => ({
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  toJSON: () => ({}),
+  ...overrides,
+});
+
+const createDefaultItems = (): PopoverParams['items'] => [
+  {
+    title: 'First',
+    name: 'first',
+    onActivate: vi.fn(),
+  },
+  {
+    title: 'Second',
+    name: 'second',
+    onActivate: vi.fn(),
+  },
+];
+
+const createPopover = (params: Partial<PopoverParams> = {}): PopoverDesktop => {
+  const scopeElement = params.scopeElement ?? document.createElement('div');
+
+  document.body.appendChild(scopeElement);
+
+  const popoverParams: PopoverParams = {
+    items: params.items ?? createDefaultItems(),
+    scopeElement,
+    ...params,
+  };
+
+  return new PopoverDesktop(popoverParams);
+};
+
+let rafSpy: MockInstance<[FrameRequestCallback], number> | undefined;
+
+beforeEach(() => {
+  document.body.innerHTML = '';
+
+  flipperRegistry.reset();
+  searchInputRegistry.reset();
+
+  if (typeof window.requestAnimationFrame !== 'function') {
+    window.requestAnimationFrame = ((callback: FrameRequestCallback) => {
+      callback(0);
+
+      return 0;
+    }) as typeof window.requestAnimationFrame;
+  }
+
+  rafSpy = vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback: FrameRequestCallback) => {
+    callback(0);
+
+    return 0;
+  });
+});
+
+afterEach(() => {
+  rafSpy?.mockRestore();
+  vi.restoreAllMocks();
+});
+
+describe('PopoverDesktop', () => {
+  describe('constructor', () => {
+    it('adds nested class when instantiated with nesting level greater than zero', () => {
+      const popover = createPopover({ nestingLevel: 1 });
+
+      expect(popover.nestingLevel).toBe(1);
+      expect(popover.getElement().classList.contains(css.popoverNested)).toBe(true);
+    });
+
+    it('reuses provided flipper instance and attaches flip handler', () => {
+      const reusableFlipper = new Flipper({});
+      const removeOnFlipSpy = vi.spyOn(reusableFlipper, 'removeOnFlip');
+      const deactivateSpy = vi.spyOn(reusableFlipper, 'deactivate');
+      const onFlipSpy = vi.spyOn(reusableFlipper, 'onFlip');
+
+      createPopover({ flipper: reusableFlipper });
+
+      expect(deactivateSpy).toHaveBeenCalledTimes(1);
+      expect(removeOnFlipSpy).toHaveBeenCalledTimes(1);
+      expect(onFlipSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('accessors', () => {
+    it('reflects flipper focus state when available', () => {
+      const popover = createPopover();
+      const flipper = getMockFlipper();
+
+      expect(popover.hasFocus()).toBe(false);
+
+      flipper.activate();
+
+      expect(popover.hasFocus()).toBe(true);
+
+      const nonFlippablePopover = createPopover({ flippable: false });
+
+      expect(nonFlippablePopover.hasFocus()).toBe(false);
+    });
+
+    it('exposes scroll position of the items container', () => {
+      const popover = createPopover();
+      const instance = popover as unknown as PopoverDesktopInternal;
+
+      instance.nodes.items.scrollTop = 24;
+
+      expect(popover.scrollTop).toBe(24);
+
+      instance.nodes.items = null as unknown as HTMLElement;
+
+      expect(popover.scrollTop).toBe(0);
+    });
+
+    it('returns zero offset when popover container is missing', () => {
+      const popover = createPopover();
+      const instance = popover as unknown as PopoverDesktopInternal;
+      const container = document.createElement('div');
+
+      Object.defineProperty(container, 'offsetTop', {
+        configurable: true,
+        get: () => 120,
+      });
+
+      instance.nodes.popoverContainer = container;
+
+      expect(popover.offsetTop).toBe(120);
+
+      instance.nodes.popoverContainer = null as unknown as HTMLElement;
+
+      expect(popover.offsetTop).toBe(0);
+    });
+  });
+
+  describe('destroy', () => {
+    it('calls hide before delegating to base destroy logic', () => {
+      const popover = createPopover();
+      const hideSpy = vi.spyOn(popover, 'hide');
+      const superDestroySpy = vi.spyOn(PopoverAbstract.prototype, 'destroy');
+
+      popover.destroy();
+
+      expect(hideSpy).toHaveBeenCalled();
+      expect(superDestroySpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('setTriggerItemPosition', () => {
+    it('calculates trigger position relative to scroll offset', () => {
+      const popover = createPopover();
+      const instance = popover as unknown as PopoverDesktopInternal;
+      const nestedElement = document.createElement('div');
+      const triggerItem = instance.itemsDefault[0];
+      const triggerElement = triggerItem.getElement();
+
+      expect(triggerElement).not.toBeNull();
+
+      Object.defineProperty(triggerElement!, 'offsetTop', {
+        configurable: true,
+        get: () => 75,
+      });
+
+      instance.nodes.items.scrollTop = 25;
+
+      Object.defineProperty(instance.nodes.popoverContainer, 'offsetTop', {
+        configurable: true,
+        get: () => 100,
+      });
+
+      instance.setTriggerItemPosition(nestedElement, triggerItem);
+
+      expect(nestedElement.style.getPropertyValue(CSSVariables.TriggerItemTop)).toBe('150px');
+    });
+  });
+
+  describe('position helpers', () => {
+    it('determines when popover should stay below the trigger', () => {
+      const scopeElement = document.createElement('div');
+      const popover = createPopover({ scopeElement });
+      const instance = popover as unknown as PopoverDesktopInternal;
+
+      vi.spyOn(instance, 'size', 'get').mockReturnValue({ height: 150,
+        width: 100 });
+      vi.spyOn(instance.nodes.popoverContainer, 'getBoundingClientRect').mockReturnValue(
+        createRect({ top: 50 }) as DOMRect
+      );
+      vi.spyOn(scopeElement, 'getBoundingClientRect').mockReturnValue(
+        createRect({ top: 40,
+          bottom: 500 }) as DOMRect
+      );
+
+      expect((instance as unknown as { shouldOpenBottom: boolean }).shouldOpenBottom).toBe(true);
+    });
+
+    it('opens upward when there is not enough space below', () => {
+      const scopeElement = document.createElement('div');
+      const popover = createPopover({ scopeElement });
+      const instance = popover as unknown as PopoverDesktopInternal;
+
+      vi.spyOn(instance, 'size', 'get').mockReturnValue({ height: 300,
+        width: 100 });
+      vi.spyOn(instance.nodes.popoverContainer, 'getBoundingClientRect').mockReturnValue(
+        createRect({ top: 400 }) as DOMRect
+      );
+      vi.spyOn(scopeElement, 'getBoundingClientRect').mockReturnValue(
+        createRect({ top: 0,
+          bottom: 600 }) as DOMRect
+      );
+
+      const originalInnerHeight = window.innerHeight;
+
+      Object.defineProperty(window, 'innerHeight', {
+        configurable: true,
+        value: 600,
+        writable: true,
+      });
+
+      try {
+        expect((instance as unknown as { shouldOpenBottom: boolean }).shouldOpenBottom).toBe(false);
+      } finally {
+        Object.defineProperty(window, 'innerHeight', {
+          configurable: true,
+          value: originalInnerHeight,
+          writable: true,
+        });
+      }
+    });
+
+    it('chooses opening to the right when there is no space on the left', () => {
+      const scopeElement = document.createElement('div');
+      const popover = createPopover({ scopeElement });
+      const instance = popover as unknown as PopoverDesktopInternal;
+
+      vi.spyOn(instance, 'size', 'get').mockReturnValue({ height: 100,
+        width: 200 });
+      vi.spyOn(instance.nodes.popover, 'getBoundingClientRect').mockReturnValue(
+        createRect({ left: 50,
+          right: 150 }) as DOMRect
+      );
+      vi.spyOn(scopeElement, 'getBoundingClientRect').mockReturnValue(
+        createRect({ left: 0,
+          right: 600 }) as DOMRect
+      );
+
+      expect((instance as unknown as { shouldOpenRight: boolean }).shouldOpenRight).toBe(true);
+    });
+
+    it('opens to the left when the right side is constrained', () => {
+      const scopeElement = document.createElement('div');
+      const popover = createPopover({ scopeElement });
+      const instance = popover as unknown as PopoverDesktopInternal;
+
+      vi.spyOn(instance, 'size', 'get').mockReturnValue({ height: 100,
+        width: 300 });
+      vi.spyOn(instance.nodes.popover, 'getBoundingClientRect').mockReturnValue(
+        createRect({ left: 400,
+          right: 500 }) as DOMRect
+      );
+      vi.spyOn(scopeElement, 'getBoundingClientRect').mockReturnValue(
+        createRect({ left: 0,
+          right: 650 }) as DOMRect
+      );
+
+      const originalInnerWidth = window.innerWidth;
+
+      Object.defineProperty(window, 'innerWidth', {
+        configurable: true,
+        value: 600,
+        writable: true,
+      });
+
+      try {
+        expect((instance as unknown as { shouldOpenRight: boolean }).shouldOpenRight).toBe(false);
+      } finally {
+        Object.defineProperty(window, 'innerWidth', {
+          configurable: true,
+          value: originalInnerWidth,
+          writable: true,
+        });
+      }
+    });
+  });
+
+  describe('size', () => {
+    it('clones popover to measure dimensions and caches the result', () => {
+      const popover = createPopover();
+      const instance = popover as unknown as PopoverDesktopInternal;
+      const clonePopover = document.createElement('div');
+
+      clonePopover.classList.add(css.popover);
+
+      const nested = document.createElement('div');
+
+      nested.classList.add(css.popoverNested);
+
+      const container = document.createElement('div');
+
+      container.classList.add(css.popoverContainer);
+
+      Object.defineProperty(container, 'offsetHeight', {
+        configurable: true,
+        get: () => 180,
+      });
+      Object.defineProperty(container, 'offsetWidth', {
+        configurable: true,
+        get: () => 90,
+      });
+
+      clonePopover.appendChild(nested);
+      clonePopover.appendChild(container);
+
+      const cloneSpy = vi.spyOn(instance.nodes.popover, 'cloneNode').mockReturnValue(clonePopover);
+
+      const firstSize = instance.size;
+      const secondSize = instance.size;
+
+      expect(firstSize).toEqual({ height: 180,
+        width: 90 });
+      expect(secondSize).toBe(firstSize);
+      expect(cloneSpy).toHaveBeenCalledTimes(1);
+      expect(clonePopover.isConnected).toBe(false);
+      expect(clonePopover.classList.contains(css.popoverOpened)).toBe(true);
+      expect(clonePopover.querySelector(`.${css.popoverNested}`)).toBeNull();
+    });
+  });
+
+  describe('flippableElements', () => {
+    it('includes only enabled default items and controls from HTML items', () => {
+      const htmlElement = document.createElement('div');
+      const htmlButton = document.createElement('button');
+      const htmlInput = document.createElement('input');
+
+      htmlElement.append(htmlButton, htmlInput);
+
+      const popover = createPopover({
+        items: [
+          {
+            title: 'Enabled',
+            name: 'enabled',
+            onActivate: vi.fn(),
+          },
+          {
+            title: 'Disabled',
+            name: 'disabled',
+            onActivate: vi.fn(),
+            isDisabled: true,
+          },
+          {
+            type: PopoverItemType.Separator,
+          },
+          {
+            type: PopoverItemType.Html,
+            name: 'custom-html',
+            element: htmlElement,
+          },
+        ],
+      });
+      const instance = popover as unknown as PopoverDesktopInternal;
+      const defaultElement = instance.itemsDefault[0].getElement();
+
+      expect(defaultElement).not.toBeNull();
+
+      const elements = instance.flippableElements;
+
+      expect(elements).toEqual([defaultElement!, htmlButton, htmlInput]);
+    });
+  });
+
+  describe('show', () => {
+    it('applies position classes, sets height variable and activates flipper', () => {
+      const popover = createPopover();
+      const instance = popover as unknown as PopoverDesktopInternal;
+      const sizeSpy = vi.spyOn(instance, 'size', 'get').mockReturnValue({
+        height: 120,
+        width: 80,
+      });
+      const openBottomSpy = vi.spyOn(instance as unknown as { readonly shouldOpenBottom: boolean }, 'shouldOpenBottom', 'get').mockReturnValue(false);
+      const openRightSpy = vi.spyOn(instance as unknown as { readonly shouldOpenRight: boolean }, 'shouldOpenRight', 'get').mockReturnValue(false);
+
+      popover.show();
+
+      const flipper = getMockFlipper();
+      const popoverElement = popover.getElement();
+
+      expect(sizeSpy).toHaveBeenCalled();
+      expect(openBottomSpy).toHaveBeenCalled();
+      expect(openRightSpy).toHaveBeenCalled();
+      expect(popoverElement.classList.contains(css.popoverOpened)).toBe(true);
+      expect(popoverElement.classList.contains(css.popoverOpenTop)).toBe(true);
+      expect(popoverElement.classList.contains(css.popoverOpenLeft)).toBe(true);
+      expect(popoverElement.style.getPropertyValue(CSSVariables.PopoverHeight)).toBe('120px');
+      expect(flipper.activate).toHaveBeenCalledWith(instance.flippableElements);
+    });
+  });
+
+  describe('hide', () => {
+    it('destroys nested popover, deactivates flipper and resets hover state', () => {
+      const popover = createPopover({
+        items: [
+          {
+            title: 'Parent',
+            name: 'parent',
+            children: {
+              items: [
+                {
+                  title: 'Child',
+                  name: 'child',
+                  onActivate: vi.fn(),
+                },
+              ],
+            },
+          },
+        ],
+      });
+      const instance = popover as unknown as PopoverDesktopInternal;
+      const parentItem = instance.items.find(
+        (item: PopoverItemDefault | PopoverItemSeparator): item is PopoverItemDefault => item instanceof PopoverItemDefault && item.hasChildren
+      );
+
+      expect(parentItem).toBeDefined();
+
+      instance.showNestedPopoverForItem(parentItem!);
+      const nestedPopoverElement = popover.getElement().querySelector(`.${css.popoverNested}`);
+
+      expect(nestedPopoverElement).toBeTruthy();
+
+      popover.hide();
+
+      const flipper = getMockFlipper();
+
+      expect(popover.getElement().hasAttribute('data-popover-opened')).toBe(false);
+      expect(flipper.deactivate).toHaveBeenCalled();
+      expect(popover.getElement().querySelector(`.${css.popoverNested}`)).toBeNull();
+      expect(instance.nestedPopover).toBeNull();
+      expect(instance.nestedPopoverTriggerItem).toBeNull();
+      expect(flipper.focusFirst).toHaveBeenCalled();
+    });
+  });
+
+  describe('handleHover', () => {
+    it('opens nested popover for hovered item with children and avoids reopening for the same item', () => {
+      const popover = createPopover({
+        items: [
+          ...createDefaultItems(),
+          {
+            title: 'Parent',
+            name: 'parent',
+            children: {
+              items: [
+                {
+                  title: 'Child',
+                  name: 'child',
+                  onActivate: vi.fn(),
+                },
+              ],
+            },
+          },
+        ],
+      });
+      const instance = popover as unknown as PopoverDesktopInternal;
+      const parentItem = instance.items.find(
+        (item: PopoverItemDefault | PopoverItemSeparator): item is PopoverItemDefault => item instanceof PopoverItemDefault && item.hasChildren
+      );
+      const parentElement = parentItem?.getElement();
+
+      expect(parentItem).toBeDefined();
+      expect(parentElement).not.toBeNull();
+
+      const destroyNestedSpy = vi.spyOn(instance, 'destroyNestedPopoverIfExists');
+      const showNestedSpy = vi.spyOn(instance, 'showNestedPopoverForItem');
+
+      const hoverEvent = {
+        composedPath: () => [ parentElement! ],
+      } as unknown as Event;
+
+      instance.handleHover(hoverEvent);
+
+      expect(destroyNestedSpy).toHaveBeenCalledTimes(1);
+      expect(showNestedSpy).toHaveBeenCalledWith(parentItem);
+      expect(instance.nestedPopover).toBeInstanceOf(PopoverDesktop);
+
+      instance.handleHover(hoverEvent);
+
+      expect(destroyNestedSpy).toHaveBeenCalledTimes(1);
+      expect(showNestedSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('search', () => {
+    it('filters items based on search results and updates flipper when active', () => {
+      const popover = createPopover({
+        searchable: true,
+        items: [
+          {
+            title: 'Alpha',
+            name: 'alpha',
+            onActivate: vi.fn(),
+          },
+          {
+            title: 'Beta',
+            name: 'beta',
+            onActivate: vi.fn(),
+          },
+          {
+            type: PopoverItemType.Separator,
+          },
+          {
+            title: 'Gamma',
+            name: 'gamma',
+            onActivate: vi.fn(),
+          },
+        ],
+      });
+      const instance = popover as unknown as PopoverDesktopInternal;
+
+      popover.show();
+
+      const flipper = getMockFlipper();
+      const searchInput = getMockSearchInput();
+
+      expect(searchInput).toBeDefined();
+
+      const items = instance.items;
+      const defaultItems = items.filter((item: PopoverItemDefault | PopoverItemSeparator): item is PopoverItemDefault => item instanceof PopoverItemDefault);
+      const separator = items.find((item: PopoverItemDefault | PopoverItemSeparator): item is PopoverItemSeparator => item instanceof PopoverItemSeparator);
+
+      searchInput.emitSearch({
+        query: 'Beta',
+        items: [ defaultItems[1] ],
+      });
+
+      expect(flipper.deactivate).toHaveBeenCalledTimes(1);
+      expect(flipper.activate).toHaveBeenCalledTimes(2);
+      expect(flipper.activate).toHaveBeenNthCalledWith(2, [ defaultItems[1].getElement() ]);
+
+      expect(defaultItems[0].getElement()?.classList.contains(popoverItemCss.hidden)).toBe(true);
+      expect(defaultItems[1].getElement()?.classList.contains(popoverItemCss.hidden)).toBe(false);
+      expect(separator?.getElement().classList.contains(separatorCss.hidden)).toBe(true);
+      expect(instance.nodes.nothingFoundMessage.classList.contains(css.nothingFoundMessageDisplayed)).toBe(false);
+
+      searchInput.emitSearch({
+        query: 'Zeta',
+        items: [],
+      });
+
+      expect(instance.nodes.nothingFoundMessage.classList.contains(css.nothingFoundMessageDisplayed)).toBe(true);
+      defaultItems.forEach((item: PopoverItemDefault) => {
+        expect(item.getElement()?.classList.contains(popoverItemCss.hidden)).toBe(true);
+      });
+      expect(separator?.getElement().classList.contains(separatorCss.hidden)).toBe(true);
+    });
+  });
+
+  describe('onFlip', () => {
+    it('focuses popover items when flipper emits flip event', () => {
+      const popover = createPopover();
+      const instance = popover as unknown as PopoverDesktopInternal;
+
+      popover.show();
+
+      const flipper = getMockFlipper();
+      const firstItem = instance.itemsDefault[0];
+      const focusSpy = vi.spyOn(firstItem, 'onFocus');
+
+      vi.spyOn(firstItem, 'isFocused', 'get').mockReturnValue(true);
+
+      flipper.triggerFlip();
+
+      expect(focusSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('events', () => {
+    it('emits ClosedOnActivate when nested popover closes due to child activation', () => {
+      const popover = createPopover({
+        items: [
+          {
+            title: 'Parent',
+            name: 'parent',
+            children: {
+              items: [
+                {
+                  title: 'Child',
+                  name: 'child',
+                  onActivate: vi.fn(),
+                },
+              ],
+            },
+          },
+        ],
+      });
+      const instance = popover as unknown as PopoverDesktopInternal;
+      const hideSpy = vi.spyOn(popover, 'hide');
+
+      const parentItem = instance.items[0] as PopoverItemDefault;
+
+      const nestedPopover = instance.showNestedPopoverForItem(parentItem);
+
+      nestedPopover.emit(PopoverEvent.ClosedOnActivate, undefined);
+
+      expect(hideSpy).toHaveBeenCalled();
+    });
+  });
+});
diff --git a/test/unit/utils/popover-inline.test.ts b/test/unit/utils/popover-inline.test.ts
new file mode 100644
index 000000000..d6f1a6f49
--- /dev/null
+++ b/test/unit/utils/popover-inline.test.ts
@@ -0,0 +1,728 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { PopoverInline } from '../../../src/components/utils/popover/popover-inline';
+import { PopoverDesktop } from '../../../src/components/utils/popover/popover-desktop';
+import { PopoverItemDefault, PopoverItemType } from '../../../src/components/utils/popover/components/popover-item';
+import type { PopoverItemHtml } from '../../../src/components/utils/popover/components/popover-item/popover-item-html/popover-item-html';
+import { CSSVariables, css } from '../../../src/components/utils/popover/popover.const';
+import type { PopoverParams } from '@/types/utils/popover/popover';
+import { PopoverEvent } from '@/types/utils/popover/popover-event';
+import Flipper from '../../../src/components/flipper';
+
+// Mock dependencies
+vi.mock('../../../src/components/utils/popover/popover-desktop');
+vi.mock('../../../src/components/utils', async () => {
+  const actual = await vi.importActual('../../../src/components/utils');
+
+  return {
+    ...actual,
+    isMobileScreen: vi.fn(() => false),
+  };
+});
+vi.mock('../../../src/components/flipper');
+
+describe('PopoverInline', () => {
+  /* eslint-disable prefer-const */
+  const OFFSET_LEFT_VALUE = 50;
+  const ITEM_OFFSET_LEFT_VALUE = 30;
+
+  interface MockPopoverDesktop {
+    getElement: ReturnType<typeof vi.fn>;
+    nodes: {
+      popover: HTMLElement;
+      popoverContainer: HTMLElement | null;
+      items: HTMLElement | null;
+      nothingFoundMessage: HTMLElement;
+    };
+    items: Array<PopoverItemDefault | PopoverItemHtml>;
+    flipper: Flipper | undefined;
+    nestingLevel: number;
+    nestedPopover: PopoverDesktop | undefined | null;
+    nestedPopoverTriggerItem: PopoverItemDefault | PopoverItemHtml | null;
+  }
+
+  interface MockFlipper {
+    activate: ReturnType<typeof vi.fn>;
+    deactivate: ReturnType<typeof vi.fn>;
+    focusFirst: ReturnType<typeof vi.fn>;
+    hasFocus: ReturnType<typeof vi.fn>;
+    setHandleContentEditableTargets: ReturnType<typeof vi.fn>;
+  }
+
+  interface MockPopoverDesktopSuperMethods {
+    show: ReturnType<typeof vi.fn>;
+    hide: ReturnType<typeof vi.fn>;
+    destroy: ReturnType<typeof vi.fn>;
+    showNestedItems: ReturnType<typeof vi.fn>;
+    destroyNestedPopoverIfExists: ReturnType<typeof vi.fn>;
+    handleItemClick: ReturnType<typeof vi.fn>;
+    setTriggerItemPosition: ReturnType<typeof vi.fn>;
+    showNestedPopoverForItem: ReturnType<typeof vi.fn>;
+  }
+
+  // Container object to hold mocks, avoiding reassignment
+  const mocks = {
+    mockPopoverDesktop: undefined as unknown as MockPopoverDesktop,
+    mockFlipper: undefined as unknown as MockFlipper,
+    mockPopoverParams: undefined as unknown as PopoverParams,
+    popoverInline: undefined as unknown as PopoverInline,
+    superMethods: undefined as unknown as MockPopoverDesktopSuperMethods,
+  };
+
+  const createMockDefaultItem = (overrides: Partial<PopoverItemDefault> = {}): PopoverItemDefault => {
+    const baseItem = {
+      hasChildren: false,
+      isChildrenOpen: false,
+      getElement: vi.fn(() => document.createElement('div')),
+      handleClick: vi.fn(),
+      onChildrenClose: vi.fn(),
+    };
+
+    const item = {
+      ...baseItem,
+      ...overrides,
+    } as unknown as PopoverItemDefault;
+
+    Object.setPrototypeOf(item, PopoverItemDefault.prototype);
+
+    return item;
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Create mock DOM elements
+    const popoverContainer = document.createElement('div');
+
+    popoverContainer.style.position = 'relative';
+    popoverContainer.style.width = '200px';
+    popoverContainer.style.height = '100px';
+    Object.defineProperty(popoverContainer, 'offsetLeft', {
+      value: OFFSET_LEFT_VALUE,
+      writable: true,
+      configurable: true,
+    });
+
+    const popover = document.createElement('div');
+
+    popover.appendChild(popoverContainer);
+
+    const items = document.createElement('div');
+    const nothingFoundMessage = document.createElement('div');
+
+    // Create mock flipper
+    mocks.mockFlipper = {
+      activate: vi.fn() as unknown as ReturnType<typeof vi.fn>,
+      deactivate: vi.fn() as unknown as ReturnType<typeof vi.fn>,
+      focusFirst: vi.fn() as unknown as ReturnType<typeof vi.fn>,
+      hasFocus: vi.fn(() => false) as unknown as ReturnType<typeof vi.fn>,
+      setHandleContentEditableTargets: vi.fn() as unknown as ReturnType<typeof vi.fn>,
+    };
+
+    // Create mock items
+    const mockItem1 = createMockDefaultItem();
+    const mockItem2 = createMockDefaultItem({
+      hasChildren: true,
+    });
+
+    const createNestedPopoverMock = (): PopoverDesktop => ({
+      getElement: () => document.createElement('div'),
+      nestingLevel: 1,
+      flipper: {
+        setHandleContentEditableTargets: vi.fn(),
+        activate: vi.fn(),
+        deactivate: vi.fn(),
+        focusFirst: vi.fn(),
+      },
+      on: vi.fn(),
+    } as unknown as PopoverDesktop);
+
+    mocks.superMethods = {
+      show: vi.fn() as unknown as ReturnType<typeof vi.fn>,
+      hide: vi.fn() as unknown as ReturnType<typeof vi.fn>,
+      destroy: vi.fn() as unknown as ReturnType<typeof vi.fn>,
+      showNestedItems: vi.fn() as unknown as ReturnType<typeof vi.fn>,
+      destroyNestedPopoverIfExists: vi.fn() as unknown as ReturnType<typeof vi.fn>,
+      handleItemClick: vi.fn() as unknown as ReturnType<typeof vi.fn>,
+      setTriggerItemPosition: vi.fn() as unknown as ReturnType<typeof vi.fn>,
+      showNestedPopoverForItem: vi.fn(createNestedPopoverMock) as unknown as ReturnType<typeof vi.fn>,
+    };
+
+    Object.assign(PopoverDesktop.prototype, mocks.superMethods);
+
+    // Setup mock PopoverDesktop
+    mocks.mockPopoverDesktop = Object.assign(Object.create(PopoverInline.prototype), {
+      getElement: vi.fn(() => popover) as unknown as ReturnType<typeof vi.fn>,
+      nodes: {
+        popover,
+        popoverContainer,
+        items,
+        nothingFoundMessage,
+      },
+      items: [mockItem1, mockItem2],
+      flipper: mocks.mockFlipper as unknown as Flipper,
+      nestingLevel: 0,
+      nestedPopover: undefined,
+      nestedPopoverTriggerItem: null,
+    }) as unknown as MockPopoverDesktop;
+
+    Object.defineProperty(mocks.mockPopoverDesktop, 'flippableElements', {
+      configurable: true,
+      get: () => [],
+    });
+
+    // Mock PopoverDesktop constructor
+    vi.mocked(PopoverDesktop).mockImplementation(() => mocks.mockPopoverDesktop as unknown as PopoverDesktop);
+
+    // Mock Flipper constructor
+    vi.mocked(Flipper).mockImplementation(() => mocks.mockFlipper as unknown as Flipper);
+
+    mocks.mockPopoverParams = {
+      items: [
+        {
+          icon: 'Icon',
+          title: 'Test Item',
+          name: 'test-item',
+          onActivate: vi.fn(),
+        },
+      ],
+    };
+  });
+
+  describe('constructor', () => {
+    it('should call super with inline class and button wrapper tag', () => {
+      mocks.popoverInline = new PopoverInline(mocks.mockPopoverParams);
+
+      expect(PopoverDesktop).toHaveBeenCalledWith(
+        {
+          ...mocks.mockPopoverParams,
+          class: css.popoverInline,
+        },
+        {
+          [PopoverItemType.Default]: {
+            wrapperTag: 'button',
+            hint: {
+              position: 'top',
+              alignment: 'center',
+              enabled: true,
+            },
+          },
+          [PopoverItemType.Html]: {
+            hint: {
+              position: 'top',
+              alignment: 'center',
+              enabled: true,
+            },
+          },
+        }
+      );
+    });
+
+    it('should disable hints on mobile screens', async () => {
+      const { isMobileScreen } = await import('../../../src/components/utils');
+
+      vi.mocked(isMobileScreen).mockReturnValue(true);
+
+      mocks.popoverInline = new PopoverInline(mocks.mockPopoverParams);
+
+      expect(PopoverDesktop).toHaveBeenCalledWith(
+        expect.any(Object),
+        expect.objectContaining({
+          [PopoverItemType.Default]: expect.objectContaining({
+            hint: expect.objectContaining({
+              enabled: false,
+            }),
+          }),
+          [PopoverItemType.Html]: expect.objectContaining({
+            hint: expect.objectContaining({
+              enabled: false,
+            }),
+          }),
+        })
+      );
+    });
+
+    it('should show nested items for items with hasChildren and isChildrenOpen set to true', () => {
+      const itemWithOpenChildren = createMockDefaultItem({
+        hasChildren: true,
+        isChildrenOpen: true,
+      });
+
+      mocks.mockPopoverDesktop.items = [
+        itemWithOpenChildren,
+        createMockDefaultItem({
+          hasChildren: false,
+          isChildrenOpen: false,
+        }),
+      ];
+
+      mocks.popoverInline = new PopoverInline(mocks.mockPopoverParams);
+
+      expect(mocks.superMethods.showNestedItems).toHaveBeenCalledWith(itemWithOpenChildren);
+    });
+
+    it('should not show nested items for items without children', () => {
+      const itemWithoutChildren = createMockDefaultItem({
+        hasChildren: false,
+        isChildrenOpen: false,
+      });
+
+      mocks.mockPopoverDesktop.items = [ itemWithoutChildren ];
+
+      mocks.popoverInline = new PopoverInline(mocks.mockPopoverParams);
+
+      expect(mocks.superMethods.showNestedItems).not.toHaveBeenCalled();
+    });
+
+    it('should skip non-default and non-html items when checking for nested items', () => {
+      const separatorItem = {
+        getElement: vi.fn(() => document.createElement('div')),
+      };
+
+      const itemWithOpenChildren = createMockDefaultItem({
+        hasChildren: true,
+        isChildrenOpen: true,
+      });
+
+      mocks.mockPopoverDesktop.items = [separatorItem, itemWithOpenChildren] as unknown as Array<PopoverItemDefault | PopoverItemHtml>;
+
+      mocks.popoverInline = new PopoverInline(mocks.mockPopoverParams);
+
+      // Should only call showNestedItems for PopoverItemDefault/PopoverItemHtml, not separator
+      expect(mocks.superMethods.showNestedItems).toHaveBeenCalledTimes(1);
+      expect(mocks.superMethods.showNestedItems).toHaveBeenCalledWith(itemWithOpenChildren);
+    });
+  });
+
+  describe('offsetLeft', () => {
+    it('should return offsetLeft of popoverContainer when container exists', () => {
+      mocks.popoverInline = new PopoverInline(mocks.mockPopoverParams);
+
+      expect(mocks.popoverInline.offsetLeft).toBe(OFFSET_LEFT_VALUE);
+    });
+
+    it('should return 0 when popoverContainer is null', () => {
+      mocks.mockPopoverDesktop.nodes.popoverContainer = null;
+
+      mocks.popoverInline = new PopoverInline(mocks.mockPopoverParams);
+
+      expect(mocks.popoverInline.offsetLeft).toBe(0);
+    });
+  });
+
+  describe('show', () => {
+    beforeEach(() => {
+      mocks.popoverInline = new PopoverInline(mocks.mockPopoverParams);
+    });
+
+    it('should call super.show()', () => {
+      mocks.popoverInline.show();
+
+      expect(mocks.superMethods.show).toHaveBeenCalled();
+    });
+
+    it('should set width and height CSS variables when nestingLevel is 0', () => {
+      mocks.mockPopoverDesktop.nestingLevel = 0;
+      const containerRect = {
+        width: 200,
+        height: 100,
+      };
+
+      vi.spyOn(mocks.mockPopoverDesktop.nodes.popoverContainer!, 'getBoundingClientRect').mockReturnValue(containerRect as DOMRect);
+
+      mocks.popoverInline.show();
+
+      expect(mocks.mockPopoverDesktop.nodes.popover.style.getPropertyValue(CSSVariables.InlinePopoverWidth)).toBe('200px');
+      expect(mocks.mockPopoverDesktop.nodes.popover.style.width).toBe('200px');
+      expect(mocks.mockPopoverDesktop.nodes.popover.style.height).toBe('100px');
+    });
+
+    it('should not set width/height CSS variables when nestingLevel is not 0', () => {
+      mocks.mockPopoverDesktop.nestingLevel = 1;
+
+      mocks.popoverInline.show();
+
+      expect(mocks.mockPopoverDesktop.nodes.popover.style.getPropertyValue(CSSVariables.InlinePopoverWidth)).toBe('');
+    });
+
+    it('should handle undefined containerRect gracefully', () => {
+      mocks.mockPopoverDesktop.nestingLevel = 0;
+      mocks.mockPopoverDesktop.nodes.popoverContainer = null;
+
+      // Should not throw
+      expect(() => mocks.popoverInline.show()).not.toThrow();
+    });
+
+    it('should deactivate and activate flipper with flippableElements', () => {
+      const flippableElements = [ document.createElement('button') ];
+
+      // Access private property to set flippableElements
+      Object.defineProperty(mocks.popoverInline, 'flippableElements', {
+        get: () => flippableElements,
+        configurable: true,
+      });
+
+      mocks.popoverInline.show();
+
+      // Use requestAnimationFrame to wait for async flipper activation
+      return new Promise<void>((resolve) => {
+        requestAnimationFrame(() => {
+          expect(mocks.mockFlipper.deactivate).toHaveBeenCalled();
+          expect(mocks.mockFlipper.activate).toHaveBeenCalledWith(flippableElements);
+          resolve();
+        });
+      });
+    });
+  });
+
+  describe('handleHover', () => {
+    beforeEach(() => {
+      mocks.popoverInline = new PopoverInline(mocks.mockPopoverParams);
+    });
+
+    it('should return early without doing anything', () => {
+      const result = (mocks.popoverInline as unknown as { handleHover: () => void }).handleHover();
+
+      expect(result).toBeUndefined();
+      // Should not call any parent methods
+      expect(mocks.superMethods.showNestedItems).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('setTriggerItemPosition', () => {
+    beforeEach(() => {
+      mocks.popoverInline = new PopoverInline(mocks.mockPopoverParams);
+    });
+
+    it('should set CSS variable with correct left offset', () => {
+      const nestedPopoverEl = document.createElement('div');
+      const itemEl = document.createElement('div');
+
+      Object.defineProperty(itemEl, 'offsetLeft', {
+        value: ITEM_OFFSET_LEFT_VALUE,
+        writable: true,
+        configurable: true,
+      });
+
+      const item = createMockDefaultItem({
+        getElement: vi.fn(() => itemEl),
+      });
+
+      const expectedOffset = OFFSET_LEFT_VALUE + ITEM_OFFSET_LEFT_VALUE;
+
+      (mocks.popoverInline as unknown as { setTriggerItemPosition: (el: HTMLElement, item: PopoverItemDefault) => void })
+        .setTriggerItemPosition(nestedPopoverEl, item);
+
+      expect(nestedPopoverEl.style.getPropertyValue(CSSVariables.TriggerItemLeft)).toBe(`${expectedOffset}px`);
+    });
+
+    it('should handle null item element', () => {
+      const nestedPopoverEl = document.createElement('div');
+
+      const item = createMockDefaultItem({
+        getElement: vi.fn(() => null),
+      });
+
+      (mocks.popoverInline as unknown as { setTriggerItemPosition: (el: HTMLElement, item: PopoverItemDefault) => void })
+        .setTriggerItemPosition(nestedPopoverEl, item);
+
+      expect(nestedPopoverEl.style.getPropertyValue(CSSVariables.TriggerItemLeft)).toBe(`${OFFSET_LEFT_VALUE}px`);
+    });
+
+    it('should handle null popoverContainer', () => {
+      const nestedPopoverEl = document.createElement('div');
+      const itemEl = document.createElement('div');
+
+      Object.defineProperty(itemEl, 'offsetLeft', {
+        value: ITEM_OFFSET_LEFT_VALUE,
+        writable: true,
+        configurable: true,
+      });
+
+      const item = createMockDefaultItem({
+        getElement: vi.fn(() => itemEl),
+      });
+
+      mocks.mockPopoverDesktop.nodes.popoverContainer = null;
+
+      (mocks.popoverInline as unknown as { setTriggerItemPosition: (el: HTMLElement, item: PopoverItemDefault) => void })
+        .setTriggerItemPosition(nestedPopoverEl, item);
+
+      expect(nestedPopoverEl.style.getPropertyValue(CSSVariables.TriggerItemLeft)).toBe(`${ITEM_OFFSET_LEFT_VALUE}px`);
+    });
+  });
+
+  describe('showNestedItems', () => {
+    beforeEach(() => {
+      mocks.popoverInline = new PopoverInline(mocks.mockPopoverParams);
+    });
+
+    it('should close nested popover if same item is clicked again', () => {
+      const item = createMockDefaultItem({
+        hasChildren: true,
+      });
+
+      mocks.mockPopoverDesktop.nestedPopoverTriggerItem = item;
+
+      (mocks.popoverInline as unknown as { showNestedItems: (item: PopoverItemDefault) => void }).showNestedItems(item);
+
+      expect(mocks.superMethods.destroyNestedPopoverIfExists).toHaveBeenCalled();
+      expect(mocks.mockPopoverDesktop.nestedPopoverTriggerItem).toBeNull();
+      expect(mocks.superMethods.showNestedItems).not.toHaveBeenCalled();
+    });
+
+    it('should show nested popover for different item', () => {
+      const item1 = createMockDefaultItem({
+        hasChildren: true,
+      });
+
+      const item2 = createMockDefaultItem({
+        hasChildren: true,
+      });
+
+      mocks.mockPopoverDesktop.nestedPopoverTriggerItem = item1;
+
+      (mocks.popoverInline as unknown as { showNestedItems: (item: PopoverItemDefault) => void }).showNestedItems(item2);
+
+      expect(mocks.superMethods.destroyNestedPopoverIfExists).not.toHaveBeenCalled();
+      expect(mocks.superMethods.showNestedItems).toHaveBeenCalledWith(item2);
+    });
+
+    it('should show nested popover when no nested popover exists', () => {
+      const item = createMockDefaultItem({
+        hasChildren: true,
+      });
+
+      mocks.mockPopoverDesktop.nestedPopoverTriggerItem = null;
+
+      (mocks.popoverInline as unknown as { showNestedItems: (item: PopoverItemDefault) => void }).showNestedItems(item);
+
+      expect(mocks.superMethods.showNestedItems).toHaveBeenCalledWith(item);
+    });
+  });
+
+  describe('showNestedPopoverForItem', () => {
+    beforeEach(() => {
+      mocks.popoverInline = new PopoverInline(mocks.mockPopoverParams);
+    });
+
+    it('should add nested level class to nested popover element', () => {
+      const item = createMockDefaultItem({
+        hasChildren: true,
+        children: [],
+        isChildrenSearchable: false,
+        isChildrenFlippable: true,
+        getElement: vi.fn(() => document.createElement('div')),
+        onChildrenOpen: vi.fn(),
+        onChildrenClose: vi.fn(),
+      });
+
+      const nestedPopoverEl = document.createElement('div');
+      const nestedPopover = {
+        getElement: vi.fn(() => nestedPopoverEl),
+        nestingLevel: 1,
+        on: vi.fn(),
+        flipper: {
+          setHandleContentEditableTargets: vi.fn(),
+          activate: vi.fn(),
+          deactivate: vi.fn(),
+          focusFirst: vi.fn(),
+        },
+      } as unknown as PopoverDesktop;
+
+      mocks.superMethods.showNestedPopoverForItem.mockReturnValue(nestedPopover);
+
+      const result = (mocks.popoverInline as unknown as { showNestedPopoverForItem: (item: PopoverItemDefault) => PopoverDesktop })
+        .showNestedPopoverForItem(item);
+
+      expect(result).toBe(nestedPopover);
+      expect(nestedPopoverEl.classList.contains(css.getPopoverNestedClass(1))).toBe(true);
+    });
+
+    it('should focus nested popover on first Tab press and remove listener', () => {
+      const flippableElements = [ document.createElement('button') ];
+      const nestedPopoverEl = document.createElement('div');
+      const nestedPopoverFlipper = {
+        setHandleContentEditableTargets: vi.fn(),
+        activate: vi.fn(),
+        deactivate: vi.fn(),
+        focusFirst: vi.fn(),
+      };
+
+      const onMock = vi.fn();
+      const nestedPopover = {
+        getElement: vi.fn(() => nestedPopoverEl),
+        nestingLevel: 1,
+        on: onMock,
+        flipper: nestedPopoverFlipper,
+      } as unknown as PopoverDesktop;
+
+      Object.defineProperty(nestedPopover, 'flippableElements', {
+        configurable: true,
+        get: () => flippableElements,
+      });
+
+      const addEventListenerSpy = vi.spyOn(document, 'addEventListener');
+      const removeEventListenerSpy = vi.spyOn(document, 'removeEventListener');
+
+      try {
+        mocks.superMethods.showNestedPopoverForItem.mockReturnValue(nestedPopover);
+
+        const item = createMockDefaultItem({
+          hasChildren: true,
+          getElement: vi.fn(() => document.createElement('div')),
+        });
+
+        (mocks.popoverInline as unknown as { showNestedPopoverForItem: (item: PopoverItemDefault) => PopoverDesktop })
+          .showNestedPopoverForItem(item);
+
+        const keydownCall = addEventListenerSpy.mock.calls.find(([ eventName ]) => eventName === 'keydown');
+
+        expect(keydownCall).toBeDefined();
+
+        const handleFirstTab = keydownCall?.[1] as EventListener;
+
+        if (!handleFirstTab) {
+          throw new Error('handleFirstTab listener is not registered');
+        }
+
+        mocks.mockPopoverDesktop.nestedPopover = nestedPopover;
+
+        const preventDefault = vi.fn();
+        const stopPropagation = vi.fn();
+
+        const event = {
+          key: 'Tab',
+          shiftKey: false,
+          preventDefault,
+          stopPropagation,
+        } as unknown as KeyboardEvent;
+
+        handleFirstTab(event);
+
+        expect(preventDefault).toHaveBeenCalled();
+        expect(stopPropagation).toHaveBeenCalled();
+        expect(nestedPopoverFlipper.activate).toHaveBeenCalledWith(flippableElements);
+        expect(nestedPopoverFlipper.focusFirst).toHaveBeenCalled();
+        expect(removeEventListenerSpy).toHaveBeenCalledWith('keydown', handleFirstTab, true);
+      } finally {
+        addEventListenerSpy.mockRestore();
+        removeEventListenerSpy.mockRestore();
+      }
+    });
+
+    it('should remove Tab listener when nested popover closes', () => {
+      const nestedPopoverEl = document.createElement('div');
+      const onMock = vi.fn();
+      const nestedPopover = {
+        getElement: vi.fn(() => nestedPopoverEl),
+        nestingLevel: 1,
+        on: onMock,
+        flipper: {
+          setHandleContentEditableTargets: vi.fn(),
+          activate: vi.fn(),
+          deactivate: vi.fn(),
+          focusFirst: vi.fn(),
+        },
+      } as unknown as PopoverDesktop;
+
+      Object.defineProperty(nestedPopover, 'flippableElements', {
+        configurable: true,
+        get: () => [],
+      });
+
+      const addEventListenerSpy = vi.spyOn(document, 'addEventListener');
+      const removeEventListenerSpy = vi.spyOn(document, 'removeEventListener');
+
+      try {
+        mocks.superMethods.showNestedPopoverForItem.mockReturnValue(nestedPopover);
+
+        const item = createMockDefaultItem({
+          hasChildren: true,
+          getElement: vi.fn(() => document.createElement('div')),
+        });
+
+        (mocks.popoverInline as unknown as { showNestedPopoverForItem: (item: PopoverItemDefault) => PopoverDesktop })
+          .showNestedPopoverForItem(item);
+
+        const keydownCall = addEventListenerSpy.mock.calls.find(([ eventName ]) => eventName === 'keydown');
+
+        expect(keydownCall).toBeDefined();
+
+        const handleFirstTab = keydownCall?.[1] as EventListener;
+
+        if (!handleFirstTab) {
+          throw new Error('handleFirstTab listener is not registered');
+        }
+
+        const closedHandler = onMock.mock.calls.find(([ event ]) => event === PopoverEvent.Closed)?.[1] as () => void;
+
+        expect(closedHandler).toBeInstanceOf(Function);
+
+        closedHandler();
+
+        expect(removeEventListenerSpy).toHaveBeenCalledWith('keydown', handleFirstTab, true);
+      } finally {
+        addEventListenerSpy.mockRestore();
+        removeEventListenerSpy.mockRestore();
+      }
+    });
+  });
+
+  describe('handleItemClick', () => {
+    beforeEach(() => {
+      mocks.popoverInline = new PopoverInline(mocks.mockPopoverParams);
+    });
+
+    it('should close nested popover and call handleClick on trigger item when different item is clicked', () => {
+      const triggerItem = createMockDefaultItem({
+        hasChildren: true,
+        handleClick: vi.fn(),
+        getElement: vi.fn(() => document.createElement('div')),
+      });
+
+      const clickedItem = createMockDefaultItem({
+        hasChildren: false,
+        handleClick: vi.fn(),
+        getElement: vi.fn(() => document.createElement('div')),
+      });
+
+      mocks.mockPopoverDesktop.nestedPopoverTriggerItem = triggerItem;
+
+      (mocks.popoverInline as unknown as { handleItemClick: (item: PopoverItemDefault) => void }).handleItemClick(clickedItem);
+
+      expect(triggerItem.handleClick).toHaveBeenCalled();
+      expect(mocks.superMethods.destroyNestedPopoverIfExists).toHaveBeenCalled();
+      expect(mocks.superMethods.handleItemClick).toHaveBeenCalledWith(clickedItem);
+    });
+
+    it('should not close nested popover when trigger item is clicked', () => {
+      const triggerItem = createMockDefaultItem({
+        hasChildren: true,
+        handleClick: vi.fn(),
+        getElement: vi.fn(() => document.createElement('div')),
+      });
+
+      mocks.mockPopoverDesktop.nestedPopoverTriggerItem = triggerItem;
+
+      (mocks.popoverInline as unknown as { handleItemClick: (item: PopoverItemDefault) => void }).handleItemClick(triggerItem);
+
+      expect(mocks.superMethods.destroyNestedPopoverIfExists).not.toHaveBeenCalled();
+      expect(mocks.superMethods.handleItemClick).toHaveBeenCalledWith(triggerItem);
+    });
+
+    it('should handle click when no nested popover exists', () => {
+      const clickedItem = createMockDefaultItem({
+        hasChildren: false,
+        handleClick: vi.fn(),
+        getElement: vi.fn(() => document.createElement('div')),
+      });
+
+      mocks.mockPopoverDesktop.nestedPopoverTriggerItem = null;
+
+      (mocks.popoverInline as unknown as { handleItemClick: (item: PopoverItemDefault) => void }).handleItemClick(clickedItem);
+
+      expect(mocks.superMethods.handleItemClick).toHaveBeenCalledWith(clickedItem);
+    });
+  });
+});
+
diff --git a/test/unit/utils/popover-item-default.test.ts b/test/unit/utils/popover-item-default.test.ts
new file mode 100644
index 000000000..bbd6e273c
--- /dev/null
+++ b/test/unit/utils/popover-item-default.test.ts
@@ -0,0 +1,226 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+vi.mock('@codexteam/icons', () => ({
+  IconDotCircle: '<svg data-test-id="dot-circle"></svg>',
+  IconChevronRight: '<svg data-test-id="chevron-right"></svg>',
+}));
+
+import {
+  PopoverItemDefault,
+  type PopoverItemDefaultParams
+} from '../../../src/components/utils/popover/components/popover-item';
+import {
+  css,
+  DATA_ATTRIBUTE_ACTIVE
+} from '../../../src/components/utils/popover/components/popover-item/popover-item-default/popover-item-default.const';
+
+type ItemSetupResult = {
+  item: PopoverItemDefault;
+  params: PopoverItemDefaultParams;
+  element: HTMLElement;
+};
+
+const createItem = (overrides: Partial<PopoverItemDefaultParams> = {}): ItemSetupResult => {
+  const params: PopoverItemDefaultParams = {
+    title: 'Test item',
+    name: 'test-item',
+    icon: '<svg data-test-id="custom-icon"></svg>',
+    onActivate: vi.fn(),
+    ...overrides,
+  };
+
+  const item = new PopoverItemDefault(params);
+  const element = item.getElement();
+
+  if (element === null) {
+    throw new Error('item root element should be created');
+  }
+
+  document.body.appendChild(element);
+
+  return {
+    item,
+    params,
+    element,
+  };
+};
+
+describe('PopoverItemDefault', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    document.body.innerHTML = '';
+  });
+
+  it('creates expected DOM structure on instantiation', () => {
+    const secondaryLabel = 'Secondary label';
+    const { element, params } = createItem({ secondaryLabel });
+
+    expect(element.classList.contains(css.container)).toBe(true);
+    expect(element.dataset.itemName).toBe(params.name);
+
+    const icon = element.querySelector<HTMLElement>(`.${css.icon}`);
+    const title = element.querySelector<HTMLElement>(`.${css.title}`);
+    const secondary = element.querySelector<HTMLElement>(`.${css.secondaryTitle}`);
+
+    expect(icon?.innerHTML).toBe(params.icon);
+    expect(title?.innerHTML).toBe(params.title);
+    expect(secondary?.textContent).toBe(secondaryLabel);
+  });
+
+  it('marks item as active when constructed with isActive=true', () => {
+    const { element } = createItem({ isActive: true });
+
+    expect(element.classList.contains(css.active)).toBe(true);
+    expect(element.getAttribute(DATA_ATTRIBUTE_ACTIVE)).toBe('true');
+  });
+
+  it('toggles active state via toggleActive()', () => {
+    const { item, element } = createItem();
+
+    item.toggleActive();
+    expect(element.classList.contains(css.active)).toBe(true);
+    expect(element.getAttribute(DATA_ATTRIBUTE_ACTIVE)).toBe('true');
+
+    item.toggleActive();
+    expect(element.classList.contains(css.active)).toBe(false);
+    expect(element.hasAttribute(DATA_ATTRIBUTE_ACTIVE)).toBe(false);
+
+    item.toggleActive(true);
+    expect(element.classList.contains(css.active)).toBe(true);
+    expect(element.getAttribute(DATA_ATTRIBUTE_ACTIVE)).toBe('true');
+
+    item.toggleActive(false);
+    expect(element.classList.contains(css.active)).toBe(false);
+    expect(element.hasAttribute(DATA_ATTRIBUTE_ACTIVE)).toBe(false);
+  });
+
+  it('toggles hidden state', () => {
+    const { item, element } = createItem();
+
+    item.toggleHidden(true);
+    expect(element.classList.contains(css.hidden)).toBe(true);
+
+    item.toggleHidden(false);
+    expect(element.classList.contains(css.hidden)).toBe(false);
+  });
+
+  it('invokes onActivate when clicked without confirmation', () => {
+    const onActivate = vi.fn();
+    const { item, params, element } = createItem({ onActivate });
+
+    item.handleClick();
+
+    expect(onActivate).toHaveBeenCalledTimes(1);
+    expect(onActivate).toHaveBeenCalledWith(params);
+    expect(element.classList.contains(css.confirmationState)).toBe(false);
+  });
+
+  it('animates error when onActivate throws', () => {
+    const onActivate = vi.fn(() => {
+      throw new Error('activation failed');
+    });
+    const { item, element } = createItem({ onActivate });
+    const icon = element.querySelector<HTMLElement>(`.${css.icon}`);
+
+    expect(icon).not.toBeNull();
+
+    item.handleClick();
+
+    expect(onActivate).toHaveBeenCalledTimes(1);
+    expect(icon?.classList.contains(css.wobbleAnimation)).toBe(true);
+
+    icon?.dispatchEvent(new Event('animationend'));
+
+    expect(icon?.classList.contains(css.wobbleAnimation)).toBe(false);
+  });
+
+  it('enters confirmation mode on first click and executes confirmation on second click', () => {
+    const confirmationActivate = vi.fn();
+    const confirmation = {
+      title: 'Confirm',
+      onActivate: confirmationActivate,
+    };
+    const { item, element } = createItem({
+      confirmation,
+    });
+
+    item.handleClick();
+    expect(item.isConfirmationStateEnabled).toBe(true);
+    expect(element.classList.contains(css.confirmationState)).toBe(true);
+    expect(element.classList.contains(css.noHover)).toBe(true);
+    expect(element.classList.contains(css.noFocus)).toBe(true);
+
+    item.handleClick();
+
+    expect(confirmationActivate).toHaveBeenCalledTimes(1);
+    expect(confirmationActivate).toHaveBeenCalledWith(confirmation);
+    expect(item.isConfirmationStateEnabled).toBe(false);
+    expect(element.classList.contains(css.confirmationState)).toBe(false);
+    expect(element.classList.contains(css.noHover)).toBe(false);
+    expect(element.classList.contains(css.noFocus)).toBe(false);
+  });
+
+  it('resets confirmation state via reset()', () => {
+    const confirmation = {
+      title: 'Confirm',
+      onActivate: vi.fn(),
+    };
+    const { item, element } = createItem({ confirmation });
+
+    item.handleClick();
+    expect(item.isConfirmationStateEnabled).toBe(true);
+
+    item.reset();
+
+    expect(item.isConfirmationStateEnabled).toBe(false);
+    expect(element.classList.contains(css.confirmationState)).toBe(false);
+  });
+
+  it('removes special hover and focus classes on focus', () => {
+    const confirmation = {
+      title: 'Confirm',
+      onActivate: vi.fn(),
+    };
+    const { item, element } = createItem({ confirmation });
+
+    item.handleClick();
+    expect(element.classList.contains(css.noHover)).toBe(true);
+    expect(element.classList.contains(css.noFocus)).toBe(true);
+
+    item.onFocus();
+
+    expect(element.classList.contains(css.noHover)).toBe(false);
+    expect(element.classList.contains(css.noFocus)).toBe(false);
+  });
+
+  it('reflects focus state through isFocused getter', () => {
+    const { item, element } = createItem();
+
+    expect(item.isFocused).toBe(false);
+
+    element.classList.add(css.focused);
+    expect(item.isFocused).toBe(true);
+
+    element.classList.remove(css.focused);
+    expect(item.isFocused).toBe(false);
+  });
+
+  it('exposes toggle, title and disabled getters', () => {
+    const toggleValue = 'group-1';
+    const customTitle = 'Custom title';
+    const { item } = createItem({
+      toggle: toggleValue,
+      title: customTitle,
+      isDisabled: true,
+    });
+
+    expect(item.toggle).toBe(toggleValue);
+    expect(item.title).toBe(customTitle);
+    expect(item.isDisabled).toBe(true);
+  });
+});
+
diff --git a/test/unit/utils/popover-mobile.test.ts b/test/unit/utils/popover-mobile.test.ts
new file mode 100644
index 000000000..2b6519293
--- /dev/null
+++ b/test/unit/utils/popover-mobile.test.ts
@@ -0,0 +1,309 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import type { PopoverParams, PopoverMobileNodes } from '@/types/utils/popover/popover';
+import type { PopoverItemDefaultParams, PopoverItemParams } from '@/types/utils/popover/popover-item';
+import type { PopoverHeaderParams } from '../../../src/components/utils/popover/components/popover-header';
+import { PopoverItemDefault } from '../../../src/components/utils/popover/components/popover-item';
+import { PopoverMobile } from '../../../src/components/utils/popover/popover-mobile';
+import { PopoverAbstract } from '../../../src/components/utils/popover/popover-abstract';
+import { PopoverStatesHistory } from '../../../src/components/utils/popover/utils/popover-states-history';
+import { css } from '../../../src/components/utils/popover/popover.const';
+
+interface MockScrollLockerInstance {
+  lock: ReturnType<typeof vi.fn>;
+  unlock: ReturnType<typeof vi.fn>;
+}
+
+interface MockPopoverHeaderInstance {
+  destroy: ReturnType<typeof vi.fn>;
+  getElement: ReturnType<typeof vi.fn<[], HTMLElement>>;
+  element: HTMLElement;
+  params: PopoverHeaderParams;
+}
+
+const scrollLockerMock = vi.hoisted(() => {
+  const instances: MockScrollLockerInstance[] = [];
+  const factory = vi.fn(() => {
+    const instance: MockScrollLockerInstance = {
+      lock: vi.fn(),
+      unlock: vi.fn(),
+    };
+
+    instances.push(instance);
+
+    return instance;
+  });
+
+  return { instances,
+    factory };
+});
+
+vi.mock('../../../src/components/utils/scroll-locker', () => ({
+  default: scrollLockerMock.factory,
+}));
+
+const popoverHeaderMock = vi.hoisted(() => {
+  const instances: MockPopoverHeaderInstance[] = [];
+  const factory = vi.fn((params: PopoverHeaderParams) => {
+    const element = document.createElement('div');
+    const instance: MockPopoverHeaderInstance = {
+      destroy: vi.fn(),
+      getElement: vi.fn<[], HTMLElement>(() => element),
+      element,
+      params,
+    };
+
+    instances.push(instance);
+
+    return instance;
+  });
+
+  return { instances,
+    factory };
+});
+
+vi.mock('../../../src/components/utils/popover/components/popover-header', () => ({
+  PopoverHeader: popoverHeaderMock.factory,
+}));
+
+const getLatestScrollLocker = (): MockScrollLockerInstance => {
+  if (scrollLockerMock.instances.length === 0) {
+    throw new Error('ScrollLocker instance was not created');
+  }
+
+  return scrollLockerMock.instances[scrollLockerMock.instances.length - 1];
+};
+
+const getNodes = (popover: PopoverMobile): PopoverMobileNodes => {
+  return (popover as unknown as { nodes: PopoverMobileNodes }).nodes;
+};
+
+const getPrivateApi = (popover: PopoverMobile): {
+  updateItemsAndHeader: (items: PopoverItemParams[], title?: string) => void;
+  showNestedItems: (item: PopoverItemDefault) => void;
+} => popover as unknown as {
+  updateItemsAndHeader: (items: PopoverItemParams[], title?: string) => void;
+  showNestedItems: (item: PopoverItemDefault) => void;
+};
+
+const createPopoverParams = (overrides: Partial<PopoverParams> = {}): PopoverParams => ({
+  items: [
+    {
+      title: 'First item',
+      onActivate: vi.fn(),
+    },
+    {
+      title: 'Second item',
+      onActivate: vi.fn(),
+    },
+  ],
+  ...overrides,
+});
+
+const createPopover = (overrides?: Partial<PopoverParams>): { popover: PopoverMobile; params: PopoverParams } => {
+  const params = createPopoverParams(overrides);
+
+  return {
+    popover: new PopoverMobile(params),
+    params,
+  };
+};
+
+describe('PopoverMobile', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+    vi.clearAllMocks();
+    scrollLockerMock.instances.length = 0;
+    popoverHeaderMock.instances.length = 0;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('creates overlay, attaches click to hide, and stores initial state in history', () => {
+      const historyPushSpy = vi.spyOn(PopoverStatesHistory.prototype, 'push');
+      const { popover, params } = createPopover();
+      const nodes = getNodes(popover);
+      const hideSpy = vi.spyOn(popover, 'hide');
+
+      expect(nodes.overlay.classList.contains(css.overlay)).toBe(true);
+      expect(nodes.overlay.classList.contains(css.overlayHidden)).toBe(true);
+      expect(nodes.popover.firstChild).toBe(nodes.overlay);
+
+      nodes.overlay.click();
+
+      expect(hideSpy).toHaveBeenCalledTimes(1);
+      expect(historyPushSpy).toHaveBeenCalledWith({ items: params.items });
+    });
+  });
+
+  describe('show', () => {
+    it('removes overlay hidden class, calls super.show, and locks scroll', () => {
+      const superShowSpy = vi.spyOn(PopoverAbstract.prototype, 'show');
+      const { popover } = createPopover();
+      const nodes = getNodes(popover);
+
+      popover.show();
+
+      expect(nodes.overlay.classList.contains(css.overlayHidden)).toBe(false);
+      expect(superShowSpy).toHaveBeenCalledTimes(1);
+      expect(getLatestScrollLocker().lock).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('hide', () => {
+    it('does nothing when already hidden', () => {
+      const superHideSpy = vi.spyOn(PopoverAbstract.prototype, 'hide');
+      const historyResetSpy = vi.spyOn(PopoverStatesHistory.prototype, 'reset');
+      const { popover } = createPopover();
+
+      popover.hide();
+
+      expect(superHideSpy).not.toHaveBeenCalled();
+      expect(historyResetSpy).not.toHaveBeenCalled();
+      expect(getLatestScrollLocker().unlock).not.toHaveBeenCalled();
+    });
+
+    it('hides overlay, resets history, and unlocks scroll when popover was visible', () => {
+      const superHideSpy = vi.spyOn(PopoverAbstract.prototype, 'hide');
+      const historyResetSpy = vi.spyOn(PopoverStatesHistory.prototype, 'reset');
+      const { popover } = createPopover();
+      const nodes = getNodes(popover);
+
+      popover.show();
+      popover.hide();
+
+      expect(nodes.overlay.classList.contains(css.overlayHidden)).toBe(true);
+      expect(superHideSpy).toHaveBeenCalledTimes(1);
+      expect(historyResetSpy).toHaveBeenCalledTimes(1);
+      expect(getLatestScrollLocker().unlock).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('destroy', () => {
+    it('calls super.destroy and unlocks scroll', () => {
+      const superDestroySpy = vi.spyOn(PopoverAbstract.prototype, 'destroy');
+      const { popover } = createPopover();
+
+      popover.destroy();
+
+      expect(superDestroySpy).toHaveBeenCalledTimes(1);
+      expect(getLatestScrollLocker().unlock).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('showNestedItems', () => {
+    it('updates rendered items and pushes nested state to history', () => {
+      const historyPushSpy = vi.spyOn(PopoverStatesHistory.prototype, 'push');
+      const { popover } = createPopover();
+      const popoverPrivate = getPrivateApi(popover);
+      const nestedItems: PopoverItemParams[] = [
+        {
+          title: 'Nested child',
+          onActivate: vi.fn(),
+        },
+      ];
+      const parentItemParams: PopoverItemDefaultParams = {
+        title: 'Parent',
+        children: {
+          items: nestedItems,
+        },
+      };
+      const parentItem = new PopoverItemDefault(parentItemParams);
+      const updateSpy = vi.spyOn(popoverPrivate, 'updateItemsAndHeader');
+
+      popoverPrivate.showNestedItems(parentItem);
+
+      expect(updateSpy).toHaveBeenCalledWith(nestedItems, 'Parent');
+      expect(historyPushSpy).toHaveBeenCalledWith({
+        title: 'Parent',
+        items: nestedItems,
+      });
+    });
+
+    it('restores previous items when back button is clicked', () => {
+      const { popover, params } = createPopover();
+      const popoverPrivate = getPrivateApi(popover);
+      const nestedItems: PopoverItemParams[] = [
+        {
+          title: 'Nested child',
+          onActivate: vi.fn(),
+        },
+      ];
+      const parentItem = new PopoverItemDefault({
+        title: 'Parent',
+        children: {
+          items: nestedItems,
+        },
+      } as PopoverItemDefaultParams);
+      const updateSpy = vi.spyOn(popoverPrivate, 'updateItemsAndHeader');
+      const historyPopSpy = vi.spyOn(PopoverStatesHistory.prototype, 'pop');
+
+      popoverPrivate.showNestedItems(parentItem);
+      updateSpy.mockClear();
+
+      const header = popoverHeaderMock.instances[popoverHeaderMock.instances.length - 1];
+
+      header.params.onBackButtonClick();
+
+      expect(historyPopSpy).toHaveBeenCalledTimes(1);
+      expect(updateSpy).toHaveBeenCalledWith(params.items, undefined);
+    });
+  });
+
+  describe('updateItemsAndHeader', () => {
+    it('renders header and replaces items when title is provided', () => {
+      const { popover } = createPopover();
+      const popoverPrivate = getPrivateApi(popover);
+      const nodes = getNodes(popover);
+      const initialItems = Array.from(nodes.items.children);
+      const nextItems: PopoverItemParams[] = [
+        {
+          title: 'Next',
+          onActivate: vi.fn(),
+        },
+        {
+          title: 'Another',
+          onActivate: vi.fn(),
+        },
+      ];
+
+      popoverPrivate.updateItemsAndHeader(nextItems, 'Nested title');
+
+      expect(popoverHeaderMock.factory).toHaveBeenCalledTimes(1);
+      expect(popoverHeaderMock.instances[0].element).toBe(nodes.popoverContainer.firstChild);
+      expect(nodes.items.childElementCount).toBe(nextItems.length);
+      initialItems.forEach(element => {
+        expect(nodes.items.contains(element)).toBe(false);
+      });
+    });
+
+    it('destroys existing header before rendering a new one', () => {
+      const { popover } = createPopover();
+      const popoverPrivate = getPrivateApi(popover);
+      const nodes = getNodes(popover);
+      const firstItems: PopoverItemParams[] = [
+        {
+          title: 'First nested',
+          onActivate: vi.fn(),
+        },
+      ];
+      const secondItems: PopoverItemParams[] = [
+        {
+          title: 'Second nested',
+          onActivate: vi.fn(),
+        },
+      ];
+
+      popoverPrivate.updateItemsAndHeader(firstItems, 'First title');
+      const [ firstHeader ] = popoverHeaderMock.instances;
+
+      popoverPrivate.updateItemsAndHeader(secondItems, 'Second title');
+
+      expect(firstHeader.destroy).toHaveBeenCalledTimes(1);
+      expect(popoverHeaderMock.factory).toHaveBeenCalledTimes(2);
+      expect(popoverHeaderMock.instances[1].element).toBe(nodes.popoverContainer.firstChild);
+    });
+  });
+});
diff --git a/test/unit/utils/sanitizer.test.ts b/test/unit/utils/sanitizer.test.ts
new file mode 100644
index 000000000..241559c53
--- /dev/null
+++ b/test/unit/utils/sanitizer.test.ts
@@ -0,0 +1,970 @@
+import { describe, it, expect } from 'vitest';
+import { sanitizeBlocks, clean, composeSanitizerConfig } from '../../../src/components/utils/sanitizer';
+import type { SanitizerConfig, SanitizerRule } from '../../../types';
+import type { SavedData } from '../../../types/data-formats';
+
+/**
+ * Unit tests for sanitizer.ts
+ *
+ * Tests edge cases and internal functionality not covered by E2E tests
+ */
+describe('sanitizer', () => {
+  describe('sanitizeBlocks', () => {
+    describe('function-based sanitizeConfig parameter', () => {
+      it('should use function to get config per tool', () => {
+        const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+          {
+            tool: 'paragraph',
+            data: {
+              text: '<strong>Bold</strong> <span>bad</span>',
+            },
+          },
+          {
+            tool: 'header',
+            data: {
+              text: '<strong>Bold</strong> <span>bad</span>',
+            },
+          },
+        ];
+
+        const getConfig = (toolName: string): SanitizerConfig | undefined => {
+          if (toolName === 'paragraph') {
+            return {
+              strong: {},
+            };
+          }
+
+          if (toolName === 'header') {
+            return {
+              span: {},
+            };
+          }
+
+          return undefined;
+        };
+
+        const result = sanitizeBlocks(blocksData, getConfig, {});
+
+        expect(result[0].data.text).toContain('<strong>');
+        expect(result[0].data.text).not.toContain('<span>');
+        expect(result[1].data.text).not.toContain('<strong>');
+        expect(result[1].data.text).toContain('<span>');
+      });
+
+      it('should handle function returning undefined', () => {
+        const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+          {
+            tool: 'paragraph',
+            data: {
+              text: '<strong>Bold</strong>',
+            },
+          },
+        ];
+
+        const getConfig = (): SanitizerConfig | undefined => undefined;
+
+        const result = sanitizeBlocks(blocksData, getConfig, {});
+
+        // Should return block unchanged when both config and globalSanitizer are empty
+        expect(result[0].data.text).toBe('<strong>Bold</strong>');
+      });
+
+      it('should use globalSanitizer when function returns undefined', () => {
+        const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+          {
+            tool: 'paragraph',
+            data: {
+              text: '<strong>Bold</strong> <span>bad</span>',
+            },
+          },
+        ];
+
+        const getConfig = (): SanitizerConfig | undefined => undefined;
+        const globalSanitizer: SanitizerConfig = {
+          strong: {},
+        };
+
+        const result = sanitizeBlocks(blocksData, getConfig, globalSanitizer);
+
+        expect(result[0].data.text).toContain('<strong>');
+        expect(result[0].data.text).not.toContain('<span>');
+      });
+    });
+
+    describe('early return path', () => {
+      it('should return block unchanged when both rules and globalSanitizer are empty', () => {
+        const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+          {
+            tool: 'paragraph',
+            data: {
+              text: '<strong>Bold</strong>',
+            },
+          },
+        ];
+
+        const result = sanitizeBlocks(blocksData, {}, {});
+
+        expect(result[0].data.text).toBe('<strong>Bold</strong>');
+        expect(result[0].tool).toBe('paragraph');
+      });
+
+      it('should sanitize when globalSanitizer is provided even if rules are empty', () => {
+        const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+          {
+            tool: 'paragraph',
+            data: {
+              text: '<strong>Bold</strong> <span>bad</span>',
+            },
+          },
+        ];
+
+        const globalSanitizer: SanitizerConfig = {
+          strong: {},
+        };
+
+        const result = sanitizeBlocks(blocksData, {}, globalSanitizer);
+
+        expect(result[0].data.text).toContain('<strong>');
+        expect(result[0].data.text).not.toContain('<span>');
+      });
+    });
+
+    describe('deep sanitization', () => {
+      it('should sanitize nested objects with field-specific rules', () => {
+        const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+          {
+            tool: 'custom',
+            data: {
+              title: '<strong>Title</strong> <span>bad</span>',
+              content: {
+                text: '<strong>Content</strong> <span>bad</span>',
+                items: [ '<strong>Item</strong> <span>bad</span>' ],
+              },
+            },
+          },
+        ];
+
+        const sanitizeConfig = {
+          title: {
+            strong: true,
+          },
+          content: {
+            text: {
+              strong: true,
+            },
+            items: {
+              strong: true,
+            },
+          },
+        } as unknown as SanitizerConfig;
+
+        const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+        const data = result[0].data as Record<string, unknown>;
+
+        expect(data.title).toContain('<strong>');
+        expect(data.title).not.toContain('<span>');
+
+        const content = data.content as Record<string, unknown>;
+
+        expect(content.text).toContain('<strong>');
+        expect(content.text).not.toContain('<span>');
+
+        const items = content.items as string[];
+
+        expect(items[0]).toContain('<strong>');
+        expect(items[0]).not.toContain('<span>');
+      });
+
+      it('should handle arrays with primitive values', () => {
+        const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+          {
+            tool: 'custom',
+            data: {
+              items: [
+                '<strong>Item 1</strong>',
+                '<span>Item 2</span>',
+                '<i>Item 3</i>',
+              ],
+            },
+          },
+        ];
+
+        const sanitizeConfig: SanitizerConfig = {
+          items: {
+            strong: {},
+          } as unknown as SanitizerRule,
+        };
+
+        const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+        const data = result[0].data as Record<string, unknown>;
+        const items = data.items as string[];
+
+        expect(items[0]).toContain('<strong>');
+        expect(items[1]).not.toContain('<span>');
+        expect(items[2]).not.toContain('<i>');
+      });
+
+      it('should handle non-string primitives unchanged', () => {
+        const expectedCount = 42;
+        const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+          {
+            tool: 'custom',
+            data: {
+              count: expectedCount,
+              active: true,
+              text: '<strong>Text</strong>',
+            },
+          },
+        ];
+
+        const sanitizeConfig: SanitizerConfig = {
+          text: {
+            strong: {},
+          } as unknown as SanitizerRule,
+        };
+
+        const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+        const data = result[0].data as Record<string, unknown>;
+
+        expect(data.count).toBe(expectedCount);
+        expect(data.active).toBe(true);
+        expect(data.text).toContain('<strong>');
+      });
+    });
+  });
+
+  describe('clean', () => {
+    it('should clean HTML with custom config', () => {
+      const taintString = '<strong>Bold</strong> <span>Span</span> <script>alert("XSS")</script>';
+      const customConfig: SanitizerConfig = {
+        strong: {},
+      };
+
+      const result = clean(taintString, customConfig);
+
+      expect(result).toContain('<strong>');
+      expect(result).not.toContain('<span>');
+      expect(result).not.toContain('<script>');
+    });
+
+    it('should handle empty config', () => {
+      const taintString = '<strong>Bold</strong>';
+      const result = clean(taintString, {});
+
+      // With empty config, HTMLJanitor should remove all tags
+      expect(result).not.toContain('<strong>');
+    });
+
+    it('should handle empty string', () => {
+      const result = clean('', {});
+
+      expect(result).toBe('');
+    });
+
+    it('should handle non-HTML string', () => {
+      const result = clean('Plain text without HTML', {});
+
+      expect(result).toBe('Plain text without HTML');
+    });
+  });
+
+  describe('composeSanitizerConfig', () => {
+    it('should merge multiple configs', () => {
+      const globalConfig: SanitizerConfig = {
+        strong: {
+          class: true,
+        },
+        span: {} as unknown as SanitizerRule,
+      };
+
+      const config1: SanitizerConfig = {
+        strong: {
+          id: true,
+        },
+      };
+
+      const config2: SanitizerConfig = {
+        span: {
+          class: true,
+        },
+      };
+
+      const result = composeSanitizerConfig(globalConfig, config1, config2);
+
+      expect(result.strong).toEqual({
+        class: true,
+        id: true,
+      });
+      expect(result.span).toEqual({
+        class: true,
+      });
+    });
+
+    it('should handle empty globalConfig', () => {
+      const config1: SanitizerConfig = {
+        strong: {},
+      };
+
+      const config2: SanitizerConfig = {
+        span: {},
+      };
+
+      const result = composeSanitizerConfig({} as SanitizerConfig, config1, config2);
+
+      expect(result.strong).toBeDefined();
+      expect(result.span).toBeDefined();
+    });
+
+    it('should skip tags not in base config', () => {
+      const globalConfig: SanitizerConfig = {
+        strong: {},
+      };
+
+      const config: SanitizerConfig = {
+        strong: {
+          class: true,
+        },
+        span: {}, // Not in globalConfig, should be skipped
+      };
+
+      const result = composeSanitizerConfig(globalConfig, config);
+
+      expect(result.strong).toEqual({
+        class: true,
+      });
+      expect(result.span).toBeUndefined();
+    });
+
+    it('should handle function values', () => {
+      const globalConfig: SanitizerConfig = {
+        a: {
+          href: true,
+        },
+      };
+
+      const config: SanitizerConfig = {
+        a: (el: Element): { [attr: string]: boolean | string } => {
+          const href = el.getAttribute('href');
+
+          return href?.startsWith('http') ? { href: true,
+            target: '_blank' } : { href: true };
+        },
+      };
+
+      const result = composeSanitizerConfig(globalConfig, config);
+
+      expect(typeof result.a).toBe('function');
+    });
+
+    it('should handle null/undefined configs', () => {
+      const globalConfig: SanitizerConfig = {
+        strong: {},
+      };
+
+      const result = composeSanitizerConfig(globalConfig, null as unknown as SanitizerConfig, undefined as unknown as SanitizerConfig);
+
+      expect(result.strong).toBeDefined();
+    });
+
+    it('should handle boolean values', () => {
+      const globalConfig: SanitizerConfig = {
+        strong: {},
+        span: true,
+      };
+
+      const config: SanitizerConfig = {
+        strong: true,
+        span: false,
+      };
+
+      const result = composeSanitizerConfig(globalConfig, config);
+
+      expect(result.strong).toEqual({});
+      expect(result.span).toBe(false);
+    });
+
+    it('should handle string values', () => {
+      const globalConfig: SanitizerConfig = {
+        a: {
+          href: true,
+        },
+      };
+
+      const config: SanitizerConfig = {
+        a: 'custom-rule' as unknown as SanitizerRule,
+      };
+
+      const result = composeSanitizerConfig(globalConfig, config);
+
+      expect(result.a).toBe('custom-rule');
+    });
+  });
+
+  describe('getEffectiveRuleForString edge cases', () => {
+    it('should handle rule === false', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<strong>Bold</strong>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: false,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      // When rule is false, should return empty config (no tags allowed)
+      expect(result[0].data.text).not.toContain('<strong>');
+    });
+
+    it('should handle rule === true', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<strong>Bold</strong> <span>bad</span>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: true,
+      };
+
+      const globalSanitizer: SanitizerConfig = {
+        strong: {},
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, globalSanitizer);
+
+      // When rule is true, should use global rules
+      expect(result[0].data.text).toContain('<strong>');
+      expect(result[0].data.text).not.toContain('<span>');
+    });
+
+    it('should handle rule === true with empty globalSanitizer', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<strong>Bold</strong>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: true,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      // When rule is true but globalSanitizer is empty, should strip unsafe URLs only
+      expect(result[0].data.text).toBe('<strong>Bold</strong>');
+    });
+  });
+
+  describe('mergeTagRules edge cases', () => {
+    it('should prioritize field function over global function', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<a href="https://example.com">Link</a>',
+          },
+        },
+      ];
+
+      const globalSanitizer: SanitizerConfig = {
+        a: (_el: Element) => {
+          return { href: true };
+        },
+      };
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          a: (el: Element): { [attr: string]: boolean | string } => {
+            const href = el.getAttribute('href');
+
+            return href?.startsWith('http') ? { href: true,
+              target: '_blank' } : { href: true };
+          },
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, globalSanitizer);
+
+      // Field function should be used
+      expect(result[0].data.text).toContain('target="_blank"');
+    });
+
+    it('should handle fieldValue === false', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<strong>Bold</strong> <span>Span</span>',
+          },
+        },
+      ];
+
+      const globalSanitizer: SanitizerConfig = {
+        strong: {},
+        span: {},
+      };
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          span: false,
+        },
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, globalSanitizer);
+
+      expect(result[0].data.text).toContain('<strong>');
+      expect(result[0].data.text).not.toContain('<span>');
+    });
+
+    it('should handle fieldValue === true', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<strong>Bold</strong>',
+          },
+        },
+      ];
+
+      const globalSanitizer: SanitizerConfig = {
+        strong: {
+          class: true,
+        },
+      };
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          strong: true,
+        },
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, globalSanitizer);
+
+      // When fieldValue is true, should use empty config (all attributes allowed)
+      expect(result[0].data.text).toContain('<strong>');
+    });
+
+    it('should merge object values', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<a href="https://example.com" class="link">Link</a>',
+          },
+        },
+      ];
+
+      const globalSanitizer: SanitizerConfig = {
+        a: {
+          href: true,
+        },
+      };
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          a: {
+            class: true,
+          },
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, globalSanitizer);
+
+      expect(result[0].data.text).toContain('href="https://example.com"');
+      expect(result[0].data.text).toContain('class="link"');
+    });
+  });
+
+  describe('stripUnsafeUrls edge cases', () => {
+    it('should strip javascript: URLs with single quotes', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<a href=\'javascript:alert(1)\'>Link</a>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          a: {
+            href: true,
+          },
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      expect(result[0].data.text).not.toContain('javascript:');
+    });
+
+    it('should strip javascript: URLs with double quotes', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<a href="javascript:alert(1)">Link</a>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          a: {
+            href: true,
+          },
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      expect(result[0].data.text).not.toContain('javascript:');
+    });
+
+    it('should strip javascript: URLs without quotes', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<a href=javascript:alert(1)>Link</a>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          a: {
+            href: true,
+          },
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      expect(result[0].data.text).not.toContain('javascript:');
+    });
+
+    it('should strip data:text/html URLs', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<img src="data:text/html,<script>alert(1)</script>">',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          img: {
+            src: true,
+          },
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      expect(result[0].data.text).not.toContain('data:text/html');
+    });
+
+    it('should handle URLs with spaces', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<a href="javascript: alert(1)">Link</a>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          a: {
+            href: true,
+          },
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      expect(result[0].data.text).not.toContain('javascript:');
+    });
+  });
+
+  describe('applyAttributeOverrides edge cases', () => {
+    it('should remove attribute when function returns false', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<a href="https://example.com" class="link">Link</a>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          a: (_el: Element) => {
+            return {
+              href: true,
+              class: false, // Should remove class attribute
+            };
+          },
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      expect(result[0].data.text).toContain('href="https://example.com"');
+      expect(result[0].data.text).not.toContain('class="link"');
+    });
+
+    it('should keep attribute when function returns true', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<a href="https://example.com" class="link">Link</a>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          a: (_el: Element) => {
+            return {
+              href: true,
+              class: true, // Should keep class attribute
+            };
+          },
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      expect(result[0].data.text).toContain('href="https://example.com"');
+      expect(result[0].data.text).toContain('class="link"');
+    });
+
+    it('should set attribute value when function returns string', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<a href="https://example.com">Link</a>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          a: (el: Element): { [attr: string]: boolean | string } => {
+            const href = el.getAttribute('href');
+
+            return {
+              href: true,
+              ...(href?.startsWith('http') && { target: '_blank' }),
+            };
+          },
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      expect(result[0].data.text).toContain('href="https://example.com"');
+      expect(result[0].data.text).toContain('target="_blank"');
+    });
+
+    it('should handle function returning null', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<a href="https://example.com">Link</a>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          a: () => null as unknown as SanitizerRule,
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      // Should not crash and should still sanitize
+      expect(result[0].data.text).toBeDefined();
+    });
+
+    it('should handle function returning boolean directly', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<a href="https://example.com">Link</a>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          a: () => false as unknown as SanitizerRule,
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      // Should not crash
+      expect(result[0].data.text).toBeDefined();
+    });
+
+    it('should handle multiple elements with function rules', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<a href="https://example.com">Link 1</a> <a href="https://test.com">Link 2</a>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: {
+          a: (el: Element): { [attr: string]: boolean | string } => {
+            const href = el.getAttribute('href');
+
+            return {
+              href: true,
+              ...(href?.startsWith('http') && { target: '_blank' }),
+            };
+          },
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      expect(result[0].data.text).toContain('target="_blank"');
+      // Both links should have target="_blank"
+      const matches = result[0].data.text.match(/target="_blank"/g);
+
+      expect(matches).toHaveLength(2);
+    });
+  });
+
+  describe('cleanObject edge cases', () => {
+    it('should handle rules === true at object level', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<strong>Bold</strong> <span>bad</span>',
+          },
+        },
+      ];
+
+      const globalSanitizer: SanitizerConfig = {
+        strong: {},
+      };
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: true,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, globalSanitizer);
+
+      expect(result[0].data.text).toContain('<strong>');
+      expect(result[0].data.text).not.toContain('<span>');
+    });
+
+    it('should handle rules === false at object level', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            text: '<strong>Bold</strong>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        text: false,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      expect(result[0].data.text).not.toContain('<strong>');
+    });
+
+    it('should use field-specific rule when available', () => {
+      const blocksData: Array<Pick<SavedData, 'data' | 'tool'>> = [
+        {
+          tool: 'paragraph',
+          data: {
+            title: '<strong>Title</strong> <span>bad</span>',
+            content: '<strong>Content</strong> <span>bad</span>',
+          },
+        },
+      ];
+
+      const sanitizeConfig: SanitizerConfig = {
+        title: {
+          strong: {},
+        } as unknown as SanitizerRule,
+        content: {
+          span: {},
+        } as unknown as SanitizerRule,
+      };
+
+      const result = sanitizeBlocks(blocksData, sanitizeConfig, {});
+
+      const data = result[0].data as Record<string, unknown>;
+
+      expect(data.title).toContain('<strong>');
+      expect(data.title).not.toContain('<span>');
+      expect(data.content).not.toContain('<strong>');
+      expect(data.content).toContain('<span>');
+    });
+  });
+
+  describe('cloneTagConfig edge cases', () => {
+    it('should handle string rule type', () => {
+      const config: SanitizerConfig = {
+        a: 'custom-string' as unknown as SanitizerRule,
+      };
+
+      const result = composeSanitizerConfig({} as SanitizerConfig, config);
+
+      expect(result.a).toBe('custom-string');
+    });
+
+    it('should handle function rule type', () => {
+      const fn = (_el: Element): { [attr: string]: boolean | string } => ({ href: true });
+
+      const config: SanitizerConfig = {
+        a: fn,
+      };
+
+      const result = composeSanitizerConfig({} as SanitizerConfig, config);
+
+      expect(result.a).toBe(fn);
+    });
+  });
+});
+
diff --git a/test/unit/utils/search-input.test.ts b/test/unit/utils/search-input.test.ts
new file mode 100644
index 000000000..952e175ef
--- /dev/null
+++ b/test/unit/utils/search-input.test.ts
@@ -0,0 +1,118 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { SearchInput } from '../../../src/components/utils/popover/components/search-input/search-input';
+import { SearchInputEvent } from '../../../src/components/utils/popover/components/search-input/search-input.types';
+import { css } from '../../../src/components/utils/popover/components/search-input/search-input.const';
+import type Listeners from '../../../src/components/utils/listeners';
+
+const getInput = (instance: SearchInput): HTMLInputElement => {
+  return (instance as unknown as { input: HTMLInputElement }).input;
+};
+
+const getListeners = (instance: SearchInput): Listeners => {
+  return (instance as unknown as { listeners: Listeners }).listeners;
+};
+
+describe('SearchInput', () => {
+  const defaultItems = [
+    { title: 'Move Up' },
+    { title: 'Delete' },
+    { title: undefined },
+  ];
+
+  const createSearchInput = (override: Partial<ConstructorParameters<typeof SearchInput>[0]> = {}): SearchInput => {
+    return new SearchInput({
+      items: defaultItems,
+      placeholder: 'Filter actions',
+      ...override,
+    });
+  };
+
+  beforeEach(() => {
+    document.body.innerHTML = '';
+    vi.restoreAllMocks();
+  });
+
+  it('builds the wrapper with icon and input', () => {
+    const searchInput = createSearchInput();
+    const element = searchInput.getElement();
+    const children = Array.from(element.children) as HTMLElement[];
+
+    expect(element.classList.contains(css.wrapper)).toBe(true);
+    expect(children.length).toBe(2);
+    const [iconWrapper, input] = children;
+
+    expect(iconWrapper.classList.contains(css.icon)).toBe(true);
+    expect(iconWrapper.innerHTML.trim()).not.toHaveLength(0);
+
+    expect(input.classList.contains(css.input)).toBe(true);
+    expect((input as HTMLInputElement).type).toBe('search');
+    expect((input as HTMLInputElement).tabIndex).toBe(-1);
+    expect((input as HTMLInputElement).dataset.flipperTabTarget).toBe('true');
+    expect((input as HTMLInputElement).placeholder).toBe('Filter actions');
+  });
+
+  it('focuses the underlying input', () => {
+    const searchInput = createSearchInput();
+    const input = getInput(searchInput);
+    const focusSpy = vi.spyOn(input, 'focus');
+
+    searchInput.focus();
+
+    expect(focusSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('emits search event with filtered items on input', () => {
+    const searchInput = createSearchInput();
+    const handler = vi.fn();
+
+    searchInput.on(SearchInputEvent.Search, handler);
+
+    const input = getInput(searchInput);
+
+    input.value = 'move';
+    input.dispatchEvent(new Event('input'));
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler).toHaveBeenCalledWith({
+      query: 'move',
+      items: [ defaultItems[0] ],
+    });
+  });
+
+  it('clears value and emits empty query', () => {
+    const customItems = [
+      { title: 'Alpha' },
+      { title: 'Beta' },
+    ];
+    const searchInput = createSearchInput({ items: customItems });
+    const input = getInput(searchInput);
+    const handler = vi.fn();
+
+    searchInput.on(SearchInputEvent.Search, handler);
+
+    input.value = 'alpha';
+    input.dispatchEvent(new Event('input'));
+
+    handler.mockClear();
+
+    searchInput.clear();
+
+    expect(input.value).toBe('');
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler).toHaveBeenCalledWith({
+      query: '',
+      items: customItems,
+    });
+  });
+
+  it('removes listeners on destroy', () => {
+    const searchInput = createSearchInput();
+    const listeners = getListeners(searchInput);
+    const removeAllSpy = vi.spyOn(listeners, 'removeAll');
+
+    searchInput.destroy();
+
+    expect(removeAllSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
diff --git a/test/unit/utils/shortcuts.test.ts b/test/unit/utils/shortcuts.test.ts
new file mode 100644
index 000000000..da745feff
--- /dev/null
+++ b/test/unit/utils/shortcuts.test.ts
@@ -0,0 +1,133 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { ShortcutData } from '../../../src/components/utils/shortcuts';
+import type Shortcuts from '../../../src/components/utils/shortcuts';
+
+type ShortcutHandler = ShortcutData['handler'];
+
+interface ShortcutMockInstance {
+  name: string;
+  on: HTMLElement | Document;
+  callback: ShortcutHandler;
+  remove: ReturnType<typeof vi.fn>;
+}
+
+const shortcutInstances: ShortcutMockInstance[] = [];
+
+const ShortcutConstructor = vi.fn();
+
+vi.mock('@codexteam/shortcuts', () => ({
+  default: ShortcutConstructor,
+}));
+
+type ShortcutsApi = typeof Shortcuts;
+
+let shortcuts: ShortcutsApi;
+
+const importShortcuts = async (): Promise<void> => {
+  const module = await import('../../../src/components/utils/shortcuts');
+
+  shortcuts = module.default;
+};
+
+beforeEach(async () => {
+  shortcutInstances.length = 0;
+  vi.clearAllMocks();
+  vi.resetModules();
+
+  ShortcutConstructor.mockImplementation(function (
+    this: ShortcutMockInstance,
+    config: {
+      name: string;
+      on: HTMLElement | Document;
+      callback: ShortcutHandler;
+    }
+  ) {
+    this.name = config.name;
+    this.on = config.on;
+    this.callback = config.callback;
+    this.remove = vi.fn();
+
+    shortcutInstances.push(this);
+  });
+
+  await importShortcuts();
+});
+
+describe('Shortcuts', () => {
+  const createShortcut = (overrides: Partial<ShortcutData> = {}): ShortcutData => {
+    return {
+      name: 'CMD+B',
+      handler: vi.fn(),
+      on: document.createElement('div'),
+      ...overrides,
+    };
+  };
+
+  it('registers a new shortcut through the constructor', () => {
+    const shortcut = createShortcut();
+
+    shortcuts.add(shortcut);
+
+    expect(ShortcutConstructor).toHaveBeenCalledTimes(1);
+    expect(ShortcutConstructor).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: shortcut.name,
+        on: shortcut.on,
+        callback: shortcut.handler,
+      })
+    );
+
+    expect(shortcutInstances).toHaveLength(1);
+    expect(shortcutInstances[0]).toMatchObject({
+      name: shortcut.name,
+      on: shortcut.on,
+      callback: shortcut.handler,
+    });
+  });
+
+  it('throws when registering the same shortcut twice for the same element', () => {
+    const shortcut = createShortcut();
+
+    shortcuts.add(shortcut);
+
+    expect(() => shortcuts.add(shortcut)).toThrow(/already registered/);
+  });
+
+  it('allows the same shortcut name on different elements', () => {
+    const elementA = document.createElement('div');
+    const elementB = document.createElement('div');
+
+    shortcuts.add(createShortcut({ on: elementA }));
+
+    expect(() => shortcuts.add(createShortcut({ on: elementB }))).not.toThrow();
+    expect(ShortcutConstructor).toHaveBeenCalledTimes(2);
+  });
+
+  it('removes a registered shortcut and allows it to be registered again', () => {
+    const shortcut = createShortcut();
+
+    shortcuts.add(shortcut);
+
+    const [ instance ] = shortcutInstances;
+
+    shortcuts.remove(shortcut.on, shortcut.name);
+
+    expect(instance.remove).toHaveBeenCalledTimes(1);
+    expect(() => shortcuts.add(createShortcut({ on: shortcut.on }))).not.toThrow();
+    expect(ShortcutConstructor).toHaveBeenCalledTimes(2);
+  });
+
+  it('ignores removal requests for shortcuts that were never registered', () => {
+    const registeredShortcut = createShortcut();
+    const otherElement = document.createElement('div');
+
+    shortcuts.add(registeredShortcut);
+
+    const [ instance ] = shortcutInstances;
+
+    expect(() => shortcuts.remove(otherElement, registeredShortcut.name)).not.toThrow();
+    expect(instance.remove).not.toHaveBeenCalled();
+    expect(ShortcutConstructor).toHaveBeenCalledTimes(1);
+  });
+});
+
diff --git a/test/unit/utils/utils.test.ts b/test/unit/utils/utils.test.ts
new file mode 100644
index 000000000..1b62f0c87
--- /dev/null
+++ b/test/unit/utils/utils.test.ts
@@ -0,0 +1,1145 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import type {
+  ChainData } from '../../../src/components/utils';
+import {
+  isFunction,
+  isObject,
+  isString,
+  isBoolean,
+  isNumber,
+  isUndefined,
+  isEmpty,
+  isPrintableKey,
+  keyCodes,
+  mouseButtons,
+  LogLevels,
+  setLogLevel,
+  log,
+  logLabeled,
+  array,
+  delay,
+  debounce,
+  throttle,
+  sequence,
+  getEditorVersion,
+  getFileExtension,
+  isValidMimeType,
+  capitalize,
+  deepMerge,
+  getUserOS,
+  beautifyShortcut,
+  getValidUrl,
+  generateBlockId,
+  generateId,
+  openTab,
+  deprecationAssert,
+  cacheable,
+  mobileScreenBreakpoint,
+  isMobileScreen,
+  isIosDevice,
+  equals
+} from '../../../src/components/utils';
+
+// Mock VERSION global variable
+declare global {
+  // eslint-disable-next-line no-var
+  var VERSION: string;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-undef
+(globalThis as { VERSION?: string }).VERSION = 'test-version';
+
+/**
+ * Unit tests for utils.ts utility functions
+ *
+ * Tests edge cases and internal functionality not covered by E2E tests
+ */
+describe('utils', () => {
+  beforeEach(() => {
+    // Reset log level to VERBOSE before each test
+    setLogLevel(LogLevels.VERBOSE);
+  });
+
+  describe('getEditorVersion', () => {
+    const versionHolder = globalThis as { VERSION?: string };
+    const initialVersion = versionHolder.VERSION;
+
+    afterEach(() => {
+      if (initialVersion === undefined) {
+        delete versionHolder.VERSION;
+      } else {
+        versionHolder.VERSION = initialVersion;
+      }
+    });
+
+    it('should return injected VERSION when defined', () => {
+      versionHolder.VERSION = '9.9.9';
+
+      expect(getEditorVersion()).toBe('9.9.9');
+    });
+
+    it('should fallback to default version when VERSION is not set', () => {
+      delete versionHolder.VERSION;
+
+      expect(getEditorVersion()).toBe('dev');
+    });
+  });
+
+  describe('isFunction', () => {
+    it('should return true for regular function', () => {
+      const fn = function (): void {};
+
+      expect(isFunction(fn)).toBe(true);
+    });
+
+    it('should return true for arrow function', () => {
+      const fn = (): void => {};
+
+      expect(isFunction(fn)).toBe(true);
+    });
+
+    it('should return true for async function', () => {
+      const fn = async (): Promise<void> => {};
+
+      expect(isFunction(fn)).toBe(true);
+    });
+
+    it('should return false for object', () => {
+      expect(isFunction({})).toBe(false);
+    });
+
+    it('should return false for string', () => {
+      expect(isFunction('function')).toBe(false);
+    });
+
+    it('should return false for number', () => {
+      expect(isFunction(123)).toBe(false);
+    });
+
+    it('should return false for null', () => {
+      expect(isFunction(null)).toBe(false);
+    });
+
+    it('should return false for undefined', () => {
+      expect(isFunction(undefined)).toBe(false);
+    });
+  });
+
+  describe('isObject', () => {
+    it('should return true for object', () => {
+      expect(isObject({})).toBe(true);
+    });
+
+    it('should return false for array (arrays have type "array", not "object")', () => {
+      expect(isObject([])).toBe(false);
+    });
+
+    it('should return false for string', () => {
+      expect(isObject('test')).toBe(false);
+    });
+
+    it('should return false for number', () => {
+      expect(isObject(123)).toBe(false);
+    });
+
+    it('should return false for null', () => {
+      expect(isObject(null)).toBe(false);
+    });
+
+    it('should return false for undefined', () => {
+      expect(isObject(undefined)).toBe(false);
+    });
+  });
+
+  describe('isString', () => {
+    it('should return true for string', () => {
+      expect(isString('test')).toBe(true);
+    });
+
+    it('should return true for empty string', () => {
+      expect(isString('')).toBe(true);
+    });
+
+    it('should return false for number', () => {
+      expect(isString(123)).toBe(false);
+    });
+
+    it('should return false for object', () => {
+      expect(isString({})).toBe(false);
+    });
+
+    it('should return false for null', () => {
+      expect(isString(null)).toBe(false);
+    });
+  });
+
+  describe('isBoolean', () => {
+    it('should return true for true', () => {
+      expect(isBoolean(true)).toBe(true);
+    });
+
+    it('should return true for false', () => {
+      expect(isBoolean(false)).toBe(true);
+    });
+
+    it('should return false for string', () => {
+      expect(isBoolean('true')).toBe(false);
+    });
+
+    it('should return false for number', () => {
+      expect(isBoolean(1)).toBe(false);
+    });
+
+    it('should return false for null', () => {
+      expect(isBoolean(null)).toBe(false);
+    });
+  });
+
+  describe('isNumber', () => {
+    it('should return true for number', () => {
+      expect(isNumber(123)).toBe(true);
+    });
+
+    it('should return true for zero', () => {
+      expect(isNumber(0)).toBe(true);
+    });
+
+    it('should return true for negative number', () => {
+      expect(isNumber(-123)).toBe(true);
+    });
+
+    it('should return false for string', () => {
+      expect(isNumber('123')).toBe(false);
+    });
+
+    it('should return true for NaN (NaN is of type "number")', () => {
+      expect(isNumber(NaN)).toBe(true);
+    });
+
+    it('should return false for null', () => {
+      expect(isNumber(null)).toBe(false);
+    });
+  });
+
+  describe('isUndefined', () => {
+    it('should return true for undefined', () => {
+      expect(isUndefined(undefined)).toBe(true);
+    });
+
+    it('should return false for null', () => {
+      expect(isUndefined(null)).toBe(false);
+    });
+
+    it('should return false for string', () => {
+      expect(isUndefined('undefined')).toBe(false);
+    });
+
+    it('should return false for number', () => {
+      expect(isUndefined(0)).toBe(false);
+    });
+  });
+
+  describe('isEmpty', () => {
+    it('should return true for empty object', () => {
+      expect(isEmpty({})).toBe(true);
+    });
+
+    it('should return false for object with properties', () => {
+      expect(isEmpty({ key: 'value' })).toBe(false);
+    });
+
+    it('should return true for null', () => {
+      expect(isEmpty(null)).toBe(true);
+    });
+
+    it('should return true for undefined', () => {
+      expect(isEmpty(undefined)).toBe(true);
+    });
+
+    it('should return true for object created with Object.create (no constructor)', () => {
+      const obj = Object.create(null);
+
+      // lodash isEmpty returns true for objects with no enumerable properties
+      expect(isEmpty(obj)).toBe(true);
+    });
+  });
+
+  describe('isPrintableKey', () => {
+    it('should return true for letter keys', () => {
+      expect(isPrintableKey(keyCodes.LETTER_KEY_MIN + 1)).toBe(true);
+    });
+
+    it('should return true for number keys', () => {
+      expect(isPrintableKey(keyCodes.NUMBER_KEY_MIN + 1)).toBe(true);
+    });
+
+    it('should return true for space', () => {
+      expect(isPrintableKey(keyCodes.SPACE)).toBe(true);
+    });
+
+    it('should return true for enter', () => {
+      expect(isPrintableKey(keyCodes.ENTER)).toBe(true);
+    });
+
+    it('should return true for processing key', () => {
+      expect(isPrintableKey(keyCodes.PROCESSING_KEY)).toBe(true);
+    });
+
+    it('should return false for control keys', () => {
+      expect(isPrintableKey(keyCodes.BACKSPACE)).toBe(false);
+      expect(isPrintableKey(keyCodes.TAB)).toBe(false);
+      expect(isPrintableKey(keyCodes.ESC)).toBe(false);
+      expect(isPrintableKey(keyCodes.LEFT)).toBe(false);
+      expect(isPrintableKey(keyCodes.UP)).toBe(false);
+      expect(isPrintableKey(keyCodes.DOWN)).toBe(false);
+      expect(isPrintableKey(keyCodes.RIGHT)).toBe(false);
+    });
+  });
+
+  describe('keyCodes', () => {
+    it('should have correct key code values', () => {
+      expect(keyCodes.BACKSPACE).toBe(8);
+      expect(keyCodes.TAB).toBe(9);
+      expect(keyCodes.ENTER).toBe(13);
+      expect(keyCodes.SPACE).toBe(32);
+      expect(keyCodes.ESC).toBe(27);
+    });
+  });
+
+  describe('mouseButtons', () => {
+    it('should have correct mouse button values', () => {
+      expect(mouseButtons.LEFT).toBe(0);
+      expect(mouseButtons.WHEEL).toBe(1);
+      expect(mouseButtons.RIGHT).toBe(2);
+      expect(mouseButtons.BACKWARD).toBe(3);
+      expect(mouseButtons.FORWARD).toBe(4);
+    });
+  });
+
+  describe('LogLevels', () => {
+    it('should have correct log level values', () => {
+      expect(LogLevels.VERBOSE).toBe('VERBOSE');
+      expect(LogLevels.INFO).toBe('INFO');
+      expect(LogLevels.WARN).toBe('WARN');
+      expect(LogLevels.ERROR).toBe('ERROR');
+    });
+  });
+
+  describe('setLogLevel and logging', () => {
+    const consoleSpy = {
+      log: vi.spyOn(console, 'log').mockImplementation(() => {}),
+      warn: vi.spyOn(console, 'warn').mockImplementation(() => {}),
+      error: vi.spyOn(console, 'error').mockImplementation(() => {}),
+      info: vi.spyOn(console, 'info').mockImplementation(() => {}),
+    };
+
+    beforeEach(() => {
+      // Reset spies before each test
+      consoleSpy.log.mockClear();
+      consoleSpy.warn.mockClear();
+      consoleSpy.error.mockClear();
+      consoleSpy.info.mockClear();
+    });
+
+    afterEach(() => {
+      consoleSpy.log.mockClear();
+      consoleSpy.warn.mockClear();
+      consoleSpy.error.mockClear();
+      consoleSpy.info.mockClear();
+    });
+
+    it('should log at VERBOSE level', () => {
+      setLogLevel(LogLevels.VERBOSE);
+      log('test message');
+      expect(consoleSpy.log).toHaveBeenCalled();
+    });
+
+    it('should not log info at INFO level when labeled', () => {
+      setLogLevel(LogLevels.INFO);
+      logLabeled('test message');
+      expect(consoleSpy.log).not.toHaveBeenCalled();
+    });
+
+    it('should log errors at ERROR level', () => {
+      setLogLevel(LogLevels.ERROR);
+      log('test message', 'error');
+      expect(consoleSpy.error).toHaveBeenCalled();
+    });
+
+    it('should not log info at ERROR level', () => {
+      setLogLevel(LogLevels.ERROR);
+      log('test message', 'log');
+      expect(consoleSpy.log).not.toHaveBeenCalled();
+    });
+
+    it('should log warnings at WARN level', () => {
+      setLogLevel(LogLevels.WARN);
+      log('test message', 'warn');
+      expect(console.warn).toHaveBeenCalled();
+    });
+
+    it('should not log info at WARN level', () => {
+      setLogLevel(LogLevels.WARN);
+      log('test message', 'log');
+      expect(consoleSpy.log).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('array', () => {
+    it('should convert NodeList to array', () => {
+      const div = document.createElement('div');
+
+      div.innerHTML = '<span></span><span></span>';
+      const nodeList = div.querySelectorAll('span');
+      const result = array(nodeList);
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(2);
+    });
+
+    it('should convert HTMLCollection to array', () => {
+      const div = document.createElement('div');
+
+      div.innerHTML = '<span></span><span></span>';
+      const htmlCollection = div.children;
+      const result = array(htmlCollection);
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(2);
+    });
+  });
+
+  describe('delay', () => {
+    it('should delay function execution', async () => {
+      vi.useFakeTimers();
+      const fn = vi.fn();
+      const delayedFn = delay(fn, 100);
+
+      delayedFn();
+      expect(fn).not.toHaveBeenCalled();
+
+      vi.advanceTimersByTime(100);
+      expect(fn).toHaveBeenCalledTimes(1);
+
+      vi.useRealTimers();
+    });
+
+    it('should pass arguments to delayed function', async () => {
+      vi.useFakeTimers();
+      const fn = vi.fn();
+      const delayedFn = delay(fn, 100);
+
+      delayedFn('arg1', 'arg2');
+      vi.advanceTimersByTime(100);
+
+      expect(fn).toHaveBeenCalledWith('arg1', 'arg2');
+      vi.useRealTimers();
+    });
+  });
+
+  describe('debounce', () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it('should debounce function calls', () => {
+      const fn = vi.fn();
+      const debouncedFn = debounce(fn, 100);
+
+      debouncedFn();
+      debouncedFn();
+      debouncedFn();
+
+      expect(fn).not.toHaveBeenCalled();
+
+      vi.advanceTimersByTime(100);
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should call function immediately when immediate is true', () => {
+      const fn = vi.fn();
+      const debouncedFn = debounce(fn, 100, true);
+
+      debouncedFn();
+      expect(fn).toHaveBeenCalledTimes(1);
+
+      debouncedFn();
+      vi.advanceTimersByTime(100);
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should pass arguments to debounced function', () => {
+      const fn = vi.fn();
+      const debouncedFn = debounce(fn, 100);
+
+      debouncedFn('arg1', 'arg2');
+      vi.advanceTimersByTime(100);
+
+      expect(fn).toHaveBeenCalledWith('arg1', 'arg2');
+    });
+  });
+
+  describe('throttle', () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it('should throttle function calls', () => {
+      const fn = vi.fn();
+      const throttledFn = throttle(fn, 100);
+
+      throttledFn();
+      throttledFn();
+      throttledFn();
+
+      expect(fn).toHaveBeenCalledTimes(1);
+
+      vi.advanceTimersByTime(100);
+      expect(fn).toHaveBeenCalledTimes(2);
+    });
+
+    it('should not call function on leading edge when leading is false', () => {
+      const fn = vi.fn();
+      const throttledFn = throttle(fn, 100, { leading: false });
+
+      throttledFn();
+      expect(fn).not.toHaveBeenCalled();
+
+      vi.advanceTimersByTime(100);
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not call function on trailing edge when trailing is false', () => {
+      const fn = vi.fn();
+      const throttledFn = throttle(fn, 100, { trailing: false });
+
+      throttledFn();
+      expect(fn).toHaveBeenCalledTimes(1);
+
+      throttledFn();
+      vi.advanceTimersByTime(100);
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should return result from throttled function', () => {
+      const fn = vi.fn(() => 'result');
+      const throttledFn = throttle(fn, 100);
+
+      const result = throttledFn();
+
+      expect(result).toBe('result');
+    });
+  });
+
+  describe('sequence', () => {
+    it('should execute functions in sequence', async () => {
+      const results: number[] = [];
+      const chains: ChainData[] = [
+        {
+          data: { order: 1 },
+          function: async (...args: unknown[]) => {
+            const data = args[0] as { order: number };
+
+            results.push(data.order);
+          },
+        },
+        {
+          data: { order: 2 },
+          function: async (...args: unknown[]) => {
+            const data = args[0] as { order: number };
+
+            results.push(data.order);
+          },
+        },
+      ];
+
+      await sequence(chains);
+
+      expect(results).toEqual([1, 2]);
+    });
+
+    it('should call success callback after each chain', async () => {
+      const successCallback = vi.fn();
+      const chains: ChainData[] = [
+        {
+          data: { test: 'data' },
+          function: async () => {},
+        },
+      ];
+
+      await sequence(chains, successCallback);
+
+      expect(successCallback).toHaveBeenCalledWith({ test: 'data' });
+    });
+
+    it('should call fallback callback on error', async () => {
+      const fallbackCallback = vi.fn();
+      const chains: ChainData[] = [
+        {
+          data: { test: 'data' },
+          function: async () => {
+            throw new Error('test error');
+          },
+        },
+      ];
+
+      await sequence(chains, () => {}, fallbackCallback);
+
+      expect(fallbackCallback).toHaveBeenCalledWith({ test: 'data' });
+    });
+  });
+
+  describe('getFileExtension', () => {
+    it('should return file extension', () => {
+      const file = new File([ '' ], 'test.txt');
+
+      expect(getFileExtension(file)).toBe('txt');
+    });
+
+    it('should return filename for file without extension', () => {
+      const file = new File([ '' ], 'test');
+
+      // When there's no extension, split('.').pop() returns the filename itself
+      expect(getFileExtension(file)).toBe('test');
+    });
+
+    it('should return last extension for file with multiple dots', () => {
+      const file = new File([ '' ], 'test.tar.gz');
+
+      expect(getFileExtension(file)).toBe('gz');
+    });
+  });
+
+  describe('isValidMimeType', () => {
+    it('should return true for valid MIME type', () => {
+      expect(isValidMimeType('text/plain')).toBe(true);
+      expect(isValidMimeType('image/png')).toBe(true);
+      expect(isValidMimeType('application/json')).toBe(true);
+      expect(isValidMimeType('text/*')).toBe(true);
+    });
+
+    it('should return false for invalid MIME type', () => {
+      expect(isValidMimeType('invalid')).toBe(false);
+      expect(isValidMimeType('text')).toBe(false);
+      expect(isValidMimeType('text/')).toBe(false);
+      expect(isValidMimeType('/plain')).toBe(false);
+    });
+  });
+
+  describe('capitalize', () => {
+    it('should capitalize first letter', () => {
+      expect(capitalize('hello')).toBe('Hello');
+    });
+
+    it('should handle single character', () => {
+      expect(capitalize('a')).toBe('A');
+    });
+
+    it('should handle already capitalized string', () => {
+      expect(capitalize('Hello')).toBe('Hello');
+    });
+
+    it('should return empty string when called with empty string', () => {
+      expect(capitalize('')).toBe('');
+    });
+  });
+
+  describe('deepMerge', () => {
+    it('should merge objects shallowly', () => {
+      const target = { a: 1 };
+      const source: Partial<typeof target & { b: number }> = { b: 2 };
+
+      const result = deepMerge(target, source);
+
+      expect(result).toEqual({ a: 1,
+        b: 2 });
+    });
+
+    it('should merge objects deeply', () => {
+      const target = { a: { b: 1 } };
+      const source: Partial<typeof target & { a: { b: number; c: number } }> = {
+        a: {
+          b: 1,
+          c: 2,
+        },
+      };
+
+      const result = deepMerge(target, source);
+
+      expect(result).toEqual({ a: { b: 1,
+        c: 2 } });
+    });
+
+    it('should merge multiple sources', () => {
+      const target = { a: 1 };
+      const source1: Partial<typeof target & { b: number }> = { b: 2 };
+      const source2: Partial<typeof target & { c: number }> = { c: 3 };
+
+      const result = deepMerge(target, source1, source2);
+
+      expect(result).toEqual({ a: 1,
+        b: 2,
+        c: 3 });
+    });
+
+    it('should not merge arrays', () => {
+      const target = { items: [1, 2] };
+      const source: Partial<typeof target> = { items: [3, 4] };
+
+      const result = deepMerge(target, source);
+
+      expect(result).toEqual({ items: [3, 4] });
+    });
+
+    it('should not merge primitives', () => {
+      const target = { value: 'old' };
+      const source: Partial<typeof target> = { value: 'new' };
+
+      const result = deepMerge(target, source);
+
+      expect(result).toEqual({ value: 'new' });
+    });
+
+    it('should handle null values', () => {
+      const target = { value: 'old' as string | null };
+      const source: Partial<typeof target> = { value: null };
+
+      const result = deepMerge(target, source);
+
+      expect(result).toEqual({ value: null });
+    });
+
+    it('should skip undefined values', () => {
+      const target = { value: 'old' };
+      const source = { value: undefined };
+
+      const result = deepMerge(target, source);
+
+      // lodash mergeWith skips undefined values (treats them as "not provided")
+      expect(result).toEqual({ value: 'old' });
+    });
+  });
+
+  describe('getUserOS', () => {
+    it('should return OS object with all false by default', () => {
+      const originalNavigator = navigator;
+
+      Object.defineProperty(window, 'navigator', {
+        value: { userAgent: '' },
+        configurable: true,
+      });
+
+      const os = getUserOS();
+
+      expect(os.win).toBe(false);
+      expect(os.mac).toBe(false);
+      expect(os.x11).toBe(false);
+      expect(os.linux).toBe(false);
+
+      Object.defineProperty(window, 'navigator', {
+        value: originalNavigator,
+        configurable: true,
+      });
+    });
+
+    it('should detect Windows OS', () => {
+      const originalNavigator = navigator;
+
+      Object.defineProperty(window, 'navigator', {
+        value: { userAgent: 'Windows' },
+        configurable: true,
+      });
+
+      const os = getUserOS();
+
+      expect(os.win).toBe(true);
+
+      Object.defineProperty(window, 'navigator', {
+        value: originalNavigator,
+        configurable: true,
+      });
+    });
+
+    it('should detect Mac OS', () => {
+      const originalNavigator = navigator;
+
+      Object.defineProperty(window, 'navigator', {
+        value: { userAgent: 'Mac' },
+        configurable: true,
+      });
+
+      const os = getUserOS();
+
+      expect(os.mac).toBe(true);
+
+      Object.defineProperty(window, 'navigator', {
+        value: originalNavigator,
+        configurable: true,
+      });
+    });
+  });
+
+  describe('beautifyShortcut', () => {
+    it('should replace shift with ⇧', () => {
+      expect(beautifyShortcut('Shift+B')).toContain('⇧');
+    });
+
+    it('should replace cmd with ⌘ on Mac', () => {
+      const originalNavigator = navigator;
+
+      Object.defineProperty(window, 'navigator', {
+        value: { userAgent: 'Mac' },
+        configurable: true,
+      });
+
+      const result = beautifyShortcut('Cmd+B');
+
+      expect(result).toContain('⌘');
+
+      Object.defineProperty(window, 'navigator', {
+        value: originalNavigator,
+        configurable: true,
+      });
+    });
+
+    it('should replace cmd with Ctrl on non-Mac', () => {
+      const originalNavigator = navigator;
+
+      Object.defineProperty(window, 'navigator', {
+        value: { userAgent: 'Windows' },
+        configurable: true,
+      });
+
+      const result = beautifyShortcut('Cmd+B');
+
+      expect(result).toContain('Ctrl');
+
+      Object.defineProperty(window, 'navigator', {
+        value: originalNavigator,
+        configurable: true,
+      });
+    });
+
+    it('should replace arrow keys', () => {
+      expect(beautifyShortcut('Up')).toContain('↑');
+      expect(beautifyShortcut('Down')).toContain('↓');
+      expect(beautifyShortcut('Left')).toContain('→');
+      expect(beautifyShortcut('Right')).toContain('←');
+    });
+  });
+
+  describe('getValidUrl', () => {
+    beforeEach(() => {
+      // Mock window.location
+      delete (window as { location?: Location }).location;
+      (window as { location: Location }).location = {
+        protocol: 'https:',
+        origin: 'https://example.com',
+      } as Location;
+    });
+
+    it('should return valid URL as-is', () => {
+      const url = 'https://example.com/path';
+
+      expect(getValidUrl(url)).toBe(url);
+    });
+
+    it('should prepend protocol for double slash URL', () => {
+      const url = '//example.com/path';
+
+      expect(getValidUrl(url)).toBe('https://example.com/path');
+    });
+
+    it('should prepend origin for single slash URL', () => {
+      const url = '/path';
+
+      expect(getValidUrl(url)).toBe('https://example.com/path');
+    });
+  });
+
+  describe('generateBlockId', () => {
+    it('should generate unique IDs', () => {
+      const id1 = generateBlockId();
+      const id2 = generateBlockId();
+
+      expect(id1).not.toBe(id2);
+      expect(typeof id1).toBe('string');
+      expect(id1.length).toBe(10);
+    });
+  });
+
+  describe('generateId', () => {
+    it('should generate ID with prefix', () => {
+      const id = generateId('test-');
+
+      expect(id).toMatch(/^test-/);
+    });
+
+    it('should generate ID without prefix', () => {
+      const id = generateId();
+
+      expect(id).toBeTruthy();
+      expect(typeof id).toBe('string');
+    });
+
+    it('should generate unique IDs', () => {
+      const id1 = generateId('prefix-');
+      const id2 = generateId('prefix-');
+
+      expect(id1).not.toBe(id2);
+    });
+  });
+
+  describe('openTab', () => {
+    it('should call window.open with correct parameters', () => {
+      const openSpy = vi.spyOn(window, 'open').mockImplementation(() => null);
+
+      openTab('https://example.com');
+
+      expect(openSpy).toHaveBeenCalledWith('https://example.com', '_blank');
+
+      openSpy.mockRestore();
+    });
+  });
+
+  describe('deprecationAssert', () => {
+    const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    beforeEach(() => {
+      consoleWarnSpy.mockClear();
+    });
+
+    afterEach(() => {
+      consoleWarnSpy.mockClear();
+    });
+
+    it('should log warning when condition is true', () => {
+      deprecationAssert(true, 'oldProperty', 'newProperty');
+
+      expect(consoleWarnSpy).toHaveBeenCalled();
+      expect(consoleWarnSpy.mock.calls[0]?.[0]).toContain('oldProperty');
+      expect(consoleWarnSpy.mock.calls[0]?.[0]).toContain('newProperty');
+    });
+
+    it('should not log warning when condition is false', () => {
+      deprecationAssert(false, 'oldProperty', 'newProperty');
+
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('cacheable', () => {
+    it('should cache method result', () => {
+      /**
+       *
+       */
+      class TestClass {
+        public callCount = 0;
+
+        /**
+         *
+         */
+        public getValue(): number {
+          this.callCount++;
+
+          return 42;
+        }
+      }
+
+      // Manually apply cacheable decorator
+      const descriptor = Object.getOwnPropertyDescriptor(TestClass.prototype, 'getValue');
+
+      if (descriptor) {
+        cacheable(TestClass.prototype, 'getValue', descriptor);
+        Object.defineProperty(TestClass.prototype, 'getValue', descriptor);
+      }
+
+      const instance = new TestClass();
+
+      expect(instance.getValue()).toBe(42);
+      expect(instance.callCount).toBe(1);
+
+      expect(instance.getValue()).toBe(42);
+      expect(instance.callCount).toBe(1); // Should not increment
+    });
+
+    it('should cache getter result', () => {
+      /**
+       *
+       */
+      class TestClass {
+        public callCount = 0;
+
+        /**
+         *
+         */
+        public get value(): number {
+          this.callCount++;
+
+          return 42;
+        }
+      }
+
+      // Manually apply cacheable decorator
+      const descriptor = Object.getOwnPropertyDescriptor(TestClass.prototype, 'value');
+
+      if (descriptor) {
+        cacheable(TestClass.prototype, 'value', descriptor);
+        Object.defineProperty(TestClass.prototype, 'value', descriptor);
+      }
+
+      const instance = new TestClass();
+
+      expect(instance.value).toBe(42);
+      expect(instance.callCount).toBe(1);
+
+      expect(instance.value).toBe(42);
+      expect(instance.callCount).toBe(1); // Should not increment
+    });
+
+    it('should clear cache when setter is called', () => {
+      /**
+       *
+       */
+      class TestClass {
+        public callCount = 0;
+        private _value = 0;
+
+        /**
+         *
+         */
+        public get value(): number {
+          this.callCount++;
+
+          return this._value;
+        }
+
+        /**
+         *
+         */
+        public set value(val: number) {
+          this._value = val;
+        }
+      }
+
+      // Manually apply cacheable decorator
+      const descriptor = Object.getOwnPropertyDescriptor(TestClass.prototype, 'value');
+
+      if (descriptor) {
+        cacheable(TestClass.prototype, 'value', descriptor);
+        Object.defineProperty(TestClass.prototype, 'value', descriptor);
+      }
+
+      const instance = new TestClass();
+
+      expect(instance.value).toBe(0);
+      expect(instance.callCount).toBe(1);
+
+      instance.value = 10;
+
+      expect(instance.value).toBe(10);
+      expect(instance.callCount).toBe(2);
+    });
+  });
+
+  describe('mobileScreenBreakpoint', () => {
+    it('should equal 650 pixels', () => {
+      expect(mobileScreenBreakpoint).toBe(650);
+    });
+  });
+
+  describe('isMobileScreen', () => {
+    beforeEach(() => {
+      Object.defineProperty(window, 'matchMedia', {
+        writable: true,
+        value: vi.fn(),
+      });
+    });
+
+    it('should return true for mobile screen', () => {
+      (window.matchMedia as ReturnType<typeof vi.fn>).mockReturnValue({
+        matches: true,
+      } as MediaQueryList);
+
+      expect(isMobileScreen()).toBe(true);
+    });
+
+    it('should return false for desktop screen', () => {
+      (window.matchMedia as ReturnType<typeof vi.fn>).mockReturnValue({
+        matches: false,
+      } as MediaQueryList);
+
+      expect(isMobileScreen()).toBe(false);
+    });
+
+    it('should return false when matchMedia is not available', () => {
+      Object.defineProperty(window, 'matchMedia', {
+        value: undefined,
+        configurable: true,
+      });
+
+      expect(() => isMobileScreen()).not.toThrow();
+      expect(isMobileScreen()).toBe(false);
+    });
+  });
+
+  describe('isIosDevice', () => {
+    it('should be a boolean value', () => {
+      expect(typeof isIosDevice).toBe('boolean');
+    });
+  });
+
+  describe('equals', () => {
+    it('should return true for equal primitives', () => {
+      expect(equals(1, 1)).toBe(true);
+      expect(equals('test', 'test')).toBe(true);
+      expect(equals(true, true)).toBe(true);
+    });
+
+    it('should return false for unequal primitives', () => {
+      expect(equals(1, 2)).toBe(false);
+      expect(equals('test', 'test2')).toBe(false);
+      expect(equals(true, false)).toBe(false);
+    });
+
+    it('should return true for equal objects', () => {
+      const obj1 = { a: 1,
+        b: 2 };
+      const obj2 = { a: 1,
+        b: 2 };
+
+      expect(equals(obj1, obj2)).toBe(true);
+    });
+
+    it('should return false for unequal objects', () => {
+      const obj1 = { a: 1,
+        b: 2 };
+      const obj2 = { a: 1,
+        b: 3 };
+
+      expect(equals(obj1, obj2)).toBe(false);
+    });
+
+    it('should return true for equal arrays', () => {
+      const arr1 = [1, 2, 3];
+      const arr2 = [1, 2, 3];
+
+      expect(equals(arr1, arr2)).toBe(true);
+    });
+
+    it('should return false for unequal arrays', () => {
+      const arr1 = [1, 2, 3];
+      const arr2 = [1, 2, 4];
+
+      expect(equals(arr1, arr2)).toBe(false);
+    });
+  });
+});
diff --git a/tsconfig.json b/tsconfig.json
index 6025fa123..fa74d4f92 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -4,8 +4,10 @@
     "sourceMap": true,
     "target": "es2017",
     "declaration": false,
-    "moduleResolution": "node", // This resolution strategy attempts to mimic the Node.js module resolution mechanism at runtime
+    "module": "esnext",
+    "moduleResolution": "bundler", // This resolution strategy handles package.json exports and is suitable for modern bundlers
     "lib": ["dom", "es2017", "es2018", "es2019"],
+    "allowJs": true,
 
     // allows to import .json files for i18n
     "resolveJsonModule": true,
@@ -17,10 +19,23 @@
     "paths": {
       "@/types": [ "./types/" ],
       "@/types/*": [ "./types/*" ],
+      "@editorjs/editorjs": [ "./types" ],
+      "@editorjs/editorjs/*": [ "./types/*" ],
     },
-
-    // @todo move to cypress/tsconfig.json when cypress will support overriding tsconfig path
-    // @see https://github.com/cypress-io/cypress/issues/23045
-    "esModuleInterop": true
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "allowArbitraryExtensions": true,
+    "noEmit": true
   },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.json",
+    "vite.config*.mjs"
+  ],
+  "exclude": [
+    "dist",
+    "node_modules"
+  ]
 }
diff --git a/tslint.json b/tslint.json
index c4406b704..cd0c553c3 100644
--- a/tslint.json
+++ b/tslint.json
@@ -16,7 +16,7 @@
     "ordered-imports": [true, {
       "import-sources-order": "any",
       "named-imports-order": "case-insensitive"
-    }],
+    } ],
     "no-string-literal": false,
     "no-empty": false,
     "no-namespace": false,
diff --git a/types/api/blocks.d.ts b/types/api/blocks.d.ts
index f5957bbac..06baafb6f 100644
--- a/types/api/blocks.d.ts
+++ b/types/api/blocks.d.ts
@@ -70,7 +70,7 @@ export interface Blocks {
   /**
    * Returns the index of Block by id;
    */
-  getBlockIndex(blockId: string): number;
+  getBlockIndex(blockId: string): number | undefined;
 
   /**
    * Get Block API object by html element
diff --git a/types/api/listeners.d.ts b/types/api/listeners.d.ts
index 10a539e1d..b148e71b2 100644
--- a/types/api/listeners.d.ts
+++ b/types/api/listeners.d.ts
@@ -10,7 +10,7 @@ export interface Listeners {
    * @param {(event: Event) => void}handler
    * @param {boolean} useCapture
    */
-  on(element: Element, eventType: string, handler: (event?: Event) => void, useCapture?: boolean): string;
+  on(element: Element, eventType: string, handler: (event?: Event) => void, useCapture?: boolean): string | undefined;
 
   /**
    * Unsubscribe from event dispatched on passed element
diff --git a/types/api/selection.d.ts b/types/api/selection.d.ts
index 606d03733..9aa26f7ed 100644
--- a/types/api/selection.d.ts
+++ b/types/api/selection.d.ts
@@ -18,10 +18,10 @@ export interface Selection {
 
   /**
    * Sets fake background.
-   * Allows to immitate selection while focus moved away
+   * Allows to imitate selection while focus moved away
   */
   setFakeBackground(): void;
-  
+
   /**
    * Removes fake background
    */
@@ -30,7 +30,7 @@ export interface Selection {
   /**
    * Save selection range.
    * Allows to save selection to be able to temporally move focus away.
-   * Might be usefull for inline tools
+   * Might be useful for inline tools
    */
   save(): void;
 
diff --git a/types/api/tooltip.d.ts b/types/api/tooltip.d.ts
index 6ca7c42a2..a6b98bbff 100644
--- a/types/api/tooltip.d.ts
+++ b/types/api/tooltip.d.ts
@@ -1,7 +1,7 @@
 /**
  * Tooltip API
  */
-import {TooltipContent, TooltipOptions} from 'codex-tooltip';
+import {TooltipContent, TooltipOptions} from '../../src/components/utils/tooltip';
 
 export interface Tooltip {
   /**
diff --git a/types/block-tunes/block-tune.d.ts b/types/block-tunes/block-tune.d.ts
index 2220a4780..a0043665b 100644
--- a/types/block-tunes/block-tune.d.ts
+++ b/types/block-tunes/block-tune.d.ts
@@ -1,6 +1,6 @@
-import {API, BlockAPI, SanitizerConfig, ToolConfig} from '../index';
+import {API, BlockAPI, ToolConfig} from '../index';
 import { BlockTuneData } from './block-tune-data';
-import { MenuConfig } from '../tools';
+import { BaseToolConstructable, MenuConfig } from '../tools';
 
 /**
  * Describes BLockTune blueprint
@@ -9,7 +9,7 @@ export interface BlockTune {
   /**
    * Returns BlockTune's UI.
    * Should return either MenuConfig (recommended) (@see https://editorjs.io/menu-config/)
-   * or HTMLElement (UI consitency is not guaranteed)
+   * or an HTMLElement (UI consistency is not guaranteed)
    */
   render(): HTMLElement | MenuConfig;
 
@@ -33,18 +33,13 @@ export interface BlockTune {
 /**
  * Describes BlockTune class constructor function
  */
-export interface BlockTuneConstructable {
+export interface BlockTuneConstructable extends BaseToolConstructable {
 
   /**
    * Flag show Tool is Block Tune
    */
   isTune: boolean;
 
-  /**
-   * Tune's sanitize configuration
-   */
-  sanitize?: SanitizerConfig;
-
   /**
    * @constructor
    *
@@ -61,10 +56,5 @@ export interface BlockTuneConstructable {
    * Tune`s prepare method. Can be async
    * @param data
    */
-  prepare?(): Promise<void> | void;
-
-  /**
-   * Tune`s reset method to clean up anything set by prepare. Can be async
-   */
-  reset?(): void | Promise<void>;
+  prepare?(data: { toolName: string; config: ToolConfig }): Promise<void> | void;
 }
diff --git a/types/index.d.ts b/types/index.d.ts
index 66f0eb38c..b7fe1f5cb 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -138,6 +138,7 @@ declare class EditorJS {
   public styles: Styles;
   public toolbar: Toolbar;
   public inlineToolbar: InlineToolbar;
+  public tooltip: Tooltip;
   public readOnly: ReadOnly;
   constructor(configuration?: EditorConfig|string);
 
diff --git a/types/tools/adapters/block-tool-adapter.d.ts b/types/tools/adapters/block-tool-adapter.d.ts
index 3b37a2433..465b21b6e 100644
--- a/types/tools/adapters/block-tool-adapter.d.ts
+++ b/types/tools/adapters/block-tool-adapter.d.ts
@@ -58,7 +58,7 @@ interface BlockToolAdapter extends BaseToolAdapter<ToolType.Block, BlockTool>{
   /**
    * Returns enabled tunes for Tool
    */
-  enabledBlockTunes: boolean | string[];
+  enabledBlockTunes: boolean | string[] | undefined;
 
   /**
    * Returns Tool paste configuration
diff --git a/types/tools/tool.d.ts b/types/tools/tool.d.ts
index 17aa0f2d9..9cdb44e1d 100644
--- a/types/tools/tool.d.ts
+++ b/types/tools/tool.d.ts
@@ -41,6 +41,11 @@ export interface BaseToolConstructable {
    */
   sanitize?: SanitizerConfig;
 
+  /**
+   * Shortcut for Tool
+   */
+  shortcut?: string;
+
   /**
    * Title of Inline Tool.
    * @deprecated use {@link MenuConfig} item title instead
diff --git a/types/utils/popover/popover-item.d.ts b/types/utils/popover/popover-item.d.ts
index 3957fdae0..942f92369 100644
--- a/types/utils/popover/popover-item.d.ts
+++ b/types/utils/popover/popover-item.d.ts
@@ -109,7 +109,7 @@ export interface PopoverItemHtmlParams {
 
   /**
    * Item name
-   * Used in data attributes needed for cypress tests
+   * Used in data attributes needed for automated end-to-end tests
    */
   name?: string;
 }
@@ -155,7 +155,7 @@ export interface PopoverItemDefaultBaseParams {
 
   /**
    * Item name
-   * Used in data attributes needed for shortcuts work and for cypress tests
+   * Used in data attributes needed for shortcuts work and automated end-to-end tests
    */
   name?: string;
 
diff --git a/types/utils/popover/popover.d.ts b/types/utils/popover/popover.d.ts
index a42641f94..098ed267e 100644
--- a/types/utils/popover/popover.d.ts
+++ b/types/utils/popover/popover.d.ts
@@ -1,4 +1,5 @@
 import { PopoverItemParams } from './popover-item';
+import type Flipper from '../../../src/components/flipper';
 import { PopoverEvent } from './popover-event';
 
 /**
@@ -27,6 +28,11 @@ export interface PopoverParams {
    */
   flippable?: boolean;
 
+  /**
+   * Optional flipper instance to reuse for keyboard navigation
+   */
+  flipper?: Flipper;
+
   /**
    * Popover texts overrides
    */
diff --git a/vite-env.d.ts b/vite-env.d.ts
new file mode 100644
index 000000000..5d2db4d6b
--- /dev/null
+++ b/vite-env.d.ts
@@ -0,0 +1,7 @@
+/// <reference types="vite/client" />
+
+declare module '*.css?inline' {
+  const content: string;
+  export default content;
+}
+
diff --git a/vite.config.js b/vite.config.mjs
similarity index 94%
rename from vite.config.js
rename to vite.config.mjs
index 98bc3c261..5385fe09f 100644
--- a/vite.config.js
+++ b/vite.config.mjs
@@ -1,15 +1,19 @@
 import path from 'path';
+import { fileURLToPath } from 'url';
 
 import cssInjectedByJsPlugin from 'vite-plugin-css-injected-by-js';
 import license from 'rollup-plugin-license';
 
 import * as pkg from './package.json';
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
 const NODE_ENV = process.argv.mode || 'development';
 const VERSION = pkg.version;
 
 /**
  * Trick to use Vite server.open option on macOS
+ *
  * @see https://github.com/facebook/create-react-app/pull/1690#issuecomment-283518768
  */
 process.env.BROWSER = 'open';
@@ -72,3 +76,4 @@ export default {
     cssInjectedByJsPlugin(),
   ],
 };
+
diff --git a/vite.config.test.js b/vite.config.test.js
deleted file mode 100644
index a053f5805..000000000
--- a/vite.config.test.js
+++ /dev/null
@@ -1,18 +0,0 @@
-import path from 'path';
-import { defineConfig } from 'vite';
-
-export default defineConfig({
-  build: {
-    minify: false,
-    sourcemap: true,
-  },
-  define: {
-    'NODE_ENV': JSON.stringify('test'),
-    'VERSION': JSON.stringify('test-version'),
-  },
-  resolve: {
-    alias: {
-      '@/types': path.resolve(__dirname, './types'),
-    },
-  },
-});
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 000000000..6ee2bad4f
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    include: [ 'test/unit/**/*.test.ts' ],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      include: [ 'src/**/*.ts' ],
+      exclude: [
+        'src/**/*.d.ts',
+        'src/**/__module.ts',
+        'src/**/index.ts',
+        'test/**',
+        'node_modules/**',
+      ],
+    },
+  },
+  resolve: {
+    alias: {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      '@/types': path.resolve(__dirname, './types'),
+    },
+  },
+});
+
diff --git a/yarn.lock b/yarn.lock
index 5294af93d..19d2c36a5 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1,5472 +1,8466 @@
-# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-# yarn lockfile v1
-
-
-"@ampproject/remapping@^2.2.0":
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-2.2.0.tgz#56c133824780de3174aed5ab6834f3026790154d"
-  integrity sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w==
-  dependencies:
-    "@jridgewell/gen-mapping" "^0.1.0"
-    "@jridgewell/trace-mapping" "^0.3.9"
-
-"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.18.6":
-  version "7.18.6"
-  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.18.6.tgz#3b25d38c89600baa2dcc219edfa88a74eb2c427a"
-  integrity sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==
-  dependencies:
-    "@babel/highlight" "^7.18.6"
-
-"@babel/compat-data@^7.20.5":
-  version "7.21.0"
-  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.21.0.tgz#c241dc454e5b5917e40d37e525e2f4530c399298"
-  integrity sha512-gMuZsmsgxk/ENC3O/fRw5QY8A9/uxQbbCEypnLIiYYc/qVJtEV7ouxC3EllIIwNzMqAQee5tanFabWsUOutS7g==
-
-"@babel/core@^7.7.5":
-  version "7.21.0"
-  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.21.0.tgz#1341aefdcc14ccc7553fcc688dd8986a2daffc13"
-  integrity sha512-PuxUbxcW6ZYe656yL3EAhpy7qXKq0DmYsrJLpbB8XrsCP9Nm+XCg9XFMb5vIDliPD7+U/+M+QJlH17XOcB7eXA==
-  dependencies:
-    "@ampproject/remapping" "^2.2.0"
-    "@babel/code-frame" "^7.18.6"
-    "@babel/generator" "^7.21.0"
-    "@babel/helper-compilation-targets" "^7.20.7"
-    "@babel/helper-module-transforms" "^7.21.0"
-    "@babel/helpers" "^7.21.0"
-    "@babel/parser" "^7.21.0"
-    "@babel/template" "^7.20.7"
-    "@babel/traverse" "^7.21.0"
-    "@babel/types" "^7.21.0"
-    convert-source-map "^1.7.0"
-    debug "^4.1.0"
-    gensync "^1.0.0-beta.2"
-    json5 "^2.2.2"
-    semver "^6.3.0"
-
-"@babel/generator@^7.21.0", "@babel/generator@^7.21.1":
-  version "7.21.1"
-  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.21.1.tgz#951cc626057bc0af2c35cd23e9c64d384dea83dd"
-  integrity sha512-1lT45bAYlQhFn/BHivJs43AiW2rg3/UbLyShGfF3C0KmHvO5fSghWd5kBJy30kpRRucGzXStvnnCFniCR2kXAA==
-  dependencies:
-    "@babel/types" "^7.21.0"
-    "@jridgewell/gen-mapping" "^0.3.2"
-    "@jridgewell/trace-mapping" "^0.3.17"
-    jsesc "^2.5.1"
-
-"@babel/helper-compilation-targets@^7.20.7":
-  version "7.20.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.20.7.tgz#a6cd33e93629f5eb473b021aac05df62c4cd09bb"
-  integrity sha512-4tGORmfQcrc+bvrjb5y3dG9Mx1IOZjsHqQVUz7XCNHO+iTmqxWnVg3KRygjGmpRLJGdQSKuvFinbIb0CnZwHAQ==
-  dependencies:
-    "@babel/compat-data" "^7.20.5"
-    "@babel/helper-validator-option" "^7.18.6"
-    browserslist "^4.21.3"
-    lru-cache "^5.1.1"
-    semver "^6.3.0"
-
-"@babel/helper-environment-visitor@^7.18.9":
-  version "7.18.9"
-  resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz#0c0cee9b35d2ca190478756865bb3528422f51be"
-  integrity sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==
-
-"@babel/helper-function-name@^7.21.0":
-  version "7.21.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.21.0.tgz#d552829b10ea9f120969304023cd0645fa00b1b4"
-  integrity sha512-HfK1aMRanKHpxemaY2gqBmL04iAPOPRj7DxtNbiDOrJK+gdwkiNRVpCpUJYbUT+aZyemKN8brqTOxzCaG6ExRg==
-  dependencies:
-    "@babel/template" "^7.20.7"
-    "@babel/types" "^7.21.0"
-
-"@babel/helper-hoist-variables@^7.18.6":
-  version "7.18.6"
-  resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz#d4d2c8fb4baeaa5c68b99cc8245c56554f926678"
-  integrity sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==
-  dependencies:
-    "@babel/types" "^7.18.6"
-
-"@babel/helper-module-imports@^7.18.6":
-  version "7.18.6"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz#1e3ebdbbd08aad1437b428c50204db13c5a3ca6e"
-  integrity sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==
-  dependencies:
-    "@babel/types" "^7.18.6"
-
-"@babel/helper-module-transforms@^7.21.0":
-  version "7.21.2"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.21.2.tgz#160caafa4978ac8c00ac66636cb0fa37b024e2d2"
-  integrity sha512-79yj2AR4U/Oqq/WOV7Lx6hUjau1Zfo4cI+JLAVYeMV5XIlbOhmjEk5ulbTc9fMpmlojzZHkUUxAiK+UKn+hNQQ==
-  dependencies:
-    "@babel/helper-environment-visitor" "^7.18.9"
-    "@babel/helper-module-imports" "^7.18.6"
-    "@babel/helper-simple-access" "^7.20.2"
-    "@babel/helper-split-export-declaration" "^7.18.6"
-    "@babel/helper-validator-identifier" "^7.19.1"
-    "@babel/template" "^7.20.7"
-    "@babel/traverse" "^7.21.2"
-    "@babel/types" "^7.21.2"
-
-"@babel/helper-simple-access@^7.20.2":
-  version "7.20.2"
-  resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.20.2.tgz#0ab452687fe0c2cfb1e2b9e0015de07fc2d62dd9"
-  integrity sha512-+0woI/WPq59IrqDYbVGfshjT5Dmk/nnbdpcF8SnMhhXObpTq2KNBdLFRFrkVdbDOyUmHBCxzm5FHV1rACIkIbA==
-  dependencies:
-    "@babel/types" "^7.20.2"
-
-"@babel/helper-split-export-declaration@^7.18.6":
-  version "7.18.6"
-  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz#7367949bc75b20c6d5a5d4a97bba2824ae8ef075"
-  integrity sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==
-  dependencies:
-    "@babel/types" "^7.18.6"
-
-"@babel/helper-string-parser@^7.19.4":
-  version "7.19.4"
-  resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.19.4.tgz#38d3acb654b4701a9b77fb0615a96f775c3a9e63"
-  integrity sha512-nHtDoQcuqFmwYNYPz3Rah5ph2p8PFeFCsZk9A/48dPc/rGocJ5J3hAAZ7pb76VWX3fZKu+uEr/FhH5jLx7umrw==
-
-"@babel/helper-validator-identifier@^7.18.6", "@babel/helper-validator-identifier@^7.19.1":
-  version "7.19.1"
-  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz#7eea834cf32901ffdc1a7ee555e2f9c27e249ca2"
-  integrity sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w==
-
-"@babel/helper-validator-option@^7.18.6":
-  version "7.21.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.21.0.tgz#8224c7e13ace4bafdc4004da2cf064ef42673180"
-  integrity sha512-rmL/B8/f0mKS2baE9ZpyTcTavvEuWhTTW8amjzXNvYG4AwBsqTLikfXsEofsJEfKHf+HQVQbFOHy6o+4cnC/fQ==
-
-"@babel/helpers@^7.21.0":
-  version "7.21.0"
-  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.21.0.tgz#9dd184fb5599862037917cdc9eecb84577dc4e7e"
-  integrity sha512-XXve0CBtOW0pd7MRzzmoyuSj0e3SEzj8pgyFxnTT1NJZL38BD1MK7yYrm8yefRPIDvNNe14xR4FdbHwpInD4rA==
-  dependencies:
-    "@babel/template" "^7.20.7"
-    "@babel/traverse" "^7.21.0"
-    "@babel/types" "^7.21.0"
-
-"@babel/highlight@^7.18.6":
-  version "7.18.6"
-  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.18.6.tgz#81158601e93e2563795adcbfbdf5d64be3f2ecdf"
-  integrity sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==
-  dependencies:
-    "@babel/helper-validator-identifier" "^7.18.6"
-    chalk "^2.0.0"
-    js-tokens "^4.0.0"
-
-"@babel/parser@7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.13.0.tgz#49b9b6ee213e5634fa80361dae139effef893f78"
-  integrity sha512-w80kxEMFhE3wjMOQkfdTvv0CSdRSJZptIlLhU4eU/coNJeWjduspUFz+IRnBbAq6m5XYBFMoT1TNkk9K9yf10g==
-
-"@babel/parser@^7.20.7", "@babel/parser@^7.21.0", "@babel/parser@^7.21.2":
-  version "7.21.2"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.21.2.tgz#dacafadfc6d7654c3051a66d6fe55b6cb2f2a0b3"
-  integrity sha512-URpaIJQwEkEC2T9Kn+Ai6Xe/02iNaVCuT/PtoRz3GPVJVDpPd7mLo+VddTbhCRU9TXqW5mSrQfXZyi8kDKOVpQ==
-
-"@babel/register@^7.21.0":
-  version "7.21.0"
-  resolved "https://registry.yarnpkg.com/@babel/register/-/register-7.21.0.tgz#c97bf56c2472e063774f31d344c592ebdcefa132"
-  integrity sha512-9nKsPmYDi5DidAqJaQooxIhsLJiNMkGr8ypQ8Uic7cIox7UCDsM7HuUGxdGT7mSDTYbqzIdsOWzfBton/YJrMw==
-  dependencies:
-    clone-deep "^4.0.1"
-    find-cache-dir "^2.0.0"
-    make-dir "^2.1.0"
-    pirates "^4.0.5"
-    source-map-support "^0.5.16"
-
-"@babel/template@^7.20.7":
-  version "7.20.7"
-  resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.20.7.tgz#a15090c2839a83b02aa996c0b4994005841fd5a8"
-  integrity sha512-8SegXApWe6VoNw0r9JHpSteLKTpTiLZ4rMlGIm9JQ18KiCtyQiAMEazujAHrUS5flrcqYZa75ukev3P6QmUwUw==
-  dependencies:
-    "@babel/code-frame" "^7.18.6"
-    "@babel/parser" "^7.20.7"
-    "@babel/types" "^7.20.7"
-
-"@babel/traverse@^7.21.0", "@babel/traverse@^7.21.2":
-  version "7.21.2"
-  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.21.2.tgz#ac7e1f27658750892e815e60ae90f382a46d8e75"
-  integrity sha512-ts5FFU/dSUPS13tv8XiEObDu9K+iagEKME9kAbaP7r0Y9KtZJZ+NGndDvWoRAYNpeWafbpFeki3q9QoMD6gxyw==
-  dependencies:
-    "@babel/code-frame" "^7.18.6"
-    "@babel/generator" "^7.21.1"
-    "@babel/helper-environment-visitor" "^7.18.9"
-    "@babel/helper-function-name" "^7.21.0"
-    "@babel/helper-hoist-variables" "^7.18.6"
-    "@babel/helper-split-export-declaration" "^7.18.6"
-    "@babel/parser" "^7.21.2"
-    "@babel/types" "^7.21.2"
-    debug "^4.1.0"
-    globals "^11.1.0"
-
-"@babel/types@^7.18.6", "@babel/types@^7.20.2", "@babel/types@^7.20.7", "@babel/types@^7.21.0", "@babel/types@^7.21.2":
-  version "7.21.2"
-  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.21.2.tgz#92246f6e00f91755893c2876ad653db70c8310d1"
-  integrity sha512-3wRZSs7jiFaB8AjxiiD+VqN5DTG2iRvJGQ+qYFrs/654lg6kGTQWIOFjlBo5RaXuAZjBmP3+OQH4dmhqiiyYxw==
-  dependencies:
-    "@babel/helper-string-parser" "^7.19.4"
-    "@babel/helper-validator-identifier" "^7.19.1"
-    to-fast-properties "^2.0.0"
-
-"@codexteam/icons@0.3.2":
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/@codexteam/icons/-/icons-0.3.2.tgz#b7aed0ba7b344e07953101f5476cded570d4f150"
-  integrity sha512-P1ep2fHoy0tv4wx85eic+uee5plDnZQ1Qa6gDfv7eHPkCXorMtVqJhzMb75o1izogh6G7380PqmFDXV3bW3Pig==
-
-"@codexteam/icons@^0.0.4":
-  version "0.0.4"
-  resolved "https://registry.yarnpkg.com/@codexteam/icons/-/icons-0.0.4.tgz#8b72dcd3f3a1b0d880bdceb2abebd74b46d3ae13"
-  integrity sha512-V8N/TY2TGyas4wLrPIFq7bcow68b3gu8DfDt1+rrHPtXxcexadKauRJL6eQgfG7Z0LCrN4boLRawR4S9gjIh/Q==
-
-"@codexteam/icons@^0.0.5":
-  version "0.0.5"
-  resolved "https://registry.yarnpkg.com/@codexteam/icons/-/icons-0.0.5.tgz#d17f39b6a0497c6439f57dd42711817a3dd3679c"
-  integrity sha512-s6H2KXhLz2rgbMZSkRm8dsMJvyUNZsEjxobBEg9ztdrb1B2H3pEzY6iTwI4XUPJWJ3c3qRKwV4TrO3J5jUdoQA==
-
-"@codexteam/icons@^0.0.6":
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/@codexteam/icons/-/icons-0.0.6.tgz#5553ada48dddf5940851ccc142cfe17835c36ad3"
-  integrity sha512-L7Q5PET8PjKcBT5wp7VR+FCjwCi5PUp7rd/XjsgQ0CI5FJz0DphyHGRILMuDUdCW2MQT9NHbVr4QP31vwAkS/A==
-
-"@codexteam/shortcuts@^1.1.1":
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/@codexteam/shortcuts/-/shortcuts-1.2.0.tgz#b8dd7396962b0bd845a5c8f8f19bc6119b520e19"
-  integrity sha512-Udb8lkwhXEiPoLm7krtUv2f8jYQTutHxsLecmsMvMbOxMJ49LA/EUUzn8Fo32mxOFrI7qozOovspLhHb+y60nQ==
-
-"@colors/colors@1.5.0":
-  version "1.5.0"
-  resolved "https://registry.yarnpkg.com/@colors/colors/-/colors-1.5.0.tgz#bb504579c1cae923e6576a4f5da43d25f97bdbd9"
-  integrity sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==
-
-"@csstools/cascade-layer-name-parser@^1.0.0":
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/@csstools/cascade-layer-name-parser/-/cascade-layer-name-parser-1.0.1.tgz#5957adeb71be8159e543d37a9c48e124dcd6c32e"
-  integrity sha512-SAAi5DpgJJWkfTvWSaqkgyIsTawa83hMwKrktkj6ra2h+q6ZN57vOGZ6ySHq6RSo+CbP64fA3aPChPBRDDUgtw==
-
-"@csstools/color-helpers@^1.0.0":
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/@csstools/color-helpers/-/color-helpers-1.0.0.tgz#7097722a51da1e9e622345ca000261f1ae6e8f58"
-  integrity sha512-tgqtiV8sU/VaWYjOB3O7PWs7HR/MmOLl2kTYRW2qSsTSEniJq7xmyAYFB1LPpXvvQcE5u2ih2dK9fyc8BnrAGQ==
-
-"@csstools/color-helpers@^2.0.0":
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/@csstools/color-helpers/-/color-helpers-2.0.0.tgz#4ac578cb00b4e853b94f2250267d85ba957c4fc9"
-  integrity sha512-VcPjEnp07RNgz/D+oI2uIALg+IPCSl6mj0XhA3pl3F2bM2B95vgzatExmmzSg/X0zkh+R2v+jFY/J2pV/bnwpw==
-
-"@csstools/css-calc@^1.0.0":
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/@csstools/css-calc/-/css-calc-1.0.0.tgz#f93e4cc9d80b504467aee1b5251bb2fd8be435a7"
-  integrity sha512-Xw0b/Jr+vLGGYD8cxsGWPaY5n1GtVC6G4tcga+eZPXZzRjjZHorPwW739UgtXzL2Da1RLxNE73c0r/KvmizPsw==
-
-"@csstools/css-calc@^1.0.1":
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/@csstools/css-calc/-/css-calc-1.0.1.tgz#c478dbfb2c10e22741b261b2a64998960d69bfc7"
-  integrity sha512-VBI8X0bmStfc85wWTa2bsbnlBQxgW4FmJ0Ts9ar9UqytE6kii3yg6GO+wpgzht2oK5Qlbpkm1Fy2kcqVmu6f3Q==
-
-"@csstools/css-color-parser@^1.0.0", "@csstools/css-color-parser@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@csstools/css-color-parser/-/css-color-parser-1.1.0.tgz#717d544aa5c5f77e3fb71e77f1500338c1ee7436"
-  integrity sha512-jRpIhjThaH8jxuJ8Q1H+jai/dekP5952kzLHTuN+rPI48eF2esf/18TMb3N/HtEgmnybhfiwUO6Ph2OkHi3jpA==
-  dependencies:
-    "@csstools/color-helpers" "^2.0.0"
-    "@csstools/css-calc" "^1.0.1"
-
-"@csstools/css-parser-algorithms@^2.0.0", "@csstools/css-parser-algorithms@^2.0.1":
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/@csstools/css-parser-algorithms/-/css-parser-algorithms-2.0.1.tgz#ff02629c7c95d1f4f8ea84d5ef1173461610535e"
-  integrity sha512-B9/8PmOtU6nBiibJg0glnNktQDZ3rZnGn/7UmDfrm2vMtrdlXO3p7ErE95N0up80IRk9YEtB5jyj/TmQ1WH3dw==
-
-"@csstools/css-parser-algorithms@^2.1.0":
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/@csstools/css-parser-algorithms/-/css-parser-algorithms-2.1.0.tgz#c0a605b0218790faeb5911f240964891c6031501"
-  integrity sha512-KP8TicdXpUyeB1NMlbHud/1l39xvLGvqNFWMpG4qC6H1zs9SadGUHe5SO92n/659sDW9aGDvm9AMru0DZkN1Bw==
-
-"@csstools/css-tokenizer@^2.0.0", "@csstools/css-tokenizer@^2.0.1", "@csstools/css-tokenizer@^2.1.0":
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/@csstools/css-tokenizer/-/css-tokenizer-2.1.0.tgz#fee4de3d444db3ce9007f3af6474af8ba3e4b930"
-  integrity sha512-dtqFyoJBHUxGi9zPZdpCKP1xk8tq6KPHJ/NY4qWXiYo6IcSGwzk3L8x2XzZbbyOyBs9xQARoGveU2AsgLj6D2A==
-
-"@csstools/media-query-list-parser@^2.0.0":
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/@csstools/media-query-list-parser/-/media-query-list-parser-2.0.1.tgz#d85a366811563a5d002755ed10e5212a1613c91d"
-  integrity sha512-X2/OuzEbjaxhzm97UJ+95GrMeT29d1Ib+Pu+paGLuRWZnWRK9sI9r3ikmKXPWGA1C4y4JEdBEFpp9jEqCvLeRA==
-
-"@csstools/media-query-list-parser@^2.0.1", "@csstools/media-query-list-parser@^2.0.2":
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/@csstools/media-query-list-parser/-/media-query-list-parser-2.0.2.tgz#36058f8ff6a28274e7dfe32e48431e1de97c2fbb"
-  integrity sha512-8V6JD8Av1HttuClYr1ZBu0LRVe5Nnz4qrv8RppO8mobsX/USBHZy5JQOXYIlpOVhl46nzkx3X5cfH6CqUghjrQ==
-
-"@csstools/postcss-cascade-layers@^3.0.1":
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-cascade-layers/-/postcss-cascade-layers-3.0.1.tgz#d839386e90428b448e3f75276bc01d516e852a0d"
-  integrity sha512-dD8W98dOYNOH/yX4V4HXOhfCOnvVAg8TtsL+qCGNoKXuq5z2C/d026wGWgySgC8cajXXo/wNezS31Glj5GcqrA==
-  dependencies:
-    "@csstools/selector-specificity" "^2.0.2"
-    postcss-selector-parser "^6.0.10"
-
-"@csstools/postcss-color-function@^2.1.0":
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-color-function/-/postcss-color-function-2.2.0.tgz#b9251d5dd13e56c5893a220c32008ac5af4b009f"
-  integrity sha512-4z3k3p35Gmv4ZDX79OytvhwYx6Hz+y3hitikw2F+XG1yhSjalXoMCV04atgLjc/ThLg+Hwnp1pxhQ2G07UHknQ==
-  dependencies:
-    "@csstools/css-color-parser" "^1.0.0"
-    "@csstools/css-parser-algorithms" "^2.0.1"
-    "@csstools/css-tokenizer" "^2.1.0"
-    "@csstools/postcss-progressive-custom-properties" "^2.0.0"
-
-"@csstools/postcss-color-mix-function@^1.0.0":
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-color-mix-function/-/postcss-color-mix-function-1.0.0.tgz#8d65782527eefc7228ea6fb9b6fa936e52b9b4ad"
-  integrity sha512-JuI8SKpE/XIpfmvALcxvk6flaq36KCJwqQgZ958Jz189r1diQZADq+7xFmjcv+B0vHQ4nSa92gGExtzOZ1iiUg==
-  dependencies:
-    "@csstools/css-color-parser" "^1.0.0"
-    "@csstools/css-parser-algorithms" "^2.0.1"
-    "@csstools/css-tokenizer" "^2.1.0"
-    "@csstools/postcss-progressive-custom-properties" "^2.0.0"
-
-"@csstools/postcss-font-format-keywords@^2.0.2":
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-font-format-keywords/-/postcss-font-format-keywords-2.0.2.tgz#d798d96f4af6cddcfee459f598c976e6011042d2"
-  integrity sha512-iKYZlIs6JsNT7NKyRjyIyezTCHLh4L4BBB3F5Nx7Dc4Z/QmBgX+YJFuUSar8IM6KclGiAUFGomXFdYxAwJydlA==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-"@csstools/postcss-gradients-interpolation-method@^3.0.1":
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-gradients-interpolation-method/-/postcss-gradients-interpolation-method-3.0.1.tgz#e5237dd765f951c1f4b113d29c4bd2438db5dc33"
-  integrity sha512-sCfFSzL5HRb/GhrGuTEi8IRrxp2bUeKakyXvuXzuBBxL0L2X8kZAljQwkuRkd0W/wIWTsQG/E72REb5XMmRfrA==
-  dependencies:
-    "@csstools/css-color-parser" "^1.1.0"
-    "@csstools/css-parser-algorithms" "^2.1.0"
-    "@csstools/css-tokenizer" "^2.1.0"
-    "@csstools/postcss-progressive-custom-properties" "^2.0.0"
-
-"@csstools/postcss-hwb-function@^2.2.0":
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-hwb-function/-/postcss-hwb-function-2.2.0.tgz#80ee5780b88994b1128ad67f98d468798413b7d7"
-  integrity sha512-7gDPKacr3KhonzEyj4dzAEcetFJbN+JVPZXtANpf9SAVUHDUK+cCw7367uRlXnCeAoTdmRAyBk3agg2+snFxAw==
-  dependencies:
-    "@csstools/css-color-parser" "^1.0.0"
-    "@csstools/css-parser-algorithms" "^2.0.1"
-    "@csstools/css-tokenizer" "^2.1.0"
-
-"@csstools/postcss-ic-unit@^2.0.2":
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-ic-unit/-/postcss-ic-unit-2.0.2.tgz#5a5e481c53977deec3d63793788eec924d4c5f7d"
-  integrity sha512-N84qGTJkfLTPj2qOG5P4CIqGjpZBbjOEMKMn+UjO5wlb9lcBTfBsxCF0lQsFdWJUzBHYFOz19dL66v71WF3Pig==
-  dependencies:
-    "@csstools/postcss-progressive-custom-properties" "^2.0.0"
-    postcss-value-parser "^4.2.0"
-
-"@csstools/postcss-is-pseudo-class@^3.1.1":
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-is-pseudo-class/-/postcss-is-pseudo-class-3.1.1.tgz#81b0f3ba388bf3c8966e1a4413e1839beef7960e"
-  integrity sha512-hhiacuby4YdUnnxfCYCRMBIobyJImozf0u+gHSbQ/tNOdwvmrZtVROvgW7zmfYuRkHVDNZJWZslq2v5jOU+j/A==
-  dependencies:
-    "@csstools/selector-specificity" "^2.0.0"
-    postcss-selector-parser "^6.0.10"
-
-"@csstools/postcss-logical-float-and-clear@^1.0.1":
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-logical-float-and-clear/-/postcss-logical-float-and-clear-1.0.1.tgz#d255ea7aad18880930b63d8a04164f56182f2ecf"
-  integrity sha512-eO9z2sMLddvlfFEW5Fxbjyd03zaO7cJafDurK4rCqyRt9P7aaWwha0LcSzoROlcZrw1NBV2JAp2vMKfPMQO1xw==
-
-"@csstools/postcss-logical-resize@^1.0.1":
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-logical-resize/-/postcss-logical-resize-1.0.1.tgz#826d3de929d7d786c32c2c118f78e813a1c2cdec"
-  integrity sha512-x1ge74eCSvpBkDDWppl+7FuD2dL68WP+wwP2qvdUcKY17vJksz+XoE1ZRV38uJgS6FNUwC0AxrPW5gy3MxsDHQ==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-"@csstools/postcss-logical-viewport-units@^1.0.2":
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-logical-viewport-units/-/postcss-logical-viewport-units-1.0.2.tgz#b968c57e1459429b48b24e2c250ca0904d71df6e"
-  integrity sha512-nnKFywBqRMYjv5jyjSplD/nbAnboUEGFfdxKw1o34Y1nvycgqjQavhKkmxbORxroBBIDwC5y6SfgENcPPUcOxQ==
-  dependencies:
-    "@csstools/css-tokenizer" "^2.0.0"
-
-"@csstools/postcss-media-minmax@^1.0.0":
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-media-minmax/-/postcss-media-minmax-1.0.0.tgz#c9978e3ae65b389d149f66cf0c266b2627cd2ec5"
-  integrity sha512-qXHZ0QVDszKf4SsLazOEzFl+m+IkhHOigqMy/gHNIzAtqB3XeBQUa+dTi1ROmQBDH1HXktGwy+tafFBg9UoaxA==
-  dependencies:
-    "@csstools/css-calc" "^1.0.1"
-    "@csstools/css-parser-algorithms" "^2.1.0"
-    "@csstools/css-tokenizer" "^2.1.0"
-    "@csstools/media-query-list-parser" "^2.0.2"
-
-"@csstools/postcss-media-queries-aspect-ratio-number-values@^1.0.1":
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-media-queries-aspect-ratio-number-values/-/postcss-media-queries-aspect-ratio-number-values-1.0.1.tgz#fd6a8e50c2d6d46a5c95b6cdc5563a091fa2f0fa"
-  integrity sha512-V9yQqXdje6OfqDf6EL5iGOpi6N0OEczwYK83rql9UapQwFEryXlAehR5AqH8QqLYb6+y31wUXK6vMxCp0920Zg==
-  dependencies:
-    "@csstools/css-parser-algorithms" "^2.0.0"
-    "@csstools/css-tokenizer" "^2.0.0"
-    "@csstools/media-query-list-parser" "^2.0.0"
-
-"@csstools/postcss-nested-calc@^2.0.2":
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-nested-calc/-/postcss-nested-calc-2.0.2.tgz#a0857650ef88b1aa7b094c7ea8ea1378c35695e0"
-  integrity sha512-jbwrP8rN4e7LNaRcpx3xpMUjhtt34I9OV+zgbcsYAAk6k1+3kODXJBf95/JMYWhu9g1oif7r06QVUgfWsKxCFw==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-"@csstools/postcss-normalize-display-values@^2.0.1":
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-normalize-display-values/-/postcss-normalize-display-values-2.0.1.tgz#35dc188c5b4713cf902959fe3c8ce613fcb7543e"
-  integrity sha512-TQT5g3JQ5gPXC239YuRK8jFceXF9d25ZvBkyjzBGGoW5st5sPXFVQS8OjYb9IJ/K3CdfK4528y483cgS2DJR/w==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-"@csstools/postcss-oklab-function@^2.2.0":
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-oklab-function/-/postcss-oklab-function-2.2.0.tgz#4f9c91736316eb881d932681ae566a38af554a39"
-  integrity sha512-5QMtgn9IWpeTbbt8DwLvr41CQRJef2fKhznTFQI1Og/v3zr/uKYu+aSKZEEaoZnO9OophM4YJnkVJne3CqvJDQ==
-  dependencies:
-    "@csstools/css-color-parser" "^1.0.0"
-    "@csstools/css-parser-algorithms" "^2.0.1"
-    "@csstools/css-tokenizer" "^2.1.0"
-    "@csstools/postcss-progressive-custom-properties" "^2.0.0"
-
-"@csstools/postcss-progressive-custom-properties@^2.0.0":
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-progressive-custom-properties/-/postcss-progressive-custom-properties-2.1.0.tgz#df35da0e85a6d5e1d8e4c9a0ba9032e8486e8b9d"
-  integrity sha512-tRX1rinsXajZlc4WiU7s9Y6O9EdSHScT997zDsvDUjQ1oZL2nvnL6Bt0s9KyQZZTdC3lrG2PIdBqdOIWXSEPlQ==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-"@csstools/postcss-progressive-custom-properties@^2.1.0":
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-progressive-custom-properties/-/postcss-progressive-custom-properties-2.1.1.tgz#82df9314451db63bf7f4975a4d32f148e85db490"
-  integrity sha512-6p8eO5+j+9hn4h2Klr9dbmya0GIb9SRrnPaCxqR1muVlV1waAZq6YkmlApEwXrox9qxggSwGZD5TnLRIY9f7WA==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-"@csstools/postcss-scope-pseudo-class@^2.0.2":
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-scope-pseudo-class/-/postcss-scope-pseudo-class-2.0.2.tgz#6325e1e3b321093c59b008ec670bb772e17f06fe"
-  integrity sha512-6Pvo4uexUCXt+Hz5iUtemQAcIuCYnL+ePs1khFR6/xPgC92aQLJ0zGHonWoewiBE+I++4gXK3pr+R1rlOFHe5w==
-  dependencies:
-    postcss-selector-parser "^6.0.10"
-
-"@csstools/postcss-stepped-value-functions@^2.1.0":
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-stepped-value-functions/-/postcss-stepped-value-functions-2.1.0.tgz#8ca134a7f70e00b14f5796fb32ed33a656ba0b1b"
-  integrity sha512-CkEo9BF8fQeMoXW3biXjlgTLY7PA4UFihn6leq7hPoRzIguLUI0WZIVgsITGXfX8LXmkhCSTjXO2DLYu/LUixQ==
-  dependencies:
-    "@csstools/css-calc" "^1.0.0"
-    "@csstools/css-parser-algorithms" "^2.0.1"
-    "@csstools/css-tokenizer" "^2.0.1"
-
-"@csstools/postcss-text-decoration-shorthand@^2.2.1":
-  version "2.2.2"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-text-decoration-shorthand/-/postcss-text-decoration-shorthand-2.2.2.tgz#75539827b56905f7c2e8273c0358cc6fec5ca72d"
-  integrity sha512-aR9l/V7p0SkdrIyBysqlQWIbGXeGC7U4ccBAIlWMpVpG/MsGhxs1JvdBpjim4UDF3U+1VmF+MbvZFb7dL+d7XA==
-  dependencies:
-    "@csstools/color-helpers" "^1.0.0"
-    postcss-value-parser "^4.2.0"
-
-"@csstools/postcss-trigonometric-functions@^2.1.0":
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-trigonometric-functions/-/postcss-trigonometric-functions-2.1.0.tgz#5a489975d445b9e79c6cb5f0f01ae711ec86639d"
-  integrity sha512-Ly7YczO+QdnByYeGqlppJoA2Tb2vsFfj5gSrszPTXJ+/4g3nnEZnG0VSeTK/WA8y7fzyL/qVNkkdEeOnruNWFQ==
-  dependencies:
-    "@csstools/css-calc" "^1.0.0"
-    "@csstools/css-parser-algorithms" "^2.0.1"
-    "@csstools/css-tokenizer" "^2.0.1"
-
-"@csstools/postcss-unset-value@^2.0.1":
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/@csstools/postcss-unset-value/-/postcss-unset-value-2.0.1.tgz#67091dd6cff556bff896c95053eb070cc6b21c25"
-  integrity sha512-oJ9Xl29/yU8U7/pnMJRqAZd4YXNCfGEdcP4ywREuqm/xMqcgDNDppYRoCGDt40aaZQIEKBS79LytUDN/DHf0Ew==
-
-"@csstools/selector-specificity@^2.0.0", "@csstools/selector-specificity@^2.0.1", "@csstools/selector-specificity@^2.0.2":
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/@csstools/selector-specificity/-/selector-specificity-2.1.1.tgz#c9c61d9fe5ca5ac664e1153bb0aa0eba1c6d6308"
-  integrity sha512-jwx+WCqszn53YHOfvFMJJRd/B2GqkCBt+1MJSG6o5/s8+ytHMvDZXsJgUEWLk12UnLd7HYKac4BYU5i/Ron1Cw==
-
-"@csstools/selector-specificity@^2.2.0":
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/@csstools/selector-specificity/-/selector-specificity-2.2.0.tgz#2cbcf822bf3764c9658c4d2e568bd0c0cb748016"
-  integrity sha512-+OJ9konv95ClSTOJCmMZqpd5+YGsB2S+x6w3E1oaM8UuR5j8nTNHYSz8c9BEPGDOCMQYIEEGlVPj/VY64iTbGw==
-
-"@cypress/code-coverage@^3.10.3":
-  version "3.10.3"
-  resolved "https://registry.yarnpkg.com/@cypress/code-coverage/-/code-coverage-3.10.3.tgz#a139953d174a629d901b9e40455d0f0b785e438b"
-  integrity sha512-wsTAhldbMI/qopvogEjwU9ISXDH+9t+ChOE8OGdxMmJ4f0yhq6xP0ZFcjdE8JGo1ZptoyT8fq/NdgwsCK4AIoA==
-  dependencies:
-    "@cypress/webpack-preprocessor" "^5.11.0"
-    chalk "4.1.2"
-    dayjs "1.10.7"
-    debug "4.3.4"
-    execa "4.1.0"
-    globby "11.0.4"
-    istanbul-lib-coverage "3.0.0"
-    js-yaml "4.1.0"
-    nyc "15.1.0"
-
-"@cypress/request@^3.0.1":
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/@cypress/request/-/request-3.0.1.tgz#72d7d5425236a2413bd3d8bb66d02d9dc3168960"
-  integrity sha512-TWivJlJi8ZDx2wGOw1dbLuHJKUYX7bWySw377nlnGOW3hP9/MUKIsEdXT/YngWxVdgNCHRBmFlBipE+5/2ZZlQ==
-  dependencies:
-    aws-sign2 "~0.7.0"
-    aws4 "^1.8.0"
-    caseless "~0.12.0"
-    combined-stream "~1.0.6"
-    extend "~3.0.2"
-    forever-agent "~0.6.1"
-    form-data "~2.3.2"
-    http-signature "~1.3.6"
-    is-typedarray "~1.0.0"
-    isstream "~0.1.2"
-    json-stringify-safe "~5.0.1"
-    mime-types "~2.1.19"
-    performance-now "^2.1.0"
-    qs "6.10.4"
-    safe-buffer "^5.1.2"
-    tough-cookie "^4.1.3"
-    tunnel-agent "^0.6.0"
-    uuid "^8.3.2"
-
-"@cypress/webpack-preprocessor@^5.11.0":
-  version "5.15.5"
-  resolved "https://registry.yarnpkg.com/@cypress/webpack-preprocessor/-/webpack-preprocessor-5.15.5.tgz#965940014e0a72366be451d8bb7efc1f46b8a713"
-  dependencies:
-    "@babel/parser" "7.13.0"
-    bluebird "3.7.1"
-    debug "^4.3.2"
-    fs-extra "^10.1.0"
-    loader-utils "^2.0.0"
-    lodash "^4.17.20"
-    md5 "2.3.0"
-    source-map "^0.6.1"
-    webpack-virtual-modules "^0.4.4"
-
-"@cypress/xvfb@^1.2.4":
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/@cypress/xvfb/-/xvfb-1.2.4.tgz#2daf42e8275b39f4aa53c14214e557bd14e7748a"
-  integrity sha512-skbBzPggOVYCbnGgV+0dmBdW/s77ZkAOXIC1knS8NagwDjBrNC1LuXtQJeiN6l+m7lzmHtaoUw/ctJKdqkG57Q==
-  dependencies:
-    debug "^3.1.0"
-    lodash.once "^4.1.1"
-
-"@editorjs/caret@^1.0.1":
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/@editorjs/caret/-/caret-1.0.1.tgz#0d33ca67a2d29d09fdea10d3d30b660f0abc7cfd"
-  integrity sha512-yMewrc/dndBbgmluFory0GbVWXnD9rhcE/xgwM0ecHWQodyfY3ZIJLvSQhf+BbgncitMlUG/FYqjJCL2Axi4+g==
-  dependencies:
-    "@editorjs/dom" "^1.0.0"
-
-"@editorjs/code@^2.7.0":
-  version "2.8.0"
-  resolved "https://registry.yarnpkg.com/@editorjs/code/-/code-2.8.0.tgz#d31fdd947b9c763daae2cd2eabdf8dc37c0c6f5a"
-  integrity sha512-qlv1OqSEPKnLv/ZQgNFmVgqsMbGDkh/qgTEnbVWsS+yujo1nlwgVkqCB8tOkQGVsrpmAYLiWRlA413nKxxCN5w==
-  dependencies:
-    "@codexteam/icons" "^0.0.5"
-
-"@editorjs/delimiter@^1.2.0":
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/@editorjs/delimiter/-/delimiter-1.3.0.tgz#abc4c5b1e512c09ec6cd0c57f41e36434fbd4da4"
-  integrity sha512-/qz+3yRSPmx6dJpBcwnDfgKtCjOrCsQRoDhXR+wLWirGOchOifhYwQ/6JZyTvcgmY84UEoYY29/dgdWOGVPEEQ==
-  dependencies:
-    "@codexteam/icons" "^0.0.5"
-
-"@editorjs/dom@^1.0.0":
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/@editorjs/dom/-/dom-1.0.0.tgz#ddf7f17651a091570766c5fa44c89ecf8a183c82"
-  integrity sha512-P5qZaQaG8NQXm2XuEDlcfDm8S1Kvdegwf0E/ld2RnwZquY5l27hufaW57w0SikT75mscr+dARQ68Gx/xEQEUKw==
-  dependencies:
-    "@editorjs/helpers" "^1.0.0"
-
-"@editorjs/editorjs@^2.29.1":
-  version "2.30.2"
-  resolved "https://registry.yarnpkg.com/@editorjs/editorjs/-/editorjs-2.30.2.tgz#b045af18a9ebe0c02cb32be41b2a98e23ee08e59"
-  integrity sha512-JjtUDs2/aHTEjNZzEf/2cugpIli1+aNeU8mloOd5USbVxv2vC02HTMpv7Vc1UyB7dIuc45JaYSJwgnBZp9duhA==
-
-"@editorjs/header@^2.8.8":
-  version "2.8.8"
-  resolved "https://registry.yarnpkg.com/@editorjs/header/-/header-2.8.8.tgz#43cff7949c44866da7716fdb562d68116d0a806a"
-  integrity sha512-bsMSs34u2hoi0UBuRoc5EGWXIFzJiwYgkFUYQGVm63y5FU+s8zPBmVx5Ip2sw1xgs0fqfDROqmteMvvmbCy62w==
-  dependencies:
-    "@codexteam/icons" "^0.0.5"
-    "@editorjs/editorjs" "^2.29.1"
-
-"@editorjs/helpers@^1.0.0":
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/@editorjs/helpers/-/helpers-1.0.0.tgz#4b0e0868e51e2772a73212f4aac5aff553725894"
-  integrity sha512-ih4yCm+x+7X9XCn1zxfNous2LQX8ZYMyTHMLdgbyjBf0Opf8GdLxVjdzSjkA+0mUp1tUe3JgWW3FTisYcSnbQA==
-
-"@editorjs/paragraph@^2.11.6":
-  version "2.11.6"
-  resolved "https://registry.yarnpkg.com/@editorjs/paragraph/-/paragraph-2.11.6.tgz#011444187a74dc603201dce37d2fc6d054022407"
-  integrity sha512-i9B50Ylvh+0ZzUGWIba09PfUXsA00Y//zFZMwqsyaXXKxMluSIJ6ADFJbbK0zaV9Ijx49Xocrlg+CEPRqATk9w==
-  dependencies:
-    "@codexteam/icons" "^0.0.4"
-
-"@editorjs/simple-image@^1.4.1":
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/@editorjs/simple-image/-/simple-image-1.5.1.tgz#a4b96f3dcabcf3db0770591d345d11470f218603"
-  integrity sha512-eXfNzYMOPE7I/HllX00XvEO1MGiFu34lzOIyQzxQ3GdD+GlEJgIN9IhLGN7glsyAhCVmNyxNXGa9kUHzWQ9c5Q==
-  dependencies:
-    "@codexteam/icons" "^0.0.6"
-
-"@es-joy/jsdoccomment@~0.36.1":
-  version "0.36.1"
-  resolved "https://registry.yarnpkg.com/@es-joy/jsdoccomment/-/jsdoccomment-0.36.1.tgz#c37db40da36e4b848da5fd427a74bae3b004a30f"
-  integrity sha512-922xqFsTpHs6D0BUiG4toiyPOMc8/jafnWKxz1KWgS4XzKPy2qXf1Pe6UFuNSCQqt6tOuhAWXBNuuyUhJmw9Vg==
-  dependencies:
-    comment-parser "1.3.1"
-    esquery "^1.4.0"
-    jsdoc-type-pratt-parser "~3.1.0"
-
-"@esbuild/android-arm64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.18.20.tgz#984b4f9c8d0377443cc2dfcef266d02244593622"
-  integrity sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ==
-
-"@esbuild/android-arm@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.18.20.tgz#fedb265bc3a589c84cc11f810804f234947c3682"
-  integrity sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw==
-
-"@esbuild/android-x64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.18.20.tgz#35cf419c4cfc8babe8893d296cd990e9e9f756f2"
-  integrity sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg==
-
-"@esbuild/darwin-arm64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.18.20.tgz#08172cbeccf95fbc383399a7f39cfbddaeb0d7c1"
-  integrity sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==
-
-"@esbuild/darwin-x64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.18.20.tgz#d70d5790d8bf475556b67d0f8b7c5bdff053d85d"
-  integrity sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ==
-
-"@esbuild/freebsd-arm64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.20.tgz#98755cd12707f93f210e2494d6a4b51b96977f54"
-  integrity sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw==
-
-"@esbuild/freebsd-x64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.18.20.tgz#c1eb2bff03915f87c29cece4c1a7fa1f423b066e"
-  integrity sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ==
-
-"@esbuild/linux-arm64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.18.20.tgz#bad4238bd8f4fc25b5a021280c770ab5fc3a02a0"
-  integrity sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA==
-
-"@esbuild/linux-arm@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.18.20.tgz#3e617c61f33508a27150ee417543c8ab5acc73b0"
-  integrity sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg==
-
-"@esbuild/linux-ia32@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.18.20.tgz#699391cccba9aee6019b7f9892eb99219f1570a7"
-  integrity sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA==
-
-"@esbuild/linux-loong64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.18.20.tgz#e6fccb7aac178dd2ffb9860465ac89d7f23b977d"
-  integrity sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg==
-
-"@esbuild/linux-mips64el@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.18.20.tgz#eeff3a937de9c2310de30622a957ad1bd9183231"
-  integrity sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ==
-
-"@esbuild/linux-ppc64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.18.20.tgz#2f7156bde20b01527993e6881435ad79ba9599fb"
-  integrity sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA==
-
-"@esbuild/linux-riscv64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.18.20.tgz#6628389f210123d8b4743045af8caa7d4ddfc7a6"
-  integrity sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A==
-
-"@esbuild/linux-s390x@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.18.20.tgz#255e81fb289b101026131858ab99fba63dcf0071"
-  integrity sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ==
-
-"@esbuild/linux-x64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.18.20.tgz#c7690b3417af318a9b6f96df3031a8865176d338"
-  integrity sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==
-
-"@esbuild/netbsd-x64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.18.20.tgz#30e8cd8a3dded63975e2df2438ca109601ebe0d1"
-  integrity sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A==
-
-"@esbuild/openbsd-x64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.18.20.tgz#7812af31b205055874c8082ea9cf9ab0da6217ae"
-  integrity sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg==
-
-"@esbuild/sunos-x64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.18.20.tgz#d5c275c3b4e73c9b0ecd38d1ca62c020f887ab9d"
-  integrity sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==
-
-"@esbuild/win32-arm64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.18.20.tgz#73bc7f5a9f8a77805f357fab97f290d0e4820ac9"
-  integrity sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg==
-
-"@esbuild/win32-ia32@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.18.20.tgz#ec93cbf0ef1085cc12e71e0d661d20569ff42102"
-  integrity sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g==
-
-"@esbuild/win32-x64@0.18.20":
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.18.20.tgz#786c5f41f043b07afb1af37683d7c33668858f6d"
-  integrity sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ==
-
-"@eslint-community/eslint-utils@^4.2.0":
-  version "4.4.0"
-  resolved "https://registry.yarnpkg.com/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz#a23514e8fb9af1269d5f7788aa556798d61c6b59"
-  integrity sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==
-  dependencies:
-    eslint-visitor-keys "^3.3.0"
-
-"@eslint-community/regexpp@^4.4.0":
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.5.0.tgz#f6f729b02feee2c749f57e334b7a1b5f40a81724"
-  integrity sha512-vITaYzIcNmjn5tF5uxcZ/ft7/RXGrMUIS9HalWckEOF6ESiwXKoMzAQf2UW0aVd6rnOeExTJVd5hmWXucBKGXQ==
-
-"@eslint/eslintrc@^2.0.2":
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-2.0.2.tgz#01575e38707add677cf73ca1589abba8da899a02"
-  integrity sha512-3W4f5tDUra+pA+FzgugqL2pRimUTDJWKr7BINqOpkZrC0uYI0NIc0/JFgBROCU07HR6GieA5m3/rsPIhDmCXTQ==
-  dependencies:
-    ajv "^6.12.4"
-    debug "^4.3.2"
-    espree "^9.5.1"
-    globals "^13.19.0"
-    ignore "^5.2.0"
-    import-fresh "^3.2.1"
-    js-yaml "^4.1.0"
-    minimatch "^3.1.2"
-    strip-json-comments "^3.1.1"
-
-"@eslint/js@8.37.0":
-  version "8.37.0"
-  resolved "https://registry.yarnpkg.com/@eslint/js/-/js-8.37.0.tgz#cf1b5fa24217fe007f6487a26d765274925efa7d"
-  integrity sha512-x5vzdtOOGgFVDCUs81QRB2+liax8rFg3+7hqM+QhBG0/G3F1ZsoYl97UrqgHgQ9KKT7G6c4V+aTUCgu/n22v1A==
-
-"@humanwhocodes/config-array@^0.11.8":
-  version "0.11.8"
-  resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.11.8.tgz#03595ac2075a4dc0f191cc2131de14fbd7d410b9"
-  integrity sha512-UybHIJzJnR5Qc/MsD9Kr+RpO2h+/P1GhOwdiLPXK5TWk5sgTdu88bTD9UP+CKbPPh5Rni1u0GjAdYQLemG8g+g==
-  dependencies:
-    "@humanwhocodes/object-schema" "^1.2.1"
-    debug "^4.1.1"
-    minimatch "^3.0.5"
-
-"@humanwhocodes/module-importer@^1.0.1":
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz#af5b2691a22b44be847b0ca81641c5fb6ad0172c"
-  integrity sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==
-
-"@humanwhocodes/object-schema@^1.2.1":
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz#b520529ec21d8e5945a1851dfd1c32e94e39ff45"
-  integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==
-
-"@istanbuljs/load-nyc-config@^1.0.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz#fd3db1d59ecf7cf121e80650bb86712f9b55eced"
-  integrity sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==
-  dependencies:
-    camelcase "^5.3.1"
-    find-up "^4.1.0"
-    get-package-type "^0.1.0"
-    js-yaml "^3.13.1"
-    resolve-from "^5.0.0"
-
-"@istanbuljs/schema@^0.1.2":
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/@istanbuljs/schema/-/schema-0.1.3.tgz#e45e384e4b8ec16bce2fd903af78450f6bf7ec98"
-  integrity sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==
-
-"@jridgewell/gen-mapping@^0.1.0":
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz#e5d2e450306a9491e3bd77e323e38d7aff315996"
-  integrity sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w==
-  dependencies:
-    "@jridgewell/set-array" "^1.0.0"
-    "@jridgewell/sourcemap-codec" "^1.4.10"
-
-"@jridgewell/gen-mapping@^0.3.2":
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz#c1aedc61e853f2bb9f5dfe6d4442d3b565b253b9"
-  integrity sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==
-  dependencies:
-    "@jridgewell/set-array" "^1.0.1"
-    "@jridgewell/sourcemap-codec" "^1.4.10"
-    "@jridgewell/trace-mapping" "^0.3.9"
-
-"@jridgewell/resolve-uri@3.1.0":
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz#2203b118c157721addfe69d47b70465463066d78"
-  integrity sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==
-
-"@jridgewell/set-array@^1.0.0", "@jridgewell/set-array@^1.0.1":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@jridgewell/set-array/-/set-array-1.1.2.tgz#7c6cf998d6d20b914c0a55a91ae928ff25965e72"
-  integrity sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==
-
-"@jridgewell/sourcemap-codec@1.4.14", "@jridgewell/sourcemap-codec@^1.4.10":
-  version "1.4.14"
-  resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz#add4c98d341472a289190b424efbdb096991bb24"
-  integrity sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==
-
-"@jridgewell/trace-mapping@^0.3.17", "@jridgewell/trace-mapping@^0.3.9":
-  version "0.3.17"
-  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.17.tgz#793041277af9073b0951a7fe0f0d8c4c98c36985"
-  integrity sha512-MCNzAp77qzKca9+W/+I0+sEpaUnZoeasnghNeVc41VZCEKaCH73Vq3BZZ/SzWIgrqE4H4ceI+p+b6C0mHf9T4g==
-  dependencies:
-    "@jridgewell/resolve-uri" "3.1.0"
-    "@jridgewell/sourcemap-codec" "1.4.14"
-
-"@nodelib/fs.scandir@2.1.5":
-  version "2.1.5"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5"
-  integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==
-  dependencies:
-    "@nodelib/fs.stat" "2.0.5"
-    run-parallel "^1.1.9"
-
-"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2":
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b"
-  integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==
-
-"@nodelib/fs.walk@^1.2.3", "@nodelib/fs.walk@^1.2.8":
-  version "1.2.8"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz#e95737e8bb6746ddedf69c556953494f196fe69a"
-  integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==
-  dependencies:
-    "@nodelib/fs.scandir" "2.1.5"
-    fastq "^1.6.0"
-
-"@types/json-schema@^7.0.9":
-  version "7.0.11"
-  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.11.tgz#d421b6c527a3037f7c84433fd2c4229e016863d3"
-  integrity sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==
-
-"@types/json5@^0.0.29":
-  version "0.0.29"
-  resolved "https://registry.yarnpkg.com/@types/json5/-/json5-0.0.29.tgz#ee28707ae94e11d2b827bcbe5270bcea7f3e71ee"
-  integrity sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==
-
-"@types/minimist@^1.2.0":
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/@types/minimist/-/minimist-1.2.2.tgz#ee771e2ba4b3dc5b372935d549fd9617bf345b8c"
-  integrity sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==
-
-"@types/node@*":
-  version "20.12.2"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-20.12.2.tgz#9facdd11102f38b21b4ebedd9d7999663343d72e"
-  integrity sha512-zQ0NYO87hyN6Xrclcqp7f8ZbXNbRfoGWNcMvHTPQp9UUrwI0mI7XBz+cu7/W6/VClYo2g63B0cjull/srU7LgQ==
-  dependencies:
-    undici-types "~5.26.4"
-
-"@types/node@^18.15.11":
-  version "18.15.11"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-18.15.11.tgz#b3b790f09cb1696cffcec605de025b088fa4225f"
-  integrity sha512-E5Kwq2n4SbMzQOn6wnmBjuK9ouqlURrcZDVfbo9ftDDTFt3nk7ZKK4GMOzoYgnpQJKcxwQw+lGaBvvlMo0qN/Q==
-
-"@types/normalize-package-data@^2.4.0":
-  version "2.4.1"
-  resolved "https://registry.yarnpkg.com/@types/normalize-package-data/-/normalize-package-data-2.4.1.tgz#d3357479a0fdfdd5907fe67e17e0a85c906e1301"
-  integrity sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==
-
-"@types/semver@^7.3.12":
-  version "7.3.13"
-  resolved "https://registry.yarnpkg.com/@types/semver/-/semver-7.3.13.tgz#da4bfd73f49bd541d28920ab0e2bf0ee80f71c91"
-  integrity sha512-21cFJr9z3g5dW8B0CVI9g2O9beqaThGQ6ZFBqHfwhzLDKUxaqTIy3vnfah/UPkfOiF2pLq+tGz+W8RyCskuslw==
-
-"@types/sinonjs__fake-timers@8.1.1":
-  version "8.1.1"
-  resolved "https://registry.yarnpkg.com/@types/sinonjs__fake-timers/-/sinonjs__fake-timers-8.1.1.tgz#b49c2c70150141a15e0fa7e79cf1f92a72934ce3"
-  integrity sha512-0kSuKjAS0TrGLJ0M/+8MaFkGsQhZpB6pxOmvS3K8FYI72K//YmdfoW9X2qPsAKh1mkwxGD5zib9s1FIFed6E8g==
-
-"@types/sizzle@^2.3.2":
-  version "2.3.8"
-  resolved "https://registry.yarnpkg.com/@types/sizzle/-/sizzle-2.3.8.tgz#518609aefb797da19bf222feb199e8f653ff7627"
-  integrity sha512-0vWLNK2D5MT9dg0iOo8GlKguPAU02QjmZitPEsXRuJXU/OGIOt9vT9Fc26wtYuavLxtO45v9PGleoL9Z0k1LHg==
-
-"@types/yauzl@^2.9.1":
-  version "2.10.3"
-  resolved "https://registry.yarnpkg.com/@types/yauzl/-/yauzl-2.10.3.tgz#e9b2808b4f109504a03cda958259876f61017999"
-  integrity sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==
-  dependencies:
-    "@types/node" "*"
-
-"@typescript-eslint/eslint-plugin@^5.46.0":
-  version "5.54.1"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.54.1.tgz#0c5091289ce28372e38ab8d28e861d2dbe1ab29e"
-  integrity sha512-a2RQAkosH3d3ZIV08s3DcL/mcGc2M/UC528VkPULFxR9VnVPT8pBu0IyBAJJmVsCmhVfwQX1v6q+QGnmSe1bew==
-  dependencies:
-    "@typescript-eslint/scope-manager" "5.54.1"
-    "@typescript-eslint/type-utils" "5.54.1"
-    "@typescript-eslint/utils" "5.54.1"
-    debug "^4.3.4"
-    grapheme-splitter "^1.0.4"
-    ignore "^5.2.0"
-    natural-compare-lite "^1.4.0"
-    regexpp "^3.2.0"
-    semver "^7.3.7"
-    tsutils "^3.21.0"
-
-"@typescript-eslint/parser@^5.46.0":
-  version "5.54.1"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-5.54.1.tgz#05761d7f777ef1c37c971d3af6631715099b084c"
-  integrity sha512-8zaIXJp/nG9Ff9vQNh7TI+C3nA6q6iIsGJ4B4L6MhZ7mHnTMR4YP5vp2xydmFXIy8rpyIVbNAG44871LMt6ujg==
-  dependencies:
-    "@typescript-eslint/scope-manager" "5.54.1"
-    "@typescript-eslint/types" "5.54.1"
-    "@typescript-eslint/typescript-estree" "5.54.1"
-    debug "^4.3.4"
-
-"@typescript-eslint/scope-manager@5.54.1":
-  version "5.54.1"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-5.54.1.tgz#6d864b4915741c608a58ce9912edf5a02bb58735"
-  integrity sha512-zWKuGliXxvuxyM71UA/EcPxaviw39dB2504LqAmFDjmkpO8qNLHcmzlh6pbHs1h/7YQ9bnsO8CCcYCSA8sykUg==
-  dependencies:
-    "@typescript-eslint/types" "5.54.1"
-    "@typescript-eslint/visitor-keys" "5.54.1"
-
-"@typescript-eslint/type-utils@5.54.1":
-  version "5.54.1"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.54.1.tgz#4825918ec27e55da8bb99cd07ec2a8e5f50ab748"
-  integrity sha512-WREHsTz0GqVYLIbzIZYbmUUr95DKEKIXZNH57W3s+4bVnuF1TKe2jH8ZNH8rO1CeMY3U4j4UQeqPNkHMiGem3g==
-  dependencies:
-    "@typescript-eslint/typescript-estree" "5.54.1"
-    "@typescript-eslint/utils" "5.54.1"
-    debug "^4.3.4"
-    tsutils "^3.21.0"
-
-"@typescript-eslint/types@5.54.1":
-  version "5.54.1"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-5.54.1.tgz#29fbac29a716d0f08c62fe5de70c9b6735de215c"
-  integrity sha512-G9+1vVazrfAfbtmCapJX8jRo2E4MDXxgm/IMOF4oGh3kq7XuK3JRkOg6y2Qu1VsTRmWETyTkWt1wxy7X7/yLkw==
-
-"@typescript-eslint/typescript-estree@5.54.1":
-  version "5.54.1"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.54.1.tgz#df7b6ae05fd8fef724a87afa7e2f57fa4a599be1"
-  integrity sha512-bjK5t+S6ffHnVwA0qRPTZrxKSaFYocwFIkZx5k7pvWfsB1I57pO/0M0Skatzzw1sCkjJ83AfGTL0oFIFiDX3bg==
-  dependencies:
-    "@typescript-eslint/types" "5.54.1"
-    "@typescript-eslint/visitor-keys" "5.54.1"
-    debug "^4.3.4"
-    globby "^11.1.0"
-    is-glob "^4.0.3"
-    semver "^7.3.7"
-    tsutils "^3.21.0"
-
-"@typescript-eslint/utils@5.54.1":
-  version "5.54.1"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-5.54.1.tgz#7a3ee47409285387b9d4609ea7e1020d1797ec34"
-  integrity sha512-IY5dyQM8XD1zfDe5X8jegX6r2EVU5o/WJnLu/znLPWCBF7KNGC+adacXnt5jEYS9JixDcoccI6CvE4RCjHMzCQ==
-  dependencies:
-    "@types/json-schema" "^7.0.9"
-    "@types/semver" "^7.3.12"
-    "@typescript-eslint/scope-manager" "5.54.1"
-    "@typescript-eslint/types" "5.54.1"
-    "@typescript-eslint/typescript-estree" "5.54.1"
-    eslint-scope "^5.1.1"
-    eslint-utils "^3.0.0"
-    semver "^7.3.7"
-
-"@typescript-eslint/visitor-keys@5.54.1":
-  version "5.54.1"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-5.54.1.tgz#d7a8a0f7181d6ac748f4d47b2306e0513b98bf8b"
-  integrity sha512-q8iSoHTgwCfgcRJ2l2x+xCbu8nBlRAlsQ33k24Adj8eoVBE0f8dUeI+bAa8F84Mv05UGbAx57g2zrRsYIooqQg==
-  dependencies:
-    "@typescript-eslint/types" "5.54.1"
-    eslint-visitor-keys "^3.3.0"
-
-acorn-jsx@^5.3.2:
-  version "5.3.2"
-  resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937"
-  integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==
-
-acorn@^8.8.0:
-  version "8.8.2"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.8.2.tgz#1b2f25db02af965399b9776b0c2c391276d37c4a"
-  integrity sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==
-
-aggregate-error@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/aggregate-error/-/aggregate-error-3.1.0.tgz#92670ff50f5359bdb7a3e0d40d0ec30c5737687a"
-  integrity sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==
-  dependencies:
-    clean-stack "^2.0.0"
-    indent-string "^4.0.0"
-
-ajv@^6.10.0, ajv@^6.12.4:
-  version "6.12.6"
-  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
-  integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
-  dependencies:
-    fast-deep-equal "^3.1.1"
-    fast-json-stable-stringify "^2.0.0"
-    json-schema-traverse "^0.4.1"
-    uri-js "^4.2.2"
-
-ajv@^8.0.1:
-  version "8.12.0"
-  resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.12.0.tgz#d1a0527323e22f53562c567c00991577dfbe19d1"
-  integrity sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==
-  dependencies:
-    fast-deep-equal "^3.1.1"
-    json-schema-traverse "^1.0.0"
-    require-from-string "^2.0.2"
-    uri-js "^4.2.2"
-
-ally.js@^1.4.1:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/ally.js/-/ally.js-1.4.1.tgz#9fb7e6ba58efac4ee9131cb29aa9ee3b540bcf1e"
-  integrity sha512-ZewdfuwP6VewtMN36QY0gmiyvBfMnmEaNwbVu2nTS6zRt069viTgkYgaDiqu6vRJ1VJCriNqV0jGMu44R8zNbA==
-  dependencies:
-    css.escape "^1.5.0"
-    platform "1.3.3"
-
-ansi-colors@4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.1.tgz#cbb9ae256bf750af1eab344f229aa27fe94ba348"
-  integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==
-
-ansi-colors@^4.1.1:
-  version "4.1.3"
-  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.3.tgz#37611340eb2243e70cc604cad35d63270d48781b"
-  integrity sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==
-
-ansi-escapes@^4.3.0:
-  version "4.3.2"
-  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-4.3.2.tgz#6b2291d1db7d98b6521d5f1efa42d0f3a9feb65e"
-  integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==
-  dependencies:
-    type-fest "^0.21.3"
-
-ansi-regex@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304"
-  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
-
-ansi-styles@^3.2.1:
-  version "3.2.1"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
-  integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
-  dependencies:
-    color-convert "^1.9.0"
-
-ansi-styles@^4.0.0, ansi-styles@^4.1.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
-  integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
-  dependencies:
-    color-convert "^2.0.1"
-
-anymatch@~3.1.2:
-  version "3.1.3"
-  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e"
-  integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==
-  dependencies:
-    normalize-path "^3.0.0"
-    picomatch "^2.0.4"
-
-append-transform@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/append-transform/-/append-transform-2.0.0.tgz#99d9d29c7b38391e6f428d28ce136551f0b77e12"
-  integrity sha512-7yeyCEurROLQJFv5Xj4lEGTy0borxepjFv1g22oAdqFu//SrAlDl1O1Nxx15SH1RoliUml6p8dwJW9jvZughhg==
-  dependencies:
-    default-require-extensions "^3.0.0"
-
-arch@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/arch/-/arch-2.2.0.tgz#1bc47818f305764f23ab3306b0bfc086c5a29d11"
-  integrity sha512-Of/R0wqp83cgHozfIYLbBMnej79U/SVGOOyuB3VVFv1NRM/PSFMK12x9KVtiYzJqmnU5WR2qp0Z5rHb7sWGnFQ==
-
-archy@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/archy/-/archy-1.0.0.tgz#f9c8c13757cc1dd7bc379ac77b2c62a5c2868c40"
-  integrity sha512-Xg+9RwCg/0p32teKdGMPTPnVXKD0w3DfHnFTficozsAgsvq2XenPJq/MYpzzQ/v8zrOyJn6Ds39VA4JIDwFfqw==
-
-argparse@^1.0.7:
-  version "1.0.10"
-  resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
-  integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
-  dependencies:
-    sprintf-js "~1.0.2"
-
-argparse@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38"
-  integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
-
-array-find-index@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/array-find-index/-/array-find-index-1.0.2.tgz#df010aa1287e164bbda6f9723b0a96a1ec4187a1"
-  integrity sha512-M1HQyIXcBGtVywBt8WVdim+lrNaK7VHp99Qt5pSNziXznKHViIBbXWtfRTpEFpF/c4FdfxNAsCCwPp5phBYJtw==
-
-array-includes@^3.1.4:
-  version "3.1.6"
-  resolved "https://registry.yarnpkg.com/array-includes/-/array-includes-3.1.6.tgz#9e9e720e194f198266ba9e18c29e6a9b0e4b225f"
-  integrity sha512-sgTbLvL6cNnw24FnbaDyjmvddQ2ML8arZsgaJhoABMoplz/4QRhtrYS+alr1BUM1Bwp6dhx8vVCBSLG+StwOFw==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.4"
-    es-abstract "^1.20.4"
-    get-intrinsic "^1.1.3"
-    is-string "^1.0.7"
-
-array-union@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/array-union/-/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d"
-  integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
-
-array.prototype.flat@^1.2.5:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/array.prototype.flat/-/array.prototype.flat-1.3.1.tgz#ffc6576a7ca3efc2f46a143b9d1dda9b4b3cf5e2"
-  integrity sha512-roTU0KWIOmJ4DRLmwKd19Otg0/mT3qPNt0Qb3GWW8iObuZXxrjB/pzn0R3hqpRSWg4HCwqx+0vwOnWnvlOyeIA==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.4"
-    es-abstract "^1.20.4"
-    es-shim-unscopables "^1.0.0"
-
-arrify@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
-  integrity sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==
-
-asn1@~0.2.3:
-  version "0.2.6"
-  resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.6.tgz#0d3a7bb6e64e02a90c0303b31f292868ea09a08d"
-  integrity sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==
-  dependencies:
-    safer-buffer "~2.1.0"
-
-assert-plus@1.0.0, assert-plus@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525"
-  integrity sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==
-
-astral-regex@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-2.0.0.tgz#483143c567aeed4785759c0865786dc77d7d2e31"
-  integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==
-
-async@^3.2.0:
-  version "3.2.5"
-  resolved "https://registry.yarnpkg.com/async/-/async-3.2.5.tgz#ebd52a8fdaf7a2289a24df399f8d8485c8a46b66"
-  integrity sha512-baNZyqaaLhyLVKm/DlvdW051MSgO6b8eVfIezl9E5PqWxFgzLm/wQntEW4zOytVburDEr0JlALEpdOFwvErLsg==
-
-asynckit@^0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
-  integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==
-
-at-least-node@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/at-least-node/-/at-least-node-1.0.0.tgz#602cd4b46e844ad4effc92a8011a3c46e0238dc2"
-  integrity sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==
-
-autoprefixer@^10.4.14:
-  version "10.4.14"
-  resolved "https://registry.yarnpkg.com/autoprefixer/-/autoprefixer-10.4.14.tgz#e28d49902f8e759dd25b153264e862df2705f79d"
-  integrity sha512-FQzyfOsTlwVzjHxKEqRIAdJx9niO6VCBCoEwax/VLSoQF29ggECcPuBqUMZ+u8jCZOPSy8b8/8KnuFbp0SaFZQ==
-  dependencies:
-    browserslist "^4.21.5"
-    caniuse-lite "^1.0.30001464"
-    fraction.js "^4.2.0"
-    normalize-range "^0.1.2"
-    picocolors "^1.0.0"
-    postcss-value-parser "^4.2.0"
-
-available-typed-arrays@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz#92f95616501069d07d10edb2fc37d3e1c65123b7"
-  integrity sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==
-
-aws-sign2@~0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.7.0.tgz#b46e890934a9591f2d2f6f86d7e6a9f1b3fe76a8"
-  integrity sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==
-
-aws4@^1.8.0:
-  version "1.12.0"
-  resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.12.0.tgz#ce1c9d143389679e253b314241ea9aa5cec980d3"
-  integrity sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg==
-
-balanced-match@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
-  integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
-
-balanced-match@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-2.0.0.tgz#dc70f920d78db8b858535795867bf48f820633d9"
-
-base64-js@^1.3.1:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a"
-  integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==
-
-bcrypt-pbkdf@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz#a4301d389b6a43f9b67ff3ca11a3f6637e360e9e"
-  integrity sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==
-  dependencies:
-    tweetnacl "^0.14.3"
-
-big.js@^5.2.2:
-  version "5.2.2"
-  resolved "https://registry.yarnpkg.com/big.js/-/big.js-5.2.2.tgz#65f0af382f578bcdc742bd9c281e9cb2d7768328"
-  integrity sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==
-
-binary-extensions@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.2.0.tgz#75f502eeaf9ffde42fc98829645be4ea76bd9e2d"
-  integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==
-
-blob-util@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/blob-util/-/blob-util-2.0.2.tgz#3b4e3c281111bb7f11128518006cdc60b403a1eb"
-  integrity sha512-T7JQa+zsXXEa6/8ZhHcQEW1UFfVM49Ts65uBkFL6fz2QmrElqmbajIDJvuA0tEhRe5eIjpV9ZF+0RfZR9voJFQ==
-
-bluebird@3.7.1:
-  version "3.7.1"
-  resolved "https://registry.yarnpkg.com/bluebird/-/bluebird-3.7.1.tgz#df70e302b471d7473489acf26a93d63b53f874de"
-  integrity sha512-DdmyoGCleJnkbp3nkbxTLJ18rjDsE4yCggEwKNXkeV123sPNfOCYeDoeuOY+F2FrSjO1YXcTU+dsy96KMy+gcg==
-
-bluebird@^3.7.2:
-  version "3.7.2"
-  resolved "https://registry.yarnpkg.com/bluebird/-/bluebird-3.7.2.tgz#9f229c15be272454ffa973ace0dbee79a1b0c36f"
-  integrity sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==
-
-brace-expansion@^1.1.7:
-  version "1.1.11"
-  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
-  integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
-  dependencies:
-    balanced-match "^1.0.0"
-    concat-map "0.0.1"
-
-brace-expansion@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-2.0.1.tgz#1edc459e0f0c548486ecf9fc99f2221364b9a0ae"
-  integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==
-  dependencies:
-    balanced-match "^1.0.0"
-
-braces@^3.0.2, braces@~3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107"
-  integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
-  dependencies:
-    fill-range "^7.0.1"
-
-browser-stdout@1.3.1:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.1.tgz#baa559ee14ced73452229bad7326467c61fabd60"
-  integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==
-
-browserslist@^4.21.3, browserslist@^4.21.5:
-  version "4.21.5"
-  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.21.5.tgz#75c5dae60063ee641f977e00edd3cfb2fb7af6a7"
-  integrity sha512-tUkiguQGW7S3IhB7N+c2MV/HZPSCPAAiYBZXLsBhFB/PCy6ZKKsZrmBayHV9fdGV/ARIfJ14NkxKzRDjvp7L6w==
-  dependencies:
-    caniuse-lite "^1.0.30001449"
-    electron-to-chromium "^1.4.284"
-    node-releases "^2.0.8"
-    update-browserslist-db "^1.0.10"
-
-buffer-crc32@~0.2.3:
-  version "0.2.13"
-  resolved "https://registry.yarnpkg.com/buffer-crc32/-/buffer-crc32-0.2.13.tgz#0d333e3f00eac50aa1454abd30ef8c2a5d9a7242"
-  integrity sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==
-
-buffer-from@^1.0.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5"
-  integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
-
-buffer@^5.7.1:
-  version "5.7.1"
-  resolved "https://registry.yarnpkg.com/buffer/-/buffer-5.7.1.tgz#ba62e7c13133053582197160851a8f648e99eed0"
-  integrity sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==
-  dependencies:
-    base64-js "^1.3.1"
-    ieee754 "^1.1.13"
-
-builtin-modules@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-1.1.1.tgz#270f076c5a72c02f5b65a47df94c5fe3a278892f"
-  integrity sha512-wxXCdllwGhI2kCC0MnvTGYTMvnVZTvqgypkiTI8Pa5tcz2i6VqsqwYGgqwXji+4RgCzms6EajE4IxiUH6HH8nQ==
-
-builtins@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/builtins/-/builtins-5.0.1.tgz#87f6db9ab0458be728564fa81d876d8d74552fa9"
-  integrity sha512-qwVpFEHNfhYJIzNRBvd2C1kyo6jz3ZSMPyyuR47OPdiKWlbYnZNyDWuyR175qDnAJLiCo5fBBqPb3RiXgWlkOQ==
-  dependencies:
-    semver "^7.0.0"
-
-cachedir@^2.3.0:
-  version "2.4.0"
-  resolved "https://registry.yarnpkg.com/cachedir/-/cachedir-2.4.0.tgz#7fef9cf7367233d7c88068fe6e34ed0d355a610d"
-  integrity sha512-9EtFOZR8g22CL7BWjJ9BUx1+A/djkofnyW3aOXZORNW2kxoUpx2h+uN2cOqwPmFhnpVmxg+KW2OjOSgChTEvsQ==
-
-caching-transform@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/caching-transform/-/caching-transform-4.0.0.tgz#00d297a4206d71e2163c39eaffa8157ac0651f0f"
-  integrity sha512-kpqOvwXnjjN44D89K5ccQC+RUrsy7jB/XLlRrx0D7/2HNcTPqzsb6XgYoErwko6QsV184CA2YgS1fxDiiDZMWA==
-  dependencies:
-    hasha "^5.0.0"
-    make-dir "^3.0.0"
-    package-hash "^4.0.0"
-    write-file-atomic "^3.0.0"
-
-call-bind@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.2.tgz#b1d4e89e688119c3c9a903ad30abb2f6a919be3c"
-  integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==
-  dependencies:
-    function-bind "^1.1.1"
-    get-intrinsic "^1.0.2"
-
-call-bind@^1.0.7:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.7.tgz#06016599c40c56498c18769d2730be242b6fa3b9"
-  integrity sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==
-  dependencies:
-    es-define-property "^1.0.0"
-    es-errors "^1.3.0"
-    function-bind "^1.1.2"
-    get-intrinsic "^1.2.4"
-    set-function-length "^1.2.1"
-
-callsites@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73"
-  integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
-
-camelcase-keys@^6.2.2:
-  version "6.2.2"
-  resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-6.2.2.tgz#5e755d6ba51aa223ec7d3d52f25778210f9dc3c0"
-  integrity sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==
-  dependencies:
-    camelcase "^5.3.1"
-    map-obj "^4.0.0"
-    quick-lru "^4.0.1"
-
-camelcase@^5.0.0, camelcase@^5.3.1:
-  version "5.3.1"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320"
-  integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==
-
-camelcase@^6.0.0:
-  version "6.3.0"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a"
-  integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==
-
-caniuse-lite@^1.0.30001449:
-  version "1.0.30001464"
-  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001464.tgz#888922718df48ce5e33dcfe1a2af7d42676c5eb7"
-  integrity sha512-oww27MtUmusatpRpCGSOneQk2/l5czXANDSFvsc7VuOQ86s3ANhZetpwXNf1zY/zdfP63Xvjz325DAdAoES13g==
-
-caniuse-lite@^1.0.30001464:
-  version "1.0.30001466"
-  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001466.tgz#c1e6197c540392e09709ecaa9e3e403428c53375"
-  integrity sha512-ewtFBSfWjEmxUgNBSZItFSmVtvk9zkwkl1OfRZlKA8slltRN+/C/tuGVrF9styXkN36Yu3+SeJ1qkXxDEyNZ5w==
-
-caseless@~0.12.0:
-  version "0.12.0"
-  resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc"
-  integrity sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==
-
-chai-subset@^1.6.0:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/chai-subset/-/chai-subset-1.6.0.tgz#a5d0ca14e329a79596ed70058b6646bd6988cfe9"
-  integrity sha512-K3d+KmqdS5XKW5DWPd5sgNffL3uxdDe+6GdnJh3AYPhwnBGRY5urfvfcbRtWIvvpz+KxkL9FeBB6MZewLUNwug==
-
-chalk@4.1.2, chalk@^4.1.0:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
-  integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
-  dependencies:
-    ansi-styles "^4.1.0"
-    supports-color "^7.1.0"
-
-chalk@^2.0.0, chalk@^2.3.0:
-  version "2.4.2"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
-  integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
-  dependencies:
-    ansi-styles "^3.2.1"
-    escape-string-regexp "^1.0.5"
-    supports-color "^5.3.0"
-
-chalk@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.0.0.tgz#6e98081ed2d17faab615eb52ac66ec1fe6209e72"
-  dependencies:
-    ansi-styles "^4.1.0"
-    supports-color "^7.1.0"
-
-charenc@0.0.2:
-  version "0.0.2"
-  resolved "https://registry.yarnpkg.com/charenc/-/charenc-0.0.2.tgz#c0a1d2f3a7092e03774bfa83f14c0fc5790a8667"
-  integrity sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==
-
-check-more-types@^2.24.0:
-  version "2.24.0"
-  resolved "https://registry.yarnpkg.com/check-more-types/-/check-more-types-2.24.0.tgz#1420ffb10fd444dcfc79b43891bbfffd32a84600"
-  integrity sha512-Pj779qHxV2tuapviy1bSZNEL1maXr13bPYpsvSDB68HlYcYuhlDrmGd63i0JHMCLKzc7rUSNIrpdJlhVlNwrxA==
-
-chokidar@3.5.3:
-  version "3.5.3"
-  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.3.tgz#1cf37c8707b932bd1af1ae22c0432e2acd1903bd"
-  integrity sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==
-  dependencies:
-    anymatch "~3.1.2"
-    braces "~3.0.2"
-    glob-parent "~5.1.2"
-    is-binary-path "~2.1.0"
-    is-glob "~4.0.1"
-    normalize-path "~3.0.0"
-    readdirp "~3.6.0"
-  optionalDependencies:
-    fsevents "~2.3.2"
-
-chokidar@^3.5.3:
-  version "3.6.0"
-  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.6.0.tgz#197c6cc669ef2a8dc5e7b4d97ee4e092c3eb0d5b"
-  integrity sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==
-  dependencies:
-    anymatch "~3.1.2"
-    braces "~3.0.2"
-    glob-parent "~5.1.2"
-    is-binary-path "~2.1.0"
-    is-glob "~4.0.1"
-    normalize-path "~3.0.0"
-    readdirp "~3.6.0"
-  optionalDependencies:
-    fsevents "~2.3.2"
-
-ci-info@^3.2.0:
-  version "3.9.0"
-  resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-3.9.0.tgz#4279a62028a7b1f262f3473fc9605f5e218c59b4"
-  integrity sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==
-
-clean-stack@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-2.2.0.tgz#ee8472dbb129e727b31e8a10a427dee9dfe4008b"
-  integrity sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==
-
-cli-cursor@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-3.1.0.tgz#264305a7ae490d1d03bf0c9ba7c925d1753af307"
-  integrity sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==
-  dependencies:
-    restore-cursor "^3.1.0"
-
-cli-table3@~0.6.1:
-  version "0.6.4"
-  resolved "https://registry.yarnpkg.com/cli-table3/-/cli-table3-0.6.4.tgz#d1c536b8a3f2e7bec58f67ac9e5769b1b30088b0"
-  integrity sha512-Lm3L0p+/npIQWNIiyF/nAn7T5dnOwR3xNTHXYEBFBFVPXzCVNZ5lqEC/1eo/EVfpDsQ1I+TX4ORPQgp+UI0CRw==
-  dependencies:
-    string-width "^4.2.0"
-  optionalDependencies:
-    "@colors/colors" "1.5.0"
-
-cli-truncate@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/cli-truncate/-/cli-truncate-2.1.0.tgz#c39e28bf05edcde5be3b98992a22deed5a2b93c7"
-  integrity sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg==
-  dependencies:
-    slice-ansi "^3.0.0"
-    string-width "^4.2.0"
-
-cliui@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/cliui/-/cliui-6.0.0.tgz#511d702c0c4e41ca156d7d0e96021f23e13225b1"
-  integrity sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==
-  dependencies:
-    string-width "^4.2.0"
-    strip-ansi "^6.0.0"
-    wrap-ansi "^6.2.0"
-
-cliui@^7.0.2:
-  version "7.0.4"
-  resolved "https://registry.yarnpkg.com/cliui/-/cliui-7.0.4.tgz#a0265ee655476fc807aea9df3df8df7783808b4f"
-  integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==
-  dependencies:
-    string-width "^4.2.0"
-    strip-ansi "^6.0.0"
-    wrap-ansi "^7.0.0"
-
-clone-deep@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/clone-deep/-/clone-deep-4.0.1.tgz#c19fd9bdbbf85942b4fd979c84dcf7d5f07c2387"
-  integrity sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==
-  dependencies:
-    is-plain-object "^2.0.4"
-    kind-of "^6.0.2"
-    shallow-clone "^3.0.0"
-
-codex-notifier@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/codex-notifier/-/codex-notifier-1.1.2.tgz#a733079185f4c927fa296f1d71eb8753fe080895"
-  integrity sha512-DCp6xe/LGueJ1N5sXEwcBc3r3PyVkEEDNWCVigfvywAkeXcZMk9K41a31tkEFBW0Ptlwji6/JlAb49E3Yrxbtg==
-
-codex-tooltip@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/codex-tooltip/-/codex-tooltip-1.0.5.tgz#ba25fd5b3a58ba2f73fd667c2b46987ffd1edef2"
-  integrity sha512-IuA8LeyLU5p1B+HyhOsqR6oxyFQ11k3i9e9aXw40CrHFTRO2Y1npNBVU3W1SvhKAbUU7R/YikUBdcYFP0RcJag==
-
-color-convert@^1.9.0:
-  version "1.9.3"
-  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8"
-  integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==
-  dependencies:
-    color-name "1.1.3"
-
-color-convert@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
-  integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
-  dependencies:
-    color-name "~1.1.4"
-
-color-name@1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25"
-  integrity sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==
-
-color-name@~1.1.4:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
-  integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
-
-colord@^2.9.3:
-  version "2.9.3"
-  resolved "https://registry.yarnpkg.com/colord/-/colord-2.9.3.tgz#4f8ce919de456f1d5c1c368c307fe20f3e59fb43"
-  integrity sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==
-
-colorette@^2.0.16:
-  version "2.0.20"
-  resolved "https://registry.yarnpkg.com/colorette/-/colorette-2.0.20.tgz#9eb793e6833067f7235902fcd3b09917a000a95a"
-  integrity sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==
-
-combined-stream@^1.0.6, combined-stream@~1.0.6:
-  version "1.0.8"
-  resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f"
-  integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==
-  dependencies:
-    delayed-stream "~1.0.0"
-
-commander@^2.12.1:
-  version "2.20.3"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
-  integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
-
-commander@^6.2.1:
-  version "6.2.1"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-6.2.1.tgz#0792eb682dfbc325999bb2b84fddddba110ac73c"
-  integrity sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==
-
-comment-parser@1.3.1:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/comment-parser/-/comment-parser-1.3.1.tgz#3d7ea3adaf9345594aedee6563f422348f165c1b"
-  integrity sha512-B52sN2VNghyq5ofvUsqZjmk6YkihBX5vMSChmSK9v4ShjKf3Vk5Xcmgpw4o+iIgtrnM/u5FiMpz9VKb8lpBveA==
-
-commenting@~1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/commenting/-/commenting-1.1.0.tgz#fae14345c6437b8554f30bc6aa6c1e1633033590"
-  integrity sha512-YeNK4tavZwtH7jEgK1ZINXzLKm6DZdEMfsaaieOsCAN0S8vsY7UeuO3Q7d/M018EFgE+IeUAuBOKkFccBZsUZA==
-
-common-tags@^1.8.0:
-  version "1.8.2"
-  resolved "https://registry.yarnpkg.com/common-tags/-/common-tags-1.8.2.tgz#94ebb3c076d26032745fd54face7f688ef5ac9c6"
-  integrity sha512-gk/Z852D2Wtb//0I+kRFNKKE9dIIVirjoqPoA1wJU+XePVXZfGeBpk45+A1rKO4Q43prqWBNY/MiIeRLbPWUaA==
-
-commondir@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/commondir/-/commondir-1.0.1.tgz#ddd800da0c66127393cca5950ea968a3aaf1253b"
-  integrity sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==
-
-concat-map@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
-  integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==
-
-convert-source-map@^1.7.0:
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.9.0.tgz#7faae62353fb4213366d0ca98358d22e8368b05f"
-  integrity sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==
-
-core-js@3.30.0:
-  version "3.30.0"
-  resolved "https://registry.yarnpkg.com/core-js/-/core-js-3.30.0.tgz#64ac6f83bc7a49fd42807327051701d4b1478dea"
-  integrity sha512-hQotSSARoNh1mYPi9O2YaWeiq/cEB95kOrFb4NCrO4RIFt1qqNpKsaE+vy/L3oiqvND5cThqXzUU3r9F7Efztg==
-
-core-util-is@1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
-  integrity sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==
-
-cosmiconfig@^8.1.3:
-  version "8.1.3"
-  resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-8.1.3.tgz#0e614a118fcc2d9e5afc2f87d53cd09931015689"
-  integrity sha512-/UkO2JKI18b5jVMJUp0lvKFMpa/Gye+ZgZjKD+DGEN9y7NRcf/nK1A0sp67ONmKtnDCNMS44E6jrk0Yc3bDuUw==
-  dependencies:
-    import-fresh "^3.2.1"
-    js-yaml "^4.1.0"
-    parse-json "^5.0.0"
-    path-type "^4.0.0"
-
-cross-spawn@^7.0.0, cross-spawn@^7.0.2, cross-spawn@^7.0.3:
-  version "7.0.3"
-  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6"
-  integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
-  dependencies:
-    path-key "^3.1.0"
-    shebang-command "^2.0.0"
-    which "^2.0.1"
-
-crypt@0.0.2:
-  version "0.0.2"
-  resolved "https://registry.yarnpkg.com/crypt/-/crypt-0.0.2.tgz#88d7ff7ec0dfb86f713dc87bbb42d044d3e6c41b"
-  integrity sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==
-
-css-blank-pseudo@^5.0.2:
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/css-blank-pseudo/-/css-blank-pseudo-5.0.2.tgz#3df5cd950f64de960974da05e76954fd3d7442f9"
-  integrity sha512-aCU4AZ7uEcVSUzagTlA9pHciz7aWPKA/YzrEkpdSopJ2pvhIxiQ5sYeMz1/KByxlIo4XBdvMNJAVKMg/GRnhfw==
-  dependencies:
-    postcss-selector-parser "^6.0.10"
-
-css-functions-list@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/css-functions-list/-/css-functions-list-3.1.0.tgz#cf5b09f835ad91a00e5959bcfc627cd498e1321b"
-  integrity sha512-/9lCvYZaUbBGvYUgYGFJ4dcYiyqdhSjG7IPVluoV8A1ILjkF7ilmhp1OGUz8n+nmBcu0RNrQAzgD8B6FJbrt2w==
-
-css-has-pseudo@^5.0.2:
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/css-has-pseudo/-/css-has-pseudo-5.0.2.tgz#8798118c705d858b7aeb9d839a39edd901c1cc83"
-  integrity sha512-q+U+4QdwwB7T9VEW/LyO6CFrLAeLqOykC5mDqJXc7aKZAhDbq7BvGT13VGJe+IwBfdN2o3Xdw2kJ5IxwV1Sc9Q==
-  dependencies:
-    "@csstools/selector-specificity" "^2.0.1"
-    postcss-selector-parser "^6.0.10"
-    postcss-value-parser "^4.2.0"
-
-css-prefers-color-scheme@^8.0.2:
-  version "8.0.2"
-  resolved "https://registry.yarnpkg.com/css-prefers-color-scheme/-/css-prefers-color-scheme-8.0.2.tgz#a0671f54eb19ed0d30b952574c0af11ec355fb6d"
-  integrity sha512-OvFghizHJ45x7nsJJUSYLyQNTzsCU8yWjxAc/nhPQg1pbs18LMoET8N3kOweFDPy0JV0OSXN2iqRFhPBHYOeMA==
-
-css-tree@^2.3.1:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/css-tree/-/css-tree-2.3.1.tgz#10264ce1e5442e8572fc82fbe490644ff54b5c20"
-  integrity sha512-6Fv1DV/TYw//QF5IzQdqsNDjx/wc8TrMBZsqjL9eW01tWb7R7k/mq+/VXfJCl7SoD5emsJop9cOByJZfs8hYIw==
-  dependencies:
-    mdn-data "2.0.30"
-    source-map-js "^1.0.1"
-
-css.escape@^1.5.0:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/css.escape/-/css.escape-1.5.1.tgz#42e27d4fa04ae32f931a4b4d4191fa9cddee97cb"
-  integrity sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==
-
-cssdb@^7.5.3:
-  version "7.5.3"
-  resolved "https://registry.yarnpkg.com/cssdb/-/cssdb-7.5.3.tgz#6bbd0c6a935919d7f78b8a3ce098faacda01ae8a"
-  integrity sha512-NQNRhrEnS6cW+RU/foLphb6xI/MDA70bI3Cy6VxJU8ilxgyTYz1X9zUzFGVTG5nGPylcKAGIt/UNc4deT56lQQ==
-
-cssesc@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/cssesc/-/cssesc-2.0.0.tgz#3b13bd1bb1cb36e1bcb5a4dcd27f54c5dcb35703"
-  integrity sha512-MsCAG1z9lPdoO/IUMLSBWBSVxVtJ1395VGIQ+Fc2gNdkQ1hNDnQdw3YhA71WJCBW1vdwA0cAnk/DnW6bqoEUYg==
-
-cssesc@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/cssesc/-/cssesc-3.0.0.tgz#37741919903b868565e1c09ea747445cd18983ee"
-  integrity sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==
-
-cypress-intellij-reporter@^0.0.7:
-  version "0.0.7"
-  resolved "https://registry.yarnpkg.com/cypress-intellij-reporter/-/cypress-intellij-reporter-0.0.7.tgz#248dd17e74cfa4b69dbba503e79c54c58124028c"
-  integrity sha512-P4A0BPz5h9TWLZFVhMJsAMktqCEdeKA0+bS+zfTGLohUtM89pmU5kAWLEGFOYRcRlVR39XbUWhyFyTjs8AoFLA==
-  dependencies:
-    mocha latest
-
-cypress-plugin-tab@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/cypress-plugin-tab/-/cypress-plugin-tab-1.0.5.tgz#a40714148104004bb05ed62b1bf46bb544f8eb4a"
-  integrity sha512-QtTJcifOVwwbeMP3hsOzQOKf3EqKsLyjtg9ZAGlYDntrCRXrsQhe4ZQGIthRMRLKpnP6/tTk6G0gJ2sZUfRliQ==
-  dependencies:
-    ally.js "^1.4.1"
-
-cypress-terminal-report@^5.3.2:
-  version "5.3.2"
-  resolved "https://registry.yarnpkg.com/cypress-terminal-report/-/cypress-terminal-report-5.3.2.tgz#3a6b1cbda6101498243d17c5a2a646cb69af0336"
-  integrity sha512-0Gf/pXjrYpTkf2aR3LAFGoxEM0KulWsMKCu+52YJB6l7GEP2RLAOAr32tcZHZiL2EWnS0vE4ollomMzGvCci0w==
-  dependencies:
-    chalk "^4.0.0"
-    fs-extra "^10.1.0"
-    safe-json-stringify "^1.2.0"
-    semver "^7.3.5"
-    tv4 "^1.3.0"
-
-cypress-vite@^1.5.0:
-  version "1.5.0"
-  resolved "https://registry.yarnpkg.com/cypress-vite/-/cypress-vite-1.5.0.tgz#471ecc1175c7ab51b3b132c595dc3c7e222fe944"
-  integrity sha512-vvTMqJZgI3sN2ylQTi4OQh8LRRjSrfrIdkQD5fOj+EC/e9oHkxS96lif1SyDF1PwailG1tnpJE+VpN6+AwO/rg==
-  dependencies:
-    chokidar "^3.5.3"
-    debug "^4.3.4"
-
-cypress@^13.13.3:
-  version "13.13.3"
-  resolved "https://registry.yarnpkg.com/cypress/-/cypress-13.13.3.tgz#21ee054bb4e00b3858f2e33b4f8f4e69128470a9"
-  integrity sha512-hUxPrdbJXhUOTzuML+y9Av7CKoYznbD83pt8g3klgpioEha0emfx4WNIuVRx0C76r0xV2MIwAW9WYiXfVJYFQw==
-  dependencies:
-    "@cypress/request" "^3.0.1"
-    "@cypress/xvfb" "^1.2.4"
-    "@types/sinonjs__fake-timers" "8.1.1"
-    "@types/sizzle" "^2.3.2"
-    arch "^2.2.0"
-    blob-util "^2.0.2"
-    bluebird "^3.7.2"
-    buffer "^5.7.1"
-    cachedir "^2.3.0"
-    chalk "^4.1.0"
-    check-more-types "^2.24.0"
-    cli-cursor "^3.1.0"
-    cli-table3 "~0.6.1"
-    commander "^6.2.1"
-    common-tags "^1.8.0"
-    dayjs "^1.10.4"
-    debug "^4.3.4"
-    enquirer "^2.3.6"
-    eventemitter2 "6.4.7"
-    execa "4.1.0"
-    executable "^4.1.1"
-    extract-zip "2.0.1"
-    figures "^3.2.0"
-    fs-extra "^9.1.0"
-    getos "^3.2.1"
-    is-ci "^3.0.1"
-    is-installed-globally "~0.4.0"
-    lazy-ass "^1.6.0"
-    listr2 "^3.8.3"
-    lodash "^4.17.21"
-    log-symbols "^4.0.0"
-    minimist "^1.2.8"
-    ospath "^1.2.2"
-    pretty-bytes "^5.6.0"
-    process "^0.11.10"
-    proxy-from-env "1.0.0"
-    request-progress "^3.0.0"
-    semver "^7.5.3"
-    supports-color "^8.1.1"
-    tmp "~0.2.3"
-    untildify "^4.0.0"
-    yauzl "^2.10.0"
-
-dashdash@^1.12.0:
-  version "1.14.1"
-  resolved "https://registry.yarnpkg.com/dashdash/-/dashdash-1.14.1.tgz#853cfa0f7cbe2fed5de20326b8dd581035f6e2f0"
-  integrity sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==
-  dependencies:
-    assert-plus "^1.0.0"
-
-dayjs@1.10.7:
-  version "1.10.7"
-  resolved "https://registry.yarnpkg.com/dayjs/-/dayjs-1.10.7.tgz#2cf5f91add28116748440866a0a1d26f3a6ce468"
-  integrity sha512-P6twpd70BcPK34K26uJ1KT3wlhpuOAPoMwJzpsIWUxHZ7wpmbdZL/hQqBDfz7hGurYSa5PhzdhDHtt319hL3ig==
-
-dayjs@^1.10.4:
-  version "1.11.10"
-  resolved "https://registry.yarnpkg.com/dayjs/-/dayjs-1.11.10.tgz#68acea85317a6e164457d6d6947564029a6a16a0"
-  integrity sha512-vjAczensTgRcqDERK0SR2XMwsF/tSvnvlv6VcF2GIhg6Sx4yOIt/irsr1RDJsKiIyBzJDpCoXiWWq28MqH2cnQ==
-
-debug@4.3.4, debug@^4.1.0, debug@^4.1.1, debug@^4.3.2, debug@^4.3.4:
-  version "4.3.4"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865"
-  integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
-  dependencies:
-    ms "2.1.2"
-
-debug@^2.6.9:
-  version "2.6.9"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
-  integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
-  dependencies:
-    ms "2.0.0"
-
-debug@^3.1.0, debug@^3.2.7:
-  version "3.2.7"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.7.tgz#72580b7e9145fb39b6676f9c5e5fb100b934179a"
-  integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==
-  dependencies:
-    ms "^2.1.1"
-
-decamelize-keys@^1.1.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/decamelize-keys/-/decamelize-keys-1.1.1.tgz#04a2d523b2f18d80d0158a43b895d56dff8d19d8"
-  integrity sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg==
-  dependencies:
-    decamelize "^1.1.0"
-    map-obj "^1.0.0"
-
-decamelize@^1.1.0, decamelize@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
-  integrity sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==
-
-decamelize@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-4.0.0.tgz#aa472d7bf660eb15f3494efd531cab7f2a709837"
-  integrity sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==
-
-deep-is@^0.1.3:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831"
-  integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==
-
-default-require-extensions@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/default-require-extensions/-/default-require-extensions-3.0.1.tgz#bfae00feeaeada68c2ae256c62540f60b80625bd"
-  integrity sha512-eXTJmRbm2TIt9MgWTsOH1wEuhew6XGZcMeGKCtLedIg/NCsg1iBePXkceTdK4Fii7pzmN9tGsZhKzZ4h7O/fxw==
-  dependencies:
-    strip-bom "^4.0.0"
-
-define-data-property@^1.1.4:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/define-data-property/-/define-data-property-1.1.4.tgz#894dc141bb7d3060ae4366f6a0107e68fbe48c5e"
-  integrity sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==
-  dependencies:
-    es-define-property "^1.0.0"
-    es-errors "^1.3.0"
-    gopd "^1.0.1"
-
-define-properties@^1.1.3, define-properties@^1.1.4:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.2.0.tgz#52988570670c9eacedd8064f4a990f2405849bd5"
-  integrity sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==
-  dependencies:
-    has-property-descriptors "^1.0.0"
-    object-keys "^1.1.1"
-
-delayed-stream@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
-  integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==
-
-diff@5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/diff/-/diff-5.0.0.tgz#7ed6ad76d859d030787ec35855f5b1daf31d852b"
-  integrity sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==
-
-diff@^4.0.1:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
-  integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
-
-dir-glob@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
-  integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
-  dependencies:
-    path-type "^4.0.0"
-
-doctrine@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-2.1.0.tgz#5cd01fc101621b42c4cd7f5d1a66243716d3f39d"
-  integrity sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==
-  dependencies:
-    esutils "^2.0.2"
-
-doctrine@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-3.0.0.tgz#addebead72a6574db783639dc87a121773973961"
-  integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==
-  dependencies:
-    esutils "^2.0.2"
-
-ecc-jsbn@~0.1.1:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz#3a83a904e54353287874c564b7549386849a98c9"
-  integrity sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==
-  dependencies:
-    jsbn "~0.1.0"
-    safer-buffer "^2.1.0"
-
-electron-to-chromium@^1.4.284:
-  version "1.4.325"
-  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.325.tgz#7b97238a61192d85d055d97f3149832b3617d37b"
-  integrity sha512-K1C03NT4I7BuzsRdCU5RWkgZxtswnKDYM6/eMhkEXqKu4e5T+ck610x3FPzu1y7HVFSiQKZqP16gnJzPpji1TQ==
-
-emoji-regex@^8.0.0:
-  version "8.0.0"
-  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
-  integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
-
-emojis-list@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-3.0.0.tgz#5570662046ad29e2e916e71aae260abdff4f6a78"
-  integrity sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==
-
-end-of-stream@^1.1.0:
-  version "1.4.4"
-  resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-1.4.4.tgz#5ae64a5f45057baf3626ec14da0ca5e4b2431eb0"
-  integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==
-  dependencies:
-    once "^1.4.0"
-
-enquirer@^2.3.6:
-  version "2.4.1"
-  resolved "https://registry.yarnpkg.com/enquirer/-/enquirer-2.4.1.tgz#93334b3fbd74fc7097b224ab4a8fb7e40bf4ae56"
-  integrity sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==
-  dependencies:
-    ansi-colors "^4.1.1"
-    strip-ansi "^6.0.1"
-
-error-ex@^1.3.1:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf"
-  integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==
-  dependencies:
-    is-arrayish "^0.2.1"
-
-es-abstract@^1.19.0, es-abstract@^1.20.4:
-  version "1.21.1"
-  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.21.1.tgz#e6105a099967c08377830a0c9cb589d570dd86c6"
-  integrity sha512-QudMsPOz86xYz/1dG1OuGBKOELjCh99IIWHLzy5znUB6j8xG2yMA7bfTV86VSqKF+Y/H08vQPR+9jyXpuC6hfg==
-  dependencies:
-    available-typed-arrays "^1.0.5"
-    call-bind "^1.0.2"
-    es-set-tostringtag "^2.0.1"
-    es-to-primitive "^1.2.1"
-    function-bind "^1.1.1"
-    function.prototype.name "^1.1.5"
-    get-intrinsic "^1.1.3"
-    get-symbol-description "^1.0.0"
-    globalthis "^1.0.3"
-    gopd "^1.0.1"
-    has "^1.0.3"
-    has-property-descriptors "^1.0.0"
-    has-proto "^1.0.1"
-    has-symbols "^1.0.3"
-    internal-slot "^1.0.4"
-    is-array-buffer "^3.0.1"
-    is-callable "^1.2.7"
-    is-negative-zero "^2.0.2"
-    is-regex "^1.1.4"
-    is-shared-array-buffer "^1.0.2"
-    is-string "^1.0.7"
-    is-typed-array "^1.1.10"
-    is-weakref "^1.0.2"
-    object-inspect "^1.12.2"
-    object-keys "^1.1.1"
-    object.assign "^4.1.4"
-    regexp.prototype.flags "^1.4.3"
-    safe-regex-test "^1.0.0"
-    string.prototype.trimend "^1.0.6"
-    string.prototype.trimstart "^1.0.6"
-    typed-array-length "^1.0.4"
-    unbox-primitive "^1.0.2"
-    which-typed-array "^1.1.9"
-
-es-define-property@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/es-define-property/-/es-define-property-1.0.0.tgz#c7faefbdff8b2696cf5f46921edfb77cc4ba3845"
-  integrity sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==
-  dependencies:
-    get-intrinsic "^1.2.4"
-
-es-errors@^1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/es-errors/-/es-errors-1.3.0.tgz#05f75a25dab98e4fb1dcd5e1472c0546d5057c8f"
-  integrity sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==
-
-es-set-tostringtag@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz#338d502f6f674301d710b80c8592de8a15f09cd8"
-  integrity sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==
-  dependencies:
-    get-intrinsic "^1.1.3"
-    has "^1.0.3"
-    has-tostringtag "^1.0.0"
-
-es-shim-unscopables@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz#702e632193201e3edf8713635d083d378e510241"
-  integrity sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==
-  dependencies:
-    has "^1.0.3"
-
-es-to-primitive@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.2.1.tgz#e55cd4c9cdc188bcefb03b366c736323fc5c898a"
-  integrity sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==
-  dependencies:
-    is-callable "^1.1.4"
-    is-date-object "^1.0.1"
-    is-symbol "^1.0.2"
-
-es6-error@^4.0.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/es6-error/-/es6-error-4.1.1.tgz#9e3af407459deed47e9a91f9b885a84eb05c561d"
-  integrity sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==
-
-esbuild@^0.18.10:
-  version "0.18.20"
-  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.18.20.tgz#4709f5a34801b43b799ab7d6d82f7284a9b7a7a6"
-  integrity sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==
-  optionalDependencies:
-    "@esbuild/android-arm" "0.18.20"
-    "@esbuild/android-arm64" "0.18.20"
-    "@esbuild/android-x64" "0.18.20"
-    "@esbuild/darwin-arm64" "0.18.20"
-    "@esbuild/darwin-x64" "0.18.20"
-    "@esbuild/freebsd-arm64" "0.18.20"
-    "@esbuild/freebsd-x64" "0.18.20"
-    "@esbuild/linux-arm" "0.18.20"
-    "@esbuild/linux-arm64" "0.18.20"
-    "@esbuild/linux-ia32" "0.18.20"
-    "@esbuild/linux-loong64" "0.18.20"
-    "@esbuild/linux-mips64el" "0.18.20"
-    "@esbuild/linux-ppc64" "0.18.20"
-    "@esbuild/linux-riscv64" "0.18.20"
-    "@esbuild/linux-s390x" "0.18.20"
-    "@esbuild/linux-x64" "0.18.20"
-    "@esbuild/netbsd-x64" "0.18.20"
-    "@esbuild/openbsd-x64" "0.18.20"
-    "@esbuild/sunos-x64" "0.18.20"
-    "@esbuild/win32-arm64" "0.18.20"
-    "@esbuild/win32-ia32" "0.18.20"
-    "@esbuild/win32-x64" "0.18.20"
-
-escalade@^3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40"
-  integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==
-
-escape-string-regexp@4.0.0, escape-string-regexp@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34"
-  integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
-
-escape-string-regexp@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
-  integrity sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==
-
-eslint-config-codex@^1.7.1:
-  version "1.7.2"
-  resolved "https://registry.yarnpkg.com/eslint-config-codex/-/eslint-config-codex-1.7.2.tgz#6b5f4afa079a5d90927b65706f914fe9ccbcba4a"
-  integrity sha512-d5voFPPOZF5aANWaleXL1UyNbQZJ30LN+yGQUkNxo9JlGY5mASYGQzAZnZpdCno+j6EclO56HwXu1o47rugHAg==
-  dependencies:
-    "@typescript-eslint/eslint-plugin" "^5.46.0"
-    "@typescript-eslint/parser" "^5.46.0"
-    eslint-config-standard "17.0.0"
-    eslint-plugin-import "2.26.0"
-    eslint-plugin-jsdoc "^39.3.6"
-    eslint-plugin-n "^15.2.5"
-    eslint-plugin-promise "6.0.1"
-    eslint-plugin-standard "5.0.0"
-
-eslint-config-standard@17.0.0:
-  version "17.0.0"
-  resolved "https://registry.yarnpkg.com/eslint-config-standard/-/eslint-config-standard-17.0.0.tgz#fd5b6cf1dcf6ba8d29f200c461de2e19069888cf"
-  integrity sha512-/2ks1GKyqSOkH7JFvXJicu0iMpoojkwB+f5Du/1SC0PtBL+s8v30k9njRZ21pm2drKYm2342jFnGWzttxPmZVg==
-
-eslint-import-resolver-node@^0.3.6:
-  version "0.3.7"
-  resolved "https://registry.yarnpkg.com/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.7.tgz#83b375187d412324a1963d84fa664377a23eb4d7"
-  integrity sha512-gozW2blMLJCeFpBwugLTGyvVjNoeo1knonXAcatC6bjPBZitotxdWf7Gimr25N4c0AAOo4eOUfaG82IJPDpqCA==
-  dependencies:
-    debug "^3.2.7"
-    is-core-module "^2.11.0"
-    resolve "^1.22.1"
-
-eslint-module-utils@^2.7.3:
-  version "2.7.4"
-  resolved "https://registry.yarnpkg.com/eslint-module-utils/-/eslint-module-utils-2.7.4.tgz#4f3e41116aaf13a20792261e61d3a2e7e0583974"
-  integrity sha512-j4GT+rqzCoRKHwURX7pddtIPGySnX9Si/cgMI5ztrcqOPtk5dDEeZ34CQVPphnqkJytlc97Vuk05Um2mJ3gEQA==
-  dependencies:
-    debug "^3.2.7"
-
-eslint-plugin-chai-friendly@^0.7.2:
-  version "0.7.2"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-chai-friendly/-/eslint-plugin-chai-friendly-0.7.2.tgz#0ebfbb2c1244f5de2997f3963d155758234f2b0f"
-  integrity sha512-LOIfGx5sZZ5FwM1shr2GlYAWV9Omdi+1/3byuVagvQNoGUuU0iHhp7AfjA1uR+4dJ4Isfb4+FwBJgQajIw9iAg==
-
-eslint-plugin-cypress@2.12.1:
-  version "2.12.1"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-cypress/-/eslint-plugin-cypress-2.12.1.tgz#9aeee700708ca8c058e00cdafe215199918c2632"
-  integrity sha512-c2W/uPADl5kospNDihgiLc7n87t5XhUbFDoTl6CfVkmG+kDAb5Ux10V9PoLPu9N+r7znpc+iQlcmAqT1A/89HA==
-  dependencies:
-    globals "^11.12.0"
-
-eslint-plugin-es@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-es/-/eslint-plugin-es-4.1.0.tgz#f0822f0c18a535a97c3e714e89f88586a7641ec9"
-  integrity sha512-GILhQTnjYE2WorX5Jyi5i4dz5ALWxBIdQECVQavL6s7cI76IZTDWleTHkxz/QT3kvcs2QlGHvKLYsSlPOlPXnQ==
-  dependencies:
-    eslint-utils "^2.0.0"
-    regexpp "^3.0.0"
-
-eslint-plugin-import@2.26.0:
-  version "2.26.0"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-import/-/eslint-plugin-import-2.26.0.tgz#f812dc47be4f2b72b478a021605a59fc6fe8b88b"
-  integrity sha512-hYfi3FXaM8WPLf4S1cikh/r4IxnO6zrhZbEGz2b660EJRbuxgpDS5gkCuYgGWg2xxh2rBuIr4Pvhve/7c31koA==
-  dependencies:
-    array-includes "^3.1.4"
-    array.prototype.flat "^1.2.5"
-    debug "^2.6.9"
-    doctrine "^2.1.0"
-    eslint-import-resolver-node "^0.3.6"
-    eslint-module-utils "^2.7.3"
-    has "^1.0.3"
-    is-core-module "^2.8.1"
-    is-glob "^4.0.3"
-    minimatch "^3.1.2"
-    object.values "^1.1.5"
-    resolve "^1.22.0"
-    tsconfig-paths "^3.14.1"
-
-eslint-plugin-jsdoc@^39.3.6:
-  version "39.9.1"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-39.9.1.tgz#e9ce1723411fd7ea0933b3ef0dd02156ae3068e2"
-  integrity sha512-Rq2QY6BZP2meNIs48aZ3GlIlJgBqFCmR55+UBvaDkA3ZNQ0SvQXOs2QKkubakEijV8UbIVbVZKsOVN8G3MuqZw==
-  dependencies:
-    "@es-joy/jsdoccomment" "~0.36.1"
-    comment-parser "1.3.1"
-    debug "^4.3.4"
-    escape-string-regexp "^4.0.0"
-    esquery "^1.4.0"
-    semver "^7.3.8"
-    spdx-expression-parse "^3.0.1"
-
-eslint-plugin-n@^15.2.5:
-  version "15.6.1"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-n/-/eslint-plugin-n-15.6.1.tgz#f7e77f24abb92a550115cf11e29695da122c398c"
-  integrity sha512-R9xw9OtCRxxaxaszTQmQAlPgM+RdGjaL1akWuY/Fv9fRAi8Wj4CUKc6iYVG8QNRjRuo8/BqVYIpfqberJUEacA==
-  dependencies:
-    builtins "^5.0.1"
-    eslint-plugin-es "^4.1.0"
-    eslint-utils "^3.0.0"
-    ignore "^5.1.1"
-    is-core-module "^2.11.0"
-    minimatch "^3.1.2"
-    resolve "^1.22.1"
-    semver "^7.3.8"
-
-eslint-plugin-promise@6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-promise/-/eslint-plugin-promise-6.0.1.tgz#a8cddf96a67c4059bdabf4d724a29572188ae423"
-  integrity sha512-uM4Tgo5u3UWQiroOyDEsYcVMOo7re3zmno0IZmB5auxoaQNIceAbXEkSt8RNrKtaYehARHG06pYK6K1JhtP0Zw==
-
-eslint-plugin-standard@5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-standard/-/eslint-plugin-standard-5.0.0.tgz#c43f6925d669f177db46f095ea30be95476b1ee4"
-  integrity sha512-eSIXPc9wBM4BrniMzJRBm2uoVuXz2EPa+NXPk2+itrVt+r5SbKFERx/IgrK/HmfjddyKVz2f+j+7gBRvu19xLg==
-
-eslint-scope@^5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c"
-  integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==
-  dependencies:
-    esrecurse "^4.3.0"
-    estraverse "^4.1.1"
-
-eslint-scope@^7.1.1:
-  version "7.1.1"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-7.1.1.tgz#fff34894c2f65e5226d3041ac480b4513a163642"
-  integrity sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==
-  dependencies:
-    esrecurse "^4.3.0"
-    estraverse "^5.2.0"
-
-eslint-utils@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-2.1.0.tgz#d2de5e03424e707dc10c74068ddedae708741b27"
-  integrity sha512-w94dQYoauyvlDc43XnGB8lU3Zt713vNChgt4EWwhXAP2XkBvndfxF0AgIqKOOasjPIPzj9JqgwkwbCYD0/V3Zg==
-  dependencies:
-    eslint-visitor-keys "^1.1.0"
-
-eslint-utils@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-3.0.0.tgz#8aebaface7345bb33559db0a1f13a1d2d48c3672"
-  integrity sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==
-  dependencies:
-    eslint-visitor-keys "^2.0.0"
-
-eslint-visitor-keys@^1.1.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz#30ebd1ef7c2fdff01c3a4f151044af25fab0523e"
-  integrity sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==
-
-eslint-visitor-keys@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz#f65328259305927392c938ed44eb0a5c9b2bd303"
-  integrity sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==
-
-eslint-visitor-keys@^3.3.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz#f6480fa6b1f30efe2d1968aa8ac745b862469826"
-  integrity sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==
-
-eslint-visitor-keys@^3.4.0:
-  version "3.4.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.4.0.tgz#c7f0f956124ce677047ddbc192a68f999454dedc"
-  integrity sha512-HPpKPUBQcAsZOsHAFwTtIKcYlCje62XB7SEAcxjtmW6TD1WVpkS6i6/hOVtTZIl4zGj/mBqpFVGvaDneik+VoQ==
-
-eslint@^8.37.0:
-  version "8.37.0"
-  resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.37.0.tgz#1f660ef2ce49a0bfdec0b0d698e0b8b627287412"
-  integrity sha512-NU3Ps9nI05GUoVMxcZx1J8CNR6xOvUT4jAUMH5+z8lpp3aEdPVCImKw6PWG4PY+Vfkpr+jvMpxs/qoE7wq0sPw==
-  dependencies:
-    "@eslint-community/eslint-utils" "^4.2.0"
-    "@eslint-community/regexpp" "^4.4.0"
-    "@eslint/eslintrc" "^2.0.2"
-    "@eslint/js" "8.37.0"
-    "@humanwhocodes/config-array" "^0.11.8"
-    "@humanwhocodes/module-importer" "^1.0.1"
-    "@nodelib/fs.walk" "^1.2.8"
-    ajv "^6.10.0"
-    chalk "^4.0.0"
-    cross-spawn "^7.0.2"
-    debug "^4.3.2"
-    doctrine "^3.0.0"
-    escape-string-regexp "^4.0.0"
-    eslint-scope "^7.1.1"
-    eslint-visitor-keys "^3.4.0"
-    espree "^9.5.1"
-    esquery "^1.4.2"
-    esutils "^2.0.2"
-    fast-deep-equal "^3.1.3"
-    file-entry-cache "^6.0.1"
-    find-up "^5.0.0"
-    glob-parent "^6.0.2"
-    globals "^13.19.0"
-    grapheme-splitter "^1.0.4"
-    ignore "^5.2.0"
-    import-fresh "^3.0.0"
-    imurmurhash "^0.1.4"
-    is-glob "^4.0.0"
-    is-path-inside "^3.0.3"
-    js-sdsl "^4.1.4"
-    js-yaml "^4.1.0"
-    json-stable-stringify-without-jsonify "^1.0.1"
-    levn "^0.4.1"
-    lodash.merge "^4.6.2"
-    minimatch "^3.1.2"
-    natural-compare "^1.4.0"
-    optionator "^0.9.1"
-    strip-ansi "^6.0.1"
-    strip-json-comments "^3.1.0"
-    text-table "^0.2.0"
-
-espree@^9.5.1:
-  version "9.5.1"
-  resolved "https://registry.yarnpkg.com/espree/-/espree-9.5.1.tgz#4f26a4d5f18905bf4f2e0bd99002aab807e96dd4"
-  integrity sha512-5yxtHSZXRSW5pvv3hAlXM5+/Oswi1AUFqBmbibKb5s6bp3rGIDkyXU6xCoyuuLhijr4SFwPrXRoZjz0AZDN9tg==
-  dependencies:
-    acorn "^8.8.0"
-    acorn-jsx "^5.3.2"
-    eslint-visitor-keys "^3.4.0"
-
-esprima@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
-  integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
-
-esquery@^1.4.0, esquery@^1.4.2:
-  version "1.5.0"
-  resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.5.0.tgz#6ce17738de8577694edd7361c57182ac8cb0db0b"
-  integrity sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==
-  dependencies:
-    estraverse "^5.1.0"
-
-esrecurse@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921"
-  integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
-  dependencies:
-    estraverse "^5.2.0"
-
-estraverse@^4.1.1:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d"
-  integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==
-
-estraverse@^5.1.0, estraverse@^5.2.0:
-  version "5.3.0"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123"
-  integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==
-
-esutils@^2.0.2:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
-  integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
-
-eventemitter2@6.4.7:
-  version "6.4.7"
-  resolved "https://registry.yarnpkg.com/eventemitter2/-/eventemitter2-6.4.7.tgz#a7f6c4d7abf28a14c1ef3442f21cb306a054271d"
-  integrity sha512-tYUSVOGeQPKt/eC1ABfhHy5Xd96N3oIijJvN3O9+TsC28T5V9yX9oEfEK5faP0EFSNVOG97qtAS68GBrQB2hDg==
-
-execa@4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/execa/-/execa-4.1.0.tgz#4e5491ad1572f2f17a77d388c6c857135b22847a"
-  integrity sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA==
-  dependencies:
-    cross-spawn "^7.0.0"
-    get-stream "^5.0.0"
-    human-signals "^1.1.1"
-    is-stream "^2.0.0"
-    merge-stream "^2.0.0"
-    npm-run-path "^4.0.0"
-    onetime "^5.1.0"
-    signal-exit "^3.0.2"
-    strip-final-newline "^2.0.0"
-
-executable@^4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/executable/-/executable-4.1.1.tgz#41532bff361d3e57af4d763b70582db18f5d133c"
-  integrity sha512-8iA79xD3uAch729dUG8xaaBBFGaEa0wdD2VkYLFHwlqosEj/jT66AzcreRDSgV7ehnNLBW2WR5jIXwGKjVdTLg==
-  dependencies:
-    pify "^2.2.0"
-
-extend@~3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
-  integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
-
-extract-zip@2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/extract-zip/-/extract-zip-2.0.1.tgz#663dca56fe46df890d5f131ef4a06d22bb8ba13a"
-  integrity sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==
-  dependencies:
-    debug "^4.1.1"
-    get-stream "^5.1.0"
-    yauzl "^2.10.0"
-  optionalDependencies:
-    "@types/yauzl" "^2.9.1"
-
-extsprintf@1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.3.0.tgz#96918440e3041a7a414f8c52e3c574eb3c3e1e05"
-  integrity sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==
-
-extsprintf@^1.2.0:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.4.1.tgz#8d172c064867f235c0c84a596806d279bf4bcc07"
-  integrity sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA==
-
-fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
-  version "3.1.3"
-  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
-  integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
-
-fast-glob@^3.1.1, fast-glob@^3.2.12, fast-glob@^3.2.9:
-  version "3.2.12"
-  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.12.tgz#7f39ec99c2e6ab030337142da9e0c18f37afae80"
-  integrity sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==
-  dependencies:
-    "@nodelib/fs.stat" "^2.0.2"
-    "@nodelib/fs.walk" "^1.2.3"
-    glob-parent "^5.1.2"
-    merge2 "^1.3.0"
-    micromatch "^4.0.4"
-
-fast-json-stable-stringify@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633"
-  integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
-
-fast-levenshtein@^2.0.6:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
-  integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==
-
-fastest-levenshtein@^1.0.16:
-  version "1.0.16"
-  resolved "https://registry.yarnpkg.com/fastest-levenshtein/-/fastest-levenshtein-1.0.16.tgz#210e61b6ff181de91ea9b3d1b84fdedd47e034e5"
-  integrity sha512-eRnCtTTtGZFpQCwhJiUOuxPQWRXVKYDn0b2PeHfXL6/Zi53SLAzAHfVhVWK2AryC/WH05kGfxhFIPvTF0SXQzg==
-
-fastq@^1.6.0:
-  version "1.15.0"
-  resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.15.0.tgz#d04d07c6a2a68fe4599fea8d2e103a937fae6b3a"
-  integrity sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==
-  dependencies:
-    reusify "^1.0.4"
-
-fd-slicer@~1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/fd-slicer/-/fd-slicer-1.1.0.tgz#25c7c89cb1f9077f8891bbe61d8f390eae256f1e"
-  integrity sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==
-  dependencies:
-    pend "~1.2.0"
-
-figures@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/figures/-/figures-3.2.0.tgz#625c18bd293c604dc4a8ddb2febf0c88341746af"
-  integrity sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==
-  dependencies:
-    escape-string-regexp "^1.0.5"
-
-file-entry-cache@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-6.0.1.tgz#211b2dd9659cb0394b073e7323ac3c933d522027"
-  integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==
-  dependencies:
-    flat-cache "^3.0.4"
-
-fill-range@^7.0.1:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40"
-  integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
-  dependencies:
-    to-regex-range "^5.0.1"
-
-find-cache-dir@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-2.1.0.tgz#8d0f94cd13fe43c6c7c261a0d86115ca918c05f7"
-  integrity sha512-Tq6PixE0w/VMFfCgbONnkiQIVol/JJL7nRMi20fqzA4NRs9AfeqMGeRdPi3wIhYkxjeBaWh2rxwapn5Tu3IqOQ==
-  dependencies:
-    commondir "^1.0.1"
-    make-dir "^2.0.0"
-    pkg-dir "^3.0.0"
-
-find-cache-dir@^3.2.0:
-  version "3.3.2"
-  resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-3.3.2.tgz#b30c5b6eff0730731aea9bbd9dbecbd80256d64b"
-  integrity sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==
-  dependencies:
-    commondir "^1.0.1"
-    make-dir "^3.0.2"
-    pkg-dir "^4.1.0"
-
-find-up@5.0.0, find-up@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-5.0.0.tgz#4c92819ecb7083561e4f4a240a86be5198f536fc"
-  integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==
-  dependencies:
-    locate-path "^6.0.0"
-    path-exists "^4.0.0"
-
-find-up@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-3.0.0.tgz#49169f1d7993430646da61ecc5ae355c21c97b73"
-  integrity sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==
-  dependencies:
-    locate-path "^3.0.0"
-
-find-up@^4.0.0, find-up@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19"
-  integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==
-  dependencies:
-    locate-path "^5.0.0"
-    path-exists "^4.0.0"
-
-flat-cache@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-3.0.4.tgz#61b0338302b2fe9f957dcc32fc2a87f1c3048b11"
-  integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==
-  dependencies:
-    flatted "^3.1.0"
-    rimraf "^3.0.2"
-
-flat@^5.0.2:
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/flat/-/flat-5.0.2.tgz#8ca6fe332069ffa9d324c327198c598259ceb241"
-  integrity sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==
-
-flatted@^3.1.0:
-  version "3.2.7"
-  resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.2.7.tgz#609f39207cb614b89d0765b477cb2d437fbf9787"
-  integrity sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==
-
-for-each@^0.3.3:
-  version "0.3.3"
-  resolved "https://registry.yarnpkg.com/for-each/-/for-each-0.3.3.tgz#69b447e88a0a5d32c3e7084f3f1710034b21376e"
-  integrity sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==
-  dependencies:
-    is-callable "^1.1.3"
-
-foreground-child@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/foreground-child/-/foreground-child-2.0.0.tgz#71b32800c9f15aa8f2f83f4a6bd9bff35d861a53"
-  integrity sha512-dCIq9FpEcyQyXKCkyzmlPTFNgrCzPudOe+mhvJU5zAtlBnGVy2yKxtfsxK2tQBThwq225jcvBjpw1Gr40uzZCA==
-  dependencies:
-    cross-spawn "^7.0.0"
-    signal-exit "^3.0.2"
-
-forever-agent@~0.6.1:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91"
-  integrity sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw==
-
-form-data@~2.3.2:
-  version "2.3.3"
-  resolved "https://registry.yarnpkg.com/form-data/-/form-data-2.3.3.tgz#dcce52c05f644f298c6a7ab936bd724ceffbf3a6"
-  integrity sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==
-  dependencies:
-    asynckit "^0.4.0"
-    combined-stream "^1.0.6"
-    mime-types "^2.1.12"
-
-fraction.js@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/fraction.js/-/fraction.js-4.2.0.tgz#448e5109a313a3527f5a3ab2119ec4cf0e0e2950"
-  integrity sha512-MhLuK+2gUcnZe8ZHlaaINnQLl0xRIGRfcGk2yl8xoQAfHrSsL3rYu6FCmBdkdbhc9EPlwyGHewaRsvwRMJtAlA==
-
-fromentries@^1.2.0:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/fromentries/-/fromentries-1.3.2.tgz#e4bca6808816bf8f93b52750f1127f5a6fd86e3a"
-  integrity sha512-cHEpEQHUg0f8XdtZCc2ZAhrHzKzT0MrFUTcvx+hfxYu7rGMDc5SKoXFh+n4YigxsHXRzc6OrCshdR1bWH6HHyg==
-
-fs-extra@^10.1.0:
-  version "10.1.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-10.1.0.tgz#02873cfbc4084dde127eaa5f9905eef2325d1abf"
-  integrity sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==
-  dependencies:
-    graceful-fs "^4.2.0"
-    jsonfile "^6.0.1"
-    universalify "^2.0.0"
-
-fs-extra@^9.1.0:
-  version "9.1.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-9.1.0.tgz#5954460c764a8da2094ba3554bf839e6b9a7c86d"
-  integrity sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==
-  dependencies:
-    at-least-node "^1.0.0"
-    graceful-fs "^4.2.0"
-    jsonfile "^6.0.1"
-    universalify "^2.0.0"
-
-fs.realpath@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
-  integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
-
-fsevents@~2.3.2:
-  version "2.3.2"
-  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a"
-  integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==
-
-function-bind@^1.1.1, function-bind@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.2.tgz#2c02d864d97f3ea6c8830c464cbd11ab6eab7a1c"
-  integrity sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==
-
-function.prototype.name@^1.1.5:
-  version "1.1.5"
-  resolved "https://registry.yarnpkg.com/function.prototype.name/-/function.prototype.name-1.1.5.tgz#cce0505fe1ffb80503e6f9e46cc64e46a12a9621"
-  integrity sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.3"
-    es-abstract "^1.19.0"
-    functions-have-names "^1.2.2"
-
-functions-have-names@^1.2.2:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/functions-have-names/-/functions-have-names-1.2.3.tgz#0404fe4ee2ba2f607f0e0ec3c80bae994133b834"
-  integrity sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==
-
-gensync@^1.0.0-beta.2:
-  version "1.0.0-beta.2"
-  resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
-  integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==
-
-get-caller-file@^2.0.1, get-caller-file@^2.0.5:
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
-  integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
-
-get-intrinsic@^1.0.2, get-intrinsic@^1.2.4:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.2.4.tgz#e385f5a4b5227d449c3eabbad05494ef0abbeadd"
-  integrity sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==
-  dependencies:
-    es-errors "^1.3.0"
-    function-bind "^1.1.2"
-    has-proto "^1.0.1"
-    has-symbols "^1.0.3"
-    hasown "^2.0.0"
-
-get-intrinsic@^1.1.1, get-intrinsic@^1.1.3, get-intrinsic@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.2.0.tgz#7ad1dc0535f3a2904bba075772763e5051f6d05f"
-  integrity sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==
-  dependencies:
-    function-bind "^1.1.1"
-    has "^1.0.3"
-    has-symbols "^1.0.3"
-
-get-package-type@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/get-package-type/-/get-package-type-0.1.0.tgz#8de2d803cff44df3bc6c456e6668b36c3926e11a"
-  integrity sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==
-
-get-stream@^5.0.0, get-stream@^5.1.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-5.2.0.tgz#4966a1795ee5ace65e706c4b7beb71257d6e22d3"
-  integrity sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==
-  dependencies:
-    pump "^3.0.0"
-
-get-symbol-description@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/get-symbol-description/-/get-symbol-description-1.0.0.tgz#7fdb81c900101fbd564dd5f1a30af5aadc1e58d6"
-  integrity sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==
-  dependencies:
-    call-bind "^1.0.2"
-    get-intrinsic "^1.1.1"
-
-getos@^3.2.1:
-  version "3.2.1"
-  resolved "https://registry.yarnpkg.com/getos/-/getos-3.2.1.tgz#0134d1f4e00eb46144c5a9c0ac4dc087cbb27dc5"
-  integrity sha512-U56CfOK17OKgTVqozZjUKNdkfEv6jk5WISBJ8SHoagjE6L69zOwl3Z+O8myjY9MEW3i2HPWQBt/LTbCgcC973Q==
-  dependencies:
-    async "^3.2.0"
-
-getpass@^0.1.1:
-  version "0.1.7"
-  resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.7.tgz#5eff8e3e684d569ae4cb2b1282604e8ba62149fa"
-  integrity sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==
-  dependencies:
-    assert-plus "^1.0.0"
-
-glob-parent@^5.1.2, glob-parent@~5.1.2:
-  version "5.1.2"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
-  integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
-  dependencies:
-    is-glob "^4.0.1"
-
-glob-parent@^6.0.2:
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-6.0.2.tgz#6d237d99083950c79290f24c7642a3de9a28f9e3"
-  integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==
-  dependencies:
-    is-glob "^4.0.3"
-
-glob@7.2.0:
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.0.tgz#d15535af7732e02e948f4c41628bd910293f6023"
-  integrity sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.0.4"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
-glob@^7.1.1, glob@^7.1.3, glob@^7.1.4, glob@^7.1.6, glob@~7.2.0:
-  version "7.2.3"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b"
-  integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.1.1"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
-global-dirs@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/global-dirs/-/global-dirs-3.0.1.tgz#0c488971f066baceda21447aecb1a8b911d22485"
-  integrity sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==
-  dependencies:
-    ini "2.0.0"
-
-global-modules@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/global-modules/-/global-modules-2.0.0.tgz#997605ad2345f27f51539bea26574421215c7780"
-  integrity sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==
-  dependencies:
-    global-prefix "^3.0.0"
-
-global-prefix@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/global-prefix/-/global-prefix-3.0.0.tgz#fc85f73064df69f50421f47f883fe5b913ba9b97"
-  integrity sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==
-  dependencies:
-    ini "^1.3.5"
-    kind-of "^6.0.2"
-    which "^1.3.1"
-
-globals@^11.1.0, globals@^11.12.0:
-  version "11.12.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e"
-  integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==
-
-globals@^13.19.0:
-  version "13.20.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-13.20.0.tgz#ea276a1e508ffd4f1612888f9d1bad1e2717bf82"
-  integrity sha512-Qg5QtVkCy/kv3FUSlu4ukeZDVf9ee0iXLAUYX13gbR17bnejFTzr4iS9bY7kwCf1NztRNm1t91fjOiyx4CSwPQ==
-  dependencies:
-    type-fest "^0.20.2"
-
-globalthis@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/globalthis/-/globalthis-1.0.3.tgz#5852882a52b80dc301b0660273e1ed082f0b6ccf"
-  integrity sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==
-  dependencies:
-    define-properties "^1.1.3"
-
-globby@11.0.4:
-  version "11.0.4"
-  resolved "https://registry.yarnpkg.com/globby/-/globby-11.0.4.tgz#2cbaff77c2f2a62e71e9b2813a67b97a3a3001a5"
-  integrity sha512-9O4MVG9ioZJ08ffbcyVYyLOJLk5JQ688pJ4eMGLpdWLHq/Wr1D9BlriLQyL0E+jbkuePVZXYFj47QM/v093wHg==
-  dependencies:
-    array-union "^2.1.0"
-    dir-glob "^3.0.1"
-    fast-glob "^3.1.1"
-    ignore "^5.1.4"
-    merge2 "^1.3.0"
-    slash "^3.0.0"
-
-globby@^11.1.0:
-  version "11.1.0"
-  resolved "https://registry.yarnpkg.com/globby/-/globby-11.1.0.tgz#bd4be98bb042f83d796f7e3811991fbe82a0d34b"
-  integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
-  dependencies:
-    array-union "^2.1.0"
-    dir-glob "^3.0.1"
-    fast-glob "^3.2.9"
-    ignore "^5.2.0"
-    merge2 "^1.4.1"
-    slash "^3.0.0"
-
-globjoin@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/globjoin/-/globjoin-0.1.4.tgz#2f4494ac8919e3767c5cbb691e9f463324285d43"
-  integrity sha512-xYfnw62CKG8nLkZBfWbhWwDw02CHty86jfPcc2cr3ZfeuK9ysoVPPEUxf21bAD/rWAgk52SuBrLJlefNy8mvFg==
-
-gopd@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/gopd/-/gopd-1.0.1.tgz#29ff76de69dac7489b7c0918a5788e56477c332c"
-  integrity sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==
-  dependencies:
-    get-intrinsic "^1.1.3"
-
-graceful-fs@^4.1.15:
-  version "4.2.10"
-  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.10.tgz#147d3a006da4ca3ce14728c7aefc287c367d7a6c"
-  integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==
-
-graceful-fs@^4.1.6, graceful-fs@^4.2.0:
-  version "4.2.11"
-  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3"
-  integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==
-
-grapheme-splitter@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz#9cf3a665c6247479896834af35cf1dbb4400767e"
-  integrity sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==
-
-hard-rejection@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/hard-rejection/-/hard-rejection-2.1.0.tgz#1c6eda5c1685c63942766d79bb40ae773cecd883"
-  integrity sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==
-
-has-bigints@^1.0.1, has-bigints@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/has-bigints/-/has-bigints-1.0.2.tgz#0871bd3e3d51626f6ca0966668ba35d5602d6eaa"
-  integrity sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==
-
-has-flag@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
-  integrity sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==
-
-has-flag@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
-  integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
-
-has-property-descriptors@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz#610708600606d36961ed04c196193b6a607fa861"
-  integrity sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==
-  dependencies:
-    get-intrinsic "^1.1.1"
-
-has-property-descriptors@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz#963ed7d071dc7bf5f084c5bfbe0d1b6222586854"
-  integrity sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==
-  dependencies:
-    es-define-property "^1.0.0"
-
-has-proto@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/has-proto/-/has-proto-1.0.1.tgz#1885c1305538958aff469fef37937c22795408e0"
-  integrity sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==
-
-has-symbols@^1.0.2, has-symbols@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8"
-  integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==
-
-has-tostringtag@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-tostringtag/-/has-tostringtag-1.0.0.tgz#7e133818a7d394734f941e73c3d3f9291e658b25"
-  integrity sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==
-  dependencies:
-    has-symbols "^1.0.2"
-
-has@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/has/-/has-1.0.4.tgz#2eb2860e000011dae4f1406a86fe80e530fb2ec6"
-  integrity sha512-qdSAmqLF6209RFj4VVItywPMbm3vWylknmB3nvNiUIs72xAimcM8nVYxYr7ncvZq5qzk9MKIZR8ijqD/1QuYjQ==
-
-hasha@^5.0.0:
-  version "5.2.2"
-  resolved "https://registry.yarnpkg.com/hasha/-/hasha-5.2.2.tgz#a48477989b3b327aea3c04f53096d816d97522a1"
-  integrity sha512-Hrp5vIK/xr5SkeN2onO32H0MgNZ0f17HRNH39WfL0SYUNOTZ5Lz1TJ8Pajo/87dYGEFlLMm7mIc/k/s6Bvz9HQ==
-  dependencies:
-    is-stream "^2.0.0"
-    type-fest "^0.8.0"
-
-hasown@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/hasown/-/hasown-2.0.2.tgz#003eaf91be7adc372e84ec59dc37252cedb80003"
-  integrity sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==
-  dependencies:
-    function-bind "^1.1.2"
-
-he@1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f"
-  integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==
-
-hosted-git-info@^2.1.4:
-  version "2.8.9"
-  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.8.9.tgz#dffc0bf9a21c02209090f2aa69429e1414daf3f9"
-  integrity sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==
-
-hosted-git-info@^4.0.1:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-4.1.0.tgz#827b82867e9ff1c8d0c4d9d53880397d2c86d224"
-  integrity sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==
-  dependencies:
-    lru-cache "^6.0.0"
-
-html-escaper@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453"
-  integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==
-
-html-janitor@^2.0.4:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/html-janitor/-/html-janitor-2.0.4.tgz#ae5a115cdf3331cd5501edd7b5471b18ea44cdbb"
-  integrity sha512-92J5h9jNZRk30PMHapjHEJfkrBWKCOy0bq3oW2pBungky6lzYSoboBGPMvxl1XRKB2q+kniQmsLsPbdpY7RM2g==
-
-html-tags@^3.2.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/html-tags/-/html-tags-3.3.0.tgz#02b73689e4b31647edd447bfe9bf5878427582e7"
-  integrity sha512-mH3dWNbvfCKcAEysbpD7wvtIJ6ImPog8aFhfzqog9gCN8CJFhKjLDtjpohG3IxYRLqHMJ1PWpBvnSMkFJBQ6Jg==
-
-http-signature@~1.3.6:
-  version "1.3.6"
-  resolved "https://registry.yarnpkg.com/http-signature/-/http-signature-1.3.6.tgz#cb6fbfdf86d1c974f343be94e87f7fc128662cf9"
-  integrity sha512-3adrsD6zqo4GsTqtO7FyrejHNv+NgiIfAfv68+jVlFmSr9OGy7zrxONceFRLKvnnZA5jbxQBX1u9PpB6Wi32Gw==
-  dependencies:
-    assert-plus "^1.0.0"
-    jsprim "^2.0.2"
-    sshpk "^1.14.1"
-
-human-signals@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-1.1.1.tgz#c5b1cd14f50aeae09ab6c59fe63ba3395fe4dfa3"
-  integrity sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==
-
-ieee754@^1.1.13:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352"
-  integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==
-
-ignore@^5.1.1, ignore@^5.1.4:
-  version "5.1.4"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.1.4.tgz#84b7b3dbe64552b6ef0eca99f6743dbec6d97adf"
-
-ignore@^5.2.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.0.tgz#6d3bac8fa7fe0d45d9f9be7bac2fc279577e345a"
-
-ignore@^5.2.4:
-  version "5.2.4"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.4.tgz#a291c0c6178ff1b960befe47fcdec301674a6324"
-  integrity sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==
-
-import-fresh@^3.0.0, import-fresh@^3.2.1:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b"
-  integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
-  dependencies:
-    parent-module "^1.0.0"
-    resolve-from "^4.0.0"
-
-import-lazy@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/import-lazy/-/import-lazy-4.0.0.tgz#e8eb627483a0a43da3c03f3e35548be5cb0cc153"
-  integrity sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw==
-
-imurmurhash@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
-  integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==
-
-indent-string@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251"
-  integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==
-
-indexes-of@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/indexes-of/-/indexes-of-1.0.1.tgz#f30f716c8e2bd346c7b67d3df3915566a7c05607"
-  integrity sha512-bup+4tap3Hympa+JBJUG7XuOsdNQ6fxt0MHyXMKuLBKn0OqsTfvUxkUrroEX1+B2VsSHvCjiIcZVxRtYa4nllA==
-
-inflight@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
-  integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
-  dependencies:
-    once "^1.3.0"
-    wrappy "1"
-
-inherits@2:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
-  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
-
-ini@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/ini/-/ini-2.0.0.tgz#e5fd556ecdd5726be978fa1001862eacb0a94bc5"
-  integrity sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==
-
-ini@^1.3.5:
-  version "1.3.8"
-  resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
-  integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
-
-internal-slot@^1.0.4:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/internal-slot/-/internal-slot-1.0.5.tgz#f2a2ee21f668f8627a4667f309dc0f4fb6674986"
-  integrity sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==
-  dependencies:
-    get-intrinsic "^1.2.0"
-    has "^1.0.3"
-    side-channel "^1.0.4"
-
-is-array-buffer@^3.0.1:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/is-array-buffer/-/is-array-buffer-3.0.2.tgz#f2653ced8412081638ecb0ebbd0c41c6e0aecbbe"
-  integrity sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==
-  dependencies:
-    call-bind "^1.0.2"
-    get-intrinsic "^1.2.0"
-    is-typed-array "^1.1.10"
-
-is-arrayish@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
-  integrity sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==
-
-is-bigint@^1.0.1:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/is-bigint/-/is-bigint-1.0.4.tgz#08147a1875bc2b32005d41ccd8291dffc6691df3"
-  integrity sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==
-  dependencies:
-    has-bigints "^1.0.1"
-
-is-binary-path@~2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09"
-  integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==
-  dependencies:
-    binary-extensions "^2.0.0"
-
-is-boolean-object@^1.1.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/is-boolean-object/-/is-boolean-object-1.1.2.tgz#5c6dc200246dd9321ae4b885a114bb1f75f63719"
-  integrity sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==
-  dependencies:
-    call-bind "^1.0.2"
-    has-tostringtag "^1.0.0"
-
-is-buffer@~1.1.6:
-  version "1.1.6"
-  resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
-  integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==
-
-is-callable@^1.1.3, is-callable@^1.1.4, is-callable@^1.2.7:
-  version "1.2.7"
-  resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.2.7.tgz#3bc2a85ea742d9e36205dcacdd72ca1fdc51b055"
-  integrity sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==
-
-is-ci@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-3.0.1.tgz#db6ecbed1bd659c43dac0f45661e7674103d1867"
-  integrity sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==
-  dependencies:
-    ci-info "^3.2.0"
-
-is-core-module@^2.11.0, is-core-module@^2.5.0, is-core-module@^2.8.1, is-core-module@^2.9.0:
-  version "2.11.0"
-  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.11.0.tgz#ad4cb3e3863e814523c96f3f58d26cc570ff0144"
-  integrity sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==
-  dependencies:
-    has "^1.0.3"
-
-is-date-object@^1.0.1:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.5.tgz#0841d5536e724c25597bf6ea62e1bd38298df31f"
-  integrity sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==
-  dependencies:
-    has-tostringtag "^1.0.0"
-
-is-extglob@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
-  integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==
-
-is-fullwidth-code-point@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d"
-  integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
-
-is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3, is-glob@~4.0.1:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084"
-  integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
-  dependencies:
-    is-extglob "^2.1.1"
-
-is-installed-globally@~0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/is-installed-globally/-/is-installed-globally-0.4.0.tgz#9a0fd407949c30f86eb6959ef1b7994ed0b7b520"
-  integrity sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==
-  dependencies:
-    global-dirs "^3.0.0"
-    is-path-inside "^3.0.2"
-
-is-negative-zero@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/is-negative-zero/-/is-negative-zero-2.0.2.tgz#7bf6f03a28003b8b3965de3ac26f664d765f3150"
-  integrity sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==
-
-is-number-object@^1.0.4:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.7.tgz#59d50ada4c45251784e9904f5246c742f07a42fc"
-  integrity sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==
-  dependencies:
-    has-tostringtag "^1.0.0"
-
-is-number@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
-  integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
-
-is-path-inside@^3.0.2, is-path-inside@^3.0.3:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-3.0.3.tgz#d231362e53a07ff2b0e0ea7fed049161ffd16283"
-  integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==
-
-is-plain-obj@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e"
-  integrity sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==
-
-is-plain-obj@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-2.1.0.tgz#45e42e37fccf1f40da8e5f76ee21515840c09287"
-  integrity sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==
-
-is-plain-object@^2.0.4:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
-  integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==
-  dependencies:
-    isobject "^3.0.1"
-
-is-plain-object@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-5.0.0.tgz#4427f50ab3429e9025ea7d52e9043a9ef4159344"
-  integrity sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==
-
-is-regex@^1.1.4:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.1.4.tgz#eef5663cd59fa4c0ae339505323df6854bb15958"
-  integrity sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==
-  dependencies:
-    call-bind "^1.0.2"
-    has-tostringtag "^1.0.0"
-
-is-shared-array-buffer@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz#8f259c573b60b6a32d4058a1a07430c0a7344c79"
-  integrity sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==
-  dependencies:
-    call-bind "^1.0.2"
-
-is-stream@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077"
-  integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==
-
-is-string@^1.0.5, is-string@^1.0.7:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.0.7.tgz#0dd12bf2006f255bb58f695110eff7491eebc0fd"
-  integrity sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==
-  dependencies:
-    has-tostringtag "^1.0.0"
-
-is-symbol@^1.0.2, is-symbol@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.4.tgz#a6dac93b635b063ca6872236de88910a57af139c"
-  integrity sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==
-  dependencies:
-    has-symbols "^1.0.2"
-
-is-typed-array@^1.1.10, is-typed-array@^1.1.9:
-  version "1.1.10"
-  resolved "https://registry.yarnpkg.com/is-typed-array/-/is-typed-array-1.1.10.tgz#36a5b5cb4189b575d1a3e4b08536bfb485801e3f"
-  integrity sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==
-  dependencies:
-    available-typed-arrays "^1.0.5"
-    call-bind "^1.0.2"
-    for-each "^0.3.3"
-    gopd "^1.0.1"
-    has-tostringtag "^1.0.0"
-
-is-typedarray@^1.0.0, is-typedarray@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
-  integrity sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==
-
-is-unicode-supported@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz#3f26c76a809593b52bfa2ecb5710ed2779b522a7"
-  integrity sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==
-
-is-weakref@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-weakref/-/is-weakref-1.0.2.tgz#9529f383a9338205e89765e0392efc2f100f06f2"
-  integrity sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==
-  dependencies:
-    call-bind "^1.0.2"
-
-is-windows@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
-  integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==
-
-isexe@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
-  integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
-
-isobject@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
-  integrity sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==
-
-isstream@~0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a"
-  integrity sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g==
-
-istanbul-lib-coverage@3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-coverage/-/istanbul-lib-coverage-3.0.0.tgz#f5944a37c70b550b02a78a5c3b2055b280cec8ec"
-  integrity sha512-UiUIqxMgRDET6eR+o5HbfRYP1l0hqkWOs7vNxC/mggutCMUIhWMm8gAHb8tHlyfD3/l6rlgNA5cKdDzEAf6hEg==
-
-istanbul-lib-coverage@^3.0.0, istanbul-lib-coverage@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz#189e7909d0a39fa5a3dfad5b03f71947770191d3"
-  integrity sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw==
-
-istanbul-lib-hook@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-hook/-/istanbul-lib-hook-3.0.0.tgz#8f84c9434888cc6b1d0a9d7092a76d239ebf0cc6"
-  integrity sha512-Pt/uge1Q9s+5VAZ+pCo16TYMWPBIl+oaNIjgLQxcX0itS6ueeaA+pEfThZpH8WxhFgCiEb8sAJY6MdUKgiIWaQ==
-  dependencies:
-    append-transform "^2.0.0"
-
-istanbul-lib-instrument@^4.0.0:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-4.0.3.tgz#873c6fff897450118222774696a3f28902d77c1d"
-  integrity sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ==
-  dependencies:
-    "@babel/core" "^7.7.5"
-    "@istanbuljs/schema" "^0.1.2"
-    istanbul-lib-coverage "^3.0.0"
-    semver "^6.3.0"
-
-istanbul-lib-processinfo@^2.0.2:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-processinfo/-/istanbul-lib-processinfo-2.0.3.tgz#366d454cd0dcb7eb6e0e419378e60072c8626169"
-  integrity sha512-NkwHbo3E00oybX6NGJi6ar0B29vxyvNwoC7eJ4G4Yq28UfY758Hgn/heV8VRFhevPED4LXfFz0DQ8z/0kw9zMg==
-  dependencies:
-    archy "^1.0.0"
-    cross-spawn "^7.0.3"
-    istanbul-lib-coverage "^3.2.0"
-    p-map "^3.0.0"
-    rimraf "^3.0.0"
-    uuid "^8.3.2"
-
-istanbul-lib-report@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz#7518fe52ea44de372f460a76b5ecda9ffb73d8a6"
-  integrity sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw==
-  dependencies:
-    istanbul-lib-coverage "^3.0.0"
-    make-dir "^3.0.0"
-    supports-color "^7.1.0"
-
-istanbul-lib-source-maps@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz#895f3a709fcfba34c6de5a42939022f3e4358551"
-  integrity sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==
-  dependencies:
-    debug "^4.1.1"
-    istanbul-lib-coverage "^3.0.0"
-    source-map "^0.6.1"
-
-istanbul-reports@^3.0.2:
-  version "3.1.5"
-  resolved "https://registry.yarnpkg.com/istanbul-reports/-/istanbul-reports-3.1.5.tgz#cc9a6ab25cb25659810e4785ed9d9fb742578bae"
-  integrity sha512-nUsEMa9pBt/NOHqbcbeJEgqIlY/K7rVWUX6Lql2orY5e9roQOthbR3vtY4zzf2orPELg80fnxxk9zUyPlgwD1w==
-  dependencies:
-    html-escaper "^2.0.0"
-    istanbul-lib-report "^3.0.0"
-
-js-sdsl@^4.1.4:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/js-sdsl/-/js-sdsl-4.3.0.tgz#aeefe32a451f7af88425b11fdb5f58c90ae1d711"
-  integrity sha512-mifzlm2+5nZ+lEcLJMoBK0/IH/bDg8XnJfd/Wq6IP+xoCjLZsTOnV2QpxlVbX9bMnkl5PdEjNtBJ9Cj1NjifhQ==
-
-js-tokens@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
-  integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
-
-js-yaml@4.1.0, js-yaml@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602"
-  integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
-  dependencies:
-    argparse "^2.0.1"
-
-js-yaml@^3.13.1:
-  version "3.14.1"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537"
-  integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
-  dependencies:
-    argparse "^1.0.7"
-    esprima "^4.0.0"
-
-jsbn@~0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513"
-  integrity sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==
-
-jsdoc-type-pratt-parser@~3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-3.1.0.tgz#a4a56bdc6e82e5865ffd9febc5b1a227ff28e67e"
-  integrity sha512-MgtD0ZiCDk9B+eI73BextfRrVQl0oyzRG8B2BjORts6jbunj4ScKPcyXGTbB6eXL4y9TzxCm6hyeLq/2ASzNdw==
-
-jsesc@^2.5.1:
-  version "2.5.2"
-  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4"
-  integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==
-
-json-parse-even-better-errors@^2.3.0:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d"
-  integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==
-
-json-schema-traverse@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
-  integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
-
-json-schema-traverse@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2"
-  integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==
-
-json-schema@0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.4.0.tgz#f7de4cf6efab838ebaeb3236474cbba5a1930ab5"
-  integrity sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==
-
-json-stable-stringify-without-jsonify@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651"
-  integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==
-
-json-stringify-safe@~5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb"
-  integrity sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==
-
-json5@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/json5/-/json5-1.0.2.tgz#63d98d60f21b313b77c4d6da18bfa69d80e1d593"
-  integrity sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==
-  dependencies:
-    minimist "^1.2.0"
-
-json5@^2.1.2, json5@^2.2.2:
-  version "2.2.3"
-  resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283"
-  integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==
-
-jsonfile@^6.0.1:
-  version "6.1.0"
-  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-6.1.0.tgz#bc55b2634793c679ec6403094eb13698a6ec0aae"
-  integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==
-  dependencies:
-    universalify "^2.0.0"
-  optionalDependencies:
-    graceful-fs "^4.1.6"
-
-jsprim@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-2.0.2.tgz#77ca23dbcd4135cd364800d22ff82c2185803d4d"
-  integrity sha512-gqXddjPqQ6G40VdnI6T6yObEC+pDNvyP95wdQhkWkg7crHH3km5qP1FsOXEkzEQwnz6gz5qGTn1c2Y52wP3OyQ==
-  dependencies:
-    assert-plus "1.0.0"
-    extsprintf "1.3.0"
-    json-schema "0.4.0"
-    verror "1.10.0"
-
-kind-of@^6.0.2, kind-of@^6.0.3:
-  version "6.0.3"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
-  integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
-
-known-css-properties@^0.27.0:
-  version "0.27.0"
-  resolved "https://registry.yarnpkg.com/known-css-properties/-/known-css-properties-0.27.0.tgz#82a9358dda5fe7f7bd12b5e7142c0a205393c0c5"
-  integrity sha512-uMCj6+hZYDoffuvAJjFAPz56E9uoowFHmTkqRtRq5WyC5Q6Cu/fTZKNQpX/RbzChBYLLl3lo8CjFZBAZXq9qFg==
-
-lazy-ass@^1.6.0:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/lazy-ass/-/lazy-ass-1.6.0.tgz#7999655e8646c17f089fdd187d150d3324d54513"
-  integrity sha512-cc8oEVoctTvsFZ/Oje/kGnHbpWHYBe8IAJe4C0QNc3t8uM/0Y8+erSz/7Y1ALuXTEZTMvxXwO6YbX1ey3ujiZw==
-
-levn@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/levn/-/levn-0.4.1.tgz#ae4562c007473b932a6200d403268dd2fffc6ade"
-  integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==
-  dependencies:
-    prelude-ls "^1.2.1"
-    type-check "~0.4.0"
-
-lines-and-columns@^1.1.6:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632"
-  integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==
-
-listr2@^3.8.3:
-  version "3.14.0"
-  resolved "https://registry.yarnpkg.com/listr2/-/listr2-3.14.0.tgz#23101cc62e1375fd5836b248276d1d2b51fdbe9e"
-  integrity sha512-TyWI8G99GX9GjE54cJ+RrNMcIFBfwMPxc3XTFiAYGN4s10hWROGtOg7+O6u6LE3mNkyld7RSLE6nrKBvTfcs3g==
-  dependencies:
-    cli-truncate "^2.1.0"
-    colorette "^2.0.16"
-    log-update "^4.0.0"
-    p-map "^4.0.0"
-    rfdc "^1.3.0"
-    rxjs "^7.5.1"
-    through "^2.3.8"
-    wrap-ansi "^7.0.0"
-
-loader-utils@^2.0.0:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-2.0.4.tgz#8b5cb38b5c34a9a018ee1fc0e6a066d1dfcc528c"
-  integrity sha512-xXqpXoINfFhgua9xiqD8fPFHgkoq1mmmpE92WlDbm9rNRd/EbRb+Gqf908T2DMfuHjjJlksiK2RbHVOdD/MqSw==
-  dependencies:
-    big.js "^5.2.2"
-    emojis-list "^3.0.0"
-    json5 "^2.1.2"
-
-locate-path@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-3.0.0.tgz#dbec3b3ab759758071b58fe59fc41871af21400e"
-  integrity sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==
-  dependencies:
-    p-locate "^3.0.0"
-    path-exists "^3.0.0"
-
-locate-path@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0"
-  integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==
-  dependencies:
-    p-locate "^4.1.0"
-
-locate-path@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-6.0.0.tgz#55321eb309febbc59c4801d931a72452a681d286"
-  integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==
-  dependencies:
-    p-locate "^5.0.0"
-
-lodash.flattendeep@^4.4.0:
-  version "4.4.0"
-  resolved "https://registry.yarnpkg.com/lodash.flattendeep/-/lodash.flattendeep-4.4.0.tgz#fb030917f86a3134e5bc9bec0d69e0013ddfedb2"
-  integrity sha512-uHaJFihxmJcEX3kT4I23ABqKKalJ/zDrDg0lsFtc1h+3uw49SIJ5beyhx5ExVRti3AvKoOJngIj7xz3oylPdWQ==
-
-lodash.merge@^4.6.2:
-  version "4.6.2"
-  resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a"
-  integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==
-
-lodash.once@^4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/lodash.once/-/lodash.once-4.1.1.tgz#0dd3971213c7c56df880977d504c88fb471a97ac"
-  integrity sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==
-
-lodash.truncate@^4.4.2:
-  version "4.4.2"
-  resolved "https://registry.yarnpkg.com/lodash.truncate/-/lodash.truncate-4.4.2.tgz#5a350da0b1113b837ecfffd5812cbe58d6eae193"
-  integrity sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==
-
-lodash@^4.17.20, lodash@^4.17.21, lodash@~4.17.21:
-  version "4.17.21"
-  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
-  integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
-
-log-symbols@4.1.0, log-symbols@^4.0.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-4.1.0.tgz#3fbdbb95b4683ac9fc785111e792e558d4abd503"
-  integrity sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==
-  dependencies:
-    chalk "^4.1.0"
-    is-unicode-supported "^0.1.0"
-
-log-update@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/log-update/-/log-update-4.0.0.tgz#589ecd352471f2a1c0c570287543a64dfd20e0a1"
-  integrity sha512-9fkkDevMefjg0mmzWFBW8YkFP91OrizzkW3diF7CpG+S2EYdy4+TVfGwz1zeF8x7hCx1ovSPTOE9Ngib74qqUg==
-  dependencies:
-    ansi-escapes "^4.3.0"
-    cli-cursor "^3.1.0"
-    slice-ansi "^4.0.0"
-    wrap-ansi "^6.2.0"
-
-lru-cache@^5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920"
-  integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==
-  dependencies:
-    yallist "^3.0.2"
-
-lru-cache@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
-  integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
-  dependencies:
-    yallist "^4.0.0"
-
-magic-string@~0.26.2:
-  version "0.26.7"
-  resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.26.7.tgz#caf7daf61b34e9982f8228c4527474dac8981d6f"
-  integrity sha512-hX9XH3ziStPoPhJxLq1syWuZMxbDvGNbVchfrdCtanC7D13888bMFow61x8axrx+GfHLtVeAx2kxL7tTGRl+Ow==
-  dependencies:
-    sourcemap-codec "^1.4.8"
-
-make-dir@^2.0.0, make-dir@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-2.1.0.tgz#5f0310e18b8be898cc07009295a30ae41e91e6f5"
-  integrity sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==
-  dependencies:
-    pify "^4.0.1"
-    semver "^5.6.0"
-
-make-dir@^3.0.0, make-dir@^3.0.2:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-3.1.0.tgz#415e967046b3a7f1d185277d84aa58203726a13f"
-  integrity sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==
-  dependencies:
-    semver "^6.0.0"
-
-map-obj@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d"
-  integrity sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==
-
-map-obj@^4.0.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-4.3.0.tgz#9304f906e93faae70880da102a9f1df0ea8bb05a"
-  integrity sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==
-
-mathml-tag-names@^2.1.3:
-  version "2.1.3"
-  resolved "https://registry.yarnpkg.com/mathml-tag-names/-/mathml-tag-names-2.1.3.tgz#4ddadd67308e780cf16a47685878ee27b736a0a3"
-  integrity sha512-APMBEanjybaPzUrfqU0IMU5I0AswKMH7k8OTLs0vvV4KZpExkTkY87nR/zpbuTPj+gARop7aGUbl11pnDfW6xg==
-
-md5@2.3.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/md5/-/md5-2.3.0.tgz#c3da9a6aae3a30b46b7b0c349b87b110dc3bda4f"
-  integrity sha512-T1GITYmFaKuO91vxyoQMFETst+O71VUPEU3ze5GNzDm0OWdP8v1ziTaAEPUr/3kLsY3Sftgz242A1SetQiDL7g==
-  dependencies:
-    charenc "0.0.2"
-    crypt "0.0.2"
-    is-buffer "~1.1.6"
-
-mdn-data@2.0.30:
-  version "2.0.30"
-  resolved "https://registry.yarnpkg.com/mdn-data/-/mdn-data-2.0.30.tgz#ce4df6f80af6cfbe218ecd5c552ba13c4dfa08cc"
-  integrity sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA==
-
-meow@^9.0.0:
-  version "9.0.0"
-  resolved "https://registry.yarnpkg.com/meow/-/meow-9.0.0.tgz#cd9510bc5cac9dee7d03c73ee1f9ad959f4ea364"
-  integrity sha512-+obSblOQmRhcyBt62furQqRAQpNyWXo8BuQ5bN7dG8wmwQ+vwHKp/rCFD4CrTP8CsDQD1sjoZ94K417XEUk8IQ==
-  dependencies:
-    "@types/minimist" "^1.2.0"
-    camelcase-keys "^6.2.2"
-    decamelize "^1.2.0"
-    decamelize-keys "^1.1.0"
-    hard-rejection "^2.1.0"
-    minimist-options "4.1.0"
-    normalize-package-data "^3.0.0"
-    read-pkg-up "^7.0.1"
-    redent "^3.0.0"
-    trim-newlines "^3.0.0"
-    type-fest "^0.18.0"
-    yargs-parser "^20.2.3"
-
-merge-stream@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
-  integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==
-
-merge2@^1.3.0, merge2@^1.4.1:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
-  integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
-
-micromatch@^4.0.4, micromatch@^4.0.5:
-  version "4.0.5"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6"
-  integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==
-  dependencies:
-    braces "^3.0.2"
-    picomatch "^2.3.1"
-
-mime-db@1.52.0:
-  version "1.52.0"
-  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70"
-  integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==
-
-mime-types@^2.1.12, mime-types@~2.1.19:
-  version "2.1.35"
-  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a"
-  integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
-  dependencies:
-    mime-db "1.52.0"
-
-mimic-fn@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b"
-  integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==
-
-min-indent@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869"
-  integrity sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==
-
-minimatch@5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-5.0.1.tgz#fb9022f7528125187c92bd9e9b6366be1cf3415b"
-  integrity sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==
-  dependencies:
-    brace-expansion "^2.0.1"
-
-minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.1, minimatch@^3.1.2:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b"
-  integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
-  dependencies:
-    brace-expansion "^1.1.7"
-
-minimist-options@4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/minimist-options/-/minimist-options-4.1.0.tgz#c0655713c53a8a2ebd77ffa247d342c40f010619"
-  integrity sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==
-  dependencies:
-    arrify "^1.0.1"
-    is-plain-obj "^1.1.0"
-    kind-of "^6.0.3"
-
-minimist@^1.2.0, minimist@^1.2.6, minimist@^1.2.8:
-  version "1.2.8"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c"
-  integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==
-
-mkdirp@^0.5.3:
-  version "0.5.6"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.6.tgz#7def03d2432dcae4ba1d611445c48396062255f6"
-  integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==
-  dependencies:
-    minimist "^1.2.6"
-
-mkdirp@~1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e"
-  integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==
-
-mocha@latest:
-  version "10.2.0"
-  resolved "https://registry.yarnpkg.com/mocha/-/mocha-10.2.0.tgz#1fd4a7c32ba5ac372e03a17eef435bd00e5c68b8"
-  integrity sha512-IDY7fl/BecMwFHzoqF2sg/SHHANeBoMMXFlS9r0OXKDssYE1M5O43wUY/9BVPeIvfH2zmEbBfseqN9gBQZzXkg==
-  dependencies:
-    ansi-colors "4.1.1"
-    browser-stdout "1.3.1"
-    chokidar "3.5.3"
-    debug "4.3.4"
-    diff "5.0.0"
-    escape-string-regexp "4.0.0"
-    find-up "5.0.0"
-    glob "7.2.0"
-    he "1.2.0"
-    js-yaml "4.1.0"
-    log-symbols "4.1.0"
-    minimatch "5.0.1"
-    ms "2.1.3"
-    nanoid "3.3.3"
-    serialize-javascript "6.0.0"
-    strip-json-comments "3.1.1"
-    supports-color "8.1.1"
-    workerpool "6.2.1"
-    yargs "16.2.0"
-    yargs-parser "20.2.4"
-    yargs-unparser "2.0.0"
-
-moment@~2.29.3:
-  version "2.29.4"
-  resolved "https://registry.yarnpkg.com/moment/-/moment-2.29.4.tgz#3dbe052889fe7c1b2ed966fcb3a77328964ef108"
-  integrity sha512-5LC9SOxjSc2HF6vO2CyuTDNivEdoz2IvyJJGj6X8DJ0eFyfszE0QiEd+iXmBvUP3WHxSjFH/vIsA0EN00cgr8w==
-
-ms@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
-  integrity sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==
-
-ms@2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
-  integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
-
-ms@2.1.3, ms@^2.1.1:
-  version "2.1.3"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
-  integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
-
-nanoid@3.3.3:
-  version "3.3.3"
-  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.3.tgz#fd8e8b7aa761fe807dba2d1b98fb7241bb724a25"
-  integrity sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w==
-
-nanoid@^3.3.7:
-  version "3.3.7"
-  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.7.tgz#d0c301a691bc8d54efa0a2226ccf3fe2fd656bd8"
-  integrity sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==
-
-nanoid@^4.0.2:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-4.0.2.tgz#140b3c5003959adbebf521c170f282c5e7f9fb9e"
-  integrity sha512-7ZtY5KTCNheRGfEFxnedV5zFiORN1+Y1N6zvPTnHQd8ENUvfaDBeuJDZb2bN/oXwXxu3qkTXDzy57W5vAmDTBw==
-
-natural-compare-lite@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz#17b09581988979fddafe0201e931ba933c96cbb4"
-  integrity sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==
-
-natural-compare@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
-  integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==
-
-node-preload@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/node-preload/-/node-preload-0.2.1.tgz#c03043bb327f417a18fee7ab7ee57b408a144301"
-  integrity sha512-RM5oyBy45cLEoHqCeh+MNuFAxO0vTFBLskvQbOKnEE7YTTSN4tbN8QWDIPQ6L+WvKsB/qLEGpYe2ZZ9d4W9OIQ==
-  dependencies:
-    process-on-spawn "^1.0.0"
-
-node-releases@^2.0.8:
-  version "2.0.10"
-  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.10.tgz#c311ebae3b6a148c89b1813fd7c4d3c024ef537f"
-  integrity sha512-5GFldHPXVG/YZmFzJvKK2zDSzPKhEp0+ZR5SVaoSag9fsL5YgHbUHDfnG5494ISANDcK4KwPXAx2xqVEydmd7w==
-
-normalize-package-data@^2.5.0:
-  version "2.5.0"
-  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.5.0.tgz#e66db1838b200c1dfc233225d12cb36520e234a8"
-  integrity sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==
-  dependencies:
-    hosted-git-info "^2.1.4"
-    resolve "^1.10.0"
-    semver "2 || 3 || 4 || 5"
-    validate-npm-package-license "^3.0.1"
-
-normalize-package-data@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-3.0.3.tgz#dbcc3e2da59509a0983422884cd172eefdfa525e"
-  integrity sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA==
-  dependencies:
-    hosted-git-info "^4.0.1"
-    is-core-module "^2.5.0"
-    semver "^7.3.4"
-    validate-npm-package-license "^3.0.1"
-
-normalize-path@^3.0.0, normalize-path@~3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
-  integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
-
-normalize-range@^0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/normalize-range/-/normalize-range-0.1.2.tgz#2d10c06bdfd312ea9777695a4d28439456b75942"
-  integrity sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==
-
-npm-run-path@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea"
-  integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==
-  dependencies:
-    path-key "^3.0.0"
-
-nyc@15.1.0:
-  version "15.1.0"
-  resolved "https://registry.yarnpkg.com/nyc/-/nyc-15.1.0.tgz#1335dae12ddc87b6e249d5a1994ca4bdaea75f02"
-  integrity sha512-jMW04n9SxKdKi1ZMGhvUTHBN0EICCRkHemEoE5jm6mTYcqcdas0ATzgUgejlQUHMvpnOZqGB5Xxsv9KxJW1j8A==
-  dependencies:
-    "@istanbuljs/load-nyc-config" "^1.0.0"
-    "@istanbuljs/schema" "^0.1.2"
-    caching-transform "^4.0.0"
-    convert-source-map "^1.7.0"
-    decamelize "^1.2.0"
-    find-cache-dir "^3.2.0"
-    find-up "^4.1.0"
-    foreground-child "^2.0.0"
-    get-package-type "^0.1.0"
-    glob "^7.1.6"
-    istanbul-lib-coverage "^3.0.0"
-    istanbul-lib-hook "^3.0.0"
-    istanbul-lib-instrument "^4.0.0"
-    istanbul-lib-processinfo "^2.0.2"
-    istanbul-lib-report "^3.0.0"
-    istanbul-lib-source-maps "^4.0.0"
-    istanbul-reports "^3.0.2"
-    make-dir "^3.0.0"
-    node-preload "^0.2.1"
-    p-map "^3.0.0"
-    process-on-spawn "^1.0.0"
-    resolve-from "^5.0.0"
-    rimraf "^3.0.0"
-    signal-exit "^3.0.2"
-    spawn-wrap "^2.0.0"
-    test-exclude "^6.0.0"
-    yargs "^15.0.2"
-
-object-inspect@^1.12.2:
-  version "1.12.3"
-  resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.12.3.tgz#ba62dffd67ee256c8c086dfae69e016cd1f198b9"
-  integrity sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==
-
-object-inspect@^1.13.1:
-  version "1.13.1"
-  resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.13.1.tgz#b96c6109324ccfef6b12216a956ca4dc2ff94bc2"
-  integrity sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==
-
-object-keys@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
-  integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
-
-object.assign@^4.1.4:
-  version "4.1.4"
-  resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.4.tgz#9673c7c7c351ab8c4d0b516f4343ebf4dfb7799f"
-  integrity sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.4"
-    has-symbols "^1.0.3"
-    object-keys "^1.1.1"
-
-object.values@^1.1.5:
-  version "1.1.6"
-  resolved "https://registry.yarnpkg.com/object.values/-/object.values-1.1.6.tgz#4abbaa71eba47d63589d402856f908243eea9b1d"
-  integrity sha512-FVVTkD1vENCsAcwNs9k6jea2uHC/X0+JcjG8YA60FN5CMaJmG95wT9jek/xX9nornqGRrBkKtzuAu2wuHpKqvw==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.4"
-    es-abstract "^1.20.4"
-
-once@^1.3.0, once@^1.3.1, once@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
-  integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
-  dependencies:
-    wrappy "1"
-
-onetime@^5.1.0:
-  version "5.1.2"
-  resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e"
-  integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==
-  dependencies:
-    mimic-fn "^2.1.0"
-
-optionator@^0.9.1:
-  version "0.9.1"
-  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.1.tgz#4f236a6373dae0566a6d43e1326674f50c291499"
-  integrity sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==
-  dependencies:
-    deep-is "^0.1.3"
-    fast-levenshtein "^2.0.6"
-    levn "^0.4.1"
-    prelude-ls "^1.2.1"
-    type-check "^0.4.0"
-    word-wrap "^1.2.3"
-
-ospath@^1.2.2:
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/ospath/-/ospath-1.2.2.tgz#1276639774a3f8ef2572f7fe4280e0ea4550c07b"
-  integrity sha512-o6E5qJV5zkAbIDNhGSIlyOhScKXgQrSRMilfph0clDfM0nEnBOlKlH4sWDmG95BW/CvwNz0vmm7dJVtU2KlMiA==
-
-p-limit@^2.0.0, p-limit@^2.2.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1"
-  integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==
-  dependencies:
-    p-try "^2.0.0"
-
-p-limit@^3.0.2:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b"
-  integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
-  dependencies:
-    yocto-queue "^0.1.0"
-
-p-locate@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-3.0.0.tgz#322d69a05c0264b25997d9f40cd8a891ab0064a4"
-  integrity sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==
-  dependencies:
-    p-limit "^2.0.0"
-
-p-locate@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07"
-  integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==
-  dependencies:
-    p-limit "^2.2.0"
-
-p-locate@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-5.0.0.tgz#83c8315c6785005e3bd021839411c9e110e6d834"
-  integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==
-  dependencies:
-    p-limit "^3.0.2"
-
-p-map@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/p-map/-/p-map-3.0.0.tgz#d704d9af8a2ba684e2600d9a215983d4141a979d"
-  integrity sha512-d3qXVTF/s+W+CdJ5A29wywV2n8CQQYahlgz2bFiA+4eVNJbHJodPZ+/gXwPGh0bOqA+j8S+6+ckmvLGPk1QpxQ==
-  dependencies:
-    aggregate-error "^3.0.0"
-
-p-map@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/p-map/-/p-map-4.0.0.tgz#bb2f95a5eda2ec168ec9274e06a747c3e2904d2b"
-  integrity sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==
-  dependencies:
-    aggregate-error "^3.0.0"
-
-p-try@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
-  integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
-
-package-hash@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/package-hash/-/package-hash-4.0.0.tgz#3537f654665ec3cc38827387fc904c163c54f506"
-  integrity sha512-whdkPIooSu/bASggZ96BWVvZTRMOFxnyUG5PnTSGKoJE2gd5mbVNmR2Nj20QFzxYYgAXpoqC+AiXzl+UMRh7zQ==
-  dependencies:
-    graceful-fs "^4.1.15"
-    hasha "^5.0.0"
-    lodash.flattendeep "^4.4.0"
-    release-zalgo "^1.0.0"
-
-package-name-regex@~2.0.6:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/package-name-regex/-/package-name-regex-2.0.6.tgz#b54bcb04d950e38082b7bb38fa558e01c1679334"
-  integrity sha512-gFL35q7kbE/zBaPA3UKhp2vSzcPYx2ecbYuwv1ucE9Il6IIgBDweBlH8D68UFGZic2MkllKa2KHCfC1IQBQUYA==
-
-parent-module@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-1.0.1.tgz#691d2709e78c79fae3a156622452d00762caaaa2"
-  integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==
-  dependencies:
-    callsites "^3.0.0"
-
-parse-json@^5.0.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd"
-  integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==
-  dependencies:
-    "@babel/code-frame" "^7.0.0"
-    error-ex "^1.3.1"
-    json-parse-even-better-errors "^2.3.0"
-    lines-and-columns "^1.1.6"
-
-path-exists@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515"
-  integrity sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==
-
-path-exists@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3"
-  integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
-
-path-is-absolute@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
-  integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==
-
-path-key@^3.0.0, path-key@^3.1.0:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
-  integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
-
-path-parse@^1.0.7:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
-  integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
-
-path-type@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
-  integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
-
-pend@~1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/pend/-/pend-1.2.0.tgz#7a57eb550a6783f9115331fcf4663d5c8e007a50"
-  integrity sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==
-
-performance-now@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-2.1.0.tgz#6309f4e0e5fa913ec1c69307ae364b4b377c9e7b"
-  integrity sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==
-
-picocolors@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-0.2.1.tgz#570670f793646851d1ba135996962abad587859f"
-  integrity sha512-cMlDqaLEqfSaW8Z7N5Jw+lyIW869EzT73/F5lhtY9cLGoVxSXznfgfXMO0Z5K0o0Q2TkTXq+0KFsdnSe3jDViA==
-
-picocolors@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c"
-  integrity sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==
-
-picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.3.1:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42"
-  integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
-
-pify@^2.2.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
-  integrity sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==
-
-pify@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-4.0.1.tgz#4b2cd25c50d598735c50292224fd8c6df41e3231"
-  integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==
-
-pirates@^4.0.5:
-  version "4.0.5"
-  resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.5.tgz#feec352ea5c3268fb23a37c702ab1699f35a5f3b"
-  integrity sha512-8V9+HQPupnaXMA23c5hvl69zXvTwTzyAYasnkb0Tts4XvO4CliqONMOnvlq26rkhLC3nWDFBJf73LU1e1VZLaQ==
-
-pkg-dir@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-3.0.0.tgz#2749020f239ed990881b1f71210d51eb6523bea3"
-  integrity sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==
-  dependencies:
-    find-up "^3.0.0"
-
-pkg-dir@^4.1.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3"
-  integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==
-  dependencies:
-    find-up "^4.0.0"
-
-platform@1.3.3:
-  version "1.3.3"
-  resolved "https://registry.yarnpkg.com/platform/-/platform-1.3.3.tgz#646c77011899870b6a0903e75e997e8e51da7461"
-  integrity sha512-VJK1SRmXBpjwsB4YOHYSturx48rLKMzHgCqDH2ZDa6ZbMS/N5huoNqyQdK5Fj/xayu3fqbXckn5SeCS1EbMDZg==
-
-postcss-apply@^0.12.0:
-  version "0.12.0"
-  resolved "https://registry.yarnpkg.com/postcss-apply/-/postcss-apply-0.12.0.tgz#11a47b271b14d81db97ed7f51a6c409d025a9c34"
-  integrity sha512-u8qZLyA9P86cD08IhqjSVV8tf1eGiKQ4fPvjcG3Ic/eOU65EAkDQClp8We7d15TG+RIWRVPSy9v7cJ2D9OReqw==
-  dependencies:
-    balanced-match "^1.0.0"
-    postcss "^7.0.14"
-
-postcss-attribute-case-insensitive@^6.0.2:
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/postcss-attribute-case-insensitive/-/postcss-attribute-case-insensitive-6.0.2.tgz#e843091859323342e461878d201ee70278809e01"
-  integrity sha512-IRuCwwAAQbgaLhxQdQcIIK0dCVXg3XDUnzgKD8iwdiYdwU4rMWRWyl/W9/0nA4ihVpq5pyALiHB2veBJ0292pw==
-  dependencies:
-    postcss-selector-parser "^6.0.10"
-
-postcss-clamp@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/postcss-clamp/-/postcss-clamp-4.1.0.tgz#7263e95abadd8c2ba1bd911b0b5a5c9c93e02363"
-  integrity sha512-ry4b1Llo/9zz+PKC+030KUnPITTJAHeOwjfAyyB60eT0AorGLdzp52s31OsPRHRf8NchkgFoG2y6fCfn1IV1Ow==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-postcss-color-functional-notation@^5.0.2:
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/postcss-color-functional-notation/-/postcss-color-functional-notation-5.0.2.tgz#6d03c928aa3a13487703af86c301bdcd501e7430"
-  integrity sha512-M6ygxWOyd6eWf3sd1Lv8xi4SeF4iBPfJvkfMU4ITh8ExJc1qhbvh/U8Cv/uOvBgUVOMDdScvCdlg8+hREQzs7w==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-postcss-color-hex-alpha@^9.0.2:
-  version "9.0.2"
-  resolved "https://registry.yarnpkg.com/postcss-color-hex-alpha/-/postcss-color-hex-alpha-9.0.2.tgz#6d3ed50342802469880981a1999515d003ff7d79"
-  integrity sha512-SfPjgr//VQ/DOCf80STIAsdAs7sbIbxATvVmd+Ec7JvR8onz9pjawhq3BJM3Pie40EE3TyB0P6hft16D33Nlyg==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-postcss-color-rebeccapurple@^8.0.2:
-  version "8.0.2"
-  resolved "https://registry.yarnpkg.com/postcss-color-rebeccapurple/-/postcss-color-rebeccapurple-8.0.2.tgz#c0f2dcf1ef4dd393314920aa181cca8c390a2648"
-  integrity sha512-xWf/JmAxVoB5bltHpXk+uGRoGFwu4WDAR7210el+iyvTdqiKpDhtcT8N3edXMoVJY0WHFMrKMUieql/wRNiXkw==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-postcss-custom-media@^9.1.2:
-  version "9.1.2"
-  resolved "https://registry.yarnpkg.com/postcss-custom-media/-/postcss-custom-media-9.1.2.tgz#0e9c34b0b5325edc2c5f42f47543cb64d777764b"
-  integrity sha512-osM9g4UKq4XKimAC7RAXroqi3BXpxfwTswAJQiZdrBjWGFGEyxQrY5H2eDWI8F+MEvEUfYDxA8scqi3QWROCSw==
-  dependencies:
-    "@csstools/cascade-layer-name-parser" "^1.0.0"
-    "@csstools/css-parser-algorithms" "^2.0.0"
-    "@csstools/css-tokenizer" "^2.0.0"
-    "@csstools/media-query-list-parser" "^2.0.0"
-
-postcss-custom-properties@^13.1.4:
-  version "13.1.4"
-  resolved "https://registry.yarnpkg.com/postcss-custom-properties/-/postcss-custom-properties-13.1.4.tgz#590e5770137011001602806da51243b6c82c1cde"
-  integrity sha512-iSAdaZrM3KMec8cOSzeTUNXPYDlhqsMJHpt62yrjwG6nAnMtRHPk5JdMzGosBJtqEahDolvD5LNbcq+EZ78o5g==
-  dependencies:
-    "@csstools/cascade-layer-name-parser" "^1.0.0"
-    "@csstools/css-parser-algorithms" "^2.0.0"
-    "@csstools/css-tokenizer" "^2.0.0"
-    postcss-value-parser "^4.2.0"
-
-postcss-custom-selectors@^7.1.2:
-  version "7.1.2"
-  resolved "https://registry.yarnpkg.com/postcss-custom-selectors/-/postcss-custom-selectors-7.1.2.tgz#e100e9dd628d969a651d7d310cdfd25b27b58d4b"
-  integrity sha512-jX7VlE3jrgfBIOfxiGNRFq81xUoHSZhvxhQurzE7ZFRv+bUmMwB7/XnA0nNlts2CwNtbXm4Ozy0ZAYKHlCRmBQ==
-  dependencies:
-    "@csstools/cascade-layer-name-parser" "^1.0.0"
-    "@csstools/css-parser-algorithms" "^2.0.0"
-    "@csstools/css-tokenizer" "^2.0.0"
-    postcss-selector-parser "^6.0.4"
-
-postcss-dir-pseudo-class@^7.0.2:
-  version "7.0.2"
-  resolved "https://registry.yarnpkg.com/postcss-dir-pseudo-class/-/postcss-dir-pseudo-class-7.0.2.tgz#71618b7eb4abe067845d11b3c8f322760c9b3e88"
-  integrity sha512-cMnslilYxBf9k3qejnovrUONZx1rXeUZJw06fgIUBzABJe3D2LiLL5WAER7Imt3nrkaIgG05XZBztueLEf5P8w==
-  dependencies:
-    postcss-selector-parser "^6.0.10"
-
-postcss-double-position-gradients@^4.0.2:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/postcss-double-position-gradients/-/postcss-double-position-gradients-4.0.2.tgz#855a23201f26be447210504e9b668429cbf4640c"
-  integrity sha512-GXL1RmFREDK4Q9aYvI2RhVrA6a6qqSMQQ5ke8gSH1xgV6exsqbcJpIumC7AOgooH6/WIG3/K/T8xxAiVHy/tJg==
-  dependencies:
-    "@csstools/postcss-progressive-custom-properties" "^2.0.0"
-    postcss-value-parser "^4.2.0"
-
-postcss-focus-visible@^8.0.2:
-  version "8.0.2"
-  resolved "https://registry.yarnpkg.com/postcss-focus-visible/-/postcss-focus-visible-8.0.2.tgz#a7ac26ffe3e9c2bd17d7200d75e2d79ee8110891"
-  integrity sha512-f/Vd+EC/GaKElknU59esVcRYr/Y3t1ZAQyL4u2xSOgkDy4bMCmG7VP5cGvj3+BTLNE9ETfEuz2nnt4qkZwTTeA==
-  dependencies:
-    postcss-selector-parser "^6.0.10"
-
-postcss-focus-within@^7.0.2:
-  version "7.0.2"
-  resolved "https://registry.yarnpkg.com/postcss-focus-within/-/postcss-focus-within-7.0.2.tgz#5d2c866030e66ed22b204c9506de640943310b1c"
-  integrity sha512-AHAJ89UQBcqBvFgQJE9XasGuwMNkKsGj4D/f9Uk60jFmEBHpAL14DrnSk3Rj+SwZTr/WUG+mh+Rvf8fid/346w==
-  dependencies:
-    postcss-selector-parser "^6.0.10"
-
-postcss-font-variant@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/postcss-font-variant/-/postcss-font-variant-5.0.0.tgz#efd59b4b7ea8bb06127f2d031bfbb7f24d32fa66"
-  integrity sha512-1fmkBaCALD72CK2a9i468mA/+tr9/1cBxRRMXOUaZqO43oWPR5imcyPjXwuv7PXbCid4ndlP5zWhidQVVa3hmA==
-
-postcss-gap-properties@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/postcss-gap-properties/-/postcss-gap-properties-4.0.1.tgz#0347d6a84a46bfbe88bedc542cc4b354e04a8338"
-  integrity sha512-V5OuQGw4lBumPlwHWk/PRfMKjaq/LTGR4WDTemIMCaMevArVfCCA9wBJiL1VjDAd+rzuCIlkRoRvDsSiAaZ4Fg==
-
-postcss-image-set-function@^5.0.2:
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/postcss-image-set-function/-/postcss-image-set-function-5.0.2.tgz#088e0f535f43e74d6ea8033ff7b0482e2735ea6e"
-  integrity sha512-Sszjwo0ubETX0Fi5MvpYzsONwrsjeabjMoc5YqHvURFItXgIu3HdCjcVuVKGMPGzKRhgaknmdM5uVWInWPJmeg==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-postcss-initial@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/postcss-initial/-/postcss-initial-4.0.1.tgz#529f735f72c5724a0fb30527df6fb7ac54d7de42"
-  integrity sha512-0ueD7rPqX8Pn1xJIjay0AZeIuDoF+V+VvMt/uOnn+4ezUKhZM/NokDeP6DwMNyIoYByuN/94IQnt5FEkaN59xQ==
-
-postcss-lab-function@^5.2.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/postcss-lab-function/-/postcss-lab-function-5.2.0.tgz#7504de96d5bd21177af241fe7601b5151f2df1a4"
-  integrity sha512-ie/k0xFCib22LV56jZoygLuWfM4J4migb89QnEXOjORGh6UwsDVSPW/x+P2MYS+AKFfZ5Npcu5HYEzYcezAAag==
-  dependencies:
-    "@csstools/css-color-parser" "^1.0.0"
-    "@csstools/css-parser-algorithms" "^2.0.1"
-    "@csstools/css-tokenizer" "^2.1.0"
-    "@csstools/postcss-progressive-custom-properties" "^2.0.0"
-
-postcss-logical@^6.1.0:
-  version "6.1.0"
-  resolved "https://registry.yarnpkg.com/postcss-logical/-/postcss-logical-6.1.0.tgz#c33ae75d3edaea7eb821e76dc4e6d0ecedc3200d"
-  integrity sha512-qb1+LpClhYjxac8SfOcWotnY3unKZesDqIOm+jnGt8rTl7xaIWpE2bPGZHxflOip1E/4ETo79qlJyRL3yrHn1g==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-postcss-media-query-parser@^0.2.3:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/postcss-media-query-parser/-/postcss-media-query-parser-0.2.3.tgz#27b39c6f4d94f81b1a73b8f76351c609e5cef244"
-  integrity sha512-3sOlxmbKcSHMjlUXQZKQ06jOswE7oVkXPxmZdoB1r5l0q6gTFTQSHxNxOrCccElbW7dxNytifNEo8qidX2Vsig==
-
-postcss-nested@4.1.2:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/postcss-nested/-/postcss-nested-4.1.2.tgz#8e0570f736bfb4be5136e31901bf2380b819a561"
-  integrity sha512-9bQFr2TezohU3KRSu9f6sfecXmf/x6RXDedl8CHF6fyuyVW7UqgNMRdWMHZQWuFY6Xqs2NYk+Fj4Z4vSOf7PQg==
-  dependencies:
-    postcss "^7.0.14"
-    postcss-selector-parser "^5.0.0"
-
-postcss-nesting@^11.2.1:
-  version "11.2.2"
-  resolved "https://registry.yarnpkg.com/postcss-nesting/-/postcss-nesting-11.2.2.tgz#ddedfea5a1fdcd8d753298d82297ad15d5640c0f"
-  integrity sha512-aOTiUniAB1bcPE6GGiynWRa6PZFPhOTAm5q3q5cem6QeSijIHHkWr6gs65ukCZMXeak8yXeZVbBJET3VM+HlhA==
-  dependencies:
-    "@csstools/selector-specificity" "^2.0.0"
-    postcss-selector-parser "^6.0.10"
-
-postcss-opacity-percentage@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/postcss-opacity-percentage/-/postcss-opacity-percentage-2.0.0.tgz#c0a56060cd4586e3f954dbde1efffc2deed53002"
-  integrity sha512-lyDrCOtntq5Y1JZpBFzIWm2wG9kbEdujpNt4NLannF+J9c8CgFIzPa80YQfdza+Y+yFfzbYj/rfoOsYsooUWTQ==
-
-postcss-overflow-shorthand@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/postcss-overflow-shorthand/-/postcss-overflow-shorthand-4.0.1.tgz#cb61ca24d8c4e1dbf14d85181b017cfa6953aa34"
-  integrity sha512-HQZ0qi/9iSYHW4w3ogNqVNr2J49DHJAl7r8O2p0Meip38jsdnRPgiDW7r/LlLrrMBMe3KHkvNtAV2UmRVxzLIg==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-postcss-page-break@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/postcss-page-break/-/postcss-page-break-3.0.4.tgz#7fbf741c233621622b68d435babfb70dd8c1ee5f"
-  integrity sha512-1JGu8oCjVXLa9q9rFTo4MbeeA5FMe00/9C7lN4va606Rdb+HkxXtXsmEDrIraQ11fGz/WvKWa8gMuCKkrXpTsQ==
-
-postcss-place@^8.0.1:
-  version "8.0.1"
-  resolved "https://registry.yarnpkg.com/postcss-place/-/postcss-place-8.0.1.tgz#408d7a27e99192df51c95fe62a3a34def62aa66a"
-  integrity sha512-Ow2LedN8sL4pq8ubukO77phSVt4QyCm35ZGCYXKvRFayAwcpgB0sjNJglDoTuRdUL32q/ZC1VkPBo0AOEr4Uiw==
-  dependencies:
-    postcss-value-parser "^4.2.0"
-
-postcss-preset-env@^8.3.0:
-  version "8.3.0"
-  resolved "https://registry.yarnpkg.com/postcss-preset-env/-/postcss-preset-env-8.3.0.tgz#a310f9029a62b5189cf1e6afd1970ccbf8c96fdc"
-  integrity sha512-VFc/bhwRo37RoTVzCTCKDJLw0lwsqLRCTc7dkJkfs9S7XXfTbk7QkhbMWHd2L+iZsAsE5yqdSRBZ41/Q828TbA==
-  dependencies:
-    "@csstools/postcss-cascade-layers" "^3.0.1"
-    "@csstools/postcss-color-function" "^2.1.0"
-    "@csstools/postcss-color-mix-function" "^1.0.0"
-    "@csstools/postcss-font-format-keywords" "^2.0.2"
-    "@csstools/postcss-gradients-interpolation-method" "^3.0.1"
-    "@csstools/postcss-hwb-function" "^2.2.0"
-    "@csstools/postcss-ic-unit" "^2.0.2"
-    "@csstools/postcss-is-pseudo-class" "^3.1.1"
-    "@csstools/postcss-logical-float-and-clear" "^1.0.1"
-    "@csstools/postcss-logical-resize" "^1.0.1"
-    "@csstools/postcss-logical-viewport-units" "^1.0.2"
-    "@csstools/postcss-media-minmax" "^1.0.0"
-    "@csstools/postcss-media-queries-aspect-ratio-number-values" "^1.0.1"
-    "@csstools/postcss-nested-calc" "^2.0.2"
-    "@csstools/postcss-normalize-display-values" "^2.0.1"
-    "@csstools/postcss-oklab-function" "^2.2.0"
-    "@csstools/postcss-progressive-custom-properties" "^2.1.0"
-    "@csstools/postcss-scope-pseudo-class" "^2.0.2"
-    "@csstools/postcss-stepped-value-functions" "^2.1.0"
-    "@csstools/postcss-text-decoration-shorthand" "^2.2.1"
-    "@csstools/postcss-trigonometric-functions" "^2.1.0"
-    "@csstools/postcss-unset-value" "^2.0.1"
-    autoprefixer "^10.4.14"
-    browserslist "^4.21.5"
-    css-blank-pseudo "^5.0.2"
-    css-has-pseudo "^5.0.2"
-    css-prefers-color-scheme "^8.0.2"
-    cssdb "^7.5.3"
-    postcss-attribute-case-insensitive "^6.0.2"
-    postcss-clamp "^4.1.0"
-    postcss-color-functional-notation "^5.0.2"
-    postcss-color-hex-alpha "^9.0.2"
-    postcss-color-rebeccapurple "^8.0.2"
-    postcss-custom-media "^9.1.2"
-    postcss-custom-properties "^13.1.4"
-    postcss-custom-selectors "^7.1.2"
-    postcss-dir-pseudo-class "^7.0.2"
-    postcss-double-position-gradients "^4.0.2"
-    postcss-focus-visible "^8.0.2"
-    postcss-focus-within "^7.0.2"
-    postcss-font-variant "^5.0.0"
-    postcss-gap-properties "^4.0.1"
-    postcss-image-set-function "^5.0.2"
-    postcss-initial "^4.0.1"
-    postcss-lab-function "^5.2.0"
-    postcss-logical "^6.1.0"
-    postcss-nesting "^11.2.1"
-    postcss-opacity-percentage "^2.0.0"
-    postcss-overflow-shorthand "^4.0.1"
-    postcss-page-break "^3.0.4"
-    postcss-place "^8.0.1"
-    postcss-pseudo-class-any-link "^8.0.2"
-    postcss-replace-overflow-wrap "^4.0.0"
-    postcss-selector-not "^7.0.1"
-    postcss-value-parser "^4.2.0"
-
-postcss-pseudo-class-any-link@^8.0.2:
-  version "8.0.2"
-  resolved "https://registry.yarnpkg.com/postcss-pseudo-class-any-link/-/postcss-pseudo-class-any-link-8.0.2.tgz#f5738503f2045de0c4dc216eca99bd835f74e42e"
-  integrity sha512-FYTIuRE07jZ2CW8POvctRgArQJ43yxhr5vLmImdKUvjFCkR09kh8pIdlCwdx/jbFm7MiW4QP58L4oOUv3grQYA==
-  dependencies:
-    postcss-selector-parser "^6.0.10"
-
-postcss-replace-overflow-wrap@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/postcss-replace-overflow-wrap/-/postcss-replace-overflow-wrap-4.0.0.tgz#d2df6bed10b477bf9c52fab28c568b4b29ca4319"
-  integrity sha512-KmF7SBPphT4gPPcKZc7aDkweHiKEEO8cla/GjcBK+ckKxiZslIu3C4GCRW3DNfL0o7yW7kMQu9xlZ1kXRXLXtw==
-
-postcss-resolve-nested-selector@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/postcss-resolve-nested-selector/-/postcss-resolve-nested-selector-0.1.1.tgz#29ccbc7c37dedfac304e9fff0bf1596b3f6a0e4e"
-  integrity sha512-HvExULSwLqHLgUy1rl3ANIqCsvMS0WHss2UOsXhXnQaZ9VCc2oBvIpXrl00IUFT5ZDITME0o6oiXeiHr2SAIfw==
-
-postcss-safe-parser@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/postcss-safe-parser/-/postcss-safe-parser-6.0.0.tgz#bb4c29894171a94bc5c996b9a30317ef402adaa1"
-  integrity sha512-FARHN8pwH+WiS2OPCxJI8FuRJpTVnn6ZNFiqAM2aeW2LwTHWWmWgIyKC6cUo0L8aeKiF/14MNvnpls6R2PBeMQ==
-
-postcss-selector-not@^7.0.1:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/postcss-selector-not/-/postcss-selector-not-7.0.1.tgz#8142e90c8eb6c8c5faecb3e9d96d4353d02e94fb"
-  integrity sha512-1zT5C27b/zeJhchN7fP0kBr16Cc61mu7Si9uWWLoA3Px/D9tIJPKchJCkUH3tPO5D0pCFmGeApAv8XpXBQJ8SQ==
-  dependencies:
-    postcss-selector-parser "^6.0.10"
-
-postcss-selector-parser@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-5.0.0.tgz#249044356697b33b64f1a8f7c80922dddee7195c"
-  integrity sha512-w+zLE5Jhg6Liz8+rQOWEAwtwkyqpfnmsinXjXg6cY7YIONZZtgvE0v2O0uhQBs0peNomOJwWRKt6JBfTdTd3OQ==
-  dependencies:
-    cssesc "^2.0.0"
-    indexes-of "^1.0.1"
-    uniq "^1.0.1"
-
-postcss-selector-parser@^6.0.10, postcss-selector-parser@^6.0.11, postcss-selector-parser@^6.0.4:
-  version "6.0.11"
-  resolved "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.0.11.tgz#2e41dc39b7ad74046e1615185185cd0b17d0c8dc"
-  integrity sha512-zbARubNdogI9j7WY4nQJBiNqQf3sLS3wCP4WfOidu+p28LofJqDH1tcXypGrcmMHhDk2t9wGhCsYe/+szLTy1g==
-  dependencies:
-    cssesc "^3.0.0"
-    util-deprecate "^1.0.2"
-
-postcss-value-parser@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz#723c09920836ba6d3e5af019f92bc0971c02e514"
-  integrity sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==
-
-postcss@^7.0.14:
-  version "7.0.39"
-  resolved "https://registry.yarnpkg.com/postcss/-/postcss-7.0.39.tgz#9624375d965630e2e1f2c02a935c82a59cb48309"
-  integrity sha512-yioayjNbHn6z1/Bywyb2Y4s3yvDAeXGOyxqD+LnVOinq6Mdmd++SW2wUNVzavyyHxd6+DxzWGIuosg6P1Rj8uA==
-  dependencies:
-    picocolors "^0.2.1"
-    source-map "^0.6.1"
-
-postcss@^8.4.21, postcss@^8.4.27:
-  version "8.4.35"
-  resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.4.35.tgz#60997775689ce09011edf083a549cea44aabe2f7"
-  integrity sha512-u5U8qYpBCpN13BsiEB0CbR1Hhh4Gc0zLFuedrHJKMctHCHAGrMdG0PRM/KErzAL3CU6/eckEtmHNB3x6e3c0vA==
-  dependencies:
-    nanoid "^3.3.7"
-    picocolors "^1.0.0"
-    source-map-js "^1.0.2"
-
-prelude-ls@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
-  integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==
-
-pretty-bytes@^5.6.0:
-  version "5.6.0"
-  resolved "https://registry.yarnpkg.com/pretty-bytes/-/pretty-bytes-5.6.0.tgz#356256f643804773c82f64723fe78c92c62beaeb"
-  integrity sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==
-
-process-on-spawn@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/process-on-spawn/-/process-on-spawn-1.0.0.tgz#95b05a23073d30a17acfdc92a440efd2baefdc93"
-  integrity sha512-1WsPDsUSMmZH5LeMLegqkPDrsGgsWwk1Exipy2hvB0o/F0ASzbpIctSCcZIK1ykJvtTJULEH+20WOFjMvGnCTg==
-  dependencies:
-    fromentries "^1.2.0"
-
-process@^0.11.10:
-  version "0.11.10"
-  resolved "https://registry.yarnpkg.com/process/-/process-0.11.10.tgz#7332300e840161bda3e69a1d1d91a7d4bc16f182"
-  integrity sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==
-
-proxy-from-env@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/proxy-from-env/-/proxy-from-env-1.0.0.tgz#33c50398f70ea7eb96d21f7b817630a55791c7ee"
-  integrity sha512-F2JHgJQ1iqwnHDcQjVBsq3n/uoaFL+iPW/eAeL7kVxy/2RrWaN4WroKjjvbsoRtv0ftelNyC01bjRhn/bhcf4A==
-
-psl@^1.1.33:
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/psl/-/psl-1.9.0.tgz#d0df2a137f00794565fcaf3b2c00cd09f8d5a5a7"
-  integrity sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==
-
-pump@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pump/-/pump-3.0.0.tgz#b4a2116815bde2f4e1ea602354e8c75565107a64"
-  integrity sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==
-  dependencies:
-    end-of-stream "^1.1.0"
-    once "^1.3.1"
-
-punycode@^2.1.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
-
-punycode@^2.1.1:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.1.tgz#027422e2faec0b25e1549c3e1bd8309b9133b6e5"
-  integrity sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==
-
-qs@6.10.4:
-  version "6.10.4"
-  resolved "https://registry.yarnpkg.com/qs/-/qs-6.10.4.tgz#6a3003755add91c0ec9eacdc5f878b034e73f9e7"
-  integrity sha512-OQiU+C+Ds5qiH91qh/mg0w+8nwQuLjM4F4M/PbmhDOoYehPh+Fb0bDjtR1sOvy7YKxvj28Y/M0PhP5uVX0kB+g==
-  dependencies:
-    side-channel "^1.0.4"
-
-querystringify@^2.1.1:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/querystringify/-/querystringify-2.2.0.tgz#3345941b4153cb9d082d8eee4cda2016a9aef7f6"
-  integrity sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==
-
-queue-microtask@^1.2.2:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
-  integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
-
-quick-lru@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-4.0.1.tgz#5b8878f113a58217848c6482026c73e1ba57727f"
-  integrity sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==
-
-randombytes@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a"
-  integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==
-  dependencies:
-    safe-buffer "^5.1.0"
-
-read-pkg-up@^7.0.1:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-7.0.1.tgz#f3a6135758459733ae2b95638056e1854e7ef507"
-  integrity sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==
-  dependencies:
-    find-up "^4.1.0"
-    read-pkg "^5.2.0"
-    type-fest "^0.8.1"
-
-read-pkg@^5.2.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-5.2.0.tgz#7bf295438ca5a33e56cd30e053b34ee7250c93cc"
-  integrity sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==
-  dependencies:
-    "@types/normalize-package-data" "^2.4.0"
-    normalize-package-data "^2.5.0"
-    parse-json "^5.0.0"
-    type-fest "^0.6.0"
-
-readdirp@~3.6.0:
-  version "3.6.0"
-  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz#74a370bd857116e245b29cc97340cd431a02a6c7"
-  integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==
-  dependencies:
-    picomatch "^2.2.1"
-
-redent@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/redent/-/redent-3.0.0.tgz#e557b7998316bb53c9f1f56fa626352c6963059f"
-  integrity sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==
-  dependencies:
-    indent-string "^4.0.0"
-    strip-indent "^3.0.0"
-
-regexp.prototype.flags@^1.4.3:
-  version "1.4.3"
-  resolved "https://registry.yarnpkg.com/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz#87cab30f80f66660181a3bb7bf5981a872b367ac"
-  integrity sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.3"
-    functions-have-names "^1.2.2"
-
-regexpp@^3.0.0, regexpp@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.2.0.tgz#0425a2768d8f23bad70ca4b90461fa2f1213e1b2"
-  integrity sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==
-
-release-zalgo@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/release-zalgo/-/release-zalgo-1.0.0.tgz#09700b7e5074329739330e535c5a90fb67851730"
-  integrity sha512-gUAyHVHPPC5wdqX/LG4LWtRYtgjxyX78oanFNTMMyFEfOqdC54s3eE82imuWKbOeqYht2CrNf64Qb8vgmmtZGA==
-  dependencies:
-    es6-error "^4.0.1"
-
-request-progress@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/request-progress/-/request-progress-3.0.0.tgz#4ca754081c7fec63f505e4faa825aa06cd669dbe"
-  integrity sha512-MnWzEHHaxHO2iWiQuHrUPBi/1WeBf5PkxQqNyNvLl9VAYSdXkP8tQ3pBSeCPD+yw0v0Aq1zosWLz0BdeXpWwZg==
-  dependencies:
-    throttleit "^1.0.0"
-
-require-directory@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
-  integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==
-
-require-from-string@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909"
-  integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==
-
-require-main-filename@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/require-main-filename/-/require-main-filename-2.0.0.tgz#d0b329ecc7cc0f61649f62215be69af54aa8989b"
-  integrity sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==
-
-requires-port@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/requires-port/-/requires-port-1.0.0.tgz#925d2601d39ac485e091cf0da5c6e694dc3dcaff"
-  integrity sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==
-
-resolve-from@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
-  integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
-
-resolve-from@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69"
-  integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==
-
-resolve@^1.10.0, resolve@^1.22.0, resolve@^1.22.1, resolve@^1.3.2:
-  version "1.22.1"
-  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.1.tgz#27cb2ebb53f91abb49470a928bba7558066ac177"
-  integrity sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw==
-  dependencies:
-    is-core-module "^2.9.0"
-    path-parse "^1.0.7"
-    supports-preserve-symlinks-flag "^1.0.0"
-
-restore-cursor@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-3.1.0.tgz#39f67c54b3a7a58cea5236d95cf0034239631f7e"
-  integrity sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==
-  dependencies:
-    onetime "^5.1.0"
-    signal-exit "^3.0.2"
-
-reusify@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76"
-  integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
-
-rfdc@^1.3.0:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/rfdc/-/rfdc-1.3.1.tgz#2b6d4df52dffe8bb346992a10ea9451f24373a8f"
-  integrity sha512-r5a3l5HzYlIC68TpmYKlxWjmOP6wiPJ1vWv2HeLhNsRZMrCkxeqxiHlQ21oXmQ4F3SiryXBHhAD7JZqvOJjFmg==
-
-rimraf@^3.0.0, rimraf@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
-  integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
-  dependencies:
-    glob "^7.1.3"
-
-rollup-plugin-license@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/rollup-plugin-license/-/rollup-plugin-license-3.0.1.tgz#e54d9464971dc2c5282b74c00cee09091b329054"
-  integrity sha512-/lec6Y94Y3wMfTDeYTO/jSXII0GQ/XkDZCiqkMKxyU5D5nGPaxr/2JNYvAgYsoCYuOLGOanKDPjCCQiTT96p7A==
-  dependencies:
-    commenting "~1.1.0"
-    glob "~7.2.0"
-    lodash "~4.17.21"
-    magic-string "~0.26.2"
-    mkdirp "~1.0.4"
-    moment "~2.29.3"
-    package-name-regex "~2.0.6"
-    spdx-expression-validate "~2.0.0"
-    spdx-satisfies "~5.0.1"
-
-rollup@^3.27.1:
-  version "3.29.4"
-  resolved "https://registry.yarnpkg.com/rollup/-/rollup-3.29.4.tgz#4d70c0f9834146df8705bfb69a9a19c9e1109981"
-  integrity sha512-oWzmBZwvYrU0iJHtDmhsm662rC15FRXmcjCk1xD771dFDx5jJ02ufAQQTn0etB2emNk4J9EZg/yWKpsn9BWGRw==
-  optionalDependencies:
-    fsevents "~2.3.2"
-
-run-parallel@^1.1.9:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee"
-  integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
-  dependencies:
-    queue-microtask "^1.2.2"
-
-rxjs@^7.5.1:
-  version "7.8.1"
-  resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-7.8.1.tgz#6f6f3d99ea8044291efd92e7c7fcf562c4057543"
-  integrity sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==
-  dependencies:
-    tslib "^2.1.0"
-
-safe-buffer@^5.0.1, safe-buffer@^5.1.2:
-  version "5.2.1"
-  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
-  integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
-
-safe-buffer@^5.1.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.0.tgz#b74daec49b1148f88c64b68d49b1e815c1f2f519"
-
-safe-json-stringify@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/safe-json-stringify/-/safe-json-stringify-1.2.0.tgz#356e44bc98f1f93ce45df14bcd7c01cda86e0afd"
-  integrity sha512-gH8eh2nZudPQO6TytOvbxnuhYBOvDBBLW52tz5q6X58lJcd/tkmqFR+5Z9adS8aJtURSXWThWy/xJtJwixErvg==
-
-safe-regex-test@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/safe-regex-test/-/safe-regex-test-1.0.0.tgz#793b874d524eb3640d1873aad03596db2d4f2295"
-  integrity sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==
-  dependencies:
-    call-bind "^1.0.2"
-    get-intrinsic "^1.1.3"
-    is-regex "^1.1.4"
-
-safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
-  integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
-
-"semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.6.0:
-  version "5.7.2"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.2.tgz#48d55db737c3287cd4835e17fa13feace1c41ef8"
-  integrity sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==
-
-semver@^6.0.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==
-
-semver@^7.0.0, semver@^7.3.4, semver@^7.3.5, semver@^7.3.7, semver@^7.3.8, semver@^7.5.3:
-  version "7.6.0"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.6.0.tgz#1a46a4db4bffcccd97b743b5005c8325f23d4e2d"
-  integrity sha512-EnwXhrlwXMk9gKu5/flx5sv/an57AkRplG3hTK68W7FRDN+k+OWBj65M7719OkA82XLBxrcX0KSHj+X5COhOVg==
-  dependencies:
-    lru-cache "^6.0.0"
-
-serialize-javascript@6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-6.0.0.tgz#efae5d88f45d7924141da8b5c3a7a7e663fefeb8"
-  integrity sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==
-  dependencies:
-    randombytes "^2.1.0"
-
-set-blocking@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7"
-  integrity sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==
-
-set-function-length@^1.2.1:
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/set-function-length/-/set-function-length-1.2.2.tgz#aac72314198eaed975cf77b2c3b6b880695e5449"
-  integrity sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==
-  dependencies:
-    define-data-property "^1.1.4"
-    es-errors "^1.3.0"
-    function-bind "^1.1.2"
-    get-intrinsic "^1.2.4"
-    gopd "^1.0.1"
-    has-property-descriptors "^1.0.2"
-
-shallow-clone@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/shallow-clone/-/shallow-clone-3.0.1.tgz#8f2981ad92531f55035b01fb230769a40e02efa3"
-  integrity sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==
-  dependencies:
-    kind-of "^6.0.2"
-
-shebang-command@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
-  integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
-  dependencies:
-    shebang-regex "^3.0.0"
-
-shebang-regex@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
-  integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
-
-side-channel@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/side-channel/-/side-channel-1.0.6.tgz#abd25fb7cd24baf45466406b1096b7831c9215f2"
-  integrity sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==
-  dependencies:
-    call-bind "^1.0.7"
-    es-errors "^1.3.0"
-    get-intrinsic "^1.2.4"
-    object-inspect "^1.13.1"
-
-signal-exit@^3.0.2, signal-exit@^3.0.7:
-  version "3.0.7"
-  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9"
-  integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==
-
-slash@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
-  integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
-
-slice-ansi@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-3.0.0.tgz#31ddc10930a1b7e0b67b08c96c2f49b77a789787"
-  integrity sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ==
-  dependencies:
-    ansi-styles "^4.0.0"
-    astral-regex "^2.0.0"
-    is-fullwidth-code-point "^3.0.0"
-
-slice-ansi@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-4.0.0.tgz#500e8dd0fd55b05815086255b3195adf2a45fe6b"
-  integrity sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==
-  dependencies:
-    ansi-styles "^4.0.0"
-    astral-regex "^2.0.0"
-    is-fullwidth-code-point "^3.0.0"
-
-source-map-js@^1.0.1, source-map-js@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/source-map-js/-/source-map-js-1.0.2.tgz#adbc361d9c62df380125e7f161f71c826f1e490c"
-  integrity sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==
-
-source-map-support@^0.5.16:
-  version "0.5.21"
-  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f"
-  integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==
-  dependencies:
-    buffer-from "^1.0.0"
-    source-map "^0.6.0"
-
-source-map@^0.6.0, source-map@^0.6.1:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
-  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
-
-sourcemap-codec@^1.4.8:
-  version "1.4.8"
-  resolved "https://registry.yarnpkg.com/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz#ea804bd94857402e6992d05a38ef1ae35a9ab4c4"
-  integrity sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==
-
-spawn-wrap@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/spawn-wrap/-/spawn-wrap-2.0.0.tgz#103685b8b8f9b79771318827aa78650a610d457e"
-  integrity sha512-EeajNjfN9zMnULLwhZZQU3GWBoFNkbngTUPfaawT4RkMiviTxcX0qfhVbGey39mfctfDHkWtuecgQ8NJcyQWHg==
-  dependencies:
-    foreground-child "^2.0.0"
-    is-windows "^1.0.2"
-    make-dir "^3.0.0"
-    rimraf "^3.0.0"
-    signal-exit "^3.0.2"
-    which "^2.0.1"
-
-spdx-compare@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/spdx-compare/-/spdx-compare-1.0.0.tgz#2c55f117362078d7409e6d7b08ce70a857cd3ed7"
-  integrity sha512-C1mDZOX0hnu0ep9dfmuoi03+eOdDoz2yvK79RxbcrVEG1NO1Ph35yW102DHWKN4pk80nwCgeMmSY5L25VE4D9A==
-  dependencies:
-    array-find-index "^1.0.2"
-    spdx-expression-parse "^3.0.0"
-    spdx-ranges "^2.0.0"
-
-spdx-correct@^3.0.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.2.0.tgz#4f5ab0668f0059e34f9c00dce331784a12de4e9c"
-  integrity sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==
-  dependencies:
-    spdx-expression-parse "^3.0.0"
-    spdx-license-ids "^3.0.0"
-
-spdx-exceptions@^2.1.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz#3f28ce1a77a00372683eade4a433183527a2163d"
-  integrity sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==
-
-spdx-expression-parse@^3.0.0, spdx-expression-parse@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz#cf70f50482eefdc98e3ce0a6833e4a53ceeba679"
-  integrity sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==
-  dependencies:
-    spdx-exceptions "^2.1.0"
-    spdx-license-ids "^3.0.0"
-
-spdx-expression-validate@~2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/spdx-expression-validate/-/spdx-expression-validate-2.0.0.tgz#25c9408e1c63fad94fff5517bb7101ffcd23350b"
-  integrity sha512-b3wydZLM+Tc6CFvaRDBOF9d76oGIHNCLYFeHbftFXUWjnfZWganmDmvtM5sm1cRwJc/VDBMLyGGrsLFd1vOxbg==
-  dependencies:
-    spdx-expression-parse "^3.0.0"
-
-spdx-license-ids@^3.0.0:
-  version "3.0.12"
-  resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.12.tgz#69077835abe2710b65f03969898b6637b505a779"
-  integrity sha512-rr+VVSXtRhO4OHbXUiAF7xW3Bo9DuuF6C5jH+q/x15j2jniycgKbxU09Hr0WqlSLUs4i4ltHGXqTe7VHclYWyA==
-
-spdx-ranges@^2.0.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/spdx-ranges/-/spdx-ranges-2.1.1.tgz#87573927ba51e92b3f4550ab60bfc83dd07bac20"
-  integrity sha512-mcdpQFV7UDAgLpXEE/jOMqvK4LBoO0uTQg0uvXUewmEFhpiZx5yJSZITHB8w1ZahKdhfZqP5GPEOKLyEq5p8XA==
-
-spdx-satisfies@~5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/spdx-satisfies/-/spdx-satisfies-5.0.1.tgz#9feeb2524686c08e5f7933c16248d4fdf07ed6a6"
-  integrity sha512-Nwor6W6gzFp8XX4neaKQ7ChV4wmpSh2sSDemMFSzHxpTw460jxFYeOn+jq4ybnSSw/5sc3pjka9MQPouksQNpw==
-  dependencies:
-    spdx-compare "^1.0.0"
-    spdx-expression-parse "^3.0.0"
-    spdx-ranges "^2.0.0"
-
-sprintf-js@~1.0.2:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
-  integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==
-
-sshpk@^1.14.1:
-  version "1.18.0"
-  resolved "https://registry.yarnpkg.com/sshpk/-/sshpk-1.18.0.tgz#1663e55cddf4d688b86a46b77f0d5fe363aba028"
-  integrity sha512-2p2KJZTSqQ/I3+HX42EpYOa2l3f8Erv8MWKsy2I9uf4wA7yFIkXRffYdsx86y6z4vHtV8u7g+pPlr8/4ouAxsQ==
-  dependencies:
-    asn1 "~0.2.3"
-    assert-plus "^1.0.0"
-    bcrypt-pbkdf "^1.0.0"
-    dashdash "^1.12.0"
-    ecc-jsbn "~0.1.1"
-    getpass "^0.1.1"
-    jsbn "~0.1.0"
-    safer-buffer "^2.0.2"
-    tweetnacl "~0.14.0"
-
-string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3:
-  version "4.2.3"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
-  integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
-  dependencies:
-    emoji-regex "^8.0.0"
-    is-fullwidth-code-point "^3.0.0"
-    strip-ansi "^6.0.1"
-
-string.prototype.trimend@^1.0.6:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz#c4a27fa026d979d79c04f17397f250a462944533"
-  integrity sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.4"
-    es-abstract "^1.20.4"
-
-string.prototype.trimstart@^1.0.6:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz#e90ab66aa8e4007d92ef591bbf3cd422c56bdcf4"
-  integrity sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.4"
-    es-abstract "^1.20.4"
-
-strip-ansi@^6.0.0, strip-ansi@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
-  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
-  dependencies:
-    ansi-regex "^5.0.1"
-
-strip-bom@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3"
-  integrity sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==
-
-strip-bom@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-4.0.0.tgz#9c3505c1db45bcedca3d9cf7a16f5c5aa3901878"
-  integrity sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==
-
-strip-final-newline@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad"
-  integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==
-
-strip-indent@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-3.0.0.tgz#c32e1cee940b6b3432c771bc2c54bcce73cd3001"
-  integrity sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==
-  dependencies:
-    min-indent "^1.0.0"
-
-strip-json-comments@3.1.1, strip-json-comments@^3.1.0, strip-json-comments@^3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"
-  integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
-
-style-search@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/style-search/-/style-search-0.1.0.tgz#7958c793e47e32e07d2b5cafe5c0bf8e12e77902"
-  integrity sha512-Dj1Okke1C3uKKwQcetra4jSuk0DqbzbYtXipzFlFMZtowbF1x7BKJwB9AayVMyFARvU8EDrZdcax4At/452cAg==
-
-stylelint@^15.4.0:
-  version "15.4.0"
-  resolved "https://registry.yarnpkg.com/stylelint/-/stylelint-15.4.0.tgz#3958fff41fbcd68cf947fdecb329762d45f87013"
-  integrity sha512-TlOvpG3MbcFwHmK0q2ykhmpKo7Dq892beJit0NPdpyY9b1tFah/hGhqnAz/bRm2PDhDbJLKvjzkEYYBEz7Dxcg==
-  dependencies:
-    "@csstools/css-parser-algorithms" "^2.1.0"
-    "@csstools/css-tokenizer" "^2.1.0"
-    "@csstools/media-query-list-parser" "^2.0.1"
-    "@csstools/selector-specificity" "^2.2.0"
-    balanced-match "^2.0.0"
-    colord "^2.9.3"
-    cosmiconfig "^8.1.3"
-    css-functions-list "^3.1.0"
-    css-tree "^2.3.1"
-    debug "^4.3.4"
-    fast-glob "^3.2.12"
-    fastest-levenshtein "^1.0.16"
-    file-entry-cache "^6.0.1"
-    global-modules "^2.0.0"
-    globby "^11.1.0"
-    globjoin "^0.1.4"
-    html-tags "^3.2.0"
-    ignore "^5.2.4"
-    import-lazy "^4.0.0"
-    imurmurhash "^0.1.4"
-    is-plain-object "^5.0.0"
-    known-css-properties "^0.27.0"
-    mathml-tag-names "^2.1.3"
-    meow "^9.0.0"
-    micromatch "^4.0.5"
-    normalize-path "^3.0.0"
-    picocolors "^1.0.0"
-    postcss "^8.4.21"
-    postcss-media-query-parser "^0.2.3"
-    postcss-resolve-nested-selector "^0.1.1"
-    postcss-safe-parser "^6.0.0"
-    postcss-selector-parser "^6.0.11"
-    postcss-value-parser "^4.2.0"
-    resolve-from "^5.0.0"
-    string-width "^4.2.3"
-    strip-ansi "^6.0.1"
-    style-search "^0.1.0"
-    supports-hyperlinks "^3.0.0"
-    svg-tags "^1.0.0"
-    table "^6.8.1"
-    v8-compile-cache "^2.3.0"
-    write-file-atomic "^5.0.0"
-
-supports-color@8.1.1, supports-color@^8.1.1:
-  version "8.1.1"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-8.1.1.tgz#cd6fc17e28500cff56c1b86c0a7fd4a54a73005c"
-  integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==
-  dependencies:
-    has-flag "^4.0.0"
-
-supports-color@^5.3.0:
-  version "5.5.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
-  integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==
-  dependencies:
-    has-flag "^3.0.0"
-
-supports-color@^7.0.0, supports-color@^7.1.0:
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da"
-  integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
-  dependencies:
-    has-flag "^4.0.0"
-
-supports-hyperlinks@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/supports-hyperlinks/-/supports-hyperlinks-3.0.0.tgz#c711352a5c89070779b4dad54c05a2f14b15c94b"
-  integrity sha512-QBDPHyPQDRTy9ku4URNGY5Lah8PAaXs6tAAwp55sL5WCsSW7GIfdf6W5ixfziW+t7wh3GVvHyHHyQ1ESsoRvaA==
-  dependencies:
-    has-flag "^4.0.0"
-    supports-color "^7.0.0"
-
-supports-preserve-symlinks-flag@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09"
-  integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
-
-svg-tags@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/svg-tags/-/svg-tags-1.0.0.tgz#58f71cee3bd519b59d4b2a843b6c7de64ac04764"
-  integrity sha512-ovssysQTa+luh7A5Weu3Rta6FJlFBBbInjOh722LIt6klpU2/HtdUbszju/G4devcvk8PGt7FCLv5wftu3THUA==
-
-table@^6.8.1:
-  version "6.8.1"
-  resolved "https://registry.yarnpkg.com/table/-/table-6.8.1.tgz#ea2b71359fe03b017a5fbc296204471158080bdf"
-  integrity sha512-Y4X9zqrCftUhMeH2EptSSERdVKt/nEdijTOacGD/97EKjhQ/Qs8RTlEGABSJNNN8lac9kheH+af7yAkEWlgneA==
-  dependencies:
-    ajv "^8.0.1"
-    lodash.truncate "^4.4.2"
-    slice-ansi "^4.0.0"
-    string-width "^4.2.3"
-    strip-ansi "^6.0.1"
-
-test-exclude@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/test-exclude/-/test-exclude-6.0.0.tgz#04a8698661d805ea6fa293b6cb9e63ac044ef15e"
-  integrity sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==
-  dependencies:
-    "@istanbuljs/schema" "^0.1.2"
-    glob "^7.1.4"
-    minimatch "^3.0.4"
-
-text-table@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
-  integrity sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==
-
-throttleit@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/throttleit/-/throttleit-1.0.1.tgz#304ec51631c3b770c65c6c6f76938b384000f4d5"
-  integrity sha512-vDZpf9Chs9mAdfY046mcPt8fg5QSZr37hEH4TXYBnDF+izxgrbRGUAAaBvIk/fJm9aOFCGFd1EsNg5AZCbnQCQ==
-
-through@^2.3.8:
-  version "2.3.8"
-  resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
-  integrity sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==
-
-tmp@~0.2.3:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.2.3.tgz#eb783cc22bc1e8bebd0671476d46ea4eb32a79ae"
-  integrity sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w==
-
-to-fast-properties@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e"
-  integrity sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==
-
-to-regex-range@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
-  integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
-  dependencies:
-    is-number "^7.0.0"
-
-tough-cookie@^4.1.3:
-  version "4.1.3"
-  resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-4.1.3.tgz#97b9adb0728b42280aa3d814b6b999b2ff0318bf"
-  integrity sha512-aX/y5pVRkfRnfmuX+OdbSdXvPe6ieKX/G2s7e98f4poJHnqH3281gDPm/metm6E/WRamfx7WC4HUqkWHfQHprw==
-  dependencies:
-    psl "^1.1.33"
-    punycode "^2.1.1"
-    universalify "^0.2.0"
-    url-parse "^1.5.3"
-
-trim-newlines@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-3.0.1.tgz#260a5d962d8b752425b32f3a7db0dcacd176c144"
-  integrity sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==
-
-tsconfig-paths@^3.14.1:
-  version "3.14.2"
-  resolved "https://registry.yarnpkg.com/tsconfig-paths/-/tsconfig-paths-3.14.2.tgz#6e32f1f79412decd261f92d633a9dc1cfa99f088"
-  integrity sha512-o/9iXgCYc5L/JxCHPe3Hvh8Q/2xm5Z+p18PESBU6Ff33695QnCHBEjcytY2q19ua7Mbl/DavtBOLq+oG0RCL+g==
-  dependencies:
-    "@types/json5" "^0.0.29"
-    json5 "^1.0.2"
-    minimist "^1.2.6"
-    strip-bom "^3.0.0"
-
-tslib@^1.13.0:
-  version "1.14.1"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"
-
-tslib@^1.8.1:
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.11.1.tgz#eb15d128827fbee2841549e171f45ed338ac7e35"
-
-tslib@^2.1.0:
-  version "2.6.2"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.6.2.tgz#703ac29425e7b37cd6fd456e92404d46d1f3e4ae"
-  integrity sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==
-
-tslint@^6.1.1:
-  version "6.1.3"
-  resolved "https://registry.yarnpkg.com/tslint/-/tslint-6.1.3.tgz#5c23b2eccc32487d5523bd3a470e9aa31789d904"
-  integrity sha512-IbR4nkT96EQOvKE2PW/djGz8iGNeJ4rF2mBfiYaR/nvUWYKJhLwimoJKgjIFEIDibBtOevj7BqCRL4oHeWWUCg==
-  dependencies:
-    "@babel/code-frame" "^7.0.0"
-    builtin-modules "^1.1.1"
-    chalk "^2.3.0"
-    commander "^2.12.1"
-    diff "^4.0.1"
-    glob "^7.1.1"
-    js-yaml "^3.13.1"
-    minimatch "^3.0.4"
-    mkdirp "^0.5.3"
-    resolve "^1.3.2"
-    semver "^5.3.0"
-    tslib "^1.13.0"
-    tsutils "^2.29.0"
-
-tsutils@^2.29.0:
-  version "2.29.0"
-  resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-2.29.0.tgz#32b488501467acbedd4b85498673a0812aca0b99"
-  integrity sha512-g5JVHCIJwzfISaXpXE1qvNalca5Jwob6FjI4AoPlqMusJ6ftFE7IkkFoMhVLRgK+4Kx3gkzb8UZK5t5yTTvEmA==
-  dependencies:
-    tslib "^1.8.1"
-
-tsutils@^3.21.0:
-  version "3.21.0"
-  resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-3.21.0.tgz#b48717d394cea6c1e096983eed58e9d61715b623"
-  integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==
-  dependencies:
-    tslib "^1.8.1"
-
-tunnel-agent@^0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd"
-  integrity sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==
-  dependencies:
-    safe-buffer "^5.0.1"
-
-tv4@^1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/tv4/-/tv4-1.3.0.tgz#d020c846fadd50c855abb25ebaecc68fc10f7963"
-  integrity sha512-afizzfpJgvPr+eDkREK4MxJ/+r8nEEHcmitwgnPUqpaP+FpwQyadnxNoSACbgc/b1LsZYtODGoPiFxQrgJgjvw==
-
-tweetnacl@^0.14.3, tweetnacl@~0.14.0:
-  version "0.14.5"
-  resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64"
-  integrity sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==
-
-type-check@^0.4.0, type-check@~0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.4.0.tgz#07b8203bfa7056c0657050e3ccd2c37730bab8f1"
-  integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==
-  dependencies:
-    prelude-ls "^1.2.1"
-
-type-fest@^0.18.0:
-  version "0.18.1"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.18.1.tgz#db4bc151a4a2cf4eebf9add5db75508db6cc841f"
-  integrity sha512-OIAYXk8+ISY+qTOwkHtKqzAuxchoMiD9Udx+FSGQDuiRR+PJKJHc2NJAXlbhkGwTt/4/nKZxELY1w3ReWOL8mw==
-
-type-fest@^0.20.2:
-  version "0.20.2"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4"
-  integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==
-
-type-fest@^0.21.3:
-  version "0.21.3"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.21.3.tgz#d260a24b0198436e133fa26a524a6d65fa3b2e37"
-  integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==
-
-type-fest@^0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.6.0.tgz#8d2a2370d3df886eb5c90ada1c5bf6188acf838b"
-  integrity sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==
-
-type-fest@^0.8.0, type-fest@^0.8.1:
-  version "0.8.1"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.8.1.tgz#09e249ebde851d3b1e48d27c105444667f17b83d"
-  integrity sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==
-
-typed-array-length@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/typed-array-length/-/typed-array-length-1.0.4.tgz#89d83785e5c4098bec72e08b319651f0eac9c1bb"
-  integrity sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==
-  dependencies:
-    call-bind "^1.0.2"
-    for-each "^0.3.3"
-    is-typed-array "^1.1.9"
-
-typedarray-to-buffer@^3.1.5:
-  version "3.1.5"
-  resolved "https://registry.yarnpkg.com/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz#a97ee7a9ff42691b9f783ff1bc5112fe3fca9080"
-  integrity sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==
-  dependencies:
-    is-typedarray "^1.0.0"
-
-typescript@5.0.3:
-  version "5.0.3"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.0.3.tgz#fe976f0c826a88d0a382007681cbb2da44afdedf"
-  integrity sha512-xv8mOEDnigb/tN9PSMTwSEqAnUvkoXMQlicOb0IUVDBSQCgBSaAAROUZYy2IcUy5qU6XajK5jjjO7TMWqBTKZA==
-
-unbox-primitive@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/unbox-primitive/-/unbox-primitive-1.0.2.tgz#29032021057d5e6cdbd08c5129c226dff8ed6f9e"
-  integrity sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==
-  dependencies:
-    call-bind "^1.0.2"
-    has-bigints "^1.0.2"
-    has-symbols "^1.0.3"
-    which-boxed-primitive "^1.0.2"
-
-undici-types@~5.26.4:
-  version "5.26.5"
-  resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-5.26.5.tgz#bcd539893d00b56e964fd2657a4866b221a65617"
-  integrity sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==
-
-uniq@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/uniq/-/uniq-1.0.1.tgz#b31c5ae8254844a3a8281541ce2b04b865a734ff"
-  integrity sha512-Gw+zz50YNKPDKXs+9d+aKAjVwpjNwqzvNpLigIruT4HA9lMZNdMqs9x07kKHB/L9WRzqp4+DlTU5s4wG2esdoA==
-
-universalify@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.2.0.tgz#6451760566fa857534745ab1dde952d1b1761be0"
-  integrity sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg==
-
-universalify@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/universalify/-/universalify-2.0.1.tgz#168efc2180964e6386d061e094df61afe239b18d"
-  integrity sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==
-
-untildify@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/untildify/-/untildify-4.0.0.tgz#2bc947b953652487e4600949fb091e3ae8cd919b"
-  integrity sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==
-
-update-browserslist-db@^1.0.10:
-  version "1.0.10"
-  resolved "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz#0f54b876545726f17d00cd9a2561e6dade943ff3"
-  integrity sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ==
-  dependencies:
-    escalade "^3.1.1"
-    picocolors "^1.0.0"
-
-uri-js@^4.2.2:
-  version "4.4.1"
-  resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e"
-  integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
-  dependencies:
-    punycode "^2.1.0"
-
-url-parse@^1.5.3:
-  version "1.5.10"
-  resolved "https://registry.yarnpkg.com/url-parse/-/url-parse-1.5.10.tgz#9d3c2f736c1d75dd3bd2be507dcc111f1e2ea9c1"
-  integrity sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==
-  dependencies:
-    querystringify "^2.1.1"
-    requires-port "^1.0.0"
-
-util-deprecate@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
-  integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==
-
-uuid@^8.3.2:
-  version "8.3.2"
-  resolved "https://registry.yarnpkg.com/uuid/-/uuid-8.3.2.tgz#80d5b5ced271bb9af6c445f21a1a04c606cefbe2"
-  integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==
-
-v8-compile-cache@^2.3.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz#2de19618c66dc247dcfb6f99338035d8245a2cee"
-  integrity sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==
-
-validate-npm-package-license@^3.0.1:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz#fc91f6b9c7ba15c857f4cb2c5defeec39d4f410a"
-  integrity sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==
-  dependencies:
-    spdx-correct "^3.0.0"
-    spdx-expression-parse "^3.0.0"
-
-verror@1.10.0:
-  version "1.10.0"
-  resolved "https://registry.yarnpkg.com/verror/-/verror-1.10.0.tgz#3a105ca17053af55d6e270c1f8288682e18da400"
-  integrity sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==
-  dependencies:
-    assert-plus "^1.0.0"
-    core-util-is "1.0.2"
-    extsprintf "^1.2.0"
-
-vite-plugin-css-injected-by-js@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/vite-plugin-css-injected-by-js/-/vite-plugin-css-injected-by-js-3.1.0.tgz#d1160c975d40f256692e2465832e6ff18c22b3a3"
-  integrity sha512-qogCmpocZfcbSAYZQjS88ieIY0PzLUm7RkLFWFgAxkXdz3N6roZbSTNTxeIOj5IxFbZWACUPuVBBoo6qCuXDcw==
-
-vite@^4.2.1:
-  version "4.5.2"
-  resolved "https://registry.yarnpkg.com/vite/-/vite-4.5.2.tgz#d6ea8610e099851dad8c7371599969e0f8b97e82"
-  integrity sha512-tBCZBNSBbHQkaGyhGCDUGqeo2ph8Fstyp6FMSvTtsXeZSPpSMGlviAOav2hxVTqFcx8Hj/twtWKsMJXNY0xI8w==
-  dependencies:
-    esbuild "^0.18.10"
-    postcss "^8.4.27"
-    rollup "^3.27.1"
-  optionalDependencies:
-    fsevents "~2.3.2"
-
-webpack-virtual-modules@^0.4.4:
-  version "0.4.6"
-  resolved "https://registry.yarnpkg.com/webpack-virtual-modules/-/webpack-virtual-modules-0.4.6.tgz#3e4008230731f1db078d9cb6f68baf8571182b45"
-  integrity sha512-5tyDlKLqPfMqjT3Q9TAqf2YqjwmnUleZwzJi1A5qXnlBCdj2AtOJ6wAWdglTIDOPgOiOrXeBeFcsQ8+aGQ6QbA==
-
-which-boxed-primitive@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz#13757bc89b209b049fe5d86430e21cf40a89a8e6"
-  integrity sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==
-  dependencies:
-    is-bigint "^1.0.1"
-    is-boolean-object "^1.1.0"
-    is-number-object "^1.0.4"
-    is-string "^1.0.5"
-    is-symbol "^1.0.3"
-
-which-module@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/which-module/-/which-module-2.0.0.tgz#d9ef07dce77b9902b8a3a8fa4b31c3e3f7e6e87a"
-  integrity sha512-B+enWhmw6cjfVC7kS8Pj9pCrKSc5txArRyaYGe088shv/FGWH+0Rjx/xPgtsWfsUtS27FkP697E4DDhgrgoc0Q==
-
-which-typed-array@^1.1.9:
-  version "1.1.9"
-  resolved "https://registry.yarnpkg.com/which-typed-array/-/which-typed-array-1.1.9.tgz#307cf898025848cf995e795e8423c7f337efbde6"
-  integrity sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==
-  dependencies:
-    available-typed-arrays "^1.0.5"
-    call-bind "^1.0.2"
-    for-each "^0.3.3"
-    gopd "^1.0.1"
-    has-tostringtag "^1.0.0"
-    is-typed-array "^1.1.10"
-
-which@^1.3.1:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
-  integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
-  dependencies:
-    isexe "^2.0.0"
-
-which@^2.0.1:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
-  integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
-  dependencies:
-    isexe "^2.0.0"
-
-word-wrap@^1.2.3:
-  version "1.2.5"
-  resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.5.tgz#d2c45c6dd4fbce621a66f136cbe328afd0410b34"
-  integrity sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==
-
-workerpool@6.2.1:
-  version "6.2.1"
-  resolved "https://registry.yarnpkg.com/workerpool/-/workerpool-6.2.1.tgz#46fc150c17d826b86a008e5a4508656777e9c343"
-  integrity sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==
-
-wrap-ansi@^6.2.0:
-  version "6.2.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53"
-  integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==
-  dependencies:
-    ansi-styles "^4.0.0"
-    string-width "^4.1.0"
-    strip-ansi "^6.0.0"
-
-wrap-ansi@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
-  integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
-  dependencies:
-    ansi-styles "^4.0.0"
-    string-width "^4.1.0"
-    strip-ansi "^6.0.0"
-
-wrappy@1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
-  integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
-
-write-file-atomic@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-3.0.3.tgz#56bd5c5a5c70481cd19c571bd39ab965a5de56e8"
-  integrity sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==
-  dependencies:
-    imurmurhash "^0.1.4"
-    is-typedarray "^1.0.0"
-    signal-exit "^3.0.2"
-    typedarray-to-buffer "^3.1.5"
-
-write-file-atomic@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-5.0.0.tgz#54303f117e109bf3d540261125c8ea5a7320fab0"
-  integrity sha512-R7NYMnHSlV42K54lwY9lvW6MnSm1HSJqZL3xiSgi9E7//FYaI74r2G0rd+/X6VAMkHEdzxQaU5HUOXWUz5kA/w==
-  dependencies:
-    imurmurhash "^0.1.4"
-    signal-exit "^3.0.7"
-
-y18n@^4.0.0:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/y18n/-/y18n-4.0.3.tgz#b5f259c82cd6e336921efd7bfd8bf560de9eeedf"
-  integrity sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==
-
-y18n@^5.0.5:
-  version "5.0.8"
-  resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55"
-  integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==
-
-yallist@^3.0.2:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd"
-  integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==
-
-yallist@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
-  integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
-
-yargs-parser@20.2.4:
-  version "20.2.4"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.4.tgz#b42890f14566796f85ae8e3a25290d205f154a54"
-  integrity sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==
-
-yargs-parser@^18.1.2:
-  version "18.1.3"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-18.1.3.tgz#be68c4975c6b2abf469236b0c870362fab09a7b0"
-  integrity sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==
-  dependencies:
-    camelcase "^5.0.0"
-    decamelize "^1.2.0"
-
-yargs-parser@^20.2.2, yargs-parser@^20.2.3:
-  version "20.2.9"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.9.tgz#2eb7dc3b0289718fc295f362753845c41a0c94ee"
-  integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==
-
-yargs-unparser@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/yargs-unparser/-/yargs-unparser-2.0.0.tgz#f131f9226911ae5d9ad38c432fe809366c2325eb"
-  integrity sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==
-  dependencies:
-    camelcase "^6.0.0"
-    decamelize "^4.0.0"
-    flat "^5.0.2"
-    is-plain-obj "^2.1.0"
-
-yargs@16.2.0:
-  version "16.2.0"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-16.2.0.tgz#1c82bf0f6b6a66eafce7ef30e376f49a12477f66"
-  integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==
-  dependencies:
-    cliui "^7.0.2"
-    escalade "^3.1.1"
-    get-caller-file "^2.0.5"
-    require-directory "^2.1.1"
-    string-width "^4.2.0"
-    y18n "^5.0.5"
-    yargs-parser "^20.2.2"
-
-yargs@^15.0.2:
-  version "15.4.1"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-15.4.1.tgz#0d87a16de01aee9d8bec2bfbf74f67851730f4f8"
-  integrity sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==
-  dependencies:
-    cliui "^6.0.0"
-    decamelize "^1.2.0"
-    find-up "^4.1.0"
-    get-caller-file "^2.0.1"
-    require-directory "^2.1.1"
-    require-main-filename "^2.0.0"
-    set-blocking "^2.0.0"
-    string-width "^4.2.0"
-    which-module "^2.0.0"
-    y18n "^4.0.0"
-    yargs-parser "^18.1.2"
-
-yauzl@^2.10.0:
-  version "2.10.0"
-  resolved "https://registry.yarnpkg.com/yauzl/-/yauzl-2.10.0.tgz#c7eb17c93e112cb1086fa6d8e51fb0667b79a5f9"
-  integrity sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==
-  dependencies:
-    buffer-crc32 "~0.2.3"
-    fd-slicer "~1.1.0"
-
-yocto-queue@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"
-  integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
+# This file is generated by running "yarn install" inside your project.
+# Manual changes might be lost - proceed with caution!
+
+__metadata:
+  version: 8
+  cacheKey: 10c0
+
+"@asamuzakjp/css-color@npm:^3.2.0":
+  version: 3.2.0
+  resolution: "@asamuzakjp/css-color@npm:3.2.0"
+  dependencies:
+    "@csstools/css-calc": "npm:^2.1.3"
+    "@csstools/css-color-parser": "npm:^3.0.9"
+    "@csstools/css-parser-algorithms": "npm:^3.0.4"
+    "@csstools/css-tokenizer": "npm:^3.0.3"
+    lru-cache: "npm:^10.4.3"
+  checksum: 10c0/a4bf1c831751b1fae46b437e37e8a38c0b5bd58d23230157ae210bd1e905fe509b89b7c243e63d1522d852668a6292ed730a160e21342772b4e5b7b8ea14c092
+  languageName: node
+  linkType: hard
+
+"@asamuzakjp/dom-selector@npm:^2.0.1":
+  version: 2.0.2
+  resolution: "@asamuzakjp/dom-selector@npm:2.0.2"
+  dependencies:
+    bidi-js: "npm:^1.0.3"
+    css-tree: "npm:^2.3.1"
+    is-potential-custom-element-name: "npm:^1.0.1"
+  checksum: 10c0/54d9afa3d654a98fcf2e45c53ea330237e513877f130f8c8c17611c603c8d50cb18f937e1b0bcc08f0030443a9c8479dcad9cebff02766025e2df2754459c647
+  languageName: node
+  linkType: hard
+
+"@axe-core/playwright@npm:^4.11.0":
+  version: 4.11.0
+  resolution: "@axe-core/playwright@npm:4.11.0"
+  dependencies:
+    axe-core: "npm:~4.11.0"
+  peerDependencies:
+    playwright-core: ">= 1.0.0"
+  checksum: 10c0/73f93cbe510b2399986aa14e4b07bff79fb757b7205240a6ed59b39f3c252014beeb6e6ce0850c1d392fe1f3f3f04c4e5ff860cbcdeaaf7b6dc1598c3209e539
+  languageName: node
+  linkType: hard
+
+"@babel/code-frame@npm:^7.0.0":
+  version: 7.27.1
+  resolution: "@babel/code-frame@npm:7.27.1"
+  dependencies:
+    "@babel/helper-validator-identifier": "npm:^7.27.1"
+    js-tokens: "npm:^4.0.0"
+    picocolors: "npm:^1.1.1"
+  checksum: 10c0/5dd9a18baa5fce4741ba729acc3a3272c49c25cb8736c4b18e113099520e7ef7b545a4096a26d600e4416157e63e87d66db46aa3fbf0a5f2286da2705c12da00
+  languageName: node
+  linkType: hard
+
+"@babel/helper-string-parser@npm:^7.27.1":
+  version: 7.27.1
+  resolution: "@babel/helper-string-parser@npm:7.27.1"
+  checksum: 10c0/8bda3448e07b5583727c103560bcf9c4c24b3c1051a4c516d4050ef69df37bb9a4734a585fe12725b8c2763de0a265aa1e909b485a4e3270b7cfd3e4dbe4b602
+  languageName: node
+  linkType: hard
+
+"@babel/helper-validator-identifier@npm:^7.27.1, @babel/helper-validator-identifier@npm:^7.28.5":
+  version: 7.28.5
+  resolution: "@babel/helper-validator-identifier@npm:7.28.5"
+  checksum: 10c0/42aaebed91f739a41f3d80b72752d1f95fd7c72394e8e4bd7cdd88817e0774d80a432451bcba17c2c642c257c483bf1d409dd4548883429ea9493a3bc4ab0847
+  languageName: node
+  linkType: hard
+
+"@babel/parser@npm:^7.6.0, @babel/parser@npm:^7.9.6":
+  version: 7.28.5
+  resolution: "@babel/parser@npm:7.28.5"
+  dependencies:
+    "@babel/types": "npm:^7.28.5"
+  bin:
+    parser: ./bin/babel-parser.js
+  checksum: 10c0/5bbe48bf2c79594ac02b490a41ffde7ef5aa22a9a88ad6bcc78432a6ba8a9d638d531d868bd1f104633f1f6bba9905746e15185b8276a3756c42b765d131b1ef
+  languageName: node
+  linkType: hard
+
+"@babel/register@npm:^7.21.0":
+  version: 7.28.3
+  resolution: "@babel/register@npm:7.28.3"
+  dependencies:
+    clone-deep: "npm:^4.0.1"
+    find-cache-dir: "npm:^2.0.0"
+    make-dir: "npm:^2.1.0"
+    pirates: "npm:^4.0.6"
+    source-map-support: "npm:^0.5.16"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 10c0/ff31870a24e862fca36d5c481eda40be610af215a922560834333a78000b0e159a209dae606d4d93d7456d35ea8caeaaea674cdeaa0c0362e7e30d7f095d2436
+  languageName: node
+  linkType: hard
+
+"@babel/types@npm:^7.28.5, @babel/types@npm:^7.6.1, @babel/types@npm:^7.9.6":
+  version: 7.28.5
+  resolution: "@babel/types@npm:7.28.5"
+  dependencies:
+    "@babel/helper-string-parser": "npm:^7.27.1"
+    "@babel/helper-validator-identifier": "npm:^7.28.5"
+  checksum: 10c0/a5a483d2100befbf125793640dec26b90b95fd233a94c19573325898a5ce1e52cdfa96e495c7dcc31b5eca5b66ce3e6d4a0f5a4a62daec271455959f208ab08a
+  languageName: node
+  linkType: hard
+
+"@codexteam/icons@npm:0.3.2":
+  version: 0.3.2
+  resolution: "@codexteam/icons@npm:0.3.2"
+  checksum: 10c0/10eee48300a9272a8f2b451e057e1b56edaddb55594bbb0612849003a63dc2ef74c0f990ed20c3debe9b6f6eb44874c22f498ab08965f69b7d286b65103afdf2
+  languageName: node
+  linkType: hard
+
+"@codexteam/icons@npm:^0.0.4":
+  version: 0.0.4
+  resolution: "@codexteam/icons@npm:0.0.4"
+  checksum: 10c0/8509a2f8f8d889ce1016bfc7ed0452a931bb75838e267c2118aec594497d472de65c90cdee203fd2d99b1bc8367f760f093ba4d83cb2e5b5c787f00186627acb
+  languageName: node
+  linkType: hard
+
+"@codexteam/icons@npm:^0.0.5":
+  version: 0.0.5
+  resolution: "@codexteam/icons@npm:0.0.5"
+  checksum: 10c0/5f73f137a65a17959d758a80a3b3846801475a9555791a13561b4a2fcb57664bb7a667b6c27ea1da6f9d462b5b0657b2c35164928ad6c0a10b7e4737ddd79104
+  languageName: node
+  linkType: hard
+
+"@codexteam/icons@npm:^0.0.6":
+  version: 0.0.6
+  resolution: "@codexteam/icons@npm:0.0.6"
+  checksum: 10c0/b29d2f4b931f763999354781199ab60ada31bc1b8c419df916d4e5857a68c73e5b8615a1c5b72434367e23f95c75e62c1053090f6b34d52d66add9d686a950cb
+  languageName: node
+  linkType: hard
+
+"@codexteam/icons@npm:^0.3.2":
+  version: 0.3.3
+  resolution: "@codexteam/icons@npm:0.3.3"
+  checksum: 10c0/336245f38a2b2a53626a552a5f0f32c822ee1265be6827670ba157c9fa101cb23e6c75e625aa067e4577c2d805e261f4ffcb61097ea94c034c0a3c0cae7d7271
+  languageName: node
+  linkType: hard
+
+"@codexteam/shortcuts@npm:^1.1.1":
+  version: 1.2.0
+  resolution: "@codexteam/shortcuts@npm:1.2.0"
+  checksum: 10c0/0afb0ca49e04a89b2ad9e86a20fd8ffbb2f08a2a3f2f3a93b82afbe2875bfadaa591d95bd334d2231d3ac979f430d70c0f21cafd9937d014710d81a308fc8585
+  languageName: node
+  linkType: hard
+
+"@colors/colors@npm:1.5.0":
+  version: 1.5.0
+  resolution: "@colors/colors@npm:1.5.0"
+  checksum: 10c0/eb42729851adca56d19a08e48d5a1e95efd2a32c55ae0323de8119052be0510d4b7a1611f2abcbf28c044a6c11e6b7d38f99fccdad7429300c37a8ea5fb95b44
+  languageName: node
+  linkType: hard
+
+"@csstools/cascade-layer-name-parser@npm:^1.0.13, @csstools/cascade-layer-name-parser@npm:^1.0.2":
+  version: 1.0.13
+  resolution: "@csstools/cascade-layer-name-parser@npm:1.0.13"
+  peerDependencies:
+    "@csstools/css-parser-algorithms": ^2.7.1
+    "@csstools/css-tokenizer": ^2.4.1
+  checksum: 10c0/a6412fc8601af1baadc8195934aa668d3476e799891c9d0883390f31ec8678e9b565ac14d919bec633bbc086657ac12aa4cd852c718851a2d34517ee6856ff8e
+  languageName: node
+  linkType: hard
+
+"@csstools/color-helpers@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "@csstools/color-helpers@npm:2.1.0"
+  checksum: 10c0/376fa79e00642129ce6b4083f5fec1d85bb5fd373963e5a5f8c26103fbd3a2fb3ae104f8294b800dcb5df2429e53a311d83fcc7cbe1600f6c866887873c84f5e
+  languageName: node
+  linkType: hard
+
+"@csstools/color-helpers@npm:^4.1.0":
+  version: 4.2.1
+  resolution: "@csstools/color-helpers@npm:4.2.1"
+  checksum: 10c0/72e11b186ad0f6019a9b4b3752e620fa798c2a40cf47e8cad565dff46e572c9342eb8cf804542d7886344a1e540555d77f20119ace6b2d8a45b6e5ef8a41685c
+  languageName: node
+  linkType: hard
+
+"@csstools/color-helpers@npm:^5.1.0":
+  version: 5.1.0
+  resolution: "@csstools/color-helpers@npm:5.1.0"
+  checksum: 10c0/b7f99d2e455cf1c9b41a67a5327d5d02888cd5c8802a68b1887dffef537d9d4bc66b3c10c1e62b40bbed638b6c1d60b85a232f904ed7b39809c4029cb36567db
+  languageName: node
+  linkType: hard
+
+"@csstools/css-calc@npm:^1.1.1, @csstools/css-calc@npm:^1.2.0, @csstools/css-calc@npm:^1.2.4":
+  version: 1.2.4
+  resolution: "@csstools/css-calc@npm:1.2.4"
+  peerDependencies:
+    "@csstools/css-parser-algorithms": ^2.7.1
+    "@csstools/css-tokenizer": ^2.4.1
+  checksum: 10c0/6233746eb642797b7fbc2cf6e7651e95700b294e78e3c29e8730c3236bb92cf62903efb6e54639e8f877683c40646e137c95e615c4450809b21b61a6192888ca
+  languageName: node
+  linkType: hard
+
+"@csstools/css-calc@npm:^2.1.3, @csstools/css-calc@npm:^2.1.4":
+  version: 2.1.4
+  resolution: "@csstools/css-calc@npm:2.1.4"
+  peerDependencies:
+    "@csstools/css-parser-algorithms": ^3.0.5
+    "@csstools/css-tokenizer": ^3.0.4
+  checksum: 10c0/42ce5793e55ec4d772083808a11e9fb2dfe36db3ec168713069a276b4c3882205b3507c4680224c28a5d35fe0bc2d308c77f8f2c39c7c09aad8747708eb8ddd8
+  languageName: node
+  linkType: hard
+
+"@csstools/css-color-parser@npm:^1.2.0":
+  version: 1.6.3
+  resolution: "@csstools/css-color-parser@npm:1.6.3"
+  dependencies:
+    "@csstools/color-helpers": "npm:^4.1.0"
+    "@csstools/css-calc": "npm:^1.2.0"
+  peerDependencies:
+    "@csstools/css-parser-algorithms": ^2.6.1
+    "@csstools/css-tokenizer": ^2.2.4
+  checksum: 10c0/3b15d9974105fe6e5d5e839953ee06153bc308bd62feacdeb88b7da7486ef1625254d0df908c68654596e477ca6be0c312d0c02a62d6dc4bddee61821be17d27
+  languageName: node
+  linkType: hard
+
+"@csstools/css-color-parser@npm:^3.0.9":
+  version: 3.1.0
+  resolution: "@csstools/css-color-parser@npm:3.1.0"
+  dependencies:
+    "@csstools/color-helpers": "npm:^5.1.0"
+    "@csstools/css-calc": "npm:^2.1.4"
+  peerDependencies:
+    "@csstools/css-parser-algorithms": ^3.0.5
+    "@csstools/css-tokenizer": ^3.0.4
+  checksum: 10c0/0e0c670ad54ec8ec4d9b07568b80defd83b9482191f5e8ca84ab546b7be6db5d7cc2ba7ac9fae54488b129a4be235d6183d3aab4416fec5e89351f73af4222c5
+  languageName: node
+  linkType: hard
+
+"@csstools/css-parser-algorithms@npm:^2.1.1, @csstools/css-parser-algorithms@npm:^2.2.0, @csstools/css-parser-algorithms@npm:^2.3.1, @csstools/css-parser-algorithms@npm:^2.7.1":
+  version: 2.7.1
+  resolution: "@csstools/css-parser-algorithms@npm:2.7.1"
+  peerDependencies:
+    "@csstools/css-tokenizer": ^2.4.1
+  checksum: 10c0/7d29bef6f5790ddb67d922ad232253bf910e4fa5293f5e4a5ed8b920ae9bd4e8171942df7d8943af23b42fd4e9fb460181394d20c97da9562e6ce98a875e8c47
+  languageName: node
+  linkType: hard
+
+"@csstools/css-parser-algorithms@npm:^3.0.4":
+  version: 3.0.5
+  resolution: "@csstools/css-parser-algorithms@npm:3.0.5"
+  peerDependencies:
+    "@csstools/css-tokenizer": ^3.0.4
+  checksum: 10c0/d9a1c888bd43849ae3437ca39251d5c95d2c8fd6b5ccdb7c45491dfd2c1cbdc3075645e80901d120e4d2c1993db9a5b2d83793b779dbbabcfb132adb142eb7f7
+  languageName: node
+  linkType: hard
+
+"@csstools/css-tokenizer@npm:^2.1.1, @csstools/css-tokenizer@npm:^2.2.0, @csstools/css-tokenizer@npm:^2.4.1":
+  version: 2.4.1
+  resolution: "@csstools/css-tokenizer@npm:2.4.1"
+  checksum: 10c0/fe71cee85ec7372da07083d088b6a704f43e5d3d2d8071c4b8a86fae60408b559a218a43f8625bf2f0be5c7f90c8f3ad20a1aae1921119a1c02b51c310cc2b6b
+  languageName: node
+  linkType: hard
+
+"@csstools/css-tokenizer@npm:^3.0.3":
+  version: 3.0.4
+  resolution: "@csstools/css-tokenizer@npm:3.0.4"
+  checksum: 10c0/3b589f8e9942075a642213b389bab75a2d50d05d203727fcdac6827648a5572674caff07907eff3f9a2389d86a4ee47308fafe4f8588f4a77b7167c588d2559f
+  languageName: node
+  linkType: hard
+
+"@csstools/media-query-list-parser@npm:^2.1.1, @csstools/media-query-list-parser@npm:^2.1.13, @csstools/media-query-list-parser@npm:^2.1.4":
+  version: 2.1.13
+  resolution: "@csstools/media-query-list-parser@npm:2.1.13"
+  peerDependencies:
+    "@csstools/css-parser-algorithms": ^2.7.1
+    "@csstools/css-tokenizer": ^2.4.1
+  checksum: 10c0/8bf72342c15581b8f658633436d83c26a214056f6b960ff121b940271f4b1b5b07e9cc3990a73e684fb72319592f0c392408b4f0e08bbe242b2065aa456e2733
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-cascade-layers@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "@csstools/postcss-cascade-layers@npm:3.0.1"
+  dependencies:
+    "@csstools/selector-specificity": "npm:^2.0.2"
+    postcss-selector-parser: "npm:^6.0.10"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/fa1fdf782c54e256e0d062a407823e26eb156e54a4325fc8b96659bb10b072eb21e311f09afeb5ffa05887841b6b6c7e34aad8c4c7c743edfa17d055823b38bf
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-color-function@npm:^2.2.3":
+  version: 2.2.3
+  resolution: "@csstools/postcss-color-function@npm:2.2.3"
+  dependencies:
+    "@csstools/css-color-parser": "npm:^1.2.0"
+    "@csstools/css-parser-algorithms": "npm:^2.1.1"
+    "@csstools/css-tokenizer": "npm:^2.1.1"
+    "@csstools/postcss-progressive-custom-properties": "npm:^2.3.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/ff46ba8e41eafc1ab2c4bdc911e0084ebf56aaab67cbcdb0087a519160cdfa5142b02b2c465781dc224e5a86a3ddb84cede7ec0c7be56850d6d9739c9d181b4c
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-color-mix-function@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "@csstools/postcss-color-mix-function@npm:1.0.3"
+  dependencies:
+    "@csstools/css-color-parser": "npm:^1.2.0"
+    "@csstools/css-parser-algorithms": "npm:^2.1.1"
+    "@csstools/css-tokenizer": "npm:^2.1.1"
+    "@csstools/postcss-progressive-custom-properties": "npm:^2.3.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/e7d4cab639e73cca946b3d2c7bf67c1fc542501fa9bbebdb132ad327256d968377472942656b63baedb907005f0e39b8097f9895780641e5fbfeb0450c19dcd4
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-font-format-keywords@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "@csstools/postcss-font-format-keywords@npm:2.0.2"
+  dependencies:
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/aeb68023756a6f29294533ea992e8547cf2d643f7ec18815c76b7f30a5aaefe290e921f1cf99a9c5af3e505489a164a73eefb675abb718abfd310b95d2a51668
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-gradients-interpolation-method@npm:^3.0.6":
+  version: 3.0.6
+  resolution: "@csstools/postcss-gradients-interpolation-method@npm:3.0.6"
+  dependencies:
+    "@csstools/css-color-parser": "npm:^1.2.0"
+    "@csstools/css-parser-algorithms": "npm:^2.1.1"
+    "@csstools/css-tokenizer": "npm:^2.1.1"
+    "@csstools/postcss-progressive-custom-properties": "npm:^2.3.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/da941b485c8c29978418ef4b31cc5f923269eebc7763df780d553487dbf10a96269e334fc7ff3d2c38f3009e62cff820cc2da27ad3249d21c453d20d812a8d89
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-hwb-function@npm:^2.2.2":
+  version: 2.2.2
+  resolution: "@csstools/postcss-hwb-function@npm:2.2.2"
+  dependencies:
+    "@csstools/css-color-parser": "npm:^1.2.0"
+    "@csstools/css-parser-algorithms": "npm:^2.1.1"
+    "@csstools/css-tokenizer": "npm:^2.1.1"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/8b356873c61b734deed70e5a6808ef2ea0d940a7192a8beb8fcdfcd254fedb666cb8245057afba24bf977f37efbd3c7ecd0f474d6b4b72d42a57bc914a2cfde3
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-ic-unit@npm:^2.0.4":
+  version: 2.0.4
+  resolution: "@csstools/postcss-ic-unit@npm:2.0.4"
+  dependencies:
+    "@csstools/postcss-progressive-custom-properties": "npm:^2.3.0"
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/642b5a97fc9fd01e5ac49d93a59b82c5e07994696661fd732f69b2253b260765d31ccdebb6da22b6418e4240e9bd6f175c95b2458223447b98cbba0597732b52
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-is-pseudo-class@npm:^3.2.1":
+  version: 3.2.1
+  resolution: "@csstools/postcss-is-pseudo-class@npm:3.2.1"
+  dependencies:
+    "@csstools/selector-specificity": "npm:^2.0.0"
+    postcss-selector-parser: "npm:^6.0.10"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/8b1902a9b27f8cb69d9eab20ccf527bf0b5f0b71e460a3ed9c63fb651786f21daaf66a678256fe1cbe42dce2309795beb51b103a50c0818b98c088763f5cf28d
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-logical-float-and-clear@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "@csstools/postcss-logical-float-and-clear@npm:1.0.1"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/2c74f784850e9f9d2d5348de41970313deaa8b79e4c187441f09a35a69376cc025cd514ae60246245bcebac1301806590dc169f1627cc5ca3a661ed1f29cbdce
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-logical-resize@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "@csstools/postcss-logical-resize@npm:1.0.1"
+  dependencies:
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/03419a73da5d50a70d2b2741a71df9e28a378277b75d1b8191eeeb37fe5aaa0ac25d6edc6009739deb3245ace278ca311d4ca1eb06b11c5681e621850e762d01
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-logical-viewport-units@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "@csstools/postcss-logical-viewport-units@npm:1.0.3"
+  dependencies:
+    "@csstools/css-tokenizer": "npm:^2.1.1"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/5569e8cfb24b24fc865859a161dc1d95cb488d16a729ff7b3c483cbbef812d7007c25c0ac029c1798480d066e4c86540aeef2ddd743ec09fffed050938b7c169
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-media-minmax@npm:^1.0.4":
+  version: 1.1.8
+  resolution: "@csstools/postcss-media-minmax@npm:1.1.8"
+  dependencies:
+    "@csstools/css-calc": "npm:^1.2.4"
+    "@csstools/css-parser-algorithms": "npm:^2.7.1"
+    "@csstools/css-tokenizer": "npm:^2.4.1"
+    "@csstools/media-query-list-parser": "npm:^2.1.13"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/7d666905282c7a89387dbce84f3429bad04870e0de264c5b1ce3e6f042b8eb72d585a18b2d7ac5e1a8c7f6785892da3cc7f6ea0b48069b06e9d383bdbc149b4a
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-media-queries-aspect-ratio-number-values@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "@csstools/postcss-media-queries-aspect-ratio-number-values@npm:1.0.4"
+  dependencies:
+    "@csstools/css-parser-algorithms": "npm:^2.2.0"
+    "@csstools/css-tokenizer": "npm:^2.1.1"
+    "@csstools/media-query-list-parser": "npm:^2.1.1"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/fa6e858578bea2c2d6e4b53fd789332782e540add4c62cfb67bc7b61e7aae9d4c957121683cdb5c063dec72f9b3818977d8eeb0b8df15f1504eaade179e1869b
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-nested-calc@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "@csstools/postcss-nested-calc@npm:2.0.2"
+  dependencies:
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/a5474b7da3bf11b9e3d1c49f79448f325075ff3530e88c10887afcc5a96ca3e7909d0e509396d18b66197911ec0685df48dff73cae2ca6d1fc26e4107eb984d1
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-normalize-display-values@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "@csstools/postcss-normalize-display-values@npm:2.0.1"
+  dependencies:
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/f270305a313c0b7a776802794b49fe2127b71576cd3e78dcce852f831ea79f9f84ec145128d68058641e0c053ce03d02eff409c8bdb52a694a29b922df2ffa2a
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-oklab-function@npm:^2.2.3":
+  version: 2.2.3
+  resolution: "@csstools/postcss-oklab-function@npm:2.2.3"
+  dependencies:
+    "@csstools/css-color-parser": "npm:^1.2.0"
+    "@csstools/css-parser-algorithms": "npm:^2.1.1"
+    "@csstools/css-tokenizer": "npm:^2.1.1"
+    "@csstools/postcss-progressive-custom-properties": "npm:^2.3.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/b1e0613b0a40f6d4bb836a73abeae3e1a5160aa03b030e36312026a2c2550a842e7f604015e11dfb0c61fb8fdd6f89d0fcc4e8e2327508a8290d7f3feff6e970
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-progressive-custom-properties@npm:^2.3.0":
+  version: 2.3.0
+  resolution: "@csstools/postcss-progressive-custom-properties@npm:2.3.0"
+  dependencies:
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/8558aa24f37be795ce8613e6c8bc82511c983fc911cf9cd5b898e64dde6ddebb2c6fd0dd1db0a5aa87e31ce00cc740dd4ece64cb6ed00e70145b397cb9b03e83
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-relative-color-syntax@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "@csstools/postcss-relative-color-syntax@npm:1.0.2"
+  dependencies:
+    "@csstools/css-color-parser": "npm:^1.2.0"
+    "@csstools/css-parser-algorithms": "npm:^2.1.1"
+    "@csstools/css-tokenizer": "npm:^2.1.1"
+    "@csstools/postcss-progressive-custom-properties": "npm:^2.3.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/98fbb2631fff411110e5e8dfba6cd75eb9a142c0a0ffc2f8c156d3a482de23fa1035b1a03d99920b1fceed9cd6436febeac7610af1348bcc1f69fd6dbd2c5272
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-scope-pseudo-class@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "@csstools/postcss-scope-pseudo-class@npm:2.0.2"
+  dependencies:
+    postcss-selector-parser: "npm:^6.0.10"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/1bd2de28e9d463187ec6a098b0b4ec3b1b299ec522625024ee99b206a0a7462748b2660ac9497196b22df128dd8f530f1a8f51956fc8c5ada9160970b4c4015e
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-stepped-value-functions@npm:^2.1.1":
+  version: 2.1.1
+  resolution: "@csstools/postcss-stepped-value-functions@npm:2.1.1"
+  dependencies:
+    "@csstools/css-calc": "npm:^1.1.1"
+    "@csstools/css-parser-algorithms": "npm:^2.1.1"
+    "@csstools/css-tokenizer": "npm:^2.1.1"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/d8186bf80741f4a73573306571d6415fa7e201dc26fa9c7cca016b493c3777cb6e2d26b74031baa8370f0ab0d025df1991eaa8823b2a398e1d7cb5261aa3445e
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-text-decoration-shorthand@npm:^2.2.4":
+  version: 2.2.4
+  resolution: "@csstools/postcss-text-decoration-shorthand@npm:2.2.4"
+  dependencies:
+    "@csstools/color-helpers": "npm:^2.1.0"
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/caff43b8c22717692044f52c0c194e55ec73bdf726a186028f6206bc2a62c254ceeac8aa57daaa9defe92d786eaf22dfcdefb4b9bc7cabf6d270d5f434a207c7
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-trigonometric-functions@npm:^2.1.1":
+  version: 2.1.1
+  resolution: "@csstools/postcss-trigonometric-functions@npm:2.1.1"
+  dependencies:
+    "@csstools/css-calc": "npm:^1.1.1"
+    "@csstools/css-parser-algorithms": "npm:^2.1.1"
+    "@csstools/css-tokenizer": "npm:^2.1.1"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/d60383f93ddd247f6039d85178ac00b6354f4b783faff96b44d7bc0394485277a5c7fc12820a87db0066cb4e7743ad706f183812d3a692430c74cc00e7c9e9ad
+  languageName: node
+  linkType: hard
+
+"@csstools/postcss-unset-value@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "@csstools/postcss-unset-value@npm:2.0.1"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/0eaa6d934beed59a49d6185eab3bd8803d577efd08ea1611bbdc4f96aafe7634ee527fda9d2dd977de6849e0a2208e2b35707b3baec1be79b0779c1f15f1eadd
+  languageName: node
+  linkType: hard
+
+"@csstools/selector-specificity@npm:^2.0.0, @csstools/selector-specificity@npm:^2.0.1, @csstools/selector-specificity@npm:^2.0.2":
+  version: 2.2.0
+  resolution: "@csstools/selector-specificity@npm:2.2.0"
+  peerDependencies:
+    postcss-selector-parser: ^6.0.10
+  checksum: 10c0/d81c9b437f7d45ad0171e09240454ced439fa3e67576daae4ec7bb9c03e7a6061afeb0fa21d41f5f45d54bf8e242a7aa8101fbbba7ca7632dd847601468b5d9e
+  languageName: node
+  linkType: hard
+
+"@csstools/selector-specificity@npm:^3.0.0":
+  version: 3.1.1
+  resolution: "@csstools/selector-specificity@npm:3.1.1"
+  peerDependencies:
+    postcss-selector-parser: ^6.0.13
+  checksum: 10c0/1d4a3f8015904d6aeb3203afe0e1f6db09b191d9c1557520e3e960c9204ad852df9db4cbde848643f78a26f6ea09101b4e528dbb9193052db28258dbcc8a6e1d
+  languageName: node
+  linkType: hard
+
+"@csstools/utilities@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "@csstools/utilities@npm:1.0.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/2ac10895e0a1f9e1fc9c092197c8595a09f632552791af91219f38c55bb39083fb44b74a6a7de9112492cf24a2fe66d20c955a2b4aff041d5c017d87bbebc0f2
+  languageName: node
+  linkType: hard
+
+"@editorjs/caret@npm:^1.0.1":
+  version: 1.0.3
+  resolution: "@editorjs/caret@npm:1.0.3"
+  dependencies:
+    "@editorjs/dom": "npm:^1.0.1"
+  checksum: 10c0/7bd9848a64b85769efba00ec57b074ff7125b902cab71e3b9114b36afd16d2a17dd041a7c2c98b1195c3dd70d63cd58dad249e5cec175cce81a4df85a1f1b9b0
+  languageName: node
+  linkType: hard
+
+"@editorjs/code@npm:^2.7.0":
+  version: 2.9.3
+  resolution: "@editorjs/code@npm:2.9.3"
+  dependencies:
+    "@codexteam/icons": "npm:^0.3.2"
+  checksum: 10c0/e467a857cb48aeccaa6fccf3efb949f59549d0d9d031b64c7f7439b1f693299316188a27f30446cf2ce782fe4e2b4f55796677dfff150b823c89e3aebe0c7b7a
+  languageName: node
+  linkType: hard
+
+"@editorjs/delimiter@npm:^1.2.0":
+  version: 1.4.2
+  resolution: "@editorjs/delimiter@npm:1.4.2"
+  dependencies:
+    "@codexteam/icons": "npm:^0.3.2"
+  checksum: 10c0/635e96097529484e3db69b565de6dd153c5b4564906f1e4ad5883c3f97236badbc2b964a512a7456f0f3819eac0809e061f4a5a0e27b49054b28b2e8e13b1d7c
+  languageName: node
+  linkType: hard
+
+"@editorjs/dom@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "@editorjs/dom@npm:1.0.1"
+  dependencies:
+    "@editorjs/helpers": "npm:^1.0.1"
+  checksum: 10c0/3446eb6bc7605a55f5b7c1452966eb5f942e7cd083d4f447f6c356cbca729e76cffe1025dceb286dc13ab82107d674325cbc1ac204f5b7027ecf5058d344a59c
+  languageName: node
+  linkType: hard
+
+"@editorjs/editorjs@npm:^2.29.1, @editorjs/editorjs@workspace:.":
+  version: 0.0.0-use.local
+  resolution: "@editorjs/editorjs@workspace:."
+  dependencies:
+    "@axe-core/playwright": "npm:^4.11.0"
+    "@babel/register": "npm:^7.21.0"
+    "@codexteam/icons": "npm:0.3.2"
+    "@codexteam/shortcuts": "npm:^1.1.1"
+    "@editorjs/caret": "npm:^1.0.1"
+    "@editorjs/code": "npm:^2.7.0"
+    "@editorjs/delimiter": "npm:^1.2.0"
+    "@editorjs/header": "npm:^2.8.8"
+    "@editorjs/paragraph": "npm:^2.11.6"
+    "@editorjs/simple-image": "npm:^1.4.1"
+    "@eslint/eslintrc": "npm:^3.1.0"
+    "@playwright/test": "npm:^1.56.1"
+    "@types/lodash": "npm:^4.17.20"
+    "@types/node": "npm:^18.15.11"
+    "@vitest/ui": "npm:^1.0.0"
+    codex-notifier: "npm:^1.1.2"
+    core-js: "npm:3.30.0"
+    eslint: "npm:^8.37.0"
+    eslint-config-codex: "npm:^1.7.1"
+    eslint-plugin-chai-friendly: "npm:^0.7.2"
+    eslint-plugin-deprecation: "npm:^1.5.0"
+    eslint-plugin-import: "npm:^2.32.0"
+    eslint-plugin-jest: "npm:^29.1.0"
+    eslint-plugin-playwright: "npm:^2.3.0"
+    eslint-plugin-sonarjs: "npm:^3.0.5"
+    html-janitor: "npm:^2.0.4"
+    jscpd: "npm:^4.0.5"
+    jsdom: "npm:^23.0.0"
+    lodash: "npm:^4.17.21"
+    nanoid: "npm:^4.0.2"
+    postcss-apply: "npm:^0.12.0"
+    postcss-nested: "npm:4.1.2"
+    postcss-preset-env: "npm:^8.3.0"
+    rollup-plugin-license: "npm:^3.0.1"
+    stylelint: "npm:^15.4.0"
+    tslint: "npm:^6.1.1"
+    typescript: "npm:5.0.3"
+    vite: "npm:^4.2.1"
+    vite-plugin-css-injected-by-js: "npm:^3.1.0"
+    vitest: "npm:^1.0.0"
+  languageName: unknown
+  linkType: soft
+
+"@editorjs/header@npm:^2.8.8":
+  version: 2.8.8
+  resolution: "@editorjs/header@npm:2.8.8"
+  dependencies:
+    "@codexteam/icons": "npm:^0.0.5"
+    "@editorjs/editorjs": "npm:^2.29.1"
+  checksum: 10c0/c208d2ea852c0e75b09a03ce08db558249c0e1efd17459f4adc80de9c30963b69129f744764769047e1766403e2e0fa249a5086eefdbcd5f3a082fbcd3ee4ec6
+  languageName: node
+  linkType: hard
+
+"@editorjs/helpers@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "@editorjs/helpers@npm:1.0.1"
+  checksum: 10c0/d163f8b3e7eb95bdc300f55e8700c38faeae90851f4759dd7f8257bdda5054909b60a23d2c5ec1db8d4909b6c86d151372ea35d1dae0b6e98c02082dcff10a96
+  languageName: node
+  linkType: hard
+
+"@editorjs/paragraph@npm:^2.11.6":
+  version: 2.11.7
+  resolution: "@editorjs/paragraph@npm:2.11.7"
+  dependencies:
+    "@codexteam/icons": "npm:^0.0.4"
+  checksum: 10c0/0a81d900196378fb8603a5a8bbc91a65aa3eae78612dddf4fdb1f039eaafca4a9b2e13bf9607faed413cbd7f42bb7d287cdafdd9e08117c825808df907de17f3
+  languageName: node
+  linkType: hard
+
+"@editorjs/simple-image@npm:^1.4.1":
+  version: 1.6.0
+  resolution: "@editorjs/simple-image@npm:1.6.0"
+  dependencies:
+    "@codexteam/icons": "npm:^0.0.6"
+  checksum: 10c0/b178e05e785e60dab8fc6985e940e3a952b8f2b4266402f043ecbaa1046590bb61f47192d486682cb1a755883ed2664c62cd8587572a2223c3487d3a5ca701be
+  languageName: node
+  linkType: hard
+
+"@es-joy/jsdoccomment@npm:~0.46.0":
+  version: 0.46.0
+  resolution: "@es-joy/jsdoccomment@npm:0.46.0"
+  dependencies:
+    comment-parser: "npm:1.4.1"
+    esquery: "npm:^1.6.0"
+    jsdoc-type-pratt-parser: "npm:~4.0.0"
+  checksum: 10c0/a7a67936ebf6d9aaf74af018c3ac744769af3552b05ad9b88fca96b2ffdca16e724b0ff497f53634ec4cca81e98d8c471b6b6bde0fa5b725af4222ad9a0707f0
+  languageName: node
+  linkType: hard
+
+"@esbuild/aix-ppc64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/aix-ppc64@npm:0.21.5"
+  conditions: os=aix & cpu=ppc64
+  languageName: node
+  linkType: hard
+
+"@esbuild/android-arm64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/android-arm64@npm:0.18.20"
+  conditions: os=android & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@esbuild/android-arm64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/android-arm64@npm:0.21.5"
+  conditions: os=android & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@esbuild/android-arm@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/android-arm@npm:0.18.20"
+  conditions: os=android & cpu=arm
+  languageName: node
+  linkType: hard
+
+"@esbuild/android-arm@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/android-arm@npm:0.21.5"
+  conditions: os=android & cpu=arm
+  languageName: node
+  linkType: hard
+
+"@esbuild/android-x64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/android-x64@npm:0.18.20"
+  conditions: os=android & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/android-x64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/android-x64@npm:0.21.5"
+  conditions: os=android & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/darwin-arm64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/darwin-arm64@npm:0.18.20"
+  conditions: os=darwin & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@esbuild/darwin-arm64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/darwin-arm64@npm:0.21.5"
+  conditions: os=darwin & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@esbuild/darwin-x64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/darwin-x64@npm:0.18.20"
+  conditions: os=darwin & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/darwin-x64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/darwin-x64@npm:0.21.5"
+  conditions: os=darwin & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/freebsd-arm64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/freebsd-arm64@npm:0.18.20"
+  conditions: os=freebsd & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@esbuild/freebsd-arm64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/freebsd-arm64@npm:0.21.5"
+  conditions: os=freebsd & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@esbuild/freebsd-x64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/freebsd-x64@npm:0.18.20"
+  conditions: os=freebsd & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/freebsd-x64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/freebsd-x64@npm:0.21.5"
+  conditions: os=freebsd & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-arm64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/linux-arm64@npm:0.18.20"
+  conditions: os=linux & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-arm64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/linux-arm64@npm:0.21.5"
+  conditions: os=linux & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-arm@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/linux-arm@npm:0.18.20"
+  conditions: os=linux & cpu=arm
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-arm@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/linux-arm@npm:0.21.5"
+  conditions: os=linux & cpu=arm
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-ia32@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/linux-ia32@npm:0.18.20"
+  conditions: os=linux & cpu=ia32
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-ia32@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/linux-ia32@npm:0.21.5"
+  conditions: os=linux & cpu=ia32
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-loong64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/linux-loong64@npm:0.18.20"
+  conditions: os=linux & cpu=loong64
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-loong64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/linux-loong64@npm:0.21.5"
+  conditions: os=linux & cpu=loong64
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-mips64el@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/linux-mips64el@npm:0.18.20"
+  conditions: os=linux & cpu=mips64el
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-mips64el@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/linux-mips64el@npm:0.21.5"
+  conditions: os=linux & cpu=mips64el
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-ppc64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/linux-ppc64@npm:0.18.20"
+  conditions: os=linux & cpu=ppc64
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-ppc64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/linux-ppc64@npm:0.21.5"
+  conditions: os=linux & cpu=ppc64
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-riscv64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/linux-riscv64@npm:0.18.20"
+  conditions: os=linux & cpu=riscv64
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-riscv64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/linux-riscv64@npm:0.21.5"
+  conditions: os=linux & cpu=riscv64
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-s390x@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/linux-s390x@npm:0.18.20"
+  conditions: os=linux & cpu=s390x
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-s390x@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/linux-s390x@npm:0.21.5"
+  conditions: os=linux & cpu=s390x
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-x64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/linux-x64@npm:0.18.20"
+  conditions: os=linux & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/linux-x64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/linux-x64@npm:0.21.5"
+  conditions: os=linux & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/netbsd-x64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/netbsd-x64@npm:0.18.20"
+  conditions: os=netbsd & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/netbsd-x64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/netbsd-x64@npm:0.21.5"
+  conditions: os=netbsd & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/openbsd-x64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/openbsd-x64@npm:0.18.20"
+  conditions: os=openbsd & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/openbsd-x64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/openbsd-x64@npm:0.21.5"
+  conditions: os=openbsd & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/sunos-x64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/sunos-x64@npm:0.18.20"
+  conditions: os=sunos & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/sunos-x64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/sunos-x64@npm:0.21.5"
+  conditions: os=sunos & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/win32-arm64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/win32-arm64@npm:0.18.20"
+  conditions: os=win32 & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@esbuild/win32-arm64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/win32-arm64@npm:0.21.5"
+  conditions: os=win32 & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@esbuild/win32-ia32@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/win32-ia32@npm:0.18.20"
+  conditions: os=win32 & cpu=ia32
+  languageName: node
+  linkType: hard
+
+"@esbuild/win32-ia32@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/win32-ia32@npm:0.21.5"
+  conditions: os=win32 & cpu=ia32
+  languageName: node
+  linkType: hard
+
+"@esbuild/win32-x64@npm:0.18.20":
+  version: 0.18.20
+  resolution: "@esbuild/win32-x64@npm:0.18.20"
+  conditions: os=win32 & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@esbuild/win32-x64@npm:0.21.5":
+  version: 0.21.5
+  resolution: "@esbuild/win32-x64@npm:0.21.5"
+  conditions: os=win32 & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@eslint-community/eslint-utils@npm:^4.1.2, @eslint-community/eslint-utils@npm:^4.2.0, @eslint-community/eslint-utils@npm:^4.4.0":
+  version: 4.9.0
+  resolution: "@eslint-community/eslint-utils@npm:4.9.0"
+  dependencies:
+    eslint-visitor-keys: "npm:^3.4.3"
+  peerDependencies:
+    eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
+  checksum: 10c0/8881e22d519326e7dba85ea915ac7a143367c805e6ba1374c987aa2fbdd09195cc51183d2da72c0e2ff388f84363e1b220fd0d19bef10c272c63455162176817
+  languageName: node
+  linkType: hard
+
+"@eslint-community/regexpp@npm:4.12.1":
+  version: 4.12.1
+  resolution: "@eslint-community/regexpp@npm:4.12.1"
+  checksum: 10c0/a03d98c246bcb9109aec2c08e4d10c8d010256538dcb3f56610191607214523d4fb1b00aa81df830b6dffb74c5fa0be03642513a289c567949d3e550ca11cdf6
+  languageName: node
+  linkType: hard
+
+"@eslint-community/regexpp@npm:^4.11.0, @eslint-community/regexpp@npm:^4.5.1, @eslint-community/regexpp@npm:^4.6.1, @eslint-community/regexpp@npm:^4.8.0":
+  version: 4.12.2
+  resolution: "@eslint-community/regexpp@npm:4.12.2"
+  checksum: 10c0/fddcbc66851b308478d04e302a4d771d6917a0b3740dc351513c0da9ca2eab8a1adf99f5e0aa7ab8b13fa0df005c81adeee7e63a92f3effd7d367a163b721c2d
+  languageName: node
+  linkType: hard
+
+"@eslint/eslintrc@npm:^2.1.4":
+  version: 2.1.4
+  resolution: "@eslint/eslintrc@npm:2.1.4"
+  dependencies:
+    ajv: "npm:^6.12.4"
+    debug: "npm:^4.3.2"
+    espree: "npm:^9.6.0"
+    globals: "npm:^13.19.0"
+    ignore: "npm:^5.2.0"
+    import-fresh: "npm:^3.2.1"
+    js-yaml: "npm:^4.1.0"
+    minimatch: "npm:^3.1.2"
+    strip-json-comments: "npm:^3.1.1"
+  checksum: 10c0/32f67052b81768ae876c84569ffd562491ec5a5091b0c1e1ca1e0f3c24fb42f804952fdd0a137873bc64303ba368a71ba079a6f691cee25beee9722d94cc8573
+  languageName: node
+  linkType: hard
+
+"@eslint/eslintrc@npm:^3.1.0":
+  version: 3.3.1
+  resolution: "@eslint/eslintrc@npm:3.3.1"
+  dependencies:
+    ajv: "npm:^6.12.4"
+    debug: "npm:^4.3.2"
+    espree: "npm:^10.0.1"
+    globals: "npm:^14.0.0"
+    ignore: "npm:^5.2.0"
+    import-fresh: "npm:^3.2.1"
+    js-yaml: "npm:^4.1.0"
+    minimatch: "npm:^3.1.2"
+    strip-json-comments: "npm:^3.1.1"
+  checksum: 10c0/b0e63f3bc5cce4555f791a4e487bf999173fcf27c65e1ab6e7d63634d8a43b33c3693e79f192cbff486d7df1be8ebb2bd2edc6e70ddd486cbfa84a359a3e3b41
+  languageName: node
+  linkType: hard
+
+"@eslint/js@npm:8.57.1":
+  version: 8.57.1
+  resolution: "@eslint/js@npm:8.57.1"
+  checksum: 10c0/b489c474a3b5b54381c62e82b3f7f65f4b8a5eaaed126546520bf2fede5532a8ed53212919fed1e9048dcf7f37167c8561d58d0ba4492a4244004e7793805223
+  languageName: node
+  linkType: hard
+
+"@humanwhocodes/config-array@npm:^0.13.0":
+  version: 0.13.0
+  resolution: "@humanwhocodes/config-array@npm:0.13.0"
+  dependencies:
+    "@humanwhocodes/object-schema": "npm:^2.0.3"
+    debug: "npm:^4.3.1"
+    minimatch: "npm:^3.0.5"
+  checksum: 10c0/205c99e756b759f92e1f44a3dc6292b37db199beacba8f26c2165d4051fe73a4ae52fdcfd08ffa93e7e5cb63da7c88648f0e84e197d154bbbbe137b2e0dd332e
+  languageName: node
+  linkType: hard
+
+"@humanwhocodes/module-importer@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "@humanwhocodes/module-importer@npm:1.0.1"
+  checksum: 10c0/909b69c3b86d482c26b3359db16e46a32e0fb30bd306a3c176b8313b9e7313dba0f37f519de6aa8b0a1921349e505f259d19475e123182416a506d7f87e7f529
+  languageName: node
+  linkType: hard
+
+"@humanwhocodes/object-schema@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "@humanwhocodes/object-schema@npm:2.0.3"
+  checksum: 10c0/80520eabbfc2d32fe195a93557cef50dfe8c8905de447f022675aaf66abc33ae54098f5ea78548d925aa671cd4ab7c7daa5ad704fe42358c9b5e7db60f80696c
+  languageName: node
+  linkType: hard
+
+"@isaacs/cliui@npm:^8.0.2":
+  version: 8.0.2
+  resolution: "@isaacs/cliui@npm:8.0.2"
+  dependencies:
+    string-width: "npm:^5.1.2"
+    string-width-cjs: "npm:string-width@^4.2.0"
+    strip-ansi: "npm:^7.0.1"
+    strip-ansi-cjs: "npm:strip-ansi@^6.0.1"
+    wrap-ansi: "npm:^8.1.0"
+    wrap-ansi-cjs: "npm:wrap-ansi@^7.0.0"
+  checksum: 10c0/b1bf42535d49f11dc137f18d5e4e63a28c5569de438a221c369483731e9dac9fb797af554e8bf02b6192d1e5eba6e6402cf93900c3d0ac86391d00d04876789e
+  languageName: node
+  linkType: hard
+
+"@isaacs/fs-minipass@npm:^4.0.0":
+  version: 4.0.1
+  resolution: "@isaacs/fs-minipass@npm:4.0.1"
+  dependencies:
+    minipass: "npm:^7.0.4"
+  checksum: 10c0/c25b6dc1598790d5b55c0947a9b7d111cfa92594db5296c3b907e2f533c033666f692a3939eadac17b1c7c40d362d0b0635dc874cbfe3e70db7c2b07cc97a5d2
+  languageName: node
+  linkType: hard
+
+"@jest/schemas@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "@jest/schemas@npm:29.6.3"
+  dependencies:
+    "@sinclair/typebox": "npm:^0.27.8"
+  checksum: 10c0/b329e89cd5f20b9278ae1233df74016ebf7b385e0d14b9f4c1ad18d096c4c19d1e687aa113a9c976b16ec07f021ae53dea811fb8c1248a50ac34fbe009fdf6be
+  languageName: node
+  linkType: hard
+
+"@jridgewell/sourcemap-codec@npm:^1.5.5":
+  version: 1.5.5
+  resolution: "@jridgewell/sourcemap-codec@npm:1.5.5"
+  checksum: 10c0/f9e538f302b63c0ebc06eecb1dd9918dd4289ed36147a0ddce35d6ea4d7ebbda243cda7b2213b6a5e1d8087a298d5cf630fb2bd39329cdecb82017023f6081a0
+  languageName: node
+  linkType: hard
+
+"@jscpd/core@npm:4.0.1":
+  version: 4.0.1
+  resolution: "@jscpd/core@npm:4.0.1"
+  dependencies:
+    eventemitter3: "npm:^5.0.1"
+  checksum: 10c0/a3df1f9f232532f696abcda9a1f74c61ca1dfe9b9d64ac9797c2a5442ce51acfe2bb4553f6f02a3089440188dd925b28a197480f2d1c8ebd8bb500ac260744c3
+  languageName: node
+  linkType: hard
+
+"@jscpd/finder@npm:4.0.1":
+  version: 4.0.1
+  resolution: "@jscpd/finder@npm:4.0.1"
+  dependencies:
+    "@jscpd/core": "npm:4.0.1"
+    "@jscpd/tokenizer": "npm:4.0.1"
+    blamer: "npm:^1.0.6"
+    bytes: "npm:^3.1.2"
+    cli-table3: "npm:^0.6.5"
+    colors: "npm:^1.4.0"
+    fast-glob: "npm:^3.3.2"
+    fs-extra: "npm:^11.2.0"
+    markdown-table: "npm:^2.0.0"
+    pug: "npm:^3.0.3"
+  checksum: 10c0/5ec96776029c267ede7a5b069740ec385d0f88a7915489e58f59e4e73086d83fde1842967aa1acbe26df97c3122e9f6d13bf1f07e55bdb7949109e7a7f38afe3
+  languageName: node
+  linkType: hard
+
+"@jscpd/html-reporter@npm:4.0.1":
+  version: 4.0.1
+  resolution: "@jscpd/html-reporter@npm:4.0.1"
+  dependencies:
+    colors: "npm:1.4.0"
+    fs-extra: "npm:^11.2.0"
+    pug: "npm:^3.0.3"
+  checksum: 10c0/0d35a4b8bd729510734e06a80a7b49334e43894fef4c8a771142885b1f69058cf1f5b014b5ca0e67daa9cefe507dbe29d0a04d02272a735441764f9413e2f09e
+  languageName: node
+  linkType: hard
+
+"@jscpd/tokenizer@npm:4.0.1":
+  version: 4.0.1
+  resolution: "@jscpd/tokenizer@npm:4.0.1"
+  dependencies:
+    "@jscpd/core": "npm:4.0.1"
+    reprism: "npm:^0.0.11"
+    spark-md5: "npm:^3.0.2"
+  checksum: 10c0/b00a8b2c0b1a65d7c6abd0a4e3931627688b5d62c02c0ca286523f30475559e2b5a68600827685753e8c172b343aa70cda3ec4b1099362ca3b03c7f74f9dd1bb
+  languageName: node
+  linkType: hard
+
+"@nodelib/fs.scandir@npm:2.1.5":
+  version: 2.1.5
+  resolution: "@nodelib/fs.scandir@npm:2.1.5"
+  dependencies:
+    "@nodelib/fs.stat": "npm:2.0.5"
+    run-parallel: "npm:^1.1.9"
+  checksum: 10c0/732c3b6d1b1e967440e65f284bd06e5821fedf10a1bea9ed2bb75956ea1f30e08c44d3def9d6a230666574edbaf136f8cfd319c14fd1f87c66e6a44449afb2eb
+  languageName: node
+  linkType: hard
+
+"@nodelib/fs.stat@npm:2.0.5, @nodelib/fs.stat@npm:^2.0.2":
+  version: 2.0.5
+  resolution: "@nodelib/fs.stat@npm:2.0.5"
+  checksum: 10c0/88dafe5e3e29a388b07264680dc996c17f4bda48d163a9d4f5c1112979f0ce8ec72aa7116122c350b4e7976bc5566dc3ddb579be1ceaacc727872eb4ed93926d
+  languageName: node
+  linkType: hard
+
+"@nodelib/fs.walk@npm:^1.2.3, @nodelib/fs.walk@npm:^1.2.8":
+  version: 1.2.8
+  resolution: "@nodelib/fs.walk@npm:1.2.8"
+  dependencies:
+    "@nodelib/fs.scandir": "npm:2.1.5"
+    fastq: "npm:^1.6.0"
+  checksum: 10c0/db9de047c3bb9b51f9335a7bb46f4fcfb6829fb628318c12115fbaf7d369bfce71c15b103d1fc3b464812d936220ee9bc1c8f762d032c9f6be9acc99249095b1
+  languageName: node
+  linkType: hard
+
+"@npmcli/agent@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "@npmcli/agent@npm:3.0.0"
+  dependencies:
+    agent-base: "npm:^7.1.0"
+    http-proxy-agent: "npm:^7.0.0"
+    https-proxy-agent: "npm:^7.0.1"
+    lru-cache: "npm:^10.0.1"
+    socks-proxy-agent: "npm:^8.0.3"
+  checksum: 10c0/efe37b982f30740ee77696a80c196912c274ecd2cb243bc6ae7053a50c733ce0f6c09fda085145f33ecf453be19654acca74b69e81eaad4c90f00ccffe2f9271
+  languageName: node
+  linkType: hard
+
+"@npmcli/fs@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "@npmcli/fs@npm:4.0.0"
+  dependencies:
+    semver: "npm:^7.3.5"
+  checksum: 10c0/c90935d5ce670c87b6b14fab04a965a3b8137e585f8b2a6257263bd7f97756dd736cb165bb470e5156a9e718ecd99413dccc54b1138c1a46d6ec7cf325982fe5
+  languageName: node
+  linkType: hard
+
+"@pkgjs/parseargs@npm:^0.11.0":
+  version: 0.11.0
+  resolution: "@pkgjs/parseargs@npm:0.11.0"
+  checksum: 10c0/5bd7576bb1b38a47a7fc7b51ac9f38748e772beebc56200450c4a817d712232b8f1d3ef70532c80840243c657d491cf6a6be1e3a214cff907645819fdc34aadd
+  languageName: node
+  linkType: hard
+
+"@pkgr/core@npm:^0.1.0":
+  version: 0.1.2
+  resolution: "@pkgr/core@npm:0.1.2"
+  checksum: 10c0/fd4acc154c8f1b5c544b6dd152b7ce68f6cbb8b92e9abf2e5d756d6e95052d08d0d693a668dea67af1386d62635b50adfe463cce03c5620402b468498cc7592f
+  languageName: node
+  linkType: hard
+
+"@playwright/test@npm:^1.56.1":
+  version: 1.56.1
+  resolution: "@playwright/test@npm:1.56.1"
+  dependencies:
+    playwright: "npm:1.56.1"
+  bin:
+    playwright: cli.js
+  checksum: 10c0/2b5b0e1f2e6a18f6e5ce6897c7440ca78f64e0b004834e9808e93ad2b78b96366b562ae4366602669cf8ad793a43d85481b58541e74be71e905e732d833dd691
+  languageName: node
+  linkType: hard
+
+"@polka/url@npm:^1.0.0-next.24":
+  version: 1.0.0-next.29
+  resolution: "@polka/url@npm:1.0.0-next.29"
+  checksum: 10c0/0d58e081844095cb029d3c19a659bfefd09d5d51a2f791bc61eba7ea826f13d6ee204a8a448c2f5a855c17df07b37517373ff916dd05801063c0568ae9937684
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-android-arm-eabi@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-android-arm-eabi@npm:4.53.2"
+  conditions: os=android & cpu=arm
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-android-arm64@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-android-arm64@npm:4.53.2"
+  conditions: os=android & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-darwin-arm64@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-darwin-arm64@npm:4.53.2"
+  conditions: os=darwin & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-darwin-x64@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-darwin-x64@npm:4.53.2"
+  conditions: os=darwin & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-freebsd-arm64@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-freebsd-arm64@npm:4.53.2"
+  conditions: os=freebsd & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-freebsd-x64@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-freebsd-x64@npm:4.53.2"
+  conditions: os=freebsd & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-linux-arm-gnueabihf@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-linux-arm-gnueabihf@npm:4.53.2"
+  conditions: os=linux & cpu=arm & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-linux-arm-musleabihf@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-linux-arm-musleabihf@npm:4.53.2"
+  conditions: os=linux & cpu=arm & libc=musl
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-linux-arm64-gnu@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-linux-arm64-gnu@npm:4.53.2"
+  conditions: os=linux & cpu=arm64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-linux-arm64-musl@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-linux-arm64-musl@npm:4.53.2"
+  conditions: os=linux & cpu=arm64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-linux-loong64-gnu@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-linux-loong64-gnu@npm:4.53.2"
+  conditions: os=linux & cpu=loong64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-linux-ppc64-gnu@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-linux-ppc64-gnu@npm:4.53.2"
+  conditions: os=linux & cpu=ppc64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-linux-riscv64-gnu@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-linux-riscv64-gnu@npm:4.53.2"
+  conditions: os=linux & cpu=riscv64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-linux-riscv64-musl@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-linux-riscv64-musl@npm:4.53.2"
+  conditions: os=linux & cpu=riscv64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-linux-s390x-gnu@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-linux-s390x-gnu@npm:4.53.2"
+  conditions: os=linux & cpu=s390x & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-linux-x64-gnu@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-linux-x64-gnu@npm:4.53.2"
+  conditions: os=linux & cpu=x64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-linux-x64-musl@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-linux-x64-musl@npm:4.53.2"
+  conditions: os=linux & cpu=x64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-openharmony-arm64@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-openharmony-arm64@npm:4.53.2"
+  conditions: os=openharmony & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-win32-arm64-msvc@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-win32-arm64-msvc@npm:4.53.2"
+  conditions: os=win32 & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-win32-ia32-msvc@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-win32-ia32-msvc@npm:4.53.2"
+  conditions: os=win32 & cpu=ia32
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-win32-x64-gnu@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-win32-x64-gnu@npm:4.53.2"
+  conditions: os=win32 & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@rollup/rollup-win32-x64-msvc@npm:4.53.2":
+  version: 4.53.2
+  resolution: "@rollup/rollup-win32-x64-msvc@npm:4.53.2"
+  conditions: os=win32 & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@rtsao/scc@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "@rtsao/scc@npm:1.1.0"
+  checksum: 10c0/b5bcfb0d87f7d1c1c7c0f7693f53b07866ed9fec4c34a97a8c948fb9a7c0082e416ce4d3b60beb4f5e167cbe04cdeefbf6771320f3ede059b9ce91188c409a5b
+  languageName: node
+  linkType: hard
+
+"@sinclair/typebox@npm:^0.27.8":
+  version: 0.27.8
+  resolution: "@sinclair/typebox@npm:0.27.8"
+  checksum: 10c0/ef6351ae073c45c2ac89494dbb3e1f87cc60a93ce4cde797b782812b6f97da0d620ae81973f104b43c9b7eaa789ad20ba4f6a1359f1cc62f63729a55a7d22d4e
+  languageName: node
+  linkType: hard
+
+"@types/estree@npm:1.0.8, @types/estree@npm:^1.0.0":
+  version: 1.0.8
+  resolution: "@types/estree@npm:1.0.8"
+  checksum: 10c0/39d34d1afaa338ab9763f37ad6066e3f349444f9052b9676a7cc0252ef9485a41c6d81c9c4e0d26e9077993354edf25efc853f3224dd4b447175ef62bdcc86a5
+  languageName: node
+  linkType: hard
+
+"@types/json-schema@npm:^7.0.12":
+  version: 7.0.15
+  resolution: "@types/json-schema@npm:7.0.15"
+  checksum: 10c0/a996a745e6c5d60292f36731dd41341339d4eeed8180bb09226e5c8d23759067692b1d88e5d91d72ee83dfc00d3aca8e7bd43ea120516c17922cbcb7c3e252db
+  languageName: node
+  linkType: hard
+
+"@types/json5@npm:^0.0.29":
+  version: 0.0.29
+  resolution: "@types/json5@npm:0.0.29"
+  checksum: 10c0/6bf5337bc447b706bb5b4431d37686aa2ea6d07cfd6f79cc31de80170d6ff9b1c7384a9c0ccbc45b3f512bae9e9f75c2e12109806a15331dc94e8a8db6dbb4ac
+  languageName: node
+  linkType: hard
+
+"@types/lodash@npm:^4.17.20":
+  version: 4.17.20
+  resolution: "@types/lodash@npm:4.17.20"
+  checksum: 10c0/98cdd0faae22cbb8079a01a3bb65aa8f8c41143367486c1cbf5adc83f16c9272a2a5d2c1f541f61d0d73da543c16ee1d21cf2ef86cb93cd0cc0ac3bced6dd88f
+  languageName: node
+  linkType: hard
+
+"@types/minimist@npm:^1.2.2":
+  version: 1.2.5
+  resolution: "@types/minimist@npm:1.2.5"
+  checksum: 10c0/3f791258d8e99a1d7d0ca2bda1ca6ea5a94e5e7b8fc6cde84dd79b0552da6fb68ade750f0e17718f6587783c24254bbca0357648dd59dc3812c150305cabdc46
+  languageName: node
+  linkType: hard
+
+"@types/node@npm:^18.15.11":
+  version: 18.19.130
+  resolution: "@types/node@npm:18.19.130"
+  dependencies:
+    undici-types: "npm:~5.26.4"
+  checksum: 10c0/22ba2bc9f8863101a7e90a56aaeba1eb3ebdc51e847cef4a6d188967ab1acbce9b4f92251372fd0329ecb924bbf610509e122c3dfe346c04dbad04013d4ad7d0
+  languageName: node
+  linkType: hard
+
+"@types/normalize-package-data@npm:^2.4.0":
+  version: 2.4.4
+  resolution: "@types/normalize-package-data@npm:2.4.4"
+  checksum: 10c0/aef7bb9b015883d6f4119c423dd28c4bdc17b0e8a0ccf112c78b4fe0e91fbc4af7c6204b04bba0e199a57d2f3fbbd5b4a14bf8739bf9d2a39b2a0aad545e0f86
+  languageName: node
+  linkType: hard
+
+"@types/sarif@npm:^2.1.4":
+  version: 2.1.7
+  resolution: "@types/sarif@npm:2.1.7"
+  checksum: 10c0/983d593735c42b288c3d95bb1655b036652438d267eecb2cd5d0f8c613ac98ae198eb7828dc171776e64a6ebe93e88c920ec9b80cf3c780e015e081ac5d26c01
+  languageName: node
+  linkType: hard
+
+"@types/semver@npm:^7.5.0":
+  version: 7.7.1
+  resolution: "@types/semver@npm:7.7.1"
+  checksum: 10c0/c938aef3bf79a73f0f3f6037c16e2e759ff40c54122ddf0b2583703393d8d3127130823facb880e694caa324eb6845628186aac1997ee8b31dc2d18fafe26268
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/eslint-plugin@npm:^6.0.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/eslint-plugin@npm:6.21.0"
+  dependencies:
+    "@eslint-community/regexpp": "npm:^4.5.1"
+    "@typescript-eslint/scope-manager": "npm:6.21.0"
+    "@typescript-eslint/type-utils": "npm:6.21.0"
+    "@typescript-eslint/utils": "npm:6.21.0"
+    "@typescript-eslint/visitor-keys": "npm:6.21.0"
+    debug: "npm:^4.3.4"
+    graphemer: "npm:^1.4.0"
+    ignore: "npm:^5.2.4"
+    natural-compare: "npm:^1.4.0"
+    semver: "npm:^7.5.4"
+    ts-api-utils: "npm:^1.0.1"
+  peerDependencies:
+    "@typescript-eslint/parser": ^6.0.0 || ^6.0.0-alpha
+    eslint: ^7.0.0 || ^8.0.0
+  peerDependenciesMeta:
+    typescript:
+      optional: true
+  checksum: 10c0/f911a79ee64d642f814a3b6cdb0d324b5f45d9ef955c5033e78903f626b7239b4aa773e464a38c3e667519066169d983538f2bf8e5d00228af587c9d438fb344
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/parser@npm:^6.0.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/parser@npm:6.21.0"
+  dependencies:
+    "@typescript-eslint/scope-manager": "npm:6.21.0"
+    "@typescript-eslint/types": "npm:6.21.0"
+    "@typescript-eslint/typescript-estree": "npm:6.21.0"
+    "@typescript-eslint/visitor-keys": "npm:6.21.0"
+    debug: "npm:^4.3.4"
+  peerDependencies:
+    eslint: ^7.0.0 || ^8.0.0
+  peerDependenciesMeta:
+    typescript:
+      optional: true
+  checksum: 10c0/a8f99820679decd0d115c0af61903fb1de3b1b5bec412dc72b67670bf636de77ab07f2a68ee65d6da7976039bbf636907f9d5ca546db3f0b98a31ffbc225bc7d
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/scope-manager@npm:^6.0.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/scope-manager@npm:6.21.0"
+  dependencies:
+    "@typescript-eslint/types": "npm:6.21.0"
+    "@typescript-eslint/visitor-keys": "npm:6.21.0"
+  checksum: 10c0/eaf868938d811cbbea33e97e44ba7050d2b6892202cea6a9622c486b85ab1cf801979edf78036179a8ba4ac26f1dfdf7fcc83a68c1ff66be0b3a8e9a9989b526
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/type-utils@npm:^6.0.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/type-utils@npm:6.21.0"
+  dependencies:
+    "@typescript-eslint/typescript-estree": "npm:6.21.0"
+    "@typescript-eslint/utils": "npm:6.21.0"
+    debug: "npm:^4.3.4"
+    ts-api-utils: "npm:^1.0.1"
+  peerDependencies:
+    eslint: ^7.0.0 || ^8.0.0
+  peerDependenciesMeta:
+    typescript:
+      optional: true
+  checksum: 10c0/7409c97d1c4a4386b488962739c4f1b5b04dc60cf51f8cd88e6b12541f84d84c6b8b67e491a147a2c95f9ec486539bf4519fb9d418411aef6537b9c156468117
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/types@npm:^6.0.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/types@npm:6.21.0"
+  checksum: 10c0/020631d3223bbcff8a0da3efbdf058220a8f48a3de221563996ad1dcc30d6c08dadc3f7608cc08830d21c0d565efd2db19b557b9528921c78aabb605eef2d74d
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/typescript-estree@npm:^6.0.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/typescript-estree@npm:6.21.0"
+  dependencies:
+    "@typescript-eslint/types": "npm:6.21.0"
+    "@typescript-eslint/visitor-keys": "npm:6.21.0"
+    debug: "npm:^4.3.4"
+    globby: "npm:^11.1.0"
+    is-glob: "npm:^4.0.3"
+    minimatch: "npm:9.0.3"
+    semver: "npm:^7.5.4"
+    ts-api-utils: "npm:^1.0.1"
+  peerDependenciesMeta:
+    typescript:
+      optional: true
+  checksum: 10c0/af1438c60f080045ebb330155a8c9bb90db345d5069cdd5d01b67de502abb7449d6c75500519df829f913a6b3f490ade3e8215279b6bdc63d0fb0ae61034df5f
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/utils@npm:^6.0.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/utils@npm:6.21.0"
+  dependencies:
+    "@eslint-community/eslint-utils": "npm:^4.4.0"
+    "@types/json-schema": "npm:^7.0.12"
+    "@types/semver": "npm:^7.5.0"
+    "@typescript-eslint/scope-manager": "npm:6.21.0"
+    "@typescript-eslint/types": "npm:6.21.0"
+    "@typescript-eslint/typescript-estree": "npm:6.21.0"
+    semver: "npm:^7.5.4"
+  peerDependencies:
+    eslint: ^7.0.0 || ^8.0.0
+  checksum: 10c0/ab2df3833b2582d4e5467a484d08942b4f2f7208f8e09d67de510008eb8001a9b7460f2f9ba11c12086fd3cdcac0c626761c7995c2c6b5657d5fa6b82030a32d
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/visitor-keys@npm:^6.0.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/visitor-keys@npm:6.21.0"
+  dependencies:
+    "@typescript-eslint/types": "npm:6.21.0"
+    eslint-visitor-keys: "npm:^3.4.1"
+  checksum: 10c0/7395f69739cfa1cb83c1fb2fad30afa2a814756367302fb4facd5893eff66abc807e8d8f63eba94ed3b0fe0c1c996ac9a1680bcbf0f83717acedc3f2bb724fbf
+  languageName: node
+  linkType: hard
+
+"@ungap/structured-clone@npm:^1.2.0":
+  version: 1.3.0
+  resolution: "@ungap/structured-clone@npm:1.3.0"
+  checksum: 10c0/0fc3097c2540ada1fc340ee56d58d96b5b536a2a0dab6e3ec17d4bfc8c4c86db345f61a375a8185f9da96f01c69678f836a2b57eeaa9e4b8eeafd26428e57b0a
+  languageName: node
+  linkType: hard
+
+"@vitest/expect@npm:1.6.1":
+  version: 1.6.1
+  resolution: "@vitest/expect@npm:1.6.1"
+  dependencies:
+    "@vitest/spy": "npm:1.6.1"
+    "@vitest/utils": "npm:1.6.1"
+    chai: "npm:^4.3.10"
+  checksum: 10c0/278164b2a32a7019b443444f21111c5e32e4cadee026cae047ae2a3b347d99dca1d1fb7b79509c88b67dc3db19fa9a16265b7d7a8377485f7e37f7851e44495a
+  languageName: node
+  linkType: hard
+
+"@vitest/runner@npm:1.6.1":
+  version: 1.6.1
+  resolution: "@vitest/runner@npm:1.6.1"
+  dependencies:
+    "@vitest/utils": "npm:1.6.1"
+    p-limit: "npm:^5.0.0"
+    pathe: "npm:^1.1.1"
+  checksum: 10c0/36333f1a596c4ad85d42c6126cc32959c984d584ef28d366d366fa3672678c1a0f5e5c2e8717a36675b6620b57e8830f765d6712d1687f163ed0a8ebf23c87db
+  languageName: node
+  linkType: hard
+
+"@vitest/snapshot@npm:1.6.1":
+  version: 1.6.1
+  resolution: "@vitest/snapshot@npm:1.6.1"
+  dependencies:
+    magic-string: "npm:^0.30.5"
+    pathe: "npm:^1.1.1"
+    pretty-format: "npm:^29.7.0"
+  checksum: 10c0/68bbc3132c195ec37376469e4b183fc408e0aeedd827dffcc899aac378e9ea324825f0873062786e18f00e3da9dd8a93c9bb871c07471ee483e8df963cb272eb
+  languageName: node
+  linkType: hard
+
+"@vitest/spy@npm:1.6.1":
+  version: 1.6.1
+  resolution: "@vitest/spy@npm:1.6.1"
+  dependencies:
+    tinyspy: "npm:^2.2.0"
+  checksum: 10c0/5207ec0e7882819f0e0811293ae6d14163e26927e781bb4de7d40b3bd99c1fae656934c437bb7a30443a3e7e736c5bccb037bbf4436dbbc83d29e65247888885
+  languageName: node
+  linkType: hard
+
+"@vitest/ui@npm:^1.0.0":
+  version: 1.6.1
+  resolution: "@vitest/ui@npm:1.6.1"
+  dependencies:
+    "@vitest/utils": "npm:1.6.1"
+    fast-glob: "npm:^3.3.2"
+    fflate: "npm:^0.8.1"
+    flatted: "npm:^3.2.9"
+    pathe: "npm:^1.1.1"
+    picocolors: "npm:^1.0.0"
+    sirv: "npm:^2.0.4"
+  peerDependencies:
+    vitest: 1.6.1
+  checksum: 10c0/ce89fa608e8f7e3b2b0e26bf3bb2466969ba6f4ccc07371b5f4ec353f8e2995b56cdf64420f028894d80b84635094a692d7ffbc7d1b3fbcdf1db5ce76509639c
+  languageName: node
+  linkType: hard
+
+"@vitest/utils@npm:1.6.1":
+  version: 1.6.1
+  resolution: "@vitest/utils@npm:1.6.1"
+  dependencies:
+    diff-sequences: "npm:^29.6.3"
+    estree-walker: "npm:^3.0.3"
+    loupe: "npm:^2.3.7"
+    pretty-format: "npm:^29.7.0"
+  checksum: 10c0/0d4c619e5688cbc22a60c412719c6baa40376b7671bdbdc3072552f5c5a5ee5d24a96ea328b054018debd49e0626a5e3db672921b2c6b5b17b9a52edd296806a
+  languageName: node
+  linkType: hard
+
+"abbrev@npm:^3.0.0":
+  version: 3.0.1
+  resolution: "abbrev@npm:3.0.1"
+  checksum: 10c0/21ba8f574ea57a3106d6d35623f2c4a9111d9ee3e9a5be47baed46ec2457d2eac46e07a5c4a60186f88cb98abbe3e24f2d4cca70bc2b12f1692523e2209a9ccf
+  languageName: node
+  linkType: hard
+
+"acorn-jsx@npm:^5.3.2":
+  version: 5.3.2
+  resolution: "acorn-jsx@npm:5.3.2"
+  peerDependencies:
+    acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
+  checksum: 10c0/4c54868fbef3b8d58927d5e33f0a4de35f59012fe7b12cf9dfbb345fb8f46607709e1c4431be869a23fb63c151033d84c4198fa9f79385cec34fcb1dd53974c1
+  languageName: node
+  linkType: hard
+
+"acorn-walk@npm:^8.3.2":
+  version: 8.3.4
+  resolution: "acorn-walk@npm:8.3.4"
+  dependencies:
+    acorn: "npm:^8.11.0"
+  checksum: 10c0/76537ac5fb2c37a64560feaf3342023dadc086c46da57da363e64c6148dc21b57d49ace26f949e225063acb6fb441eabffd89f7a3066de5ad37ab3e328927c62
+  languageName: node
+  linkType: hard
+
+"acorn@npm:^7.1.1":
+  version: 7.4.1
+  resolution: "acorn@npm:7.4.1"
+  bin:
+    acorn: bin/acorn
+  checksum: 10c0/bd0b2c2b0f334bbee48828ff897c12bd2eb5898d03bf556dcc8942022cec795ac5bb5b6b585e2de687db6231faf07e096b59a361231dd8c9344d5df5f7f0e526
+  languageName: node
+  linkType: hard
+
+"acorn@npm:^8.11.0, acorn@npm:^8.15.0, acorn@npm:^8.9.0":
+  version: 8.15.0
+  resolution: "acorn@npm:8.15.0"
+  bin:
+    acorn: bin/acorn
+  checksum: 10c0/dec73ff59b7d6628a01eebaece7f2bdb8bb62b9b5926dcad0f8931f2b8b79c2be21f6c68ac095592adb5adb15831a3635d9343e6a91d028bbe85d564875ec3ec
+  languageName: node
+  linkType: hard
+
+"agent-base@npm:^7.1.0, agent-base@npm:^7.1.2":
+  version: 7.1.4
+  resolution: "agent-base@npm:7.1.4"
+  checksum: 10c0/c2c9ab7599692d594b6a161559ada307b7a624fa4c7b03e3afdb5a5e31cd0e53269115b620fcab024c5ac6a6f37fa5eb2e004f076ad30f5f7e6b8b671f7b35fe
+  languageName: node
+  linkType: hard
+
+"ajv@npm:^6.12.4":
+  version: 6.12.6
+  resolution: "ajv@npm:6.12.6"
+  dependencies:
+    fast-deep-equal: "npm:^3.1.1"
+    fast-json-stable-stringify: "npm:^2.0.0"
+    json-schema-traverse: "npm:^0.4.1"
+    uri-js: "npm:^4.2.2"
+  checksum: 10c0/41e23642cbe545889245b9d2a45854ebba51cda6c778ebced9649420d9205f2efb39cb43dbc41e358409223b1ea43303ae4839db682c848b891e4811da1a5a71
+  languageName: node
+  linkType: hard
+
+"ajv@npm:^8.0.1":
+  version: 8.17.1
+  resolution: "ajv@npm:8.17.1"
+  dependencies:
+    fast-deep-equal: "npm:^3.1.3"
+    fast-uri: "npm:^3.0.1"
+    json-schema-traverse: "npm:^1.0.0"
+    require-from-string: "npm:^2.0.2"
+  checksum: 10c0/ec3ba10a573c6b60f94639ffc53526275917a2df6810e4ab5a6b959d87459f9ef3f00d5e7865b82677cb7d21590355b34da14d1d0b9c32d75f95a187e76fff35
+  languageName: node
+  linkType: hard
+
+"ansi-regex@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "ansi-regex@npm:5.0.1"
+  checksum: 10c0/9a64bb8627b434ba9327b60c027742e5d17ac69277960d041898596271d992d4d52ba7267a63ca10232e29f6107fc8a835f6ce8d719b88c5f8493f8254813737
+  languageName: node
+  linkType: hard
+
+"ansi-regex@npm:^6.0.1":
+  version: 6.2.2
+  resolution: "ansi-regex@npm:6.2.2"
+  checksum: 10c0/05d4acb1d2f59ab2cf4b794339c7b168890d44dda4bf0ce01152a8da0213aca207802f930442ce8cd22d7a92f44907664aac6508904e75e038fa944d2601b30f
+  languageName: node
+  linkType: hard
+
+"ansi-styles@npm:^3.2.1":
+  version: 3.2.1
+  resolution: "ansi-styles@npm:3.2.1"
+  dependencies:
+    color-convert: "npm:^1.9.0"
+  checksum: 10c0/ece5a8ef069fcc5298f67e3f4771a663129abd174ea2dfa87923a2be2abf6cd367ef72ac87942da00ce85bd1d651d4cd8595aebdb1b385889b89b205860e977b
+  languageName: node
+  linkType: hard
+
+"ansi-styles@npm:^4.0.0, ansi-styles@npm:^4.1.0":
+  version: 4.3.0
+  resolution: "ansi-styles@npm:4.3.0"
+  dependencies:
+    color-convert: "npm:^2.0.1"
+  checksum: 10c0/895a23929da416f2bd3de7e9cb4eabd340949328ab85ddd6e484a637d8f6820d485f53933446f5291c3b760cbc488beb8e88573dd0f9c7daf83dccc8fe81b041
+  languageName: node
+  linkType: hard
+
+"ansi-styles@npm:^5.0.0":
+  version: 5.2.0
+  resolution: "ansi-styles@npm:5.2.0"
+  checksum: 10c0/9c4ca80eb3c2fb7b33841c210d2f20807f40865d27008d7c3f707b7f95cab7d67462a565e2388ac3285b71cb3d9bb2173de8da37c57692a362885ec34d6e27df
+  languageName: node
+  linkType: hard
+
+"ansi-styles@npm:^6.1.0":
+  version: 6.2.3
+  resolution: "ansi-styles@npm:6.2.3"
+  checksum: 10c0/23b8a4ce14e18fb854693b95351e286b771d23d8844057ed2e7d083cd3e708376c3323707ec6a24365f7d7eda3ca00327fe04092e29e551499ec4c8b7bfac868
+  languageName: node
+  linkType: hard
+
+"are-docs-informative@npm:^0.0.2":
+  version: 0.0.2
+  resolution: "are-docs-informative@npm:0.0.2"
+  checksum: 10c0/f0326981bd699c372d268b526b170a28f2e1aec2cf99d7de0686083528427ecdf6ae41fef5d9988e224a5616298af747ad8a76e7306b0a7c97cc085a99636d60
+  languageName: node
+  linkType: hard
+
+"argparse@npm:^1.0.7":
+  version: 1.0.10
+  resolution: "argparse@npm:1.0.10"
+  dependencies:
+    sprintf-js: "npm:~1.0.2"
+  checksum: 10c0/b2972c5c23c63df66bca144dbc65d180efa74f25f8fd9b7d9a0a6c88ae839db32df3d54770dcb6460cf840d232b60695d1a6b1053f599d84e73f7437087712de
+  languageName: node
+  linkType: hard
+
+"argparse@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "argparse@npm:2.0.1"
+  checksum: 10c0/c5640c2d89045371c7cedd6a70212a04e360fd34d6edeae32f6952c63949e3525ea77dbec0289d8213a99bbaeab5abfa860b5c12cf88a2e6cf8106e90dd27a7e
+  languageName: node
+  linkType: hard
+
+"array-buffer-byte-length@npm:^1.0.1, array-buffer-byte-length@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "array-buffer-byte-length@npm:1.0.2"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    is-array-buffer: "npm:^3.0.5"
+  checksum: 10c0/74e1d2d996941c7a1badda9cabb7caab8c449db9086407cad8a1b71d2604cc8abf105db8ca4e02c04579ec58b7be40279ddb09aea4784832984485499f48432d
+  languageName: node
+  linkType: hard
+
+"array-find-index@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "array-find-index@npm:1.0.2"
+  checksum: 10c0/86b9485c74ddd324feab807e10a6de3f9c1683856267236fac4bb4d4667ada6463e106db3f6c540ae6b720e0442b590ec701d13676df4c6af30ebf4da09b4f57
+  languageName: node
+  linkType: hard
+
+"array-includes@npm:^3.1.6, array-includes@npm:^3.1.9":
+  version: 3.1.9
+  resolution: "array-includes@npm:3.1.9"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.4"
+    define-properties: "npm:^1.2.1"
+    es-abstract: "npm:^1.24.0"
+    es-object-atoms: "npm:^1.1.1"
+    get-intrinsic: "npm:^1.3.0"
+    is-string: "npm:^1.1.1"
+    math-intrinsics: "npm:^1.1.0"
+  checksum: 10c0/0235fa69078abeac05ac4250699c44996bc6f774a9cbe45db48674ce6bd142f09b327d31482ff75cf03344db4ea03eae23edb862d59378b484b47ed842574856
+  languageName: node
+  linkType: hard
+
+"array-union@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "array-union@npm:2.1.0"
+  checksum: 10c0/429897e68110374f39b771ec47a7161fc6a8fc33e196857c0a396dc75df0b5f65e4d046674db764330b6bb66b39ef48dd7c53b6a2ee75cfb0681e0c1a7033962
+  languageName: node
+  linkType: hard
+
+"array.prototype.findlastindex@npm:^1.2.2, array.prototype.findlastindex@npm:^1.2.6":
+  version: 1.2.6
+  resolution: "array.prototype.findlastindex@npm:1.2.6"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.4"
+    define-properties: "npm:^1.2.1"
+    es-abstract: "npm:^1.23.9"
+    es-errors: "npm:^1.3.0"
+    es-object-atoms: "npm:^1.1.1"
+    es-shim-unscopables: "npm:^1.1.0"
+  checksum: 10c0/82559310d2e57ec5f8fc53d7df420e3abf0ba497935de0a5570586035478ba7d07618cb18e2d4ada2da514c8fb98a034aaf5c06caa0a57e2f7f4c4adedef5956
+  languageName: node
+  linkType: hard
+
+"array.prototype.flat@npm:^1.3.1, array.prototype.flat@npm:^1.3.3":
+  version: 1.3.3
+  resolution: "array.prototype.flat@npm:1.3.3"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    define-properties: "npm:^1.2.1"
+    es-abstract: "npm:^1.23.5"
+    es-shim-unscopables: "npm:^1.0.2"
+  checksum: 10c0/d90e04dfbc43bb96b3d2248576753d1fb2298d2d972e29ca7ad5ec621f0d9e16ff8074dae647eac4f31f4fb7d3f561a7ac005fb01a71f51705a13b5af06a7d8a
+  languageName: node
+  linkType: hard
+
+"array.prototype.flatmap@npm:^1.3.1, array.prototype.flatmap@npm:^1.3.3":
+  version: 1.3.3
+  resolution: "array.prototype.flatmap@npm:1.3.3"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    define-properties: "npm:^1.2.1"
+    es-abstract: "npm:^1.23.5"
+    es-shim-unscopables: "npm:^1.0.2"
+  checksum: 10c0/ba899ea22b9dc9bf276e773e98ac84638ed5e0236de06f13d63a90b18ca9e0ec7c97d622d899796e3773930b946cd2413d098656c0c5d8cc58c6f25c21e6bd54
+  languageName: node
+  linkType: hard
+
+"arraybuffer.prototype.slice@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "arraybuffer.prototype.slice@npm:1.0.4"
+  dependencies:
+    array-buffer-byte-length: "npm:^1.0.1"
+    call-bind: "npm:^1.0.8"
+    define-properties: "npm:^1.2.1"
+    es-abstract: "npm:^1.23.5"
+    es-errors: "npm:^1.3.0"
+    get-intrinsic: "npm:^1.2.6"
+    is-array-buffer: "npm:^3.0.4"
+  checksum: 10c0/2f2459caa06ae0f7f615003f9104b01f6435cc803e11bd2a655107d52a1781dc040532dc44d93026b694cc18793993246237423e13a5337e86b43ed604932c06
+  languageName: node
+  linkType: hard
+
+"arrify@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "arrify@npm:1.0.1"
+  checksum: 10c0/c35c8d1a81bcd5474c0c57fe3f4bad1a4d46a5fa353cedcff7a54da315df60db71829e69104b859dff96c5d68af46bd2be259fe5e50dc6aa9df3b36bea0383ab
+  languageName: node
+  linkType: hard
+
+"asap@npm:~2.0.3":
+  version: 2.0.6
+  resolution: "asap@npm:2.0.6"
+  checksum: 10c0/c6d5e39fe1f15e4b87677460bd66b66050cd14c772269cee6688824c1410a08ab20254bb6784f9afb75af9144a9f9a7692d49547f4d19d715aeb7c0318f3136d
+  languageName: node
+  linkType: hard
+
+"assert-never@npm:^1.2.1":
+  version: 1.4.0
+  resolution: "assert-never@npm:1.4.0"
+  checksum: 10c0/494db08b89fb43d6231c9b4c48da22824f1912d88992bf0268e43b3dad0f64bd56d380addbb997d2dea7d859421d5e2904e8bd01243794f2bb5bfbc8d32d1fc6
+  languageName: node
+  linkType: hard
+
+"assertion-error@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "assertion-error@npm:1.1.0"
+  checksum: 10c0/25456b2aa333250f01143968e02e4884a34588a8538fbbf65c91a637f1dbfb8069249133cd2f4e530f10f624d206a664e7df30207830b659e9f5298b00a4099b
+  languageName: node
+  linkType: hard
+
+"astral-regex@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "astral-regex@npm:2.0.0"
+  checksum: 10c0/f63d439cc383db1b9c5c6080d1e240bd14dae745f15d11ec5da863e182bbeca70df6c8191cffef5deba0b566ef98834610a68be79ac6379c95eeb26e1b310e25
+  languageName: node
+  linkType: hard
+
+"async-function@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "async-function@npm:1.0.0"
+  checksum: 10c0/669a32c2cb7e45091330c680e92eaeb791bc1d4132d827591e499cd1f776ff5a873e77e5f92d0ce795a8d60f10761dec9ddfe7225a5de680f5d357f67b1aac73
+  languageName: node
+  linkType: hard
+
+"async-generator-function@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "async-generator-function@npm:1.0.0"
+  checksum: 10c0/2c50ef856c543ad500d8d8777d347e3c1ba623b93e99c9263ecc5f965c1b12d2a140e2ab6e43c3d0b85366110696f28114649411cbcd10b452a92a2318394186
+  languageName: node
+  linkType: hard
+
+"asynckit@npm:^0.4.0":
+  version: 0.4.0
+  resolution: "asynckit@npm:0.4.0"
+  checksum: 10c0/d73e2ddf20c4eb9337e1b3df1a0f6159481050a5de457c55b14ea2e5cb6d90bb69e004c9af54737a5ee0917fcf2c9e25de67777bbe58261847846066ba75bc9d
+  languageName: node
+  linkType: hard
+
+"autoprefixer@npm:^10.4.14":
+  version: 10.4.21
+  resolution: "autoprefixer@npm:10.4.21"
+  dependencies:
+    browserslist: "npm:^4.24.4"
+    caniuse-lite: "npm:^1.0.30001702"
+    fraction.js: "npm:^4.3.7"
+    normalize-range: "npm:^0.1.2"
+    picocolors: "npm:^1.1.1"
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.1.0
+  bin:
+    autoprefixer: bin/autoprefixer
+  checksum: 10c0/de5b71d26d0baff4bbfb3d59f7cf7114a6030c9eeb66167acf49a32c5b61c68e308f1e0f869d92334436a221035d08b51cd1b2f2c4689b8d955149423c16d4d4
+  languageName: node
+  linkType: hard
+
+"available-typed-arrays@npm:^1.0.7":
+  version: 1.0.7
+  resolution: "available-typed-arrays@npm:1.0.7"
+  dependencies:
+    possible-typed-array-names: "npm:^1.0.0"
+  checksum: 10c0/d07226ef4f87daa01bd0fe80f8f310982e345f372926da2e5296aecc25c41cab440916bbaa4c5e1034b453af3392f67df5961124e4b586df1e99793a1374bdb2
+  languageName: node
+  linkType: hard
+
+"axe-core@npm:~4.11.0":
+  version: 4.11.0
+  resolution: "axe-core@npm:4.11.0"
+  checksum: 10c0/7d7020a568a824c303711858c2fcfe56d001d27e46c0c2ff75dc31b436cfddfd4857a301e70536cc9e64829d25338f7fb782102d23497ebdc66801e9900fc895
+  languageName: node
+  linkType: hard
+
+"babel-walk@npm:3.0.0-canary-5":
+  version: 3.0.0-canary-5
+  resolution: "babel-walk@npm:3.0.0-canary-5"
+  dependencies:
+    "@babel/types": "npm:^7.9.6"
+  checksum: 10c0/17b689874d15c37714cedf6797dd9321dcb998d8e0dda9a8fe8c8bbbf128bbdeb8935cf56e8630d6b67eae76d2a0bc1e470751e082c3b0e30b80d58beafb5e64
+  languageName: node
+  linkType: hard
+
+"balanced-match@npm:^1.0.0":
+  version: 1.0.2
+  resolution: "balanced-match@npm:1.0.2"
+  checksum: 10c0/9308baf0a7e4838a82bbfd11e01b1cb0f0cf2893bc1676c27c2a8c0e70cbae1c59120c3268517a8ae7fb6376b4639ef81ca22582611dbee4ed28df945134aaee
+  languageName: node
+  linkType: hard
+
+"balanced-match@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "balanced-match@npm:2.0.0"
+  checksum: 10c0/60a54e0b75a61674e16a7a336b805f06c72d6f8fc457639c24efc512ba2bf9cb5744b9f6f5225afcefb99da39714440c83c737208cc65c5d9ecd1f3093331ca3
+  languageName: node
+  linkType: hard
+
+"baseline-browser-mapping@npm:^2.8.19":
+  version: 2.8.25
+  resolution: "baseline-browser-mapping@npm:2.8.25"
+  bin:
+    baseline-browser-mapping: dist/cli.js
+  checksum: 10c0/93d5631ef1d1770c6166c760adb75e510a2f9ea9bccc1e2f3ec97c1e946ce71f9480e6314ad37e3ed933f2edc597cc9c7a0ec98d42691028e300bd62efd9cddd
+  languageName: node
+  linkType: hard
+
+"bidi-js@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "bidi-js@npm:1.0.3"
+  dependencies:
+    require-from-string: "npm:^2.0.2"
+  checksum: 10c0/fdddea4aa4120a34285486f2267526cd9298b6e8b773ad25e765d4f104b6d7437ab4ba542e6939e3ac834a7570bcf121ee2cf6d3ae7cd7082c4b5bedc8f271e1
+  languageName: node
+  linkType: hard
+
+"blamer@npm:^1.0.6":
+  version: 1.0.7
+  resolution: "blamer@npm:1.0.7"
+  dependencies:
+    execa: "npm:^4.0.0"
+    which: "npm:^2.0.2"
+  checksum: 10c0/55d35d08d5fda9dab089c88010f222426eedaf769972ab5f18ba8d4aa5717b20993f1d1b30f9386a3d73db1a5a2c137506b1b5002f07d77bef939dcbee16294f
+  languageName: node
+  linkType: hard
+
+"brace-expansion@npm:^1.1.7":
+  version: 1.1.12
+  resolution: "brace-expansion@npm:1.1.12"
+  dependencies:
+    balanced-match: "npm:^1.0.0"
+    concat-map: "npm:0.0.1"
+  checksum: 10c0/975fecac2bb7758c062c20d0b3b6288c7cc895219ee25f0a64a9de662dbac981ff0b6e89909c3897c1f84fa353113a721923afdec5f8b2350255b097f12b1f73
+  languageName: node
+  linkType: hard
+
+"brace-expansion@npm:^2.0.1":
+  version: 2.0.2
+  resolution: "brace-expansion@npm:2.0.2"
+  dependencies:
+    balanced-match: "npm:^1.0.0"
+  checksum: 10c0/6d117a4c793488af86b83172deb6af143e94c17bc53b0b3cec259733923b4ca84679d506ac261f4ba3c7ed37c46018e2ff442f9ce453af8643ecd64f4a54e6cf
+  languageName: node
+  linkType: hard
+
+"braces@npm:^3.0.3":
+  version: 3.0.3
+  resolution: "braces@npm:3.0.3"
+  dependencies:
+    fill-range: "npm:^7.1.1"
+  checksum: 10c0/7c6dfd30c338d2997ba77500539227b9d1f85e388a5f43220865201e407e076783d0881f2d297b9f80951b4c957fcf0b51c1d2d24227631643c3f7c284b0aa04
+  languageName: node
+  linkType: hard
+
+"browserslist@npm:^4.21.9, browserslist@npm:^4.24.4":
+  version: 4.27.0
+  resolution: "browserslist@npm:4.27.0"
+  dependencies:
+    baseline-browser-mapping: "npm:^2.8.19"
+    caniuse-lite: "npm:^1.0.30001751"
+    electron-to-chromium: "npm:^1.5.238"
+    node-releases: "npm:^2.0.26"
+    update-browserslist-db: "npm:^1.1.4"
+  bin:
+    browserslist: cli.js
+  checksum: 10c0/395611e54374da9171cdbe7e3704ab426e0f1d622751392df6d6cbf60c539bf06cf2407e9dd769bc01ee2abca6a14af6509a2e0bbb448ba75a054db6c1840643
+  languageName: node
+  linkType: hard
+
+"buffer-from@npm:^1.0.0":
+  version: 1.1.2
+  resolution: "buffer-from@npm:1.1.2"
+  checksum: 10c0/124fff9d66d691a86d3b062eff4663fe437a9d9ee4b47b1b9e97f5a5d14f6d5399345db80f796827be7c95e70a8e765dd404b7c3ff3b3324f98e9b0c8826cc34
+  languageName: node
+  linkType: hard
+
+"builtin-modules@npm:3.3.0, builtin-modules@npm:^3.3.0":
+  version: 3.3.0
+  resolution: "builtin-modules@npm:3.3.0"
+  checksum: 10c0/2cb3448b4f7306dc853632a4fcddc95e8d4e4b9868c139400027b71938fc6806d4ff44007deffb362ac85724bd40c2c6452fb6a0aa4531650eeddb98d8e5ee8a
+  languageName: node
+  linkType: hard
+
+"builtin-modules@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "builtin-modules@npm:1.1.1"
+  checksum: 10c0/58d72ea7f59db3c2ae854e1058d85b226f75ff7386d0f71d628e25a600383fc6652af218e20ba2361925c605a4144590ceb890dfdca298fdf8f3d040c0591a23
+  languageName: node
+  linkType: hard
+
+"builtins@npm:^5.0.1":
+  version: 5.1.0
+  resolution: "builtins@npm:5.1.0"
+  dependencies:
+    semver: "npm:^7.0.0"
+  checksum: 10c0/3c32fe5bd7ed4ff7dbd6fb14bcb9d7eaa7e967327f1899cd336f8625d3f46fceead0a53528f1e332aeaee757034ebb307cb2f1a37af2b86a3c5ad4845d01c0c8
+  languageName: node
+  linkType: hard
+
+"bytes@npm:3.1.2, bytes@npm:^3.1.2":
+  version: 3.1.2
+  resolution: "bytes@npm:3.1.2"
+  checksum: 10c0/76d1c43cbd602794ad8ad2ae94095cddeb1de78c5dddaa7005c51af10b0176c69971a6d88e805a90c2b6550d76636e43c40d8427a808b8645ede885de4a0358e
+  languageName: node
+  linkType: hard
+
+"cac@npm:^6.7.14":
+  version: 6.7.14
+  resolution: "cac@npm:6.7.14"
+  checksum: 10c0/4ee06aaa7bab8981f0d54e5f5f9d4adcd64058e9697563ce336d8a3878ed018ee18ebe5359b2430eceae87e0758e62ea2019c3f52ae6e211b1bd2e133856cd10
+  languageName: node
+  linkType: hard
+
+"cacache@npm:^19.0.1":
+  version: 19.0.1
+  resolution: "cacache@npm:19.0.1"
+  dependencies:
+    "@npmcli/fs": "npm:^4.0.0"
+    fs-minipass: "npm:^3.0.0"
+    glob: "npm:^10.2.2"
+    lru-cache: "npm:^10.0.1"
+    minipass: "npm:^7.0.3"
+    minipass-collect: "npm:^2.0.1"
+    minipass-flush: "npm:^1.0.5"
+    minipass-pipeline: "npm:^1.2.4"
+    p-map: "npm:^7.0.2"
+    ssri: "npm:^12.0.0"
+    tar: "npm:^7.4.3"
+    unique-filename: "npm:^4.0.0"
+  checksum: 10c0/01f2134e1bd7d3ab68be851df96c8d63b492b1853b67f2eecb2c37bb682d37cb70bb858a16f2f0554d3c0071be6dfe21456a1ff6fa4b7eed996570d6a25ffe9c
+  languageName: node
+  linkType: hard
+
+"call-bind-apply-helpers@npm:^1.0.0, call-bind-apply-helpers@npm:^1.0.1, call-bind-apply-helpers@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "call-bind-apply-helpers@npm:1.0.2"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    function-bind: "npm:^1.1.2"
+  checksum: 10c0/47bd9901d57b857590431243fea704ff18078b16890a6b3e021e12d279bbf211d039155e27d7566b374d49ee1f8189344bac9833dec7a20cdec370506361c938
+  languageName: node
+  linkType: hard
+
+"call-bind@npm:^1.0.7, call-bind@npm:^1.0.8":
+  version: 1.0.8
+  resolution: "call-bind@npm:1.0.8"
+  dependencies:
+    call-bind-apply-helpers: "npm:^1.0.0"
+    es-define-property: "npm:^1.0.0"
+    get-intrinsic: "npm:^1.2.4"
+    set-function-length: "npm:^1.2.2"
+  checksum: 10c0/a13819be0681d915144467741b69875ae5f4eba8961eb0bf322aab63ec87f8250eb6d6b0dcbb2e1349876412a56129ca338592b3829ef4343527f5f18a0752d4
+  languageName: node
+  linkType: hard
+
+"call-bound@npm:^1.0.2, call-bound@npm:^1.0.3, call-bound@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "call-bound@npm:1.0.4"
+  dependencies:
+    call-bind-apply-helpers: "npm:^1.0.2"
+    get-intrinsic: "npm:^1.3.0"
+  checksum: 10c0/f4796a6a0941e71c766aea672f63b72bc61234c4f4964dc6d7606e3664c307e7d77845328a8f3359ce39ddb377fed67318f9ee203dea1d47e46165dcf2917644
+  languageName: node
+  linkType: hard
+
+"callsites@npm:^3.0.0":
+  version: 3.1.0
+  resolution: "callsites@npm:3.1.0"
+  checksum: 10c0/fff92277400eb06c3079f9e74f3af120db9f8ea03bad0e84d9aede54bbe2d44a56cccb5f6cf12211f93f52306df87077ecec5b712794c5a9b5dac6d615a3f301
+  languageName: node
+  linkType: hard
+
+"camelcase-keys@npm:^7.0.0":
+  version: 7.0.2
+  resolution: "camelcase-keys@npm:7.0.2"
+  dependencies:
+    camelcase: "npm:^6.3.0"
+    map-obj: "npm:^4.1.0"
+    quick-lru: "npm:^5.1.1"
+    type-fest: "npm:^1.2.1"
+  checksum: 10c0/ae86a51168643e9e8a2f2c7bfa17850729979ec3dafc5253056a7d97931cbb0e3ef5b4185e59d54b7a56c54405dee2874b0c82033498d8626e512ff9034cb05c
+  languageName: node
+  linkType: hard
+
+"camelcase@npm:^6.3.0":
+  version: 6.3.0
+  resolution: "camelcase@npm:6.3.0"
+  checksum: 10c0/0d701658219bd3116d12da3eab31acddb3f9440790c0792e0d398f0a520a6a4058018e546862b6fba89d7ae990efaeb97da71e1913e9ebf5a8b5621a3d55c710
+  languageName: node
+  linkType: hard
+
+"caniuse-lite@npm:^1.0.30001702, caniuse-lite@npm:^1.0.30001751":
+  version: 1.0.30001754
+  resolution: "caniuse-lite@npm:1.0.30001754"
+  checksum: 10c0/d38709ab11abc36eea28068d241434eba925c4d3462916ccaa17a34a6227dfdeb58ab0e1eb614bab12fb393c7d527db392a0f477b48c33d70d8e466954f381ba
+  languageName: node
+  linkType: hard
+
+"chai@npm:^4.3.10":
+  version: 4.5.0
+  resolution: "chai@npm:4.5.0"
+  dependencies:
+    assertion-error: "npm:^1.1.0"
+    check-error: "npm:^1.0.3"
+    deep-eql: "npm:^4.1.3"
+    get-func-name: "npm:^2.0.2"
+    loupe: "npm:^2.3.6"
+    pathval: "npm:^1.1.1"
+    type-detect: "npm:^4.1.0"
+  checksum: 10c0/b8cb596bd1aece1aec659e41a6e479290c7d9bee5b3ad63d2898ad230064e5b47889a3bc367b20100a0853b62e026e2dc514acf25a3c9385f936aa3614d4ab4d
+  languageName: node
+  linkType: hard
+
+"chalk@npm:^2.3.0":
+  version: 2.4.2
+  resolution: "chalk@npm:2.4.2"
+  dependencies:
+    ansi-styles: "npm:^3.2.1"
+    escape-string-regexp: "npm:^1.0.5"
+    supports-color: "npm:^5.3.0"
+  checksum: 10c0/e6543f02ec877732e3a2d1c3c3323ddb4d39fbab687c23f526e25bd4c6a9bf3b83a696e8c769d078e04e5754921648f7821b2a2acfd16c550435fd630026e073
+  languageName: node
+  linkType: hard
+
+"chalk@npm:^4.0.0":
+  version: 4.1.2
+  resolution: "chalk@npm:4.1.2"
+  dependencies:
+    ansi-styles: "npm:^4.1.0"
+    supports-color: "npm:^7.1.0"
+  checksum: 10c0/4a3fef5cc34975c898ffe77141450f679721df9dde00f6c304353fa9c8b571929123b26a0e4617bde5018977eb655b31970c297b91b63ee83bb82aeb04666880
+  languageName: node
+  linkType: hard
+
+"character-parser@npm:^2.2.0":
+  version: 2.2.0
+  resolution: "character-parser@npm:2.2.0"
+  dependencies:
+    is-regex: "npm:^1.0.3"
+  checksum: 10c0/5a8d3eff2c912a6878c84e2ebf9d42524e858aa7e1a1c7e8bb79ab54da109ad008fe9057a9d2b3230541d7ff858eda98983a2ae15db57ba01af2e989d29e932e
+  languageName: node
+  linkType: hard
+
+"check-error@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "check-error@npm:1.0.3"
+  dependencies:
+    get-func-name: "npm:^2.0.2"
+  checksum: 10c0/94aa37a7315c0e8a83d0112b5bfb5a8624f7f0f81057c73e4707729cdd8077166c6aefb3d8e2b92c63ee130d4a2ff94bad46d547e12f3238cc1d78342a973841
+  languageName: node
+  linkType: hard
+
+"chownr@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "chownr@npm:3.0.0"
+  checksum: 10c0/43925b87700f7e3893296c8e9c56cc58f926411cce3a6e5898136daaf08f08b9a8eb76d37d3267e707d0dcc17aed2e2ebdf5848c0c3ce95cf910a919935c1b10
+  languageName: node
+  linkType: hard
+
+"cli-table3@npm:^0.6.5":
+  version: 0.6.5
+  resolution: "cli-table3@npm:0.6.5"
+  dependencies:
+    "@colors/colors": "npm:1.5.0"
+    string-width: "npm:^4.2.0"
+  dependenciesMeta:
+    "@colors/colors":
+      optional: true
+  checksum: 10c0/d7cc9ed12212ae68241cc7a3133c52b844113b17856e11f4f81308acc3febcea7cc9fd298e70933e294dd642866b29fd5d113c2c098948701d0c35f09455de78
+  languageName: node
+  linkType: hard
+
+"clone-deep@npm:^4.0.1":
+  version: 4.0.1
+  resolution: "clone-deep@npm:4.0.1"
+  dependencies:
+    is-plain-object: "npm:^2.0.4"
+    kind-of: "npm:^6.0.2"
+    shallow-clone: "npm:^3.0.0"
+  checksum: 10c0/637753615aa24adf0f2d505947a1bb75e63964309034a1cf56ba4b1f30af155201edd38d26ffe26911adaae267a3c138b344a4947d39f5fc1b6d6108125aa758
+  languageName: node
+  linkType: hard
+
+"codex-notifier@npm:^1.1.2":
+  version: 1.1.2
+  resolution: "codex-notifier@npm:1.1.2"
+  checksum: 10c0/fef16977cdc067802004a29f3e52862f28a2821e7079c716ba27a8d51b218e566201a560614d54d3d4ea9c8ece3ffe49304ec9df38cde75da551db32afc508c8
+  languageName: node
+  linkType: hard
+
+"color-convert@npm:^1.9.0":
+  version: 1.9.3
+  resolution: "color-convert@npm:1.9.3"
+  dependencies:
+    color-name: "npm:1.1.3"
+  checksum: 10c0/5ad3c534949a8c68fca8fbc6f09068f435f0ad290ab8b2f76841b9e6af7e0bb57b98cb05b0e19fe33f5d91e5a8611ad457e5f69e0a484caad1f7487fd0e8253c
+  languageName: node
+  linkType: hard
+
+"color-convert@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "color-convert@npm:2.0.1"
+  dependencies:
+    color-name: "npm:~1.1.4"
+  checksum: 10c0/37e1150172f2e311fe1b2df62c6293a342ee7380da7b9cfdba67ea539909afbd74da27033208d01d6d5cfc65ee7868a22e18d7e7648e004425441c0f8a15a7d7
+  languageName: node
+  linkType: hard
+
+"color-name@npm:1.1.3":
+  version: 1.1.3
+  resolution: "color-name@npm:1.1.3"
+  checksum: 10c0/566a3d42cca25b9b3cd5528cd7754b8e89c0eb646b7f214e8e2eaddb69994ac5f0557d9c175eb5d8f0ad73531140d9c47525085ee752a91a2ab15ab459caf6d6
+  languageName: node
+  linkType: hard
+
+"color-name@npm:~1.1.4":
+  version: 1.1.4
+  resolution: "color-name@npm:1.1.4"
+  checksum: 10c0/a1a3f914156960902f46f7f56bc62effc6c94e84b2cae157a526b1c1f74b677a47ec602bf68a61abfa2b42d15b7c5651c6dbe72a43af720bc588dff885b10f95
+  languageName: node
+  linkType: hard
+
+"colord@npm:^2.9.3":
+  version: 2.9.3
+  resolution: "colord@npm:2.9.3"
+  checksum: 10c0/9699e956894d8996b28c686afe8988720785f476f59335c80ce852ded76ab3ebe252703aec53d9bef54f6219aea6b960fb3d9a8300058a1d0c0d4026460cd110
+  languageName: node
+  linkType: hard
+
+"colors@npm:1.4.0, colors@npm:^1.4.0":
+  version: 1.4.0
+  resolution: "colors@npm:1.4.0"
+  checksum: 10c0/9af357c019da3c5a098a301cf64e3799d27549d8f185d86f79af23069e4f4303110d115da98483519331f6fb71c8568d5688fa1c6523600044fd4a54e97c4efb
+  languageName: node
+  linkType: hard
+
+"combined-stream@npm:^1.0.8":
+  version: 1.0.8
+  resolution: "combined-stream@npm:1.0.8"
+  dependencies:
+    delayed-stream: "npm:~1.0.0"
+  checksum: 10c0/0dbb829577e1b1e839fa82b40c07ffaf7de8a09b935cadd355a73652ae70a88b4320db322f6634a4ad93424292fa80973ac6480986247f1734a1137debf271d5
+  languageName: node
+  linkType: hard
+
+"commander@npm:^2.12.1":
+  version: 2.20.3
+  resolution: "commander@npm:2.20.3"
+  checksum: 10c0/74c781a5248c2402a0a3e966a0a2bba3c054aad144f5c023364be83265e796b20565aa9feff624132ff629aa64e16999fa40a743c10c12f7c61e96a794b99288
+  languageName: node
+  linkType: hard
+
+"commander@npm:^5.0.0":
+  version: 5.1.0
+  resolution: "commander@npm:5.1.0"
+  checksum: 10c0/da9d71dbe4ce039faf1fe9eac3771dca8c11d66963341f62602f7b66e36d2a3f8883407af4f9a37b1db1a55c59c0c1325f186425764c2e963dc1d67aec2a4b6d
+  languageName: node
+  linkType: hard
+
+"comment-parser@npm:1.4.1":
+  version: 1.4.1
+  resolution: "comment-parser@npm:1.4.1"
+  checksum: 10c0/d6c4be3f5be058f98b24f2d557f745d8fe1cc9eb75bebbdccabd404a0e1ed41563171b16285f593011f8b6a5ec81f564fb1f2121418ac5cbf0f49255bf0840dd
+  languageName: node
+  linkType: hard
+
+"commenting@npm:~1.1.0":
+  version: 1.1.0
+  resolution: "commenting@npm:1.1.0"
+  checksum: 10c0/23f9ecb680b561bdd3dba6c9aada0636e42e8804073b623175e6e58bea77d12fcacc6979b009ac5c5a7c8b82590c64d87296827641bf5ac31dd900617b1b84e7
+  languageName: node
+  linkType: hard
+
+"commondir@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "commondir@npm:1.0.1"
+  checksum: 10c0/33a124960e471c25ee19280c9ce31ccc19574b566dc514fe4f4ca4c34fa8b0b57cf437671f5de380e11353ea9426213fca17687dd2ef03134fea2dbc53809fd6
+  languageName: node
+  linkType: hard
+
+"concat-map@npm:0.0.1":
+  version: 0.0.1
+  resolution: "concat-map@npm:0.0.1"
+  checksum: 10c0/c996b1cfdf95b6c90fee4dae37e332c8b6eb7d106430c17d538034c0ad9a1630cb194d2ab37293b1bdd4d779494beee7786d586a50bd9376fd6f7bcc2bd4c98f
+  languageName: node
+  linkType: hard
+
+"confbox@npm:^0.1.8":
+  version: 0.1.8
+  resolution: "confbox@npm:0.1.8"
+  checksum: 10c0/fc2c68d97cb54d885b10b63e45bd8da83a8a71459d3ecf1825143dd4c7f9f1b696b3283e07d9d12a144c1301c2ebc7842380bdf0014e55acc4ae1c9550102418
+  languageName: node
+  linkType: hard
+
+"constantinople@npm:^4.0.1":
+  version: 4.0.1
+  resolution: "constantinople@npm:4.0.1"
+  dependencies:
+    "@babel/parser": "npm:^7.6.0"
+    "@babel/types": "npm:^7.6.1"
+  checksum: 10c0/15129adef19b1af2c3ade8bd38f97c34781bf461472a30ab414384b28d072be83070c8d2175787c045ef7c222c415101ae609936e7903427796a0c0eca8449fd
+  languageName: node
+  linkType: hard
+
+"core-js@npm:3.30.0":
+  version: 3.30.0
+  resolution: "core-js@npm:3.30.0"
+  checksum: 10c0/b96be6526e025f8b3382d6e7823c406987425c72d24efb27f64d7c4c38372b47dddb80ccf44cf4e198ab27765e8fa680f30e251b4758426701f252c2a0c49b4e
+  languageName: node
+  linkType: hard
+
+"cosmiconfig@npm:^8.2.0":
+  version: 8.3.6
+  resolution: "cosmiconfig@npm:8.3.6"
+  dependencies:
+    import-fresh: "npm:^3.3.0"
+    js-yaml: "npm:^4.1.0"
+    parse-json: "npm:^5.2.0"
+    path-type: "npm:^4.0.0"
+  peerDependencies:
+    typescript: ">=4.9.5"
+  peerDependenciesMeta:
+    typescript:
+      optional: true
+  checksum: 10c0/0382a9ed13208f8bfc22ca2f62b364855207dffdb73dc26e150ade78c3093f1cf56172df2dd460c8caf2afa91c0ed4ec8a88c62f8f9cd1cf423d26506aa8797a
+  languageName: node
+  linkType: hard
+
+"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.2, cross-spawn@npm:^7.0.3, cross-spawn@npm:^7.0.6":
+  version: 7.0.6
+  resolution: "cross-spawn@npm:7.0.6"
+  dependencies:
+    path-key: "npm:^3.1.0"
+    shebang-command: "npm:^2.0.0"
+    which: "npm:^2.0.1"
+  checksum: 10c0/053ea8b2135caff68a9e81470e845613e374e7309a47731e81639de3eaeb90c3d01af0e0b44d2ab9d50b43467223b88567dfeb3262db942dc063b9976718ffc1
+  languageName: node
+  linkType: hard
+
+"css-blank-pseudo@npm:^5.0.2":
+  version: 5.0.2
+  resolution: "css-blank-pseudo@npm:5.0.2"
+  dependencies:
+    postcss-selector-parser: "npm:^6.0.10"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/e15d1b8bb5f8016b93b19d0fe7f6f1a5219e41023c183b172a669a74b76ce2f9b527679ef32d662115d616aa80cb291fa47c36c651b59bdde24309549a851e97
+  languageName: node
+  linkType: hard
+
+"css-functions-list@npm:^3.2.1":
+  version: 3.2.3
+  resolution: "css-functions-list@npm:3.2.3"
+  checksum: 10c0/03f9ed34eeed310d2b1cf0e524eea02bc5f87854a4de85f8957ea432ab1036841a3fb00879590519f7bb8fda40d992ce7a72fa9b61696ca1dc53b90064858f96
+  languageName: node
+  linkType: hard
+
+"css-has-pseudo@npm:^5.0.2":
+  version: 5.0.2
+  resolution: "css-has-pseudo@npm:5.0.2"
+  dependencies:
+    "@csstools/selector-specificity": "npm:^2.0.1"
+    postcss-selector-parser: "npm:^6.0.10"
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/b7d468b5118cf7537aad27cedfe5137e9f8273e641284a9ff0359dfcdd5e3312e932d2ee1ea99b0e60fe6e2c2b00cc7a2e413dc0e0ace81695febb398c5d25df
+  languageName: node
+  linkType: hard
+
+"css-prefers-color-scheme@npm:^8.0.2":
+  version: 8.0.2
+  resolution: "css-prefers-color-scheme@npm:8.0.2"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/08585dd159963731eba08b7cfa1922e39b3ba09a3193b6c41ac3b2f48ee34d340f5665df7c547f443500980172e7fba242b4c94882b274f6fbe4849c311a3b5f
+  languageName: node
+  linkType: hard
+
+"css-tree@npm:^2.3.1":
+  version: 2.3.1
+  resolution: "css-tree@npm:2.3.1"
+  dependencies:
+    mdn-data: "npm:2.0.30"
+    source-map-js: "npm:^1.0.1"
+  checksum: 10c0/6f8c1a11d5e9b14bf02d10717fc0351b66ba12594166f65abfbd8eb8b5b490dd367f5c7721db241a3c792d935fc6751fbc09f7e1598d421477ad9fadc30f4f24
+  languageName: node
+  linkType: hard
+
+"cssdb@npm:^7.6.0":
+  version: 7.11.2
+  resolution: "cssdb@npm:7.11.2"
+  checksum: 10c0/5cd8dfee703dfbd7b7a8c3a93d65d26007ec1cd9692379b5868a0ceedf23b88e28d4b98f1cb9a4161f8b01e4a229e08ba9603fb94b756a3df6e07c423fff5b5d
+  languageName: node
+  linkType: hard
+
+"cssesc@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "cssesc@npm:2.0.0"
+  bin:
+    cssesc: bin/cssesc
+  checksum: 10c0/3cf8cb06782e70bea7ccc3a215682399e0a1c42061b4f09411617ec8c04567eab52e132af5b35abea16269220e0e7d3d66f5d14014926eac63471406fec12094
+  languageName: node
+  linkType: hard
+
+"cssesc@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "cssesc@npm:3.0.0"
+  bin:
+    cssesc: bin/cssesc
+  checksum: 10c0/6bcfd898662671be15ae7827120472c5667afb3d7429f1f917737f3bf84c4176003228131b643ae74543f17a394446247df090c597bb9a728cce298606ed0aa7
+  languageName: node
+  linkType: hard
+
+"cssstyle@npm:^4.0.1":
+  version: 4.6.0
+  resolution: "cssstyle@npm:4.6.0"
+  dependencies:
+    "@asamuzakjp/css-color": "npm:^3.2.0"
+    rrweb-cssom: "npm:^0.8.0"
+  checksum: 10c0/71add1b0ffafa1bedbef6855db6189b9523d3320e015a0bf3fbd504760efb9a81e1f1a225228d5fa892ee58e56d06994ca372e7f4e461cda7c4c9985fe075f65
+  languageName: node
+  linkType: hard
+
+"data-urls@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "data-urls@npm:5.0.0"
+  dependencies:
+    whatwg-mimetype: "npm:^4.0.0"
+    whatwg-url: "npm:^14.0.0"
+  checksum: 10c0/1b894d7d41c861f3a4ed2ae9b1c3f0909d4575ada02e36d3d3bc584bdd84278e20709070c79c3b3bff7ac98598cb191eb3e86a89a79ea4ee1ef360e1694f92ad
+  languageName: node
+  linkType: hard
+
+"data-view-buffer@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "data-view-buffer@npm:1.0.2"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    es-errors: "npm:^1.3.0"
+    is-data-view: "npm:^1.0.2"
+  checksum: 10c0/7986d40fc7979e9e6241f85db8d17060dd9a71bd53c894fa29d126061715e322a4cd47a00b0b8c710394854183d4120462b980b8554012acc1c0fa49df7ad38c
+  languageName: node
+  linkType: hard
+
+"data-view-byte-length@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "data-view-byte-length@npm:1.0.2"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    es-errors: "npm:^1.3.0"
+    is-data-view: "npm:^1.0.2"
+  checksum: 10c0/f8a4534b5c69384d95ac18137d381f18a5cfae1f0fc1df0ef6feef51ef0d568606d970b69e02ea186c6c0f0eac77fe4e6ad96fec2569cc86c3afcc7475068c55
+  languageName: node
+  linkType: hard
+
+"data-view-byte-offset@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "data-view-byte-offset@npm:1.0.1"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    es-errors: "npm:^1.3.0"
+    is-data-view: "npm:^1.0.1"
+  checksum: 10c0/fa7aa40078025b7810dcffc16df02c480573b7b53ef1205aa6a61533011005c1890e5ba17018c692ce7c900212b547262d33279fde801ad9843edc0863bf78c4
+  languageName: node
+  linkType: hard
+
+"debug@npm:4, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.4, debug@npm:^4.3.5":
+  version: 4.4.3
+  resolution: "debug@npm:4.4.3"
+  dependencies:
+    ms: "npm:^2.1.3"
+  peerDependenciesMeta:
+    supports-color:
+      optional: true
+  checksum: 10c0/d79136ec6c83ecbefd0f6a5593da6a9c91ec4d7ddc4b54c883d6e71ec9accb5f67a1a5e96d00a328196b5b5c86d365e98d8a3a70856aaf16b4e7b1985e67f5a6
+  languageName: node
+  linkType: hard
+
+"debug@npm:^3.2.7":
+  version: 3.2.7
+  resolution: "debug@npm:3.2.7"
+  dependencies:
+    ms: "npm:^2.1.1"
+  checksum: 10c0/37d96ae42cbc71c14844d2ae3ba55adf462ec89fd3a999459dec3833944cd999af6007ff29c780f1c61153bcaaf2c842d1e4ce1ec621e4fc4923244942e4a02a
+  languageName: node
+  linkType: hard
+
+"decamelize-keys@npm:^1.1.0":
+  version: 1.1.1
+  resolution: "decamelize-keys@npm:1.1.1"
+  dependencies:
+    decamelize: "npm:^1.1.0"
+    map-obj: "npm:^1.0.0"
+  checksum: 10c0/4ca385933127437658338c65fb9aead5f21b28d3dd3ccd7956eb29aab0953b5d3c047fbc207111672220c71ecf7a4d34f36c92851b7bbde6fca1a02c541bdd7d
+  languageName: node
+  linkType: hard
+
+"decamelize@npm:^1.1.0":
+  version: 1.2.0
+  resolution: "decamelize@npm:1.2.0"
+  checksum: 10c0/85c39fe8fbf0482d4a1e224ef0119db5c1897f8503bcef8b826adff7a1b11414972f6fef2d7dec2ee0b4be3863cf64ac1439137ae9e6af23a3d8dcbe26a5b4b2
+  languageName: node
+  linkType: hard
+
+"decamelize@npm:^5.0.0":
+  version: 5.0.1
+  resolution: "decamelize@npm:5.0.1"
+  checksum: 10c0/3da71022bc1e85487810fa0833138effb599fa331ca21e179650e93a765d0c4dabeb1ecdd6ad1474fa0bacd2457953c63ea335afb6e53b35f2b4bf779514e2a3
+  languageName: node
+  linkType: hard
+
+"decimal.js@npm:^10.4.3":
+  version: 10.6.0
+  resolution: "decimal.js@npm:10.6.0"
+  checksum: 10c0/07d69fbcc54167a340d2d97de95f546f9ff1f69d2b45a02fd7a5292412df3cd9eb7e23065e532a318f5474a2e1bccf8392fdf0443ef467f97f3bf8cb0477e5aa
+  languageName: node
+  linkType: hard
+
+"deep-eql@npm:^4.1.3":
+  version: 4.1.4
+  resolution: "deep-eql@npm:4.1.4"
+  dependencies:
+    type-detect: "npm:^4.0.0"
+  checksum: 10c0/264e0613493b43552fc908f4ff87b8b445c0e6e075656649600e1b8a17a57ee03e960156fce7177646e4d2ddaf8e5ee616d76bd79929ff593e5c79e4e5e6c517
+  languageName: node
+  linkType: hard
+
+"deep-is@npm:^0.1.3":
+  version: 0.1.4
+  resolution: "deep-is@npm:0.1.4"
+  checksum: 10c0/7f0ee496e0dff14a573dc6127f14c95061b448b87b995fc96c017ce0a1e66af1675e73f1d6064407975bc4ea6ab679497a29fff7b5b9c4e99cb10797c1ad0b4c
+  languageName: node
+  linkType: hard
+
+"define-data-property@npm:^1.0.1, define-data-property@npm:^1.1.4":
+  version: 1.1.4
+  resolution: "define-data-property@npm:1.1.4"
+  dependencies:
+    es-define-property: "npm:^1.0.0"
+    es-errors: "npm:^1.3.0"
+    gopd: "npm:^1.0.1"
+  checksum: 10c0/dea0606d1483eb9db8d930d4eac62ca0fa16738b0b3e07046cddfacf7d8c868bbe13fa0cb263eb91c7d0d527960dc3f2f2471a69ed7816210307f6744fe62e37
+  languageName: node
+  linkType: hard
+
+"define-properties@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "define-properties@npm:1.2.1"
+  dependencies:
+    define-data-property: "npm:^1.0.1"
+    has-property-descriptors: "npm:^1.0.0"
+    object-keys: "npm:^1.1.1"
+  checksum: 10c0/88a152319ffe1396ccc6ded510a3896e77efac7a1bfbaa174a7b00414a1747377e0bb525d303794a47cf30e805c2ec84e575758512c6e44a993076d29fd4e6c3
+  languageName: node
+  linkType: hard
+
+"delayed-stream@npm:~1.0.0":
+  version: 1.0.0
+  resolution: "delayed-stream@npm:1.0.0"
+  checksum: 10c0/d758899da03392e6712f042bec80aa293bbe9e9ff1b2634baae6a360113e708b91326594c8a486d475c69d6259afb7efacdc3537bfcda1c6c648e390ce601b19
+  languageName: node
+  linkType: hard
+
+"diff-sequences@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "diff-sequences@npm:29.6.3"
+  checksum: 10c0/32e27ac7dbffdf2fb0eb5a84efd98a9ad084fbabd5ac9abb8757c6770d5320d2acd172830b28c4add29bb873d59420601dfc805ac4064330ce59b1adfd0593b2
+  languageName: node
+  linkType: hard
+
+"diff@npm:^4.0.1":
+  version: 4.0.2
+  resolution: "diff@npm:4.0.2"
+  checksum: 10c0/81b91f9d39c4eaca068eb0c1eb0e4afbdc5bb2941d197f513dd596b820b956fef43485876226d65d497bebc15666aa2aa82c679e84f65d5f2bfbf14ee46e32c1
+  languageName: node
+  linkType: hard
+
+"dir-glob@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "dir-glob@npm:3.0.1"
+  dependencies:
+    path-type: "npm:^4.0.0"
+  checksum: 10c0/dcac00920a4d503e38bb64001acb19df4efc14536ada475725e12f52c16777afdee4db827f55f13a908ee7efc0cb282e2e3dbaeeb98c0993dd93d1802d3bf00c
+  languageName: node
+  linkType: hard
+
+"doctrine@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "doctrine@npm:2.1.0"
+  dependencies:
+    esutils: "npm:^2.0.2"
+  checksum: 10c0/b6416aaff1f380bf56c3b552f31fdf7a69b45689368deca72d28636f41c16bb28ec3ebc40ace97db4c1afc0ceeb8120e8492fe0046841c94c2933b2e30a7d5ac
+  languageName: node
+  linkType: hard
+
+"doctrine@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "doctrine@npm:3.0.0"
+  dependencies:
+    esutils: "npm:^2.0.2"
+  checksum: 10c0/c96bdccabe9d62ab6fea9399fdff04a66e6563c1d6fb3a3a063e8d53c3bb136ba63e84250bbf63d00086a769ad53aef92d2bd483f03f837fc97b71cbee6b2520
+  languageName: node
+  linkType: hard
+
+"doctypes@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "doctypes@npm:1.1.0"
+  checksum: 10c0/b3f9d597ad8b9ac6aeba9d64df61f0098174f7570e3d34f7ee245ebc736c7bee122d9738a18e22010b98983fd9a340d63043d3841f02d8a7742a2d96d2c72610
+  languageName: node
+  linkType: hard
+
+"dunder-proto@npm:^1.0.0, dunder-proto@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "dunder-proto@npm:1.0.1"
+  dependencies:
+    call-bind-apply-helpers: "npm:^1.0.1"
+    es-errors: "npm:^1.3.0"
+    gopd: "npm:^1.2.0"
+  checksum: 10c0/199f2a0c1c16593ca0a145dbf76a962f8033ce3129f01284d48c45ed4e14fea9bbacd7b3610b6cdc33486cef20385ac054948fefc6272fcce645c09468f93031
+  languageName: node
+  linkType: hard
+
+"eastasianwidth@npm:^0.2.0":
+  version: 0.2.0
+  resolution: "eastasianwidth@npm:0.2.0"
+  checksum: 10c0/26f364ebcdb6395f95124fda411f63137a4bfb5d3a06453f7f23dfe52502905bd84e0488172e0f9ec295fdc45f05c23d5d91baf16bd26f0fe9acd777a188dc39
+  languageName: node
+  linkType: hard
+
+"electron-to-chromium@npm:^1.5.238":
+  version: 1.5.245
+  resolution: "electron-to-chromium@npm:1.5.245"
+  checksum: 10c0/b129116a3a77eba49a5c3f35de16a6b76e39a08f608f8eedbefdd86669f255ead2e9a15f596eecd4521b3a87bcecab86cbd80843cd0a64a5daffde4af338d9c3
+  languageName: node
+  linkType: hard
+
+"emoji-regex@npm:^8.0.0":
+  version: 8.0.0
+  resolution: "emoji-regex@npm:8.0.0"
+  checksum: 10c0/b6053ad39951c4cf338f9092d7bfba448cdfd46fe6a2a034700b149ac9ffbc137e361cbd3c442297f86bed2e5f7576c1b54cc0a6bf8ef5106cc62f496af35010
+  languageName: node
+  linkType: hard
+
+"emoji-regex@npm:^9.2.2":
+  version: 9.2.2
+  resolution: "emoji-regex@npm:9.2.2"
+  checksum: 10c0/af014e759a72064cf66e6e694a7fc6b0ed3d8db680427b021a89727689671cefe9d04151b2cad51dbaf85d5ba790d061cd167f1cf32eb7b281f6368b3c181639
+  languageName: node
+  linkType: hard
+
+"encoding@npm:^0.1.13":
+  version: 0.1.13
+  resolution: "encoding@npm:0.1.13"
+  dependencies:
+    iconv-lite: "npm:^0.6.2"
+  checksum: 10c0/36d938712ff00fe1f4bac88b43bcffb5930c1efa57bbcdca9d67e1d9d6c57cfb1200fb01efe0f3109b2ce99b231f90779532814a81370a1bd3274a0f58585039
+  languageName: node
+  linkType: hard
+
+"end-of-stream@npm:^1.1.0":
+  version: 1.4.5
+  resolution: "end-of-stream@npm:1.4.5"
+  dependencies:
+    once: "npm:^1.4.0"
+  checksum: 10c0/b0701c92a10b89afb1cb45bf54a5292c6f008d744eb4382fa559d54775ff31617d1d7bc3ef617575f552e24fad2c7c1a1835948c66b3f3a4be0a6c1f35c883d8
+  languageName: node
+  linkType: hard
+
+"entities@npm:^6.0.0":
+  version: 6.0.1
+  resolution: "entities@npm:6.0.1"
+  checksum: 10c0/ed836ddac5acb34341094eb495185d527bd70e8632b6c0d59548cbfa23defdbae70b96f9a405c82904efa421230b5b3fd2283752447d737beffd3f3e6ee74414
+  languageName: node
+  linkType: hard
+
+"env-paths@npm:^2.2.0":
+  version: 2.2.1
+  resolution: "env-paths@npm:2.2.1"
+  checksum: 10c0/285325677bf00e30845e330eec32894f5105529db97496ee3f598478e50f008c5352a41a30e5e72ec9de8a542b5a570b85699cd63bd2bc646dbcb9f311d83bc4
+  languageName: node
+  linkType: hard
+
+"err-code@npm:^2.0.2":
+  version: 2.0.3
+  resolution: "err-code@npm:2.0.3"
+  checksum: 10c0/b642f7b4dd4a376e954947550a3065a9ece6733ab8e51ad80db727aaae0817c2e99b02a97a3d6cecc648a97848305e728289cf312d09af395403a90c9d4d8a66
+  languageName: node
+  linkType: hard
+
+"error-ex@npm:^1.3.1":
+  version: 1.3.4
+  resolution: "error-ex@npm:1.3.4"
+  dependencies:
+    is-arrayish: "npm:^0.2.1"
+  checksum: 10c0/b9e34ff4778b8f3b31a8377e1c654456f4c41aeaa3d10a1138c3b7635d8b7b2e03eb2475d46d8ae055c1f180a1063e100bffabf64ea7e7388b37735df5328664
+  languageName: node
+  linkType: hard
+
+"es-abstract@npm:^1.23.2, es-abstract@npm:^1.23.5, es-abstract@npm:^1.23.9, es-abstract@npm:^1.24.0":
+  version: 1.24.0
+  resolution: "es-abstract@npm:1.24.0"
+  dependencies:
+    array-buffer-byte-length: "npm:^1.0.2"
+    arraybuffer.prototype.slice: "npm:^1.0.4"
+    available-typed-arrays: "npm:^1.0.7"
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.4"
+    data-view-buffer: "npm:^1.0.2"
+    data-view-byte-length: "npm:^1.0.2"
+    data-view-byte-offset: "npm:^1.0.1"
+    es-define-property: "npm:^1.0.1"
+    es-errors: "npm:^1.3.0"
+    es-object-atoms: "npm:^1.1.1"
+    es-set-tostringtag: "npm:^2.1.0"
+    es-to-primitive: "npm:^1.3.0"
+    function.prototype.name: "npm:^1.1.8"
+    get-intrinsic: "npm:^1.3.0"
+    get-proto: "npm:^1.0.1"
+    get-symbol-description: "npm:^1.1.0"
+    globalthis: "npm:^1.0.4"
+    gopd: "npm:^1.2.0"
+    has-property-descriptors: "npm:^1.0.2"
+    has-proto: "npm:^1.2.0"
+    has-symbols: "npm:^1.1.0"
+    hasown: "npm:^2.0.2"
+    internal-slot: "npm:^1.1.0"
+    is-array-buffer: "npm:^3.0.5"
+    is-callable: "npm:^1.2.7"
+    is-data-view: "npm:^1.0.2"
+    is-negative-zero: "npm:^2.0.3"
+    is-regex: "npm:^1.2.1"
+    is-set: "npm:^2.0.3"
+    is-shared-array-buffer: "npm:^1.0.4"
+    is-string: "npm:^1.1.1"
+    is-typed-array: "npm:^1.1.15"
+    is-weakref: "npm:^1.1.1"
+    math-intrinsics: "npm:^1.1.0"
+    object-inspect: "npm:^1.13.4"
+    object-keys: "npm:^1.1.1"
+    object.assign: "npm:^4.1.7"
+    own-keys: "npm:^1.0.1"
+    regexp.prototype.flags: "npm:^1.5.4"
+    safe-array-concat: "npm:^1.1.3"
+    safe-push-apply: "npm:^1.0.0"
+    safe-regex-test: "npm:^1.1.0"
+    set-proto: "npm:^1.0.0"
+    stop-iteration-iterator: "npm:^1.1.0"
+    string.prototype.trim: "npm:^1.2.10"
+    string.prototype.trimend: "npm:^1.0.9"
+    string.prototype.trimstart: "npm:^1.0.8"
+    typed-array-buffer: "npm:^1.0.3"
+    typed-array-byte-length: "npm:^1.0.3"
+    typed-array-byte-offset: "npm:^1.0.4"
+    typed-array-length: "npm:^1.0.7"
+    unbox-primitive: "npm:^1.1.0"
+    which-typed-array: "npm:^1.1.19"
+  checksum: 10c0/b256e897be32df5d382786ce8cce29a1dd8c97efbab77a26609bd70f2ed29fbcfc7a31758cb07488d532e7ccccdfca76c1118f2afe5a424cdc05ca007867c318
+  languageName: node
+  linkType: hard
+
+"es-define-property@npm:^1.0.0, es-define-property@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "es-define-property@npm:1.0.1"
+  checksum: 10c0/3f54eb49c16c18707949ff25a1456728c883e81259f045003499efba399c08bad00deebf65cccde8c0e07908c1a225c9d472b7107e558f2a48e28d530e34527c
+  languageName: node
+  linkType: hard
+
+"es-errors@npm:^1.3.0":
+  version: 1.3.0
+  resolution: "es-errors@npm:1.3.0"
+  checksum: 10c0/0a61325670072f98d8ae3b914edab3559b6caa980f08054a3b872052640d91da01d38df55df797fcc916389d77fc92b8d5906cf028f4db46d7e3003abecbca85
+  languageName: node
+  linkType: hard
+
+"es-module-lexer@npm:^1.5.3":
+  version: 1.7.0
+  resolution: "es-module-lexer@npm:1.7.0"
+  checksum: 10c0/4c935affcbfeba7fb4533e1da10fa8568043df1e3574b869385980de9e2d475ddc36769891936dbb07036edb3c3786a8b78ccf44964cd130dedc1f2c984b6c7b
+  languageName: node
+  linkType: hard
+
+"es-object-atoms@npm:^1.0.0, es-object-atoms@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "es-object-atoms@npm:1.1.1"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+  checksum: 10c0/65364812ca4daf48eb76e2a3b7a89b3f6a2e62a1c420766ce9f692665a29d94fe41fe88b65f24106f449859549711e4b40d9fb8002d862dfd7eb1c512d10be0c
+  languageName: node
+  linkType: hard
+
+"es-set-tostringtag@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "es-set-tostringtag@npm:2.1.0"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    get-intrinsic: "npm:^1.2.6"
+    has-tostringtag: "npm:^1.0.2"
+    hasown: "npm:^2.0.2"
+  checksum: 10c0/ef2ca9ce49afe3931cb32e35da4dcb6d86ab02592cfc2ce3e49ced199d9d0bb5085fc7e73e06312213765f5efa47cc1df553a6a5154584b21448e9fb8355b1af
+  languageName: node
+  linkType: hard
+
+"es-shim-unscopables@npm:^1.0.2, es-shim-unscopables@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "es-shim-unscopables@npm:1.1.0"
+  dependencies:
+    hasown: "npm:^2.0.2"
+  checksum: 10c0/1b9702c8a1823fc3ef39035a4e958802cf294dd21e917397c561d0b3e195f383b978359816b1732d02b255ccf63e1e4815da0065b95db8d7c992037be3bbbcdb
+  languageName: node
+  linkType: hard
+
+"es-to-primitive@npm:^1.3.0":
+  version: 1.3.0
+  resolution: "es-to-primitive@npm:1.3.0"
+  dependencies:
+    is-callable: "npm:^1.2.7"
+    is-date-object: "npm:^1.0.5"
+    is-symbol: "npm:^1.0.4"
+  checksum: 10c0/c7e87467abb0b438639baa8139f701a06537d2b9bc758f23e8622c3b42fd0fdb5bde0f535686119e446dd9d5e4c0f238af4e14960f4771877cf818d023f6730b
+  languageName: node
+  linkType: hard
+
+"esbuild@npm:^0.18.10":
+  version: 0.18.20
+  resolution: "esbuild@npm:0.18.20"
+  dependencies:
+    "@esbuild/android-arm": "npm:0.18.20"
+    "@esbuild/android-arm64": "npm:0.18.20"
+    "@esbuild/android-x64": "npm:0.18.20"
+    "@esbuild/darwin-arm64": "npm:0.18.20"
+    "@esbuild/darwin-x64": "npm:0.18.20"
+    "@esbuild/freebsd-arm64": "npm:0.18.20"
+    "@esbuild/freebsd-x64": "npm:0.18.20"
+    "@esbuild/linux-arm": "npm:0.18.20"
+    "@esbuild/linux-arm64": "npm:0.18.20"
+    "@esbuild/linux-ia32": "npm:0.18.20"
+    "@esbuild/linux-loong64": "npm:0.18.20"
+    "@esbuild/linux-mips64el": "npm:0.18.20"
+    "@esbuild/linux-ppc64": "npm:0.18.20"
+    "@esbuild/linux-riscv64": "npm:0.18.20"
+    "@esbuild/linux-s390x": "npm:0.18.20"
+    "@esbuild/linux-x64": "npm:0.18.20"
+    "@esbuild/netbsd-x64": "npm:0.18.20"
+    "@esbuild/openbsd-x64": "npm:0.18.20"
+    "@esbuild/sunos-x64": "npm:0.18.20"
+    "@esbuild/win32-arm64": "npm:0.18.20"
+    "@esbuild/win32-ia32": "npm:0.18.20"
+    "@esbuild/win32-x64": "npm:0.18.20"
+  dependenciesMeta:
+    "@esbuild/android-arm":
+      optional: true
+    "@esbuild/android-arm64":
+      optional: true
+    "@esbuild/android-x64":
+      optional: true
+    "@esbuild/darwin-arm64":
+      optional: true
+    "@esbuild/darwin-x64":
+      optional: true
+    "@esbuild/freebsd-arm64":
+      optional: true
+    "@esbuild/freebsd-x64":
+      optional: true
+    "@esbuild/linux-arm":
+      optional: true
+    "@esbuild/linux-arm64":
+      optional: true
+    "@esbuild/linux-ia32":
+      optional: true
+    "@esbuild/linux-loong64":
+      optional: true
+    "@esbuild/linux-mips64el":
+      optional: true
+    "@esbuild/linux-ppc64":
+      optional: true
+    "@esbuild/linux-riscv64":
+      optional: true
+    "@esbuild/linux-s390x":
+      optional: true
+    "@esbuild/linux-x64":
+      optional: true
+    "@esbuild/netbsd-x64":
+      optional: true
+    "@esbuild/openbsd-x64":
+      optional: true
+    "@esbuild/sunos-x64":
+      optional: true
+    "@esbuild/win32-arm64":
+      optional: true
+    "@esbuild/win32-ia32":
+      optional: true
+    "@esbuild/win32-x64":
+      optional: true
+  bin:
+    esbuild: bin/esbuild
+  checksum: 10c0/473b1d92842f50a303cf948a11ebd5f69581cd254d599dd9d62f9989858e0533f64e83b723b5e1398a5b488c0f5fd088795b4235f65ecaf4f007d4b79f04bc88
+  languageName: node
+  linkType: hard
+
+"esbuild@npm:^0.21.3":
+  version: 0.21.5
+  resolution: "esbuild@npm:0.21.5"
+  dependencies:
+    "@esbuild/aix-ppc64": "npm:0.21.5"
+    "@esbuild/android-arm": "npm:0.21.5"
+    "@esbuild/android-arm64": "npm:0.21.5"
+    "@esbuild/android-x64": "npm:0.21.5"
+    "@esbuild/darwin-arm64": "npm:0.21.5"
+    "@esbuild/darwin-x64": "npm:0.21.5"
+    "@esbuild/freebsd-arm64": "npm:0.21.5"
+    "@esbuild/freebsd-x64": "npm:0.21.5"
+    "@esbuild/linux-arm": "npm:0.21.5"
+    "@esbuild/linux-arm64": "npm:0.21.5"
+    "@esbuild/linux-ia32": "npm:0.21.5"
+    "@esbuild/linux-loong64": "npm:0.21.5"
+    "@esbuild/linux-mips64el": "npm:0.21.5"
+    "@esbuild/linux-ppc64": "npm:0.21.5"
+    "@esbuild/linux-riscv64": "npm:0.21.5"
+    "@esbuild/linux-s390x": "npm:0.21.5"
+    "@esbuild/linux-x64": "npm:0.21.5"
+    "@esbuild/netbsd-x64": "npm:0.21.5"
+    "@esbuild/openbsd-x64": "npm:0.21.5"
+    "@esbuild/sunos-x64": "npm:0.21.5"
+    "@esbuild/win32-arm64": "npm:0.21.5"
+    "@esbuild/win32-ia32": "npm:0.21.5"
+    "@esbuild/win32-x64": "npm:0.21.5"
+  dependenciesMeta:
+    "@esbuild/aix-ppc64":
+      optional: true
+    "@esbuild/android-arm":
+      optional: true
+    "@esbuild/android-arm64":
+      optional: true
+    "@esbuild/android-x64":
+      optional: true
+    "@esbuild/darwin-arm64":
+      optional: true
+    "@esbuild/darwin-x64":
+      optional: true
+    "@esbuild/freebsd-arm64":
+      optional: true
+    "@esbuild/freebsd-x64":
+      optional: true
+    "@esbuild/linux-arm":
+      optional: true
+    "@esbuild/linux-arm64":
+      optional: true
+    "@esbuild/linux-ia32":
+      optional: true
+    "@esbuild/linux-loong64":
+      optional: true
+    "@esbuild/linux-mips64el":
+      optional: true
+    "@esbuild/linux-ppc64":
+      optional: true
+    "@esbuild/linux-riscv64":
+      optional: true
+    "@esbuild/linux-s390x":
+      optional: true
+    "@esbuild/linux-x64":
+      optional: true
+    "@esbuild/netbsd-x64":
+      optional: true
+    "@esbuild/openbsd-x64":
+      optional: true
+    "@esbuild/sunos-x64":
+      optional: true
+    "@esbuild/win32-arm64":
+      optional: true
+    "@esbuild/win32-ia32":
+      optional: true
+    "@esbuild/win32-x64":
+      optional: true
+  bin:
+    esbuild: bin/esbuild
+  checksum: 10c0/fa08508adf683c3f399e8a014a6382a6b65542213431e26206c0720e536b31c09b50798747c2a105a4bbba1d9767b8d3615a74c2f7bf1ddf6d836cd11eb672de
+  languageName: node
+  linkType: hard
+
+"escalade@npm:^3.2.0":
+  version: 3.2.0
+  resolution: "escalade@npm:3.2.0"
+  checksum: 10c0/ced4dd3a78e15897ed3be74e635110bbf3b08877b0a41be50dcb325ee0e0b5f65fc2d50e9845194d7c4633f327e2e1c6cce00a71b617c5673df0374201d67f65
+  languageName: node
+  linkType: hard
+
+"escape-string-regexp@npm:^1.0.5":
+  version: 1.0.5
+  resolution: "escape-string-regexp@npm:1.0.5"
+  checksum: 10c0/a968ad453dd0c2724e14a4f20e177aaf32bb384ab41b674a8454afe9a41c5e6fe8903323e0a1052f56289d04bd600f81278edf140b0fcc02f5cac98d0f5b5371
+  languageName: node
+  linkType: hard
+
+"escape-string-regexp@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "escape-string-regexp@npm:4.0.0"
+  checksum: 10c0/9497d4dd307d845bd7f75180d8188bb17ea8c151c1edbf6b6717c100e104d629dc2dfb687686181b0f4b7d732c7dfdc4d5e7a8ff72de1b0ca283a75bbb3a9cd9
+  languageName: node
+  linkType: hard
+
+"eslint-compat-utils@npm:^0.5.1":
+  version: 0.5.1
+  resolution: "eslint-compat-utils@npm:0.5.1"
+  dependencies:
+    semver: "npm:^7.5.4"
+  peerDependencies:
+    eslint: ">=6.0.0"
+  checksum: 10c0/325e815205fab70ebcd379f6d4b5d44c7d791bb8dfe0c9888233f30ebabd9418422595b53a781b946c768d9244d858540e5e6129a6b3dd6d606f467d599edc6c
+  languageName: node
+  linkType: hard
+
+"eslint-config-codex@npm:^1.7.1":
+  version: 1.9.2
+  resolution: "eslint-config-codex@npm:1.9.2"
+  dependencies:
+    "@typescript-eslint/eslint-plugin": "npm:^6.2.0"
+    "@typescript-eslint/parser": "npm:^6.2.0"
+    eslint-config-standard: "npm:17.1.0"
+    eslint-plugin-import: "npm:2.28.0"
+    eslint-plugin-jsdoc: "npm:^46.4.5"
+    eslint-plugin-n: "npm:^16.0.1"
+    eslint-plugin-promise: "npm:6.1.1"
+    eslint-plugin-standard: "npm:5.0.0"
+  peerDependencies:
+    eslint: ">= 5.3.0"
+  checksum: 10c0/89f1ea8e1c1d4e5f5a7ea699d635ca0a017cc6f98872caf192d2b53f660fa0a6911efa7c92143007ebb28798e7927fb8cd82410f9d202c4787fc5a2e8431d484
+  languageName: node
+  linkType: hard
+
+"eslint-config-standard@npm:17.1.0":
+  version: 17.1.0
+  resolution: "eslint-config-standard@npm:17.1.0"
+  peerDependencies:
+    eslint: ^8.0.1
+    eslint-plugin-import: ^2.25.2
+    eslint-plugin-n: "^15.0.0 || ^16.0.0 "
+    eslint-plugin-promise: ^6.0.0
+  checksum: 10c0/d32f37ec4bea541debd3a8c9e05227673a9b1a9977da078195ee55fb371813ddf1349c75f2c33d76699fe3412f1e303181795f146e8d0e546b94fa0dce2bfbf9
+  languageName: node
+  linkType: hard
+
+"eslint-import-resolver-node@npm:^0.3.7, eslint-import-resolver-node@npm:^0.3.9":
+  version: 0.3.9
+  resolution: "eslint-import-resolver-node@npm:0.3.9"
+  dependencies:
+    debug: "npm:^3.2.7"
+    is-core-module: "npm:^2.13.0"
+    resolve: "npm:^1.22.4"
+  checksum: 10c0/0ea8a24a72328a51fd95aa8f660dcca74c1429806737cf10261ab90cfcaaf62fd1eff664b76a44270868e0a932711a81b250053942595bcd00a93b1c1575dd61
+  languageName: node
+  linkType: hard
+
+"eslint-module-utils@npm:^2.12.1, eslint-module-utils@npm:^2.8.0":
+  version: 2.12.1
+  resolution: "eslint-module-utils@npm:2.12.1"
+  dependencies:
+    debug: "npm:^3.2.7"
+  peerDependenciesMeta:
+    eslint:
+      optional: true
+  checksum: 10c0/6f4efbe7a91ae49bf67b4ab3644cb60bc5bd7db4cb5521de1b65be0847ffd3fb6bce0dd68f0995e1b312d137f768e2a1f842ee26fe73621afa05f850628fdc40
+  languageName: node
+  linkType: hard
+
+"eslint-plugin-chai-friendly@npm:^0.7.2":
+  version: 0.7.4
+  resolution: "eslint-plugin-chai-friendly@npm:0.7.4"
+  peerDependencies:
+    eslint: ">=3.0.0"
+  checksum: 10c0/b161e4796de4db304042ea8da1bd467d63d22e89f74e85134c2a6755c49c53021ac2e48003af06d41b7a1b1b5e8cceacca6dc18ffaee02afd79a1c243728b8a7
+  languageName: node
+  linkType: hard
+
+"eslint-plugin-deprecation@npm:^1.5.0":
+  version: 1.5.0
+  resolution: "eslint-plugin-deprecation@npm:1.5.0"
+  dependencies:
+    "@typescript-eslint/utils": "npm:^5.57.0"
+    tslib: "npm:^2.3.1"
+    tsutils: "npm:^3.21.0"
+  peerDependencies:
+    eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
+    typescript: ^3.7.5 || ^4.0.0 || ^5.0.0
+  checksum: 10c0/d53d821e96b8ab6dc7711275f3708eda6cfa7bf82858400a882cc0e8750ac89ea4870169b888d7e19985c7e6cb922a8120a56783110882b43c4f34cbe8a1ccb0
+  languageName: node
+  linkType: hard
+
+"eslint-plugin-es-x@npm:^7.5.0":
+  version: 7.8.0
+  resolution: "eslint-plugin-es-x@npm:7.8.0"
+  dependencies:
+    "@eslint-community/eslint-utils": "npm:^4.1.2"
+    "@eslint-community/regexpp": "npm:^4.11.0"
+    eslint-compat-utils: "npm:^0.5.1"
+  peerDependencies:
+    eslint: ">=8"
+  checksum: 10c0/002fda8c029bc5da41e24e7ac11654062831d675fc4f5f20d0de460e24bf1e05cd559000678ef3e46c48641190f4fc07ae3d57aa5e8b085ef5f67e5f63742614
+  languageName: node
+  linkType: hard
+
+"eslint-plugin-import@npm:2.28.0":
+  version: 2.28.0
+  resolution: "eslint-plugin-import@npm:2.28.0"
+  dependencies:
+    array-includes: "npm:^3.1.6"
+    array.prototype.findlastindex: "npm:^1.2.2"
+    array.prototype.flat: "npm:^1.3.1"
+    array.prototype.flatmap: "npm:^1.3.1"
+    debug: "npm:^3.2.7"
+    doctrine: "npm:^2.1.0"
+    eslint-import-resolver-node: "npm:^0.3.7"
+    eslint-module-utils: "npm:^2.8.0"
+    has: "npm:^1.0.3"
+    is-core-module: "npm:^2.12.1"
+    is-glob: "npm:^4.0.3"
+    minimatch: "npm:^3.1.2"
+    object.fromentries: "npm:^2.0.6"
+    object.groupby: "npm:^1.0.0"
+    object.values: "npm:^1.1.6"
+    resolve: "npm:^1.22.3"
+    semver: "npm:^6.3.1"
+    tsconfig-paths: "npm:^3.14.2"
+  peerDependencies:
+    eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8
+  checksum: 10c0/0d7b978a3c4778b68bede2c8a14512e33581091bd8a508c4a424d2e8bff1f174549ffc3f2b7cfb28345cfb63061d3e43fdaa810ebfe9c96b5a4a1dc4047f6e9d
+  languageName: node
+  linkType: hard
+
+"eslint-plugin-import@npm:^2.32.0":
+  version: 2.32.0
+  resolution: "eslint-plugin-import@npm:2.32.0"
+  dependencies:
+    "@rtsao/scc": "npm:^1.1.0"
+    array-includes: "npm:^3.1.9"
+    array.prototype.findlastindex: "npm:^1.2.6"
+    array.prototype.flat: "npm:^1.3.3"
+    array.prototype.flatmap: "npm:^1.3.3"
+    debug: "npm:^3.2.7"
+    doctrine: "npm:^2.1.0"
+    eslint-import-resolver-node: "npm:^0.3.9"
+    eslint-module-utils: "npm:^2.12.1"
+    hasown: "npm:^2.0.2"
+    is-core-module: "npm:^2.16.1"
+    is-glob: "npm:^4.0.3"
+    minimatch: "npm:^3.1.2"
+    object.fromentries: "npm:^2.0.8"
+    object.groupby: "npm:^1.0.3"
+    object.values: "npm:^1.2.1"
+    semver: "npm:^6.3.1"
+    string.prototype.trimend: "npm:^1.0.9"
+    tsconfig-paths: "npm:^3.15.0"
+  peerDependencies:
+    eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9
+  checksum: 10c0/bfb1b8fc8800398e62ddfefbf3638d185286edfed26dfe00875cc2846d954491b4f5112457831588b757fa789384e1ae585f812614c4797f0499fa234fd4a48b
+  languageName: node
+  linkType: hard
+
+"eslint-plugin-jest@npm:^29.1.0":
+  version: 29.1.0
+  resolution: "eslint-plugin-jest@npm:29.1.0"
+  dependencies:
+    "@typescript-eslint/utils": "npm:^8.0.0"
+  peerDependencies:
+    "@typescript-eslint/eslint-plugin": ^8.0.0
+    eslint: ^8.57.0 || ^9.0.0
+    jest: "*"
+  peerDependenciesMeta:
+    "@typescript-eslint/eslint-plugin":
+      optional: true
+    jest:
+      optional: true
+  checksum: 10c0/3fe5d4c35279025eb96bfb0adfad1b0eca03f5987db96adbe656279b5b4ed3eaa5240dd1876e54e7ea98b28acbd451256f8c7613cf2d2d6d3387f6360fcb3704
+  languageName: node
+  linkType: hard
+
+"eslint-plugin-jsdoc@npm:^48.0.0":
+  version: 48.11.0
+  resolution: "eslint-plugin-jsdoc@npm:48.11.0"
+  dependencies:
+    "@es-joy/jsdoccomment": "npm:~0.46.0"
+    are-docs-informative: "npm:^0.0.2"
+    comment-parser: "npm:1.4.1"
+    debug: "npm:^4.3.5"
+    escape-string-regexp: "npm:^4.0.0"
+    espree: "npm:^10.1.0"
+    esquery: "npm:^1.6.0"
+    parse-imports: "npm:^2.1.1"
+    semver: "npm:^7.6.3"
+    spdx-expression-parse: "npm:^4.0.0"
+    synckit: "npm:^0.9.1"
+  peerDependencies:
+    eslint: ^7.0.0 || ^8.0.0 || ^9.0.0
+  checksum: 10c0/f78bac109e62f838c14f90ebd572a06a865f2896a16201c9324cb92be25b5ba8deb54ee1d8ea36232ee53a41c177d5d5ac80662c0fe2479d1e1e1e7633385659
+  languageName: node
+  linkType: hard
+
+"eslint-plugin-n@npm:^16.0.1":
+  version: 16.6.2
+  resolution: "eslint-plugin-n@npm:16.6.2"
+  dependencies:
+    "@eslint-community/eslint-utils": "npm:^4.4.0"
+    builtins: "npm:^5.0.1"
+    eslint-plugin-es-x: "npm:^7.5.0"
+    get-tsconfig: "npm:^4.7.0"
+    globals: "npm:^13.24.0"
+    ignore: "npm:^5.2.4"
+    is-builtin-module: "npm:^3.2.1"
+    is-core-module: "npm:^2.12.1"
+    minimatch: "npm:^3.1.2"
+    resolve: "npm:^1.22.2"
+    semver: "npm:^7.5.3"
+  peerDependencies:
+    eslint: ">=7.0.0"
+  checksum: 10c0/6008493754b51c6b9ce18c17e7c3d455b69444d2c454dd399a5c2f1b833bb5a649992052f141a5dd695d22e3946a518063b2dd01e872c67dc0294eb143b80633
+  languageName: node
+  linkType: hard
+
+"eslint-plugin-playwright@npm:^2.3.0":
+  version: 2.3.0
+  resolution: "eslint-plugin-playwright@npm:2.3.0"
+  dependencies:
+    globals: "npm:^16.4.0"
+  peerDependencies:
+    eslint: ">=8.40.0"
+  checksum: 10c0/ae7dcff6b65da93992e97dd558d34b07147c9bd3b41f7183e41222b8bf9445406be9449907162dded8f906044a6b65b6876f0c48e43bf24ecf3a027f4c924e79
+  languageName: node
+  linkType: hard
+
+"eslint-plugin-promise@npm:6.1.1":
+  version: 6.1.1
+  resolution: "eslint-plugin-promise@npm:6.1.1"
+  peerDependencies:
+    eslint: ^7.0.0 || ^8.0.0
+  checksum: 10c0/ec705741c110cd1cb4d702776e1c7f7fe60b671b71f706c88054ab443cf2767aae5a663928fb426373ba1095eaeda312a740a4f880546631f0e0727f298b3393
+  languageName: node
+  linkType: hard
+
+"eslint-plugin-sonarjs@npm:^3.0.5":
+  version: 3.0.5
+  resolution: "eslint-plugin-sonarjs@npm:3.0.5"
+  dependencies:
+    "@eslint-community/regexpp": "npm:4.12.1"
+    builtin-modules: "npm:3.3.0"
+    bytes: "npm:3.1.2"
+    functional-red-black-tree: "npm:1.0.1"
+    jsx-ast-utils-x: "npm:0.1.0"
+    lodash.merge: "npm:4.6.2"
+    minimatch: "npm:9.0.5"
+    scslre: "npm:0.3.0"
+    semver: "npm:7.7.2"
+    typescript: "npm:>=5"
+  peerDependencies:
+    eslint: ^8.0.0 || ^9.0.0
+  checksum: 10c0/e771084f7d01ed32be882cf341a3e78f76655e73bd7916080a798d2323ea650a0330f4cd6c5b9cd020696eab4a931184df37de1fd38a3109083ecf28b97362f5
+  languageName: node
+  linkType: hard
+
+"eslint-plugin-standard@npm:5.0.0":
+  version: 5.0.0
+  resolution: "eslint-plugin-standard@npm:5.0.0"
+  peerDependencies:
+    eslint: ">=5.0.0"
+  checksum: 10c0/563835504443b6f1feafca6a1f4b35a827bd9e36d9d358f6f8ce9d375951abdf45e4949b34e795da952a822919109420fc4a2c3cc339d2500b6c26789a0617ea
+  languageName: node
+  linkType: hard
+
+"eslint-scope@npm:^7.2.2":
+  version: 7.2.2
+  resolution: "eslint-scope@npm:7.2.2"
+  dependencies:
+    esrecurse: "npm:^4.3.0"
+    estraverse: "npm:^5.2.0"
+  checksum: 10c0/613c267aea34b5a6d6c00514e8545ef1f1433108097e857225fed40d397dd6b1809dffd11c2fde23b37ca53d7bf935fe04d2a18e6fc932b31837b6ad67e1c116
+  languageName: node
+  linkType: hard
+
+"eslint-visitor-keys@npm:^3.4.1, eslint-visitor-keys@npm:^3.4.3":
+  version: 3.4.3
+  resolution: "eslint-visitor-keys@npm:3.4.3"
+  checksum: 10c0/92708e882c0a5ffd88c23c0b404ac1628cf20104a108c745f240a13c332a11aac54f49a22d5762efbffc18ecbc9a580d1b7ad034bf5f3cc3307e5cbff2ec9820
+  languageName: node
+  linkType: hard
+
+"eslint-visitor-keys@npm:^4.2.1":
+  version: 4.2.1
+  resolution: "eslint-visitor-keys@npm:4.2.1"
+  checksum: 10c0/fcd43999199d6740db26c58dbe0c2594623e31ca307e616ac05153c9272f12f1364f5a0b1917a8e962268fdecc6f3622c1c2908b4fcc2e047a106fe6de69dc43
+  languageName: node
+  linkType: hard
+
+"eslint@npm:^8.37.0":
+  version: 8.57.1
+  resolution: "eslint@npm:8.57.1"
+  dependencies:
+    "@eslint-community/eslint-utils": "npm:^4.2.0"
+    "@eslint-community/regexpp": "npm:^4.6.1"
+    "@eslint/eslintrc": "npm:^2.1.4"
+    "@eslint/js": "npm:8.57.1"
+    "@humanwhocodes/config-array": "npm:^0.13.0"
+    "@humanwhocodes/module-importer": "npm:^1.0.1"
+    "@nodelib/fs.walk": "npm:^1.2.8"
+    "@ungap/structured-clone": "npm:^1.2.0"
+    ajv: "npm:^6.12.4"
+    chalk: "npm:^4.0.0"
+    cross-spawn: "npm:^7.0.2"
+    debug: "npm:^4.3.2"
+    doctrine: "npm:^3.0.0"
+    escape-string-regexp: "npm:^4.0.0"
+    eslint-scope: "npm:^7.2.2"
+    eslint-visitor-keys: "npm:^3.4.3"
+    espree: "npm:^9.6.1"
+    esquery: "npm:^1.4.2"
+    esutils: "npm:^2.0.2"
+    fast-deep-equal: "npm:^3.1.3"
+    file-entry-cache: "npm:^6.0.1"
+    find-up: "npm:^5.0.0"
+    glob-parent: "npm:^6.0.2"
+    globals: "npm:^13.19.0"
+    graphemer: "npm:^1.4.0"
+    ignore: "npm:^5.2.0"
+    imurmurhash: "npm:^0.1.4"
+    is-glob: "npm:^4.0.0"
+    is-path-inside: "npm:^3.0.3"
+    js-yaml: "npm:^4.1.0"
+    json-stable-stringify-without-jsonify: "npm:^1.0.1"
+    levn: "npm:^0.4.1"
+    lodash.merge: "npm:^4.6.2"
+    minimatch: "npm:^3.1.2"
+    natural-compare: "npm:^1.4.0"
+    optionator: "npm:^0.9.3"
+    strip-ansi: "npm:^6.0.1"
+    text-table: "npm:^0.2.0"
+  bin:
+    eslint: bin/eslint.js
+  checksum: 10c0/1fd31533086c1b72f86770a4d9d7058ee8b4643fd1cfd10c7aac1ecb8725698e88352a87805cf4b2ce890aa35947df4b4da9655fb7fdfa60dbb448a43f6ebcf1
+  languageName: node
+  linkType: hard
+
+"espree@npm:^10.0.1, espree@npm:^10.1.0":
+  version: 10.4.0
+  resolution: "espree@npm:10.4.0"
+  dependencies:
+    acorn: "npm:^8.15.0"
+    acorn-jsx: "npm:^5.3.2"
+    eslint-visitor-keys: "npm:^4.2.1"
+  checksum: 10c0/c63fe06131c26c8157b4083313cb02a9a54720a08e21543300e55288c40e06c3fc284bdecf108d3a1372c5934a0a88644c98714f38b6ae8ed272b40d9ea08d6b
+  languageName: node
+  linkType: hard
+
+"espree@npm:^9.6.0, espree@npm:^9.6.1":
+  version: 9.6.1
+  resolution: "espree@npm:9.6.1"
+  dependencies:
+    acorn: "npm:^8.9.0"
+    acorn-jsx: "npm:^5.3.2"
+    eslint-visitor-keys: "npm:^3.4.1"
+  checksum: 10c0/1a2e9b4699b715347f62330bcc76aee224390c28bb02b31a3752e9d07549c473f5f986720483c6469cf3cfb3c9d05df612ffc69eb1ee94b54b739e67de9bb460
+  languageName: node
+  linkType: hard
+
+"esprima@npm:^4.0.0":
+  version: 4.0.1
+  resolution: "esprima@npm:4.0.1"
+  bin:
+    esparse: ./bin/esparse.js
+    esvalidate: ./bin/esvalidate.js
+  checksum: 10c0/ad4bab9ead0808cf56501750fd9d3fb276f6b105f987707d059005d57e182d18a7c9ec7f3a01794ebddcca676773e42ca48a32d67a250c9d35e009ca613caba3
+  languageName: node
+  linkType: hard
+
+"esquery@npm:^1.4.2, esquery@npm:^1.6.0":
+  version: 1.6.0
+  resolution: "esquery@npm:1.6.0"
+  dependencies:
+    estraverse: "npm:^5.1.0"
+  checksum: 10c0/cb9065ec605f9da7a76ca6dadb0619dfb611e37a81e318732977d90fab50a256b95fee2d925fba7c2f3f0523aa16f91587246693bc09bc34d5a59575fe6e93d2
+  languageName: node
+  linkType: hard
+
+"esrecurse@npm:^4.3.0":
+  version: 4.3.0
+  resolution: "esrecurse@npm:4.3.0"
+  dependencies:
+    estraverse: "npm:^5.2.0"
+  checksum: 10c0/81a37116d1408ded88ada45b9fb16dbd26fba3aadc369ce50fcaf82a0bac12772ebd7b24cd7b91fc66786bf2c1ac7b5f196bc990a473efff972f5cb338877cf5
+  languageName: node
+  linkType: hard
+
+"estraverse@npm:^5.1.0, estraverse@npm:^5.2.0":
+  version: 5.3.0
+  resolution: "estraverse@npm:5.3.0"
+  checksum: 10c0/1ff9447b96263dec95d6d67431c5e0771eb9776427421260a3e2f0fdd5d6bd4f8e37a7338f5ad2880c9f143450c9b1e4fc2069060724570a49cf9cf0312bd107
+  languageName: node
+  linkType: hard
+
+"estree-walker@npm:^3.0.3":
+  version: 3.0.3
+  resolution: "estree-walker@npm:3.0.3"
+  dependencies:
+    "@types/estree": "npm:^1.0.0"
+  checksum: 10c0/c12e3c2b2642d2bcae7d5aa495c60fa2f299160946535763969a1c83fc74518ffa9c2cd3a8b69ac56aea547df6a8aac25f729a342992ef0bbac5f1c73e78995d
+  languageName: node
+  linkType: hard
+
+"esutils@npm:^2.0.2":
+  version: 2.0.3
+  resolution: "esutils@npm:2.0.3"
+  checksum: 10c0/9a2fe69a41bfdade834ba7c42de4723c97ec776e40656919c62cbd13607c45e127a003f05f724a1ea55e5029a4cf2de444b13009f2af71271e42d93a637137c7
+  languageName: node
+  linkType: hard
+
+"eventemitter3@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "eventemitter3@npm:5.0.1"
+  checksum: 10c0/4ba5c00c506e6c786b4d6262cfbce90ddc14c10d4667e5c83ae993c9de88aa856033994dd2b35b83e8dc1170e224e66a319fa80adc4c32adcd2379bbc75da814
+  languageName: node
+  linkType: hard
+
+"execa@npm:^4.0.0":
+  version: 4.1.0
+  resolution: "execa@npm:4.1.0"
+  dependencies:
+    cross-spawn: "npm:^7.0.0"
+    get-stream: "npm:^5.0.0"
+    human-signals: "npm:^1.1.1"
+    is-stream: "npm:^2.0.0"
+    merge-stream: "npm:^2.0.0"
+    npm-run-path: "npm:^4.0.0"
+    onetime: "npm:^5.1.0"
+    signal-exit: "npm:^3.0.2"
+    strip-final-newline: "npm:^2.0.0"
+  checksum: 10c0/02211601bb1c52710260edcc68fb84c3c030dc68bafc697c90ada3c52cc31375337de8c24826015b8382a58d63569ffd203b79c94fef217d65503e3e8d2c52ba
+  languageName: node
+  linkType: hard
+
+"execa@npm:^8.0.1":
+  version: 8.0.1
+  resolution: "execa@npm:8.0.1"
+  dependencies:
+    cross-spawn: "npm:^7.0.3"
+    get-stream: "npm:^8.0.1"
+    human-signals: "npm:^5.0.0"
+    is-stream: "npm:^3.0.0"
+    merge-stream: "npm:^2.0.0"
+    npm-run-path: "npm:^5.1.0"
+    onetime: "npm:^6.0.0"
+    signal-exit: "npm:^4.1.0"
+    strip-final-newline: "npm:^3.0.0"
+  checksum: 10c0/2c52d8775f5bf103ce8eec9c7ab3059909ba350a5164744e9947ed14a53f51687c040a250bda833f906d1283aa8803975b84e6c8f7a7c42f99dc8ef80250d1af
+  languageName: node
+  linkType: hard
+
+"exponential-backoff@npm:^3.1.1":
+  version: 3.1.3
+  resolution: "exponential-backoff@npm:3.1.3"
+  checksum: 10c0/77e3ae682b7b1f4972f563c6dbcd2b0d54ac679e62d5d32f3e5085feba20483cf28bd505543f520e287a56d4d55a28d7874299941faf637e779a1aa5994d1267
+  languageName: node
+  linkType: hard
+
+"fast-deep-equal@npm:^3.1.1, fast-deep-equal@npm:^3.1.3":
+  version: 3.1.3
+  resolution: "fast-deep-equal@npm:3.1.3"
+  checksum: 10c0/40dedc862eb8992c54579c66d914635afbec43350afbbe991235fdcb4e3a8d5af1b23ae7e79bef7d4882d0ecee06c3197488026998fb19f72dc95acff1d1b1d0
+  languageName: node
+  linkType: hard
+
+"fast-glob@npm:^3.2.9, fast-glob@npm:^3.3.1, fast-glob@npm:^3.3.2":
+  version: 3.3.3
+  resolution: "fast-glob@npm:3.3.3"
+  dependencies:
+    "@nodelib/fs.stat": "npm:^2.0.2"
+    "@nodelib/fs.walk": "npm:^1.2.3"
+    glob-parent: "npm:^5.1.2"
+    merge2: "npm:^1.3.0"
+    micromatch: "npm:^4.0.8"
+  checksum: 10c0/f6aaa141d0d3384cf73cbcdfc52f475ed293f6d5b65bfc5def368b09163a9f7e5ec2b3014d80f733c405f58e470ee0cc451c2937685045cddcdeaa24199c43fe
+  languageName: node
+  linkType: hard
+
+"fast-json-stable-stringify@npm:^2.0.0":
+  version: 2.1.0
+  resolution: "fast-json-stable-stringify@npm:2.1.0"
+  checksum: 10c0/7f081eb0b8a64e0057b3bb03f974b3ef00135fbf36c1c710895cd9300f13c94ba809bb3a81cf4e1b03f6e5285610a61abbd7602d0652de423144dfee5a389c9b
+  languageName: node
+  linkType: hard
+
+"fast-levenshtein@npm:^2.0.6":
+  version: 2.0.6
+  resolution: "fast-levenshtein@npm:2.0.6"
+  checksum: 10c0/111972b37338bcb88f7d9e2c5907862c280ebf4234433b95bc611e518d192ccb2d38119c4ac86e26b668d75f7f3894f4ff5c4982899afced7ca78633b08287c4
+  languageName: node
+  linkType: hard
+
+"fast-uri@npm:^3.0.1":
+  version: 3.1.0
+  resolution: "fast-uri@npm:3.1.0"
+  checksum: 10c0/44364adca566f70f40d1e9b772c923138d47efeac2ae9732a872baafd77061f26b097ba2f68f0892885ad177becd065520412b8ffeec34b16c99433c5b9e2de7
+  languageName: node
+  linkType: hard
+
+"fastest-levenshtein@npm:^1.0.16":
+  version: 1.0.16
+  resolution: "fastest-levenshtein@npm:1.0.16"
+  checksum: 10c0/7e3d8ae812a7f4fdf8cad18e9cde436a39addf266a5986f653ea0d81e0de0900f50c0f27c6d5aff3f686bcb48acbd45be115ae2216f36a6a13a7dbbf5cad878b
+  languageName: node
+  linkType: hard
+
+"fastq@npm:^1.6.0":
+  version: 1.19.1
+  resolution: "fastq@npm:1.19.1"
+  dependencies:
+    reusify: "npm:^1.0.4"
+  checksum: 10c0/ebc6e50ac7048daaeb8e64522a1ea7a26e92b3cee5cd1c7f2316cdca81ba543aa40a136b53891446ea5c3a67ec215fbaca87ad405f102dd97012f62916905630
+  languageName: node
+  linkType: hard
+
+"fdir@npm:^6.4.3, fdir@npm:^6.5.0":
+  version: 6.5.0
+  resolution: "fdir@npm:6.5.0"
+  peerDependencies:
+    picomatch: ^3 || ^4
+  peerDependenciesMeta:
+    picomatch:
+      optional: true
+  checksum: 10c0/e345083c4306b3aed6cb8ec551e26c36bab5c511e99ea4576a16750ddc8d3240e63826cc624f5ae17ad4dc82e68a253213b60d556c11bfad064b7607847ed07f
+  languageName: node
+  linkType: hard
+
+"fflate@npm:^0.8.1":
+  version: 0.8.2
+  resolution: "fflate@npm:0.8.2"
+  checksum: 10c0/03448d630c0a583abea594835a9fdb2aaf7d67787055a761515bf4ed862913cfd693b4c4ffd5c3f3b355a70cf1e19033e9ae5aedcca103188aaff91b8bd6e293
+  languageName: node
+  linkType: hard
+
+"file-entry-cache@npm:^6.0.1":
+  version: 6.0.1
+  resolution: "file-entry-cache@npm:6.0.1"
+  dependencies:
+    flat-cache: "npm:^3.0.4"
+  checksum: 10c0/58473e8a82794d01b38e5e435f6feaf648e3f36fdb3a56e98f417f4efae71ad1c0d4ebd8a9a7c50c3ad085820a93fc7494ad721e0e4ebc1da3573f4e1c3c7cdd
+  languageName: node
+  linkType: hard
+
+"file-entry-cache@npm:^7.0.0":
+  version: 7.0.2
+  resolution: "file-entry-cache@npm:7.0.2"
+  dependencies:
+    flat-cache: "npm:^3.2.0"
+  checksum: 10c0/822664e35c3e295e6a8ca7ec490d8d8077017607f41f94b29922f1f49c6dd07025048e3ed528e2909a1439eba66d60f802c0774aa612cf6ee053ee4ecc16c8c5
+  languageName: node
+  linkType: hard
+
+"fill-range@npm:^7.1.1":
+  version: 7.1.1
+  resolution: "fill-range@npm:7.1.1"
+  dependencies:
+    to-regex-range: "npm:^5.0.1"
+  checksum: 10c0/b75b691bbe065472f38824f694c2f7449d7f5004aa950426a2c28f0306c60db9b880c0b0e4ed819997ffb882d1da02cfcfc819bddc94d71627f5269682edf018
+  languageName: node
+  linkType: hard
+
+"find-cache-dir@npm:^2.0.0":
+  version: 2.1.0
+  resolution: "find-cache-dir@npm:2.1.0"
+  dependencies:
+    commondir: "npm:^1.0.1"
+    make-dir: "npm:^2.0.0"
+    pkg-dir: "npm:^3.0.0"
+  checksum: 10c0/556117fd0af14eb88fb69250f4bba9e905e7c355c6136dff0e161b9cbd1f5285f761b778565a278da73a130f42eccc723d7ad4c002ae547ed1d698d39779dabb
+  languageName: node
+  linkType: hard
+
+"find-up@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "find-up@npm:3.0.0"
+  dependencies:
+    locate-path: "npm:^3.0.0"
+  checksum: 10c0/2c2e7d0a26db858e2f624f39038c74739e38306dee42b45f404f770db357947be9d0d587f1cac72d20c114deb38aa57316e879eb0a78b17b46da7dab0a3bd6e3
+  languageName: node
+  linkType: hard
+
+"find-up@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "find-up@npm:5.0.0"
+  dependencies:
+    locate-path: "npm:^6.0.0"
+    path-exists: "npm:^4.0.0"
+  checksum: 10c0/062c5a83a9c02f53cdd6d175a37ecf8f87ea5bbff1fdfb828f04bfa021441bc7583e8ebc0872a4c1baab96221fb8a8a275a19809fb93fbc40bd69ec35634069a
+  languageName: node
+  linkType: hard
+
+"flat-cache@npm:^3.0.4, flat-cache@npm:^3.2.0":
+  version: 3.2.0
+  resolution: "flat-cache@npm:3.2.0"
+  dependencies:
+    flatted: "npm:^3.2.9"
+    keyv: "npm:^4.5.3"
+    rimraf: "npm:^3.0.2"
+  checksum: 10c0/b76f611bd5f5d68f7ae632e3ae503e678d205cf97a17c6ab5b12f6ca61188b5f1f7464503efae6dc18683ed8f0b41460beb48ac4b9ac63fe6201296a91ba2f75
+  languageName: node
+  linkType: hard
+
+"flatted@npm:^3.2.9":
+  version: 3.3.3
+  resolution: "flatted@npm:3.3.3"
+  checksum: 10c0/e957a1c6b0254aa15b8cce8533e24165abd98fadc98575db082b786b5da1b7d72062b81bfdcd1da2f4d46b6ed93bec2434e62333e9b4261d79ef2e75a10dd538
+  languageName: node
+  linkType: hard
+
+"for-each@npm:^0.3.3, for-each@npm:^0.3.5":
+  version: 0.3.5
+  resolution: "for-each@npm:0.3.5"
+  dependencies:
+    is-callable: "npm:^1.2.7"
+  checksum: 10c0/0e0b50f6a843a282637d43674d1fb278dda1dd85f4f99b640024cfb10b85058aac0cc781bf689d5fe50b4b7f638e91e548560723a4e76e04fe96ae35ef039cee
+  languageName: node
+  linkType: hard
+
+"foreground-child@npm:^3.1.0":
+  version: 3.3.1
+  resolution: "foreground-child@npm:3.3.1"
+  dependencies:
+    cross-spawn: "npm:^7.0.6"
+    signal-exit: "npm:^4.0.1"
+  checksum: 10c0/8986e4af2430896e65bc2788d6679067294d6aee9545daefc84923a0a4b399ad9c7a3ea7bd8c0b2b80fdf4a92de4c69df3f628233ff3224260e9c1541a9e9ed3
+  languageName: node
+  linkType: hard
+
+"form-data@npm:^4.0.0":
+  version: 4.0.4
+  resolution: "form-data@npm:4.0.4"
+  dependencies:
+    asynckit: "npm:^0.4.0"
+    combined-stream: "npm:^1.0.8"
+    es-set-tostringtag: "npm:^2.1.0"
+    hasown: "npm:^2.0.2"
+    mime-types: "npm:^2.1.12"
+  checksum: 10c0/373525a9a034b9d57073e55eab79e501a714ffac02e7a9b01be1c820780652b16e4101819785e1e18f8d98f0aee866cc654d660a435c378e16a72f2e7cac9695
+  languageName: node
+  linkType: hard
+
+"fraction.js@npm:^4.3.7":
+  version: 4.3.7
+  resolution: "fraction.js@npm:4.3.7"
+  checksum: 10c0/df291391beea9ab4c263487ffd9d17fed162dbb736982dee1379b2a8cc94e4e24e46ed508c6d278aded9080ba51872f1bc5f3a5fd8d7c74e5f105b508ac28711
+  languageName: node
+  linkType: hard
+
+"fs-extra@npm:^10.0.0":
+  version: 10.1.0
+  resolution: "fs-extra@npm:10.1.0"
+  dependencies:
+    graceful-fs: "npm:^4.2.0"
+    jsonfile: "npm:^6.0.1"
+    universalify: "npm:^2.0.0"
+  checksum: 10c0/5f579466e7109719d162a9249abbeffe7f426eb133ea486e020b89bc6d67a741134076bf439983f2eb79276ceaf6bd7b7c1e43c3fd67fe889863e69072fb0a5e
+  languageName: node
+  linkType: hard
+
+"fs-extra@npm:^11.2.0":
+  version: 11.3.2
+  resolution: "fs-extra@npm:11.3.2"
+  dependencies:
+    graceful-fs: "npm:^4.2.0"
+    jsonfile: "npm:^6.0.1"
+    universalify: "npm:^2.0.0"
+  checksum: 10c0/f5d629e1bb646d5dedb4d8b24c5aad3deb8cc1d5438979d6f237146cd10e113b49a949ae1b54212c2fbc98e2d0995f38009a9a1d0520f0287943335e65fe919b
+  languageName: node
+  linkType: hard
+
+"fs-minipass@npm:^3.0.0":
+  version: 3.0.3
+  resolution: "fs-minipass@npm:3.0.3"
+  dependencies:
+    minipass: "npm:^7.0.3"
+  checksum: 10c0/63e80da2ff9b621e2cb1596abcb9207f1cf82b968b116ccd7b959e3323144cce7fb141462200971c38bbf2ecca51695069db45265705bed09a7cd93ae5b89f94
+  languageName: node
+  linkType: hard
+
+"fs.realpath@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "fs.realpath@npm:1.0.0"
+  checksum: 10c0/444cf1291d997165dfd4c0d58b69f0e4782bfd9149fd72faa4fe299e68e0e93d6db941660b37dd29153bf7186672ececa3b50b7e7249477b03fdf850f287c948
+  languageName: node
+  linkType: hard
+
+"fsevents@npm:2.3.2":
+  version: 2.3.2
+  resolution: "fsevents@npm:2.3.2"
+  dependencies:
+    node-gyp: "npm:latest"
+  checksum: 10c0/be78a3efa3e181cda3cf7a4637cb527bcebb0bd0ea0440105a3bb45b86f9245b307dc10a2507e8f4498a7d4ec349d1910f4d73e4d4495b16103106e07eee735b
+  conditions: os=darwin
+  languageName: node
+  linkType: hard
+
+"fsevents@npm:~2.3.2, fsevents@npm:~2.3.3":
+  version: 2.3.3
+  resolution: "fsevents@npm:2.3.3"
+  dependencies:
+    node-gyp: "npm:latest"
+  checksum: 10c0/a1f0c44595123ed717febbc478aa952e47adfc28e2092be66b8ab1635147254ca6cfe1df792a8997f22716d4cbafc73309899ff7bfac2ac3ad8cf2e4ecc3ec60
+  conditions: os=darwin
+  languageName: node
+  linkType: hard
+
+"fsevents@patch:fsevents@npm%3A2.3.2#optional!builtin<compat/fsevents>":
+  version: 2.3.2
+  resolution: "fsevents@patch:fsevents@npm%3A2.3.2#optional!builtin<compat/fsevents>::version=2.3.2&hash=df0bf1"
+  dependencies:
+    node-gyp: "npm:latest"
+  conditions: os=darwin
+  languageName: node
+  linkType: hard
+
+"fsevents@patch:fsevents@npm%3A~2.3.2#optional!builtin<compat/fsevents>, fsevents@patch:fsevents@npm%3A~2.3.3#optional!builtin<compat/fsevents>":
+  version: 2.3.3
+  resolution: "fsevents@patch:fsevents@npm%3A2.3.3#optional!builtin<compat/fsevents>::version=2.3.3&hash=df0bf1"
+  dependencies:
+    node-gyp: "npm:latest"
+  conditions: os=darwin
+  languageName: node
+  linkType: hard
+
+"function-bind@npm:^1.1.2":
+  version: 1.1.2
+  resolution: "function-bind@npm:1.1.2"
+  checksum: 10c0/d8680ee1e5fcd4c197e4ac33b2b4dce03c71f4d91717292785703db200f5c21f977c568d28061226f9b5900cbcd2c84463646134fd5337e7925e0942bc3f46d5
+  languageName: node
+  linkType: hard
+
+"function.prototype.name@npm:^1.1.6, function.prototype.name@npm:^1.1.8":
+  version: 1.1.8
+  resolution: "function.prototype.name@npm:1.1.8"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.3"
+    define-properties: "npm:^1.2.1"
+    functions-have-names: "npm:^1.2.3"
+    hasown: "npm:^2.0.2"
+    is-callable: "npm:^1.2.7"
+  checksum: 10c0/e920a2ab52663005f3cbe7ee3373e3c71c1fb5558b0b0548648cdf3e51961085032458e26c71ff1a8c8c20e7ee7caeb03d43a5d1fa8610c459333323a2e71253
+  languageName: node
+  linkType: hard
+
+"functional-red-black-tree@npm:1.0.1":
+  version: 1.0.1
+  resolution: "functional-red-black-tree@npm:1.0.1"
+  checksum: 10c0/5959eed0375803d9924f47688479bb017e0c6816a0e5ac151e22ba6bfe1d12c41de2f339188885e0aa8eeea2072dad509d8e4448467e816bde0a2ca86a0670d3
+  languageName: node
+  linkType: hard
+
+"functions-have-names@npm:^1.2.3":
+  version: 1.2.3
+  resolution: "functions-have-names@npm:1.2.3"
+  checksum: 10c0/33e77fd29bddc2d9bb78ab3eb854c165909201f88c75faa8272e35899e2d35a8a642a15e7420ef945e1f64a9670d6aa3ec744106b2aa42be68ca5114025954ca
+  languageName: node
+  linkType: hard
+
+"generator-function@npm:^2.0.0":
+  version: 2.0.1
+  resolution: "generator-function@npm:2.0.1"
+  checksum: 10c0/8a9f59df0f01cfefafdb3b451b80555e5cf6d76487095db91ac461a0e682e4ff7a9dbce15f4ecec191e53586d59eece01949e05a4b4492879600bbbe8e28d6b8
+  languageName: node
+  linkType: hard
+
+"get-func-name@npm:^2.0.1, get-func-name@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "get-func-name@npm:2.0.2"
+  checksum: 10c0/89830fd07623fa73429a711b9daecdb304386d237c71268007f788f113505ef1d4cc2d0b9680e072c5082490aec9df5d7758bf5ac6f1c37062855e8e3dc0b9df
+  languageName: node
+  linkType: hard
+
+"get-intrinsic@npm:^1.2.4, get-intrinsic@npm:^1.2.5, get-intrinsic@npm:^1.2.6, get-intrinsic@npm:^1.2.7, get-intrinsic@npm:^1.3.0":
+  version: 1.3.1
+  resolution: "get-intrinsic@npm:1.3.1"
+  dependencies:
+    async-function: "npm:^1.0.0"
+    async-generator-function: "npm:^1.0.0"
+    call-bind-apply-helpers: "npm:^1.0.2"
+    es-define-property: "npm:^1.0.1"
+    es-errors: "npm:^1.3.0"
+    es-object-atoms: "npm:^1.1.1"
+    function-bind: "npm:^1.1.2"
+    generator-function: "npm:^2.0.0"
+    get-proto: "npm:^1.0.1"
+    gopd: "npm:^1.2.0"
+    has-symbols: "npm:^1.1.0"
+    hasown: "npm:^2.0.2"
+    math-intrinsics: "npm:^1.1.0"
+  checksum: 10c0/9f4ab0cf7efe0fd2c8185f52e6f637e708f3a112610c88869f8f041bb9ecc2ce44bf285dfdbdc6f4f7c277a5b88d8e94a432374d97cca22f3de7fc63795deb5d
+  languageName: node
+  linkType: hard
+
+"get-proto@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "get-proto@npm:1.0.1"
+  dependencies:
+    dunder-proto: "npm:^1.0.1"
+    es-object-atoms: "npm:^1.0.0"
+  checksum: 10c0/9224acb44603c5526955e83510b9da41baf6ae73f7398875fba50edc5e944223a89c4a72b070fcd78beb5f7bdda58ecb6294adc28f7acfc0da05f76a2399643c
+  languageName: node
+  linkType: hard
+
+"get-stream@npm:^5.0.0":
+  version: 5.2.0
+  resolution: "get-stream@npm:5.2.0"
+  dependencies:
+    pump: "npm:^3.0.0"
+  checksum: 10c0/43797ffd815fbb26685bf188c8cfebecb8af87b3925091dd7b9a9c915993293d78e3c9e1bce125928ff92f2d0796f3889b92b5ec6d58d1041b574682132e0a80
+  languageName: node
+  linkType: hard
+
+"get-stream@npm:^8.0.1":
+  version: 8.0.1
+  resolution: "get-stream@npm:8.0.1"
+  checksum: 10c0/5c2181e98202b9dae0bb4a849979291043e5892eb40312b47f0c22b9414fc9b28a3b6063d2375705eb24abc41ecf97894d9a51f64ff021511b504477b27b4290
+  languageName: node
+  linkType: hard
+
+"get-symbol-description@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "get-symbol-description@npm:1.1.0"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    es-errors: "npm:^1.3.0"
+    get-intrinsic: "npm:^1.2.6"
+  checksum: 10c0/d6a7d6afca375779a4b307738c9e80dbf7afc0bdbe5948768d54ab9653c865523d8920e670991a925936eb524b7cb6a6361d199a760b21d0ca7620194455aa4b
+  languageName: node
+  linkType: hard
+
+"get-tsconfig@npm:^4.7.0":
+  version: 4.13.0
+  resolution: "get-tsconfig@npm:4.13.0"
+  dependencies:
+    resolve-pkg-maps: "npm:^1.0.0"
+  checksum: 10c0/2c49ef8d3907047a107f229fd610386fe3b7fe9e42dfd6b42e7406499493cdda8c62e83e57e8d7a98125610774b9f604d3a0ff308d7f9de5c7ac6d1b07cb6036
+  languageName: node
+  linkType: hard
+
+"gitignore-to-glob@npm:^0.3.0":
+  version: 0.3.0
+  resolution: "gitignore-to-glob@npm:0.3.0"
+  checksum: 10c0/3c1baa2b7ca61ebd3d4784ef13a71ca2b98ee478ccafe234d6947b6f1b75343492304a7972fe15885b5c5e8f8d2c006cb6ca431dd7e9f270885766288f038f6a
+  languageName: node
+  linkType: hard
+
+"glob-parent@npm:^5.1.2":
+  version: 5.1.2
+  resolution: "glob-parent@npm:5.1.2"
+  dependencies:
+    is-glob: "npm:^4.0.1"
+  checksum: 10c0/cab87638e2112bee3f839ef5f6e0765057163d39c66be8ec1602f3823da4692297ad4e972de876ea17c44d652978638d2fd583c6713d0eb6591706825020c9ee
+  languageName: node
+  linkType: hard
+
+"glob-parent@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "glob-parent@npm:6.0.2"
+  dependencies:
+    is-glob: "npm:^4.0.3"
+  checksum: 10c0/317034d88654730230b3f43bb7ad4f7c90257a426e872ea0bf157473ac61c99bf5d205fad8f0185f989be8d2fa6d3c7dce1645d99d545b6ea9089c39f838e7f8
+  languageName: node
+  linkType: hard
+
+"glob@npm:^10.2.2":
+  version: 10.4.5
+  resolution: "glob@npm:10.4.5"
+  dependencies:
+    foreground-child: "npm:^3.1.0"
+    jackspeak: "npm:^3.1.2"
+    minimatch: "npm:^9.0.4"
+    minipass: "npm:^7.1.2"
+    package-json-from-dist: "npm:^1.0.0"
+    path-scurry: "npm:^1.11.1"
+  bin:
+    glob: dist/esm/bin.mjs
+  checksum: 10c0/19a9759ea77b8e3ca0a43c2f07ecddc2ad46216b786bb8f993c445aee80d345925a21e5280c7b7c6c59e860a0154b84e4b2b60321fea92cd3c56b4a7489f160e
+  languageName: node
+  linkType: hard
+
+"glob@npm:^7.1.1, glob@npm:^7.1.3":
+  version: 7.2.3
+  resolution: "glob@npm:7.2.3"
+  dependencies:
+    fs.realpath: "npm:^1.0.0"
+    inflight: "npm:^1.0.4"
+    inherits: "npm:2"
+    minimatch: "npm:^3.1.1"
+    once: "npm:^1.3.0"
+    path-is-absolute: "npm:^1.0.0"
+  checksum: 10c0/65676153e2b0c9095100fe7f25a778bf45608eeb32c6048cf307f579649bcc30353277b3b898a3792602c65764e5baa4f643714dfbdfd64ea271d210c7a425fe
+  languageName: node
+  linkType: hard
+
+"global-modules@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "global-modules@npm:2.0.0"
+  dependencies:
+    global-prefix: "npm:^3.0.0"
+  checksum: 10c0/43b770fe24aa6028f4b9770ea583a47f39750be15cf6e2578f851e4ccc9e4fa674b8541928c0b09c21461ca0763f0d36e4068cec86c914b07fd6e388e66ba5b9
+  languageName: node
+  linkType: hard
+
+"global-prefix@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "global-prefix@npm:3.0.0"
+  dependencies:
+    ini: "npm:^1.3.5"
+    kind-of: "npm:^6.0.2"
+    which: "npm:^1.3.1"
+  checksum: 10c0/510f489fb68d1cc7060f276541709a0ee6d41356ef852de48f7906c648ac223082a1cc8fce86725ca6c0e032bcdc1189ae77b4744a624b29c34a9d0ece498269
+  languageName: node
+  linkType: hard
+
+"globals@npm:^13.19.0, globals@npm:^13.24.0":
+  version: 13.24.0
+  resolution: "globals@npm:13.24.0"
+  dependencies:
+    type-fest: "npm:^0.20.2"
+  checksum: 10c0/d3c11aeea898eb83d5ec7a99508600fbe8f83d2cf00cbb77f873dbf2bcb39428eff1b538e4915c993d8a3b3473fa71eeebfe22c9bb3a3003d1e26b1f2c8a42cd
+  languageName: node
+  linkType: hard
+
+"globals@npm:^14.0.0":
+  version: 14.0.0
+  resolution: "globals@npm:14.0.0"
+  checksum: 10c0/b96ff42620c9231ad468d4c58ff42afee7777ee1c963013ff8aabe095a451d0ceeb8dcd8ef4cbd64d2538cef45f787a78ba3a9574f4a634438963e334471302d
+  languageName: node
+  linkType: hard
+
+"globals@npm:^16.4.0":
+  version: 16.5.0
+  resolution: "globals@npm:16.5.0"
+  checksum: 10c0/615241dae7851c8012f5aa0223005b1ed6607713d6813de0741768bd4ddc39353117648f1a7086b4b0fa45eae733f1c0a0fe369aa4e543bb63f8de8990178ea9
+  languageName: node
+  linkType: hard
+
+"globalthis@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "globalthis@npm:1.0.4"
+  dependencies:
+    define-properties: "npm:^1.2.1"
+    gopd: "npm:^1.0.1"
+  checksum: 10c0/9d156f313af79d80b1566b93e19285f481c591ad6d0d319b4be5e03750d004dde40a39a0f26f7e635f9007a3600802f53ecd85a759b86f109e80a5f705e01846
+  languageName: node
+  linkType: hard
+
+"globby@npm:^11.1.0":
+  version: 11.1.0
+  resolution: "globby@npm:11.1.0"
+  dependencies:
+    array-union: "npm:^2.1.0"
+    dir-glob: "npm:^3.0.1"
+    fast-glob: "npm:^3.2.9"
+    ignore: "npm:^5.2.0"
+    merge2: "npm:^1.4.1"
+    slash: "npm:^3.0.0"
+  checksum: 10c0/b39511b4afe4bd8a7aead3a27c4ade2b9968649abab0a6c28b1a90141b96ca68ca5db1302f7c7bd29eab66bf51e13916b8e0a3d0ac08f75e1e84a39b35691189
+  languageName: node
+  linkType: hard
+
+"globjoin@npm:^0.1.4":
+  version: 0.1.4
+  resolution: "globjoin@npm:0.1.4"
+  checksum: 10c0/236e991b48f1a9869fe2aa7bb5141fb1f32973940567a3c012f8ccb58c3c85ab78ce594d374fa819410fff3b48cfd24584d7ef726939f8a3c3772890e62ea16b
+  languageName: node
+  linkType: hard
+
+"gopd@npm:^1.0.1, gopd@npm:^1.2.0":
+  version: 1.2.0
+  resolution: "gopd@npm:1.2.0"
+  checksum: 10c0/50fff1e04ba2b7737c097358534eacadad1e68d24cccee3272e04e007bed008e68d2614f3987788428fd192a5ae3889d08fb2331417e4fc4a9ab366b2043cead
+  languageName: node
+  linkType: hard
+
+"graceful-fs@npm:^4.1.6, graceful-fs@npm:^4.2.0, graceful-fs@npm:^4.2.6":
+  version: 4.2.11
+  resolution: "graceful-fs@npm:4.2.11"
+  checksum: 10c0/386d011a553e02bc594ac2ca0bd6d9e4c22d7fa8cfbfc448a6d148c59ea881b092db9dbe3547ae4b88e55f1b01f7c4a2ecc53b310c042793e63aa44cf6c257f2
+  languageName: node
+  linkType: hard
+
+"graphemer@npm:^1.4.0":
+  version: 1.4.0
+  resolution: "graphemer@npm:1.4.0"
+  checksum: 10c0/e951259d8cd2e0d196c72ec711add7115d42eb9a8146c8eeda5b8d3ac91e5dd816b9cd68920726d9fd4490368e7ed86e9c423f40db87e2d8dfafa00fa17c3a31
+  languageName: node
+  linkType: hard
+
+"hard-rejection@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "hard-rejection@npm:2.1.0"
+  checksum: 10c0/febc3343a1ad575aedcc112580835b44a89a89e01f400b4eda6e8110869edfdab0b00cd1bd4c3bfec9475a57e79e0b355aecd5be46454b6a62b9a359af60e564
+  languageName: node
+  linkType: hard
+
+"has-bigints@npm:^1.0.2":
+  version: 1.1.0
+  resolution: "has-bigints@npm:1.1.0"
+  checksum: 10c0/2de0cdc4a1ccf7a1e75ffede1876994525ac03cc6f5ae7392d3415dd475cd9eee5bceec63669ab61aa997ff6cceebb50ef75561c7002bed8988de2b9d1b40788
+  languageName: node
+  linkType: hard
+
+"has-flag@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "has-flag@npm:3.0.0"
+  checksum: 10c0/1c6c83b14b8b1b3c25b0727b8ba3e3b647f99e9e6e13eb7322107261de07a4c1be56fc0d45678fc376e09772a3a1642ccdaf8fc69bdf123b6c086598397ce473
+  languageName: node
+  linkType: hard
+
+"has-flag@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "has-flag@npm:4.0.0"
+  checksum: 10c0/2e789c61b7888d66993e14e8331449e525ef42aac53c627cc53d1c3334e768bcb6abdc4f5f0de1478a25beec6f0bd62c7549058b7ac53e924040d4f301f02fd1
+  languageName: node
+  linkType: hard
+
+"has-property-descriptors@npm:^1.0.0, has-property-descriptors@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "has-property-descriptors@npm:1.0.2"
+  dependencies:
+    es-define-property: "npm:^1.0.0"
+  checksum: 10c0/253c1f59e80bb476cf0dde8ff5284505d90c3bdb762983c3514d36414290475fe3fd6f574929d84de2a8eec00d35cf07cb6776205ff32efd7c50719125f00236
+  languageName: node
+  linkType: hard
+
+"has-proto@npm:^1.2.0":
+  version: 1.2.0
+  resolution: "has-proto@npm:1.2.0"
+  dependencies:
+    dunder-proto: "npm:^1.0.0"
+  checksum: 10c0/46538dddab297ec2f43923c3d35237df45d8c55a6fc1067031e04c13ed8a9a8f94954460632fd4da84c31a1721eefee16d901cbb1ae9602bab93bb6e08f93b95
+  languageName: node
+  linkType: hard
+
+"has-symbols@npm:^1.0.3, has-symbols@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "has-symbols@npm:1.1.0"
+  checksum: 10c0/dde0a734b17ae51e84b10986e651c664379018d10b91b6b0e9b293eddb32f0f069688c841fb40f19e9611546130153e0a2a48fd7f512891fb000ddfa36f5a20e
+  languageName: node
+  linkType: hard
+
+"has-tostringtag@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "has-tostringtag@npm:1.0.2"
+  dependencies:
+    has-symbols: "npm:^1.0.3"
+  checksum: 10c0/a8b166462192bafe3d9b6e420a1d581d93dd867adb61be223a17a8d6dad147aa77a8be32c961bb2f27b3ef893cae8d36f564ab651f5e9b7938ae86f74027c48c
+  languageName: node
+  linkType: hard
+
+"has@npm:^1.0.3":
+  version: 1.0.4
+  resolution: "has@npm:1.0.4"
+  checksum: 10c0/82c1220573dc1f0a014a5d6189ae52a1f820f99dfdc00323c3a725b5002dcb7f04e44f460fea7af068474b2dd7c88cbe1846925c84017be9e31e1708936d305b
+  languageName: node
+  linkType: hard
+
+"hasown@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "hasown@npm:2.0.2"
+  dependencies:
+    function-bind: "npm:^1.1.2"
+  checksum: 10c0/3769d434703b8ac66b209a4cca0737519925bbdb61dd887f93a16372b14694c63ff4e797686d87c90f08168e81082248b9b028bad60d4da9e0d1148766f56eb9
+  languageName: node
+  linkType: hard
+
+"hosted-git-info@npm:^4.0.1":
+  version: 4.1.0
+  resolution: "hosted-git-info@npm:4.1.0"
+  dependencies:
+    lru-cache: "npm:^6.0.0"
+  checksum: 10c0/150fbcb001600336d17fdbae803264abed013548eea7946c2264c49ebe2ebd8c4441ba71dd23dd8e18c65de79d637f98b22d4760ba5fb2e0b15d62543d0fff07
+  languageName: node
+  linkType: hard
+
+"html-encoding-sniffer@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "html-encoding-sniffer@npm:4.0.0"
+  dependencies:
+    whatwg-encoding: "npm:^3.1.1"
+  checksum: 10c0/523398055dc61ac9b34718a719cb4aa691e4166f29187e211e1607de63dc25ac7af52ca7c9aead0c4b3c0415ffecb17326396e1202e2e86ff4bca4c0ee4c6140
+  languageName: node
+  linkType: hard
+
+"html-janitor@npm:^2.0.4":
+  version: 2.0.4
+  resolution: "html-janitor@npm:2.0.4"
+  checksum: 10c0/2c5b99a1db92aa0ca6041f7063d3a11460e6a30b06b88dfaa548fa7e86ced4c27f4b55daf6ace8503d2dc397431fcb33a7e6b726de234e8d8cb4c0c20cfeabe0
+  languageName: node
+  linkType: hard
+
+"html-tags@npm:^3.3.1":
+  version: 3.3.1
+  resolution: "html-tags@npm:3.3.1"
+  checksum: 10c0/680165e12baa51bad7397452d247dbcc5a5c29dac0e6754b1187eee3bf26f514bc1907a431dd2f7eb56207611ae595ee76a0acc8eaa0d931e72c791dd6463d79
+  languageName: node
+  linkType: hard
+
+"http-cache-semantics@npm:^4.1.1":
+  version: 4.2.0
+  resolution: "http-cache-semantics@npm:4.2.0"
+  checksum: 10c0/45b66a945cf13ec2d1f29432277201313babf4a01d9e52f44b31ca923434083afeca03f18417f599c9ab3d0e7b618ceb21257542338b57c54b710463b4a53e37
+  languageName: node
+  linkType: hard
+
+"http-proxy-agent@npm:^7.0.0":
+  version: 7.0.2
+  resolution: "http-proxy-agent@npm:7.0.2"
+  dependencies:
+    agent-base: "npm:^7.1.0"
+    debug: "npm:^4.3.4"
+  checksum: 10c0/4207b06a4580fb85dd6dff521f0abf6db517489e70863dca1a0291daa7f2d3d2d6015a57bd702af068ea5cf9f1f6ff72314f5f5b4228d299c0904135d2aef921
+  languageName: node
+  linkType: hard
+
+"https-proxy-agent@npm:^7.0.1, https-proxy-agent@npm:^7.0.2":
+  version: 7.0.6
+  resolution: "https-proxy-agent@npm:7.0.6"
+  dependencies:
+    agent-base: "npm:^7.1.2"
+    debug: "npm:4"
+  checksum: 10c0/f729219bc735edb621fa30e6e84e60ee5d00802b8247aac0d7b79b0bd6d4b3294737a337b93b86a0bd9e68099d031858a39260c976dc14cdbba238ba1f8779ac
+  languageName: node
+  linkType: hard
+
+"human-signals@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "human-signals@npm:1.1.1"
+  checksum: 10c0/18810ed239a7a5e23fb6c32d0fd4be75d7cd337a07ad59b8dbf0794cb0761e6e628349ee04c409e605fe55344716eab5d0a47a62ba2a2d0d367c89a2b4247b1e
+  languageName: node
+  linkType: hard
+
+"human-signals@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "human-signals@npm:5.0.0"
+  checksum: 10c0/5a9359073fe17a8b58e5a085e9a39a950366d9f00217c4ff5878bd312e09d80f460536ea6a3f260b5943a01fe55c158d1cea3fc7bee3d0520aeef04f6d915c82
+  languageName: node
+  linkType: hard
+
+"iconv-lite@npm:0.6.3, iconv-lite@npm:^0.6.2":
+  version: 0.6.3
+  resolution: "iconv-lite@npm:0.6.3"
+  dependencies:
+    safer-buffer: "npm:>= 2.1.2 < 3.0.0"
+  checksum: 10c0/98102bc66b33fcf5ac044099d1257ba0b7ad5e3ccd3221f34dd508ab4070edff183276221684e1e0555b145fce0850c9f7d2b60a9fcac50fbb4ea0d6e845a3b1
+  languageName: node
+  linkType: hard
+
+"ignore@npm:^5.2.0, ignore@npm:^5.2.4":
+  version: 5.3.2
+  resolution: "ignore@npm:5.3.2"
+  checksum: 10c0/f9f652c957983634ded1e7f02da3b559a0d4cc210fca3792cb67f1b153623c9c42efdc1c4121af171e295444459fc4a9201101fb041b1104a3c000bccb188337
+  languageName: node
+  linkType: hard
+
+"import-fresh@npm:^3.2.1, import-fresh@npm:^3.3.0":
+  version: 3.3.1
+  resolution: "import-fresh@npm:3.3.1"
+  dependencies:
+    parent-module: "npm:^1.0.0"
+    resolve-from: "npm:^4.0.0"
+  checksum: 10c0/bf8cc494872fef783249709385ae883b447e3eb09db0ebd15dcead7d9afe7224dad7bd7591c6b73b0b19b3c0f9640eb8ee884f01cfaf2887ab995b0b36a0cbec
+  languageName: node
+  linkType: hard
+
+"import-lazy@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "import-lazy@npm:4.0.0"
+  checksum: 10c0/a3520313e2c31f25c0b06aa66d167f329832b68a4f957d7c9daf6e0fa41822b6e84948191648b9b9d8ca82f94740cdf15eecf2401a5b42cd1c33fd84f2225cca
+  languageName: node
+  linkType: hard
+
+"imurmurhash@npm:^0.1.4":
+  version: 0.1.4
+  resolution: "imurmurhash@npm:0.1.4"
+  checksum: 10c0/8b51313850dd33605c6c9d3fd9638b714f4c4c40250cff658209f30d40da60f78992fb2df5dabee4acf589a6a82bbc79ad5486550754bd9ec4e3fc0d4a57d6a6
+  languageName: node
+  linkType: hard
+
+"indent-string@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "indent-string@npm:5.0.0"
+  checksum: 10c0/8ee77b57d92e71745e133f6f444d6fa3ed503ad0e1bcd7e80c8da08b42375c07117128d670589725ed07b1978065803fa86318c309ba45415b7fe13e7f170220
+  languageName: node
+  linkType: hard
+
+"indexes-of@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "indexes-of@npm:1.0.1"
+  checksum: 10c0/1ea1d2d00173fa38f728acfa00303657e1115361481e52f6cbae47c5d603219006c9357abf6bc323f1fb0fbe937e363bbb19e5c66c12578eea6ec6b7e892bdba
+  languageName: node
+  linkType: hard
+
+"inflight@npm:^1.0.4":
+  version: 1.0.6
+  resolution: "inflight@npm:1.0.6"
+  dependencies:
+    once: "npm:^1.3.0"
+    wrappy: "npm:1"
+  checksum: 10c0/7faca22584600a9dc5b9fca2cd5feb7135ac8c935449837b315676b4c90aa4f391ec4f42240178244b5a34e8bede1948627fda392ca3191522fc46b34e985ab2
+  languageName: node
+  linkType: hard
+
+"inherits@npm:2":
+  version: 2.0.4
+  resolution: "inherits@npm:2.0.4"
+  checksum: 10c0/4e531f648b29039fb7426fb94075e6545faa1eb9fe83c29f0b6d9e7263aceb4289d2d4557db0d428188eeb449cc7c5e77b0a0b2c4e248ff2a65933a0dee49ef2
+  languageName: node
+  linkType: hard
+
+"ini@npm:^1.3.5":
+  version: 1.3.8
+  resolution: "ini@npm:1.3.8"
+  checksum: 10c0/ec93838d2328b619532e4f1ff05df7909760b6f66d9c9e2ded11e5c1897d6f2f9980c54dd638f88654b00919ce31e827040631eab0a3969e4d1abefa0719516a
+  languageName: node
+  linkType: hard
+
+"internal-slot@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "internal-slot@npm:1.1.0"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    hasown: "npm:^2.0.2"
+    side-channel: "npm:^1.1.0"
+  checksum: 10c0/03966f5e259b009a9bf1a78d60da920df198af4318ec004f57b8aef1dd3fe377fbc8cce63a96e8c810010302654de89f9e19de1cd8ad0061d15be28a695465c7
+  languageName: node
+  linkType: hard
+
+"ip-address@npm:^10.0.1":
+  version: 10.0.1
+  resolution: "ip-address@npm:10.0.1"
+  checksum: 10c0/1634d79dae18394004775cb6d699dc46b7c23df6d2083164025a2b15240c1164fccde53d0e08bd5ee4fc53913d033ab6b5e395a809ad4b956a940c446e948843
+  languageName: node
+  linkType: hard
+
+"is-array-buffer@npm:^3.0.4, is-array-buffer@npm:^3.0.5":
+  version: 3.0.5
+  resolution: "is-array-buffer@npm:3.0.5"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.3"
+    get-intrinsic: "npm:^1.2.6"
+  checksum: 10c0/c5c9f25606e86dbb12e756694afbbff64bc8b348d1bc989324c037e1068695131930199d6ad381952715dad3a9569333817f0b1a72ce5af7f883ce802e49c83d
+  languageName: node
+  linkType: hard
+
+"is-arrayish@npm:^0.2.1":
+  version: 0.2.1
+  resolution: "is-arrayish@npm:0.2.1"
+  checksum: 10c0/e7fb686a739068bb70f860b39b67afc62acc62e36bb61c5f965768abce1873b379c563e61dd2adad96ebb7edf6651111b385e490cf508378959b0ed4cac4e729
+  languageName: node
+  linkType: hard
+
+"is-async-function@npm:^2.0.0":
+  version: 2.1.1
+  resolution: "is-async-function@npm:2.1.1"
+  dependencies:
+    async-function: "npm:^1.0.0"
+    call-bound: "npm:^1.0.3"
+    get-proto: "npm:^1.0.1"
+    has-tostringtag: "npm:^1.0.2"
+    safe-regex-test: "npm:^1.1.0"
+  checksum: 10c0/d70c236a5e82de6fc4d44368ffd0c2fee2b088b893511ce21e679da275a5ecc6015ff59a7d7e1bdd7ca39f71a8dbdd253cf8cce5c6b3c91cdd5b42b5ce677298
+  languageName: node
+  linkType: hard
+
+"is-bigint@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "is-bigint@npm:1.1.0"
+  dependencies:
+    has-bigints: "npm:^1.0.2"
+  checksum: 10c0/f4f4b905ceb195be90a6ea7f34323bf1c18e3793f18922e3e9a73c684c29eeeeff5175605c3a3a74cc38185fe27758f07efba3dbae812e5c5afbc0d2316b40e4
+  languageName: node
+  linkType: hard
+
+"is-boolean-object@npm:^1.2.1":
+  version: 1.2.2
+  resolution: "is-boolean-object@npm:1.2.2"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    has-tostringtag: "npm:^1.0.2"
+  checksum: 10c0/36ff6baf6bd18b3130186990026f5a95c709345c39cd368468e6c1b6ab52201e9fd26d8e1f4c066357b4938b0f0401e1a5000e08257787c1a02f3a719457001e
+  languageName: node
+  linkType: hard
+
+"is-builtin-module@npm:^3.2.1":
+  version: 3.2.1
+  resolution: "is-builtin-module@npm:3.2.1"
+  dependencies:
+    builtin-modules: "npm:^3.3.0"
+  checksum: 10c0/5a66937a03f3b18803381518f0ef679752ac18cdb7dd53b5e23ee8df8d440558737bd8dcc04d2aae555909d2ecb4a81b5c0d334d119402584b61e6a003e31af1
+  languageName: node
+  linkType: hard
+
+"is-callable@npm:^1.2.7":
+  version: 1.2.7
+  resolution: "is-callable@npm:1.2.7"
+  checksum: 10c0/ceebaeb9d92e8adee604076971dd6000d38d6afc40bb843ea8e45c5579b57671c3f3b50d7f04869618242c6cee08d1b67806a8cb8edaaaf7c0748b3720d6066f
+  languageName: node
+  linkType: hard
+
+"is-core-module@npm:^2.12.1, is-core-module@npm:^2.13.0, is-core-module@npm:^2.16.1, is-core-module@npm:^2.5.0":
+  version: 2.16.1
+  resolution: "is-core-module@npm:2.16.1"
+  dependencies:
+    hasown: "npm:^2.0.2"
+  checksum: 10c0/898443c14780a577e807618aaae2b6f745c8538eca5c7bc11388a3f2dc6de82b9902bcc7eb74f07be672b11bbe82dd6a6edded44a00cb3d8f933d0459905eedd
+  languageName: node
+  linkType: hard
+
+"is-data-view@npm:^1.0.1, is-data-view@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "is-data-view@npm:1.0.2"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    get-intrinsic: "npm:^1.2.6"
+    is-typed-array: "npm:^1.1.13"
+  checksum: 10c0/ef3548a99d7e7f1370ce21006baca6d40c73e9f15c941f89f0049c79714c873d03b02dae1c64b3f861f55163ecc16da06506c5b8a1d4f16650b3d9351c380153
+  languageName: node
+  linkType: hard
+
+"is-date-object@npm:^1.0.5, is-date-object@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "is-date-object@npm:1.1.0"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    has-tostringtag: "npm:^1.0.2"
+  checksum: 10c0/1a4d199c8e9e9cac5128d32e6626fa7805175af9df015620ac0d5d45854ccf348ba494679d872d37301032e35a54fc7978fba1687e8721b2139aea7870cafa2f
+  languageName: node
+  linkType: hard
+
+"is-expression@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "is-expression@npm:4.0.0"
+  dependencies:
+    acorn: "npm:^7.1.1"
+    object-assign: "npm:^4.1.1"
+  checksum: 10c0/541831d39d3e7bfc8cecd966d6b0f3c0e6d9055342f17b634fb23e74f51ce90f1bfc3cf231c722fe003a61e8d4f0b9e07244fdaba57f4fc70a163c74006fd5a0
+  languageName: node
+  linkType: hard
+
+"is-extglob@npm:^2.1.1":
+  version: 2.1.1
+  resolution: "is-extglob@npm:2.1.1"
+  checksum: 10c0/5487da35691fbc339700bbb2730430b07777a3c21b9ebaecb3072512dfd7b4ba78ac2381a87e8d78d20ea08affb3f1971b4af629173a6bf435ff8a4c47747912
+  languageName: node
+  linkType: hard
+
+"is-finalizationregistry@npm:^1.1.0":
+  version: 1.1.1
+  resolution: "is-finalizationregistry@npm:1.1.1"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+  checksum: 10c0/818dff679b64f19e228a8205a1e2d09989a98e98def3a817f889208cfcbf918d321b251aadf2c05918194803ebd2eb01b14fc9d0b2bea53d984f4137bfca5e97
+  languageName: node
+  linkType: hard
+
+"is-fullwidth-code-point@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "is-fullwidth-code-point@npm:3.0.0"
+  checksum: 10c0/bb11d825e049f38e04c06373a8d72782eee0205bda9d908cc550ccb3c59b99d750ff9537982e01733c1c94a58e35400661f57042158ff5e8f3e90cf936daf0fc
+  languageName: node
+  linkType: hard
+
+"is-generator-function@npm:^1.0.10":
+  version: 1.1.2
+  resolution: "is-generator-function@npm:1.1.2"
+  dependencies:
+    call-bound: "npm:^1.0.4"
+    generator-function: "npm:^2.0.0"
+    get-proto: "npm:^1.0.1"
+    has-tostringtag: "npm:^1.0.2"
+    safe-regex-test: "npm:^1.1.0"
+  checksum: 10c0/83da102e89c3e3b71d67b51d47c9f9bc862bceb58f87201727e27f7fa19d1d90b0ab223644ecaee6fc6e3d2d622bb25c966fbdaf87c59158b01ce7c0fe2fa372
+  languageName: node
+  linkType: hard
+
+"is-glob@npm:^4.0.0, is-glob@npm:^4.0.1, is-glob@npm:^4.0.3":
+  version: 4.0.3
+  resolution: "is-glob@npm:4.0.3"
+  dependencies:
+    is-extglob: "npm:^2.1.1"
+  checksum: 10c0/17fb4014e22be3bbecea9b2e3a76e9e34ff645466be702f1693e8f1ee1adac84710d0be0bd9f967d6354036fd51ab7c2741d954d6e91dae6bb69714de92c197a
+  languageName: node
+  linkType: hard
+
+"is-map@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "is-map@npm:2.0.3"
+  checksum: 10c0/2c4d431b74e00fdda7162cd8e4b763d6f6f217edf97d4f8538b94b8702b150610e2c64961340015fe8df5b1fcee33ccd2e9b62619c4a8a3a155f8de6d6d355fc
+  languageName: node
+  linkType: hard
+
+"is-negative-zero@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "is-negative-zero@npm:2.0.3"
+  checksum: 10c0/bcdcf6b8b9714063ffcfa9929c575ac69bfdabb8f4574ff557dfc086df2836cf07e3906f5bbc4f2a5c12f8f3ba56af640c843cdfc74da8caed86c7c7d66fd08e
+  languageName: node
+  linkType: hard
+
+"is-number-object@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "is-number-object@npm:1.1.1"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    has-tostringtag: "npm:^1.0.2"
+  checksum: 10c0/97b451b41f25135ff021d85c436ff0100d84a039bb87ffd799cbcdbea81ef30c464ced38258cdd34f080be08fc3b076ca1f472086286d2aa43521d6ec6a79f53
+  languageName: node
+  linkType: hard
+
+"is-number@npm:^7.0.0":
+  version: 7.0.0
+  resolution: "is-number@npm:7.0.0"
+  checksum: 10c0/b4686d0d3053146095ccd45346461bc8e53b80aeb7671cc52a4de02dbbf7dc0d1d2a986e2fe4ae206984b4d34ef37e8b795ebc4f4295c978373e6575e295d811
+  languageName: node
+  linkType: hard
+
+"is-path-inside@npm:^3.0.3":
+  version: 3.0.3
+  resolution: "is-path-inside@npm:3.0.3"
+  checksum: 10c0/cf7d4ac35fb96bab6a1d2c3598fe5ebb29aafb52c0aaa482b5a3ed9d8ba3edc11631e3ec2637660c44b3ce0e61a08d54946e8af30dec0b60a7c27296c68ffd05
+  languageName: node
+  linkType: hard
+
+"is-plain-obj@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "is-plain-obj@npm:1.1.0"
+  checksum: 10c0/daaee1805add26f781b413fdf192fc91d52409583be30ace35c82607d440da63cc4cac0ac55136716688d6c0a2c6ef3edb2254fecbd1fe06056d6bd15975ee8c
+  languageName: node
+  linkType: hard
+
+"is-plain-object@npm:^2.0.4":
+  version: 2.0.4
+  resolution: "is-plain-object@npm:2.0.4"
+  dependencies:
+    isobject: "npm:^3.0.1"
+  checksum: 10c0/f050fdd5203d9c81e8c4df1b3ff461c4bc64e8b5ca383bcdde46131361d0a678e80bcf00b5257646f6c636197629644d53bd8e2375aea633de09a82d57e942f4
+  languageName: node
+  linkType: hard
+
+"is-plain-object@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "is-plain-object@npm:5.0.0"
+  checksum: 10c0/893e42bad832aae3511c71fd61c0bf61aa3a6d853061c62a307261842727d0d25f761ce9379f7ba7226d6179db2a3157efa918e7fe26360f3bf0842d9f28942c
+  languageName: node
+  linkType: hard
+
+"is-potential-custom-element-name@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "is-potential-custom-element-name@npm:1.0.1"
+  checksum: 10c0/b73e2f22bc863b0939941d369486d308b43d7aef1f9439705e3582bfccaa4516406865e32c968a35f97a99396dac84e2624e67b0a16b0a15086a785e16ce7db9
+  languageName: node
+  linkType: hard
+
+"is-promise@npm:^2.0.0":
+  version: 2.2.2
+  resolution: "is-promise@npm:2.2.2"
+  checksum: 10c0/2dba959812380e45b3df0fb12e7cb4d4528c989c7abb03ececb1d1fd6ab1cbfee956ca9daa587b9db1d8ac3c1e5738cf217bdb3dfd99df8c691be4c00ae09069
+  languageName: node
+  linkType: hard
+
+"is-regex@npm:^1.0.3, is-regex@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "is-regex@npm:1.2.1"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    gopd: "npm:^1.2.0"
+    has-tostringtag: "npm:^1.0.2"
+    hasown: "npm:^2.0.2"
+  checksum: 10c0/1d3715d2b7889932349241680032e85d0b492cfcb045acb75ffc2c3085e8d561184f1f7e84b6f8321935b4aea39bc9c6ba74ed595b57ce4881a51dfdbc214e04
+  languageName: node
+  linkType: hard
+
+"is-set@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "is-set@npm:2.0.3"
+  checksum: 10c0/f73732e13f099b2dc879c2a12341cfc22ccaca8dd504e6edae26484bd5707a35d503fba5b4daad530a9b088ced1ae6c9d8200fd92e09b428fe14ea79ce8080b7
+  languageName: node
+  linkType: hard
+
+"is-shared-array-buffer@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "is-shared-array-buffer@npm:1.0.4"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+  checksum: 10c0/65158c2feb41ff1edd6bbd6fd8403a69861cf273ff36077982b5d4d68e1d59278c71691216a4a64632bd76d4792d4d1d2553901b6666d84ade13bba5ea7bc7db
+  languageName: node
+  linkType: hard
+
+"is-stream@npm:^2.0.0":
+  version: 2.0.1
+  resolution: "is-stream@npm:2.0.1"
+  checksum: 10c0/7c284241313fc6efc329b8d7f08e16c0efeb6baab1b4cd0ba579eb78e5af1aa5da11e68559896a2067cd6c526bd29241dda4eb1225e627d5aa1a89a76d4635a5
+  languageName: node
+  linkType: hard
+
+"is-stream@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "is-stream@npm:3.0.0"
+  checksum: 10c0/eb2f7127af02ee9aa2a0237b730e47ac2de0d4e76a4a905a50a11557f2339df5765eaea4ceb8029f1efa978586abe776908720bfcb1900c20c6ec5145f6f29d8
+  languageName: node
+  linkType: hard
+
+"is-string@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "is-string@npm:1.1.1"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    has-tostringtag: "npm:^1.0.2"
+  checksum: 10c0/2f518b4e47886bb81567faba6ffd0d8a8333cf84336e2e78bf160693972e32ad00fe84b0926491cc598dee576fdc55642c92e62d0cbe96bf36f643b6f956f94d
+  languageName: node
+  linkType: hard
+
+"is-symbol@npm:^1.0.4, is-symbol@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "is-symbol@npm:1.1.1"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    has-symbols: "npm:^1.1.0"
+    safe-regex-test: "npm:^1.1.0"
+  checksum: 10c0/f08f3e255c12442e833f75a9e2b84b2d4882fdfd920513cf2a4a2324f0a5b076c8fd913778e3ea5d258d5183e9d92c0cd20e04b03ab3df05316b049b2670af1e
+  languageName: node
+  linkType: hard
+
+"is-typed-array@npm:^1.1.13, is-typed-array@npm:^1.1.14, is-typed-array@npm:^1.1.15":
+  version: 1.1.15
+  resolution: "is-typed-array@npm:1.1.15"
+  dependencies:
+    which-typed-array: "npm:^1.1.16"
+  checksum: 10c0/415511da3669e36e002820584e264997ffe277ff136643a3126cc949197e6ca3334d0f12d084e83b1994af2e9c8141275c741cf2b7da5a2ff62dd0cac26f76c4
+  languageName: node
+  linkType: hard
+
+"is-weakmap@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "is-weakmap@npm:2.0.2"
+  checksum: 10c0/443c35bb86d5e6cc5929cd9c75a4024bb0fff9586ed50b092f94e700b89c43a33b186b76dbc6d54f3d3d09ece689ab38dcdc1af6a482cbe79c0f2da0a17f1299
+  languageName: node
+  linkType: hard
+
+"is-weakref@npm:^1.0.2, is-weakref@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "is-weakref@npm:1.1.1"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+  checksum: 10c0/8e0a9c07b0c780949a100e2cab2b5560a48ecd4c61726923c1a9b77b6ab0aa0046c9e7fb2206042296817045376dee2c8ab1dabe08c7c3dfbf195b01275a085b
+  languageName: node
+  linkType: hard
+
+"is-weakset@npm:^2.0.3":
+  version: 2.0.4
+  resolution: "is-weakset@npm:2.0.4"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    get-intrinsic: "npm:^1.2.6"
+  checksum: 10c0/6491eba08acb8dc9532da23cb226b7d0192ede0b88f16199e592e4769db0a077119c1f5d2283d1e0d16d739115f70046e887e477eb0e66cd90e1bb29f28ba647
+  languageName: node
+  linkType: hard
+
+"isarray@npm:^2.0.5":
+  version: 2.0.5
+  resolution: "isarray@npm:2.0.5"
+  checksum: 10c0/4199f14a7a13da2177c66c31080008b7124331956f47bca57dd0b6ea9f11687aa25e565a2c7a2b519bc86988d10398e3049a1f5df13c9f6b7664154690ae79fd
+  languageName: node
+  linkType: hard
+
+"isexe@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "isexe@npm:2.0.0"
+  checksum: 10c0/228cfa503fadc2c31596ab06ed6aa82c9976eec2bfd83397e7eaf06d0ccf42cd1dfd6743bf9aeb01aebd4156d009994c5f76ea898d2832c1fe342da923ca457d
+  languageName: node
+  linkType: hard
+
+"isexe@npm:^3.1.1":
+  version: 3.1.1
+  resolution: "isexe@npm:3.1.1"
+  checksum: 10c0/9ec257654093443eb0a528a9c8cbba9c0ca7616ccb40abd6dde7202734d96bb86e4ac0d764f0f8cd965856aacbff2f4ce23e730dc19dfb41e3b0d865ca6fdcc7
+  languageName: node
+  linkType: hard
+
+"isobject@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "isobject@npm:3.0.1"
+  checksum: 10c0/03344f5064a82f099a0cd1a8a407f4c0d20b7b8485e8e816c39f249e9416b06c322e8dec5b842b6bb8a06de0af9cb48e7bc1b5352f0fadc2f0abac033db3d4db
+  languageName: node
+  linkType: hard
+
+"jackspeak@npm:^3.1.2":
+  version: 3.4.3
+  resolution: "jackspeak@npm:3.4.3"
+  dependencies:
+    "@isaacs/cliui": "npm:^8.0.2"
+    "@pkgjs/parseargs": "npm:^0.11.0"
+  dependenciesMeta:
+    "@pkgjs/parseargs":
+      optional: true
+  checksum: 10c0/6acc10d139eaefdbe04d2f679e6191b3abf073f111edf10b1de5302c97ec93fffeb2fdd8681ed17f16268aa9dd4f8c588ed9d1d3bffbbfa6e8bf897cbb3149b9
+  languageName: node
+  linkType: hard
+
+"js-stringify@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "js-stringify@npm:1.0.2"
+  checksum: 10c0/a450c04fde3a7e1c27f1c3c4300433f8d79322f9e3c2e76266843cef8c0b5a69b5f11b5f173212b2f15f2df09e068ef7ddf46ef775e2486f3006a6f4e912578d
+  languageName: node
+  linkType: hard
+
+"js-tokens@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "js-tokens@npm:4.0.0"
+  checksum: 10c0/e248708d377aa058eacf2037b07ded847790e6de892bbad3dac0abba2e759cb9f121b00099a65195616badcb6eca8d14d975cb3e89eb1cfda644756402c8aeed
+  languageName: node
+  linkType: hard
+
+"js-tokens@npm:^9.0.1":
+  version: 9.0.1
+  resolution: "js-tokens@npm:9.0.1"
+  checksum: 10c0/68dcab8f233dde211a6b5fd98079783cbcd04b53617c1250e3553ee16ab3e6134f5e65478e41d82f6d351a052a63d71024553933808570f04dbf828d7921e80e
+  languageName: node
+  linkType: hard
+
+"js-yaml@npm:^3.13.1":
+  version: 3.14.1
+  resolution: "js-yaml@npm:3.14.1"
+  dependencies:
+    argparse: "npm:^1.0.7"
+    esprima: "npm:^4.0.0"
+  bin:
+    js-yaml: bin/js-yaml.js
+  checksum: 10c0/6746baaaeac312c4db8e75fa22331d9a04cccb7792d126ed8ce6a0bbcfef0cedaddd0c5098fade53db067c09fe00aa1c957674b4765610a8b06a5a189e46433b
+  languageName: node
+  linkType: hard
+
+"js-yaml@npm:^4.1.0":
+  version: 4.1.0
+  resolution: "js-yaml@npm:4.1.0"
+  dependencies:
+    argparse: "npm:^2.0.1"
+  bin:
+    js-yaml: bin/js-yaml.js
+  checksum: 10c0/184a24b4eaacfce40ad9074c64fd42ac83cf74d8c8cd137718d456ced75051229e5061b8633c3366b8aada17945a7a356b337828c19da92b51ae62126575018f
+  languageName: node
+  linkType: hard
+
+"jscpd-sarif-reporter@npm:4.0.3":
+  version: 4.0.3
+  resolution: "jscpd-sarif-reporter@npm:4.0.3"
+  dependencies:
+    colors: "npm:^1.4.0"
+    fs-extra: "npm:^11.2.0"
+    node-sarif-builder: "npm:^2.0.3"
+  checksum: 10c0/bc8d45e60937946ca6457f4a8486376ff5b40b3d756e92b753445dbadeb4758a568c1191d5393a605e0172e7876c1145a96885437a82336380ba122a6cdda295
+  languageName: node
+  linkType: hard
+
+"jscpd@npm:^4.0.5":
+  version: 4.0.5
+  resolution: "jscpd@npm:4.0.5"
+  dependencies:
+    "@jscpd/core": "npm:4.0.1"
+    "@jscpd/finder": "npm:4.0.1"
+    "@jscpd/html-reporter": "npm:4.0.1"
+    "@jscpd/tokenizer": "npm:4.0.1"
+    colors: "npm:^1.4.0"
+    commander: "npm:^5.0.0"
+    fs-extra: "npm:^11.2.0"
+    gitignore-to-glob: "npm:^0.3.0"
+    jscpd-sarif-reporter: "npm:4.0.3"
+  bin:
+    jscpd: bin/jscpd
+  checksum: 10c0/f6fc533df6344521ca7869efe423f3d38c8f8206477eaeb0c2ee7e6c5551067823d571b30101449c4f487f8b2b0d585aa405ccb6e8b6cdaa20c937e541005986
+  languageName: node
+  linkType: hard
+
+"jsdoc-type-pratt-parser@npm:~4.0.0":
+  version: 4.0.0
+  resolution: "jsdoc-type-pratt-parser@npm:4.0.0"
+  checksum: 10c0/b23ef7bbbe2f56d72630d1c5a233dc9fecaff399063d373c57bef136908c1b05e723dac107177303c03ccf8d75aa51507510b282aa567600477479c5ea0c36d1
+  languageName: node
+  linkType: hard
+
+"jsdom@npm:^23.0.0":
+  version: 23.2.0
+  resolution: "jsdom@npm:23.2.0"
+  dependencies:
+    "@asamuzakjp/dom-selector": "npm:^2.0.1"
+    cssstyle: "npm:^4.0.1"
+    data-urls: "npm:^5.0.0"
+    decimal.js: "npm:^10.4.3"
+    form-data: "npm:^4.0.0"
+    html-encoding-sniffer: "npm:^4.0.0"
+    http-proxy-agent: "npm:^7.0.0"
+    https-proxy-agent: "npm:^7.0.2"
+    is-potential-custom-element-name: "npm:^1.0.1"
+    parse5: "npm:^7.1.2"
+    rrweb-cssom: "npm:^0.6.0"
+    saxes: "npm:^6.0.0"
+    symbol-tree: "npm:^3.2.4"
+    tough-cookie: "npm:^4.1.3"
+    w3c-xmlserializer: "npm:^5.0.0"
+    webidl-conversions: "npm:^7.0.0"
+    whatwg-encoding: "npm:^3.1.1"
+    whatwg-mimetype: "npm:^4.0.0"
+    whatwg-url: "npm:^14.0.0"
+    ws: "npm:^8.16.0"
+    xml-name-validator: "npm:^5.0.0"
+  peerDependencies:
+    canvas: ^2.11.2
+  peerDependenciesMeta:
+    canvas:
+      optional: true
+  checksum: 10c0/b062af50f7be59d914ba75236b7817c848ef3cd007aea1d6b8020a41eb263b7d5bd2652298106e9756b56892f773d990598778d02adab7d0d0d8e58726fc41d3
+  languageName: node
+  linkType: hard
+
+"json-buffer@npm:3.0.1":
+  version: 3.0.1
+  resolution: "json-buffer@npm:3.0.1"
+  checksum: 10c0/0d1c91569d9588e7eef2b49b59851f297f3ab93c7b35c7c221e288099322be6b562767d11e4821da500f3219542b9afd2e54c5dc573107c1126ed1080f8e96d7
+  languageName: node
+  linkType: hard
+
+"json-parse-even-better-errors@npm:^2.3.0":
+  version: 2.3.1
+  resolution: "json-parse-even-better-errors@npm:2.3.1"
+  checksum: 10c0/140932564c8f0b88455432e0f33c4cb4086b8868e37524e07e723f4eaedb9425bdc2bafd71bd1d9765bd15fd1e2d126972bc83990f55c467168c228c24d665f3
+  languageName: node
+  linkType: hard
+
+"json-schema-traverse@npm:^0.4.1":
+  version: 0.4.1
+  resolution: "json-schema-traverse@npm:0.4.1"
+  checksum: 10c0/108fa90d4cc6f08243aedc6da16c408daf81793bf903e9fd5ab21983cda433d5d2da49e40711da016289465ec2e62e0324dcdfbc06275a607fe3233fde4942ce
+  languageName: node
+  linkType: hard
+
+"json-schema-traverse@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "json-schema-traverse@npm:1.0.0"
+  checksum: 10c0/71e30015d7f3d6dc1c316d6298047c8ef98a06d31ad064919976583eb61e1018a60a0067338f0f79cabc00d84af3fcc489bd48ce8a46ea165d9541ba17fb30c6
+  languageName: node
+  linkType: hard
+
+"json-stable-stringify-without-jsonify@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "json-stable-stringify-without-jsonify@npm:1.0.1"
+  checksum: 10c0/cb168b61fd4de83e58d09aaa6425ef71001bae30d260e2c57e7d09a5fd82223e2f22a042dedaab8db23b7d9ae46854b08bb1f91675a8be11c5cffebef5fb66a5
+  languageName: node
+  linkType: hard
+
+"json5@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "json5@npm:1.0.2"
+  dependencies:
+    minimist: "npm:^1.2.0"
+  bin:
+    json5: lib/cli.js
+  checksum: 10c0/9ee316bf21f000b00752e6c2a3b79ecf5324515a5c60ee88983a1910a45426b643a4f3461657586e8aeca87aaf96f0a519b0516d2ae527a6c3e7eed80f68717f
+  languageName: node
+  linkType: hard
+
+"jsonfile@npm:^6.0.1":
+  version: 6.2.0
+  resolution: "jsonfile@npm:6.2.0"
+  dependencies:
+    graceful-fs: "npm:^4.1.6"
+    universalify: "npm:^2.0.0"
+  dependenciesMeta:
+    graceful-fs:
+      optional: true
+  checksum: 10c0/7f4f43b08d1869ded8a6822213d13ae3b99d651151d77efd1557ced0889c466296a7d9684e397bd126acf5eb2cfcb605808c3e681d0fdccd2fe5a04b47e76c0d
+  languageName: node
+  linkType: hard
+
+"jstransformer@npm:1.0.0":
+  version: 1.0.0
+  resolution: "jstransformer@npm:1.0.0"
+  dependencies:
+    is-promise: "npm:^2.0.0"
+    promise: "npm:^7.0.1"
+  checksum: 10c0/11f9b4f368a55878dd7973154cd83b0adca27f974d21217728652530775b2bec281e92109de66f0c9e37c76af796d5b76b33f3e38363214a83d102d523a7285b
+  languageName: node
+  linkType: hard
+
+"jsx-ast-utils-x@npm:0.1.0":
+  version: 0.1.0
+  resolution: "jsx-ast-utils-x@npm:0.1.0"
+  checksum: 10c0/bd147ff19bace8309e48110ec5c7a0c9f750148bcab699b5ba5d44dfac6cea8f358127f3da35ebe073f81cfe46494ce1e9647dd45681bb6c84d83c315904b72b
+  languageName: node
+  linkType: hard
+
+"keyv@npm:^4.5.3":
+  version: 4.5.4
+  resolution: "keyv@npm:4.5.4"
+  dependencies:
+    json-buffer: "npm:3.0.1"
+  checksum: 10c0/aa52f3c5e18e16bb6324876bb8b59dd02acf782a4b789c7b2ae21107fab95fab3890ed448d4f8dba80ce05391eeac4bfabb4f02a20221342982f806fa2cf271e
+  languageName: node
+  linkType: hard
+
+"kind-of@npm:^6.0.2, kind-of@npm:^6.0.3":
+  version: 6.0.3
+  resolution: "kind-of@npm:6.0.3"
+  checksum: 10c0/61cdff9623dabf3568b6445e93e31376bee1cdb93f8ba7033d86022c2a9b1791a1d9510e026e6465ebd701a6dd2f7b0808483ad8838341ac52f003f512e0b4c4
+  languageName: node
+  linkType: hard
+
+"known-css-properties@npm:^0.29.0":
+  version: 0.29.0
+  resolution: "known-css-properties@npm:0.29.0"
+  checksum: 10c0/f66e9992097b8f54e97dbe729943d4a11b8d3ba15f68dbb3deb8bb0122cb89c22c90c9221ecb1e3f2e236838fe3c0faae319b43908c81b6e254ac43cafde2906
+  languageName: node
+  linkType: hard
+
+"levn@npm:^0.4.1":
+  version: 0.4.1
+  resolution: "levn@npm:0.4.1"
+  dependencies:
+    prelude-ls: "npm:^1.2.1"
+    type-check: "npm:~0.4.0"
+  checksum: 10c0/effb03cad7c89dfa5bd4f6989364bfc79994c2042ec5966cb9b95990e2edee5cd8969ddf42616a0373ac49fac1403437deaf6e9050fbbaa3546093a59b9ac94e
+  languageName: node
+  linkType: hard
+
+"lines-and-columns@npm:^1.1.6":
+  version: 1.2.4
+  resolution: "lines-and-columns@npm:1.2.4"
+  checksum: 10c0/3da6ee62d4cd9f03f5dc90b4df2540fb85b352081bee77fe4bbcd12c9000ead7f35e0a38b8d09a9bb99b13223446dd8689ff3c4959807620726d788701a83d2d
+  languageName: node
+  linkType: hard
+
+"local-pkg@npm:^0.5.0":
+  version: 0.5.1
+  resolution: "local-pkg@npm:0.5.1"
+  dependencies:
+    mlly: "npm:^1.7.3"
+    pkg-types: "npm:^1.2.1"
+  checksum: 10c0/ade8346f1dc04875921461adee3c40774b00d4b74095261222ebd4d5fd0a444676e36e325f76760f21af6a60bc82480e154909b54d2d9f7173671e36dacf1808
+  languageName: node
+  linkType: hard
+
+"locate-path@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "locate-path@npm:3.0.0"
+  dependencies:
+    p-locate: "npm:^3.0.0"
+    path-exists: "npm:^3.0.0"
+  checksum: 10c0/3db394b7829a7fe2f4fbdd25d3c4689b85f003c318c5da4052c7e56eed697da8f1bce5294f685c69ff76e32cba7a33629d94396976f6d05fb7f4c755c5e2ae8b
+  languageName: node
+  linkType: hard
+
+"locate-path@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "locate-path@npm:6.0.0"
+  dependencies:
+    p-locate: "npm:^5.0.0"
+  checksum: 10c0/d3972ab70dfe58ce620e64265f90162d247e87159b6126b01314dd67be43d50e96a50b517bce2d9452a79409c7614054c277b5232377de50416564a77ac7aad3
+  languageName: node
+  linkType: hard
+
+"lodash.merge@npm:4.6.2, lodash.merge@npm:^4.6.2":
+  version: 4.6.2
+  resolution: "lodash.merge@npm:4.6.2"
+  checksum: 10c0/402fa16a1edd7538de5b5903a90228aa48eb5533986ba7fa26606a49db2572bf414ff73a2c9f5d5fd36b31c46a5d5c7e1527749c07cbcf965ccff5fbdf32c506
+  languageName: node
+  linkType: hard
+
+"lodash.truncate@npm:^4.4.2":
+  version: 4.4.2
+  resolution: "lodash.truncate@npm:4.4.2"
+  checksum: 10c0/4e870d54e8a6c86c8687e057cec4069d2e941446ccab7f40b4d9555fa5872d917d0b6aa73bece7765500a3123f1723bcdba9ae881b679ef120bba9e1a0b0ed70
+  languageName: node
+  linkType: hard
+
+"lodash@npm:^4.17.21, lodash@npm:~4.17.21":
+  version: 4.17.21
+  resolution: "lodash@npm:4.17.21"
+  checksum: 10c0/d8cbea072bb08655bb4c989da418994b073a608dffa608b09ac04b43a791b12aeae7cd7ad919aa4c925f33b48490b5cfe6c1f71d827956071dae2e7bb3a6b74c
+  languageName: node
+  linkType: hard
+
+"loupe@npm:^2.3.6, loupe@npm:^2.3.7":
+  version: 2.3.7
+  resolution: "loupe@npm:2.3.7"
+  dependencies:
+    get-func-name: "npm:^2.0.1"
+  checksum: 10c0/71a781c8fc21527b99ed1062043f1f2bb30bdaf54fa4cf92463427e1718bc6567af2988300bc243c1f276e4f0876f29e3cbf7b58106fdc186915687456ce5bf4
+  languageName: node
+  linkType: hard
+
+"lru-cache@npm:^10.0.1, lru-cache@npm:^10.2.0, lru-cache@npm:^10.4.3":
+  version: 10.4.3
+  resolution: "lru-cache@npm:10.4.3"
+  checksum: 10c0/ebd04fbca961e6c1d6c0af3799adcc966a1babe798f685bb84e6599266599cd95d94630b10262f5424539bc4640107e8a33aa28585374abf561d30d16f4b39fb
+  languageName: node
+  linkType: hard
+
+"lru-cache@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "lru-cache@npm:6.0.0"
+  dependencies:
+    yallist: "npm:^4.0.0"
+  checksum: 10c0/cb53e582785c48187d7a188d3379c181b5ca2a9c78d2bce3e7dee36f32761d1c42983da3fe12b55cb74e1779fa94cdc2e5367c028a9b35317184ede0c07a30a9
+  languageName: node
+  linkType: hard
+
+"magic-string@npm:^0.30.5, magic-string@npm:~0.30.0":
+  version: 0.30.21
+  resolution: "magic-string@npm:0.30.21"
+  dependencies:
+    "@jridgewell/sourcemap-codec": "npm:^1.5.5"
+  checksum: 10c0/299378e38f9a270069fc62358522ddfb44e94244baa0d6a8980ab2a9b2490a1d03b236b447eee309e17eb3bddfa482c61259d47960eb018a904f0ded52780c4a
+  languageName: node
+  linkType: hard
+
+"make-dir@npm:^2.0.0, make-dir@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "make-dir@npm:2.1.0"
+  dependencies:
+    pify: "npm:^4.0.1"
+    semver: "npm:^5.6.0"
+  checksum: 10c0/ada869944d866229819735bee5548944caef560d7a8536ecbc6536edca28c72add47cc4f6fc39c54fb25d06b58da1f8994cf7d9df7dadea047064749efc085d8
+  languageName: node
+  linkType: hard
+
+"make-fetch-happen@npm:^14.0.3":
+  version: 14.0.3
+  resolution: "make-fetch-happen@npm:14.0.3"
+  dependencies:
+    "@npmcli/agent": "npm:^3.0.0"
+    cacache: "npm:^19.0.1"
+    http-cache-semantics: "npm:^4.1.1"
+    minipass: "npm:^7.0.2"
+    minipass-fetch: "npm:^4.0.0"
+    minipass-flush: "npm:^1.0.5"
+    minipass-pipeline: "npm:^1.2.4"
+    negotiator: "npm:^1.0.0"
+    proc-log: "npm:^5.0.0"
+    promise-retry: "npm:^2.0.1"
+    ssri: "npm:^12.0.0"
+  checksum: 10c0/c40efb5e5296e7feb8e37155bde8eb70bc57d731b1f7d90e35a092fde403d7697c56fb49334d92d330d6f1ca29a98142036d6480a12681133a0a1453164cb2f0
+  languageName: node
+  linkType: hard
+
+"map-obj@npm:^1.0.0":
+  version: 1.0.1
+  resolution: "map-obj@npm:1.0.1"
+  checksum: 10c0/ccca88395e7d38671ed9f5652ecf471ecd546924be2fb900836b9da35e068a96687d96a5f93dcdfa94d9a27d649d2f10a84595590f89a347fb4dda47629dcc52
+  languageName: node
+  linkType: hard
+
+"map-obj@npm:^4.1.0":
+  version: 4.3.0
+  resolution: "map-obj@npm:4.3.0"
+  checksum: 10c0/1c19e1c88513c8abdab25c316367154c6a0a6a0f77e3e8c391bb7c0e093aefed293f539d026dc013d86219e5e4c25f23b0003ea588be2101ccd757bacc12d43b
+  languageName: node
+  linkType: hard
+
+"markdown-table@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "markdown-table@npm:2.0.0"
+  dependencies:
+    repeat-string: "npm:^1.0.0"
+  checksum: 10c0/f257e0781ea50eb946919df84bdee4ba61f983971b277a369ca7276f89740fd0e2749b9b187163a42df4c48682b71962d4007215ce3523480028f06c11ddc2e6
+  languageName: node
+  linkType: hard
+
+"math-intrinsics@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "math-intrinsics@npm:1.1.0"
+  checksum: 10c0/7579ff94e899e2f76ab64491d76cf606274c874d8f2af4a442c016bd85688927fcfca157ba6bf74b08e9439dc010b248ce05b96cc7c126a354c3bae7fcb48b7f
+  languageName: node
+  linkType: hard
+
+"mathml-tag-names@npm:^2.1.3":
+  version: 2.1.3
+  resolution: "mathml-tag-names@npm:2.1.3"
+  checksum: 10c0/e2b094658a2618433efd2678a5a3e551645e09ba17c7c777783cd8dfa0178b0195fda0a5c46a6be5e778923662cf8dde891c894c869ff14fbb4ea3208c31bc4d
+  languageName: node
+  linkType: hard
+
+"mdn-data@npm:2.0.30":
+  version: 2.0.30
+  resolution: "mdn-data@npm:2.0.30"
+  checksum: 10c0/a2c472ea16cee3911ae742593715aa4c634eb3d4b9f1e6ada0902aa90df13dcbb7285d19435f3ff213ebaa3b2e0c0265c1eb0e3fb278fda7f8919f046a410cd9
+  languageName: node
+  linkType: hard
+
+"meow@npm:^10.1.5":
+  version: 10.1.5
+  resolution: "meow@npm:10.1.5"
+  dependencies:
+    "@types/minimist": "npm:^1.2.2"
+    camelcase-keys: "npm:^7.0.0"
+    decamelize: "npm:^5.0.0"
+    decamelize-keys: "npm:^1.1.0"
+    hard-rejection: "npm:^2.1.0"
+    minimist-options: "npm:4.1.0"
+    normalize-package-data: "npm:^3.0.2"
+    read-pkg-up: "npm:^8.0.0"
+    redent: "npm:^4.0.0"
+    trim-newlines: "npm:^4.0.2"
+    type-fest: "npm:^1.2.2"
+    yargs-parser: "npm:^20.2.9"
+  checksum: 10c0/a513849022edd5ddcc41d28c679d31978abe414d9db5bc457e95e537a4327b2910fd2f699cdd883293f9a5da8951a50939bf60fbd62f7fe12b9ddf96a84b1b27
+  languageName: node
+  linkType: hard
+
+"merge-stream@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "merge-stream@npm:2.0.0"
+  checksum: 10c0/867fdbb30a6d58b011449b8885601ec1690c3e41c759ecd5a9d609094f7aed0096c37823ff4a7190ef0b8f22cc86beb7049196ff68c016e3b3c671d0dac91ce5
+  languageName: node
+  linkType: hard
+
+"merge2@npm:^1.3.0, merge2@npm:^1.4.1":
+  version: 1.4.1
+  resolution: "merge2@npm:1.4.1"
+  checksum: 10c0/254a8a4605b58f450308fc474c82ac9a094848081bf4c06778200207820e5193726dc563a0d2c16468810516a5c97d9d3ea0ca6585d23c58ccfff2403e8dbbeb
+  languageName: node
+  linkType: hard
+
+"micromatch@npm:^4.0.5, micromatch@npm:^4.0.8":
+  version: 4.0.8
+  resolution: "micromatch@npm:4.0.8"
+  dependencies:
+    braces: "npm:^3.0.3"
+    picomatch: "npm:^2.3.1"
+  checksum: 10c0/166fa6eb926b9553f32ef81f5f531d27b4ce7da60e5baf8c021d043b27a388fb95e46a8038d5045877881e673f8134122b59624d5cecbd16eb50a42e7a6b5ca8
+  languageName: node
+  linkType: hard
+
+"mime-db@npm:1.52.0":
+  version: 1.52.0
+  resolution: "mime-db@npm:1.52.0"
+  checksum: 10c0/0557a01deebf45ac5f5777fe7740b2a5c309c6d62d40ceab4e23da9f821899ce7a900b7ac8157d4548ddbb7beffe9abc621250e6d182b0397ec7f10c7b91a5aa
+  languageName: node
+  linkType: hard
+
+"mime-types@npm:^2.1.12":
+  version: 2.1.35
+  resolution: "mime-types@npm:2.1.35"
+  dependencies:
+    mime-db: "npm:1.52.0"
+  checksum: 10c0/82fb07ec56d8ff1fc999a84f2f217aa46cb6ed1033fefaabd5785b9a974ed225c90dc72fff460259e66b95b73648596dbcc50d51ed69cdf464af2d237d3149b2
+  languageName: node
+  linkType: hard
+
+"mimic-fn@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "mimic-fn@npm:2.1.0"
+  checksum: 10c0/b26f5479d7ec6cc2bce275a08f146cf78f5e7b661b18114e2506dd91ec7ec47e7a25bf4360e5438094db0560bcc868079fb3b1fb3892b833c1ecbf63f80c95a4
+  languageName: node
+  linkType: hard
+
+"mimic-fn@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "mimic-fn@npm:4.0.0"
+  checksum: 10c0/de9cc32be9996fd941e512248338e43407f63f6d497abe8441fa33447d922e927de54d4cc3c1a3c6d652857acd770389d5a3823f311a744132760ce2be15ccbf
+  languageName: node
+  linkType: hard
+
+"minimatch@npm:9.0.3":
+  version: 9.0.3
+  resolution: "minimatch@npm:9.0.3"
+  dependencies:
+    brace-expansion: "npm:^2.0.1"
+  checksum: 10c0/85f407dcd38ac3e180f425e86553911d101455ca3ad5544d6a7cec16286657e4f8a9aa6695803025c55e31e35a91a2252b5dc8e7d527211278b8b65b4dbd5eac
+  languageName: node
+  linkType: hard
+
+"minimatch@npm:9.0.5, minimatch@npm:^9.0.4":
+  version: 9.0.5
+  resolution: "minimatch@npm:9.0.5"
+  dependencies:
+    brace-expansion: "npm:^2.0.1"
+  checksum: 10c0/de96cf5e35bdf0eab3e2c853522f98ffbe9a36c37797778d2665231ec1f20a9447a7e567cb640901f89e4daaa95ae5d70c65a9e8aa2bb0019b6facbc3c0575ed
+  languageName: node
+  linkType: hard
+
+"minimatch@npm:^3.0.4, minimatch@npm:^3.0.5, minimatch@npm:^3.1.1, minimatch@npm:^3.1.2":
+  version: 3.1.2
+  resolution: "minimatch@npm:3.1.2"
+  dependencies:
+    brace-expansion: "npm:^1.1.7"
+  checksum: 10c0/0262810a8fc2e72cca45d6fd86bd349eee435eb95ac6aa45c9ea2180e7ee875ef44c32b55b5973ceabe95ea12682f6e3725cbb63d7a2d1da3ae1163c8b210311
+  languageName: node
+  linkType: hard
+
+"minimist-options@npm:4.1.0":
+  version: 4.1.0
+  resolution: "minimist-options@npm:4.1.0"
+  dependencies:
+    arrify: "npm:^1.0.1"
+    is-plain-obj: "npm:^1.1.0"
+    kind-of: "npm:^6.0.3"
+  checksum: 10c0/7871f9cdd15d1e7374e5b013e2ceda3d327a06a8c7b38ae16d9ef941e07d985e952c589e57213f7aa90a8744c60aed9524c0d85e501f5478382d9181f2763f54
+  languageName: node
+  linkType: hard
+
+"minimist@npm:^1.2.0, minimist@npm:^1.2.6":
+  version: 1.2.8
+  resolution: "minimist@npm:1.2.8"
+  checksum: 10c0/19d3fcdca050087b84c2029841a093691a91259a47def2f18222f41e7645a0b7c44ef4b40e88a1e58a40c84d2ef0ee6047c55594d298146d0eb3f6b737c20ce6
+  languageName: node
+  linkType: hard
+
+"minipass-collect@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "minipass-collect@npm:2.0.1"
+  dependencies:
+    minipass: "npm:^7.0.3"
+  checksum: 10c0/5167e73f62bb74cc5019594709c77e6a742051a647fe9499abf03c71dca75515b7959d67a764bdc4f8b361cf897fbf25e2d9869ee039203ed45240f48b9aa06e
+  languageName: node
+  linkType: hard
+
+"minipass-fetch@npm:^4.0.0":
+  version: 4.0.1
+  resolution: "minipass-fetch@npm:4.0.1"
+  dependencies:
+    encoding: "npm:^0.1.13"
+    minipass: "npm:^7.0.3"
+    minipass-sized: "npm:^1.0.3"
+    minizlib: "npm:^3.0.1"
+  dependenciesMeta:
+    encoding:
+      optional: true
+  checksum: 10c0/a3147b2efe8e078c9bf9d024a0059339c5a09c5b1dded6900a219c218cc8b1b78510b62dae556b507304af226b18c3f1aeb1d48660283602d5b6586c399eed5c
+  languageName: node
+  linkType: hard
+
+"minipass-flush@npm:^1.0.5":
+  version: 1.0.5
+  resolution: "minipass-flush@npm:1.0.5"
+  dependencies:
+    minipass: "npm:^3.0.0"
+  checksum: 10c0/2a51b63feb799d2bb34669205eee7c0eaf9dce01883261a5b77410c9408aa447e478efd191b4de6fc1101e796ff5892f8443ef20d9544385819093dbb32d36bd
+  languageName: node
+  linkType: hard
+
+"minipass-pipeline@npm:^1.2.4":
+  version: 1.2.4
+  resolution: "minipass-pipeline@npm:1.2.4"
+  dependencies:
+    minipass: "npm:^3.0.0"
+  checksum: 10c0/cbda57cea20b140b797505dc2cac71581a70b3247b84480c1fed5ca5ba46c25ecc25f68bfc9e6dcb1a6e9017dab5c7ada5eab73ad4f0a49d84e35093e0c643f2
+  languageName: node
+  linkType: hard
+
+"minipass-sized@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "minipass-sized@npm:1.0.3"
+  dependencies:
+    minipass: "npm:^3.0.0"
+  checksum: 10c0/298f124753efdc745cfe0f2bdfdd81ba25b9f4e753ca4a2066eb17c821f25d48acea607dfc997633ee5bf7b6dfffb4eee4f2051eb168663f0b99fad2fa4829cb
+  languageName: node
+  linkType: hard
+
+"minipass@npm:^3.0.0":
+  version: 3.3.6
+  resolution: "minipass@npm:3.3.6"
+  dependencies:
+    yallist: "npm:^4.0.0"
+  checksum: 10c0/a114746943afa1dbbca8249e706d1d38b85ed1298b530f5808ce51f8e9e941962e2a5ad2e00eae7dd21d8a4aae6586a66d4216d1a259385e9d0358f0c1eba16c
+  languageName: node
+  linkType: hard
+
+"minipass@npm:^5.0.0 || ^6.0.2 || ^7.0.0, minipass@npm:^7.0.2, minipass@npm:^7.0.3, minipass@npm:^7.0.4, minipass@npm:^7.1.2":
+  version: 7.1.2
+  resolution: "minipass@npm:7.1.2"
+  checksum: 10c0/b0fd20bb9fb56e5fa9a8bfac539e8915ae07430a619e4b86ff71f5fc757ef3924b23b2c4230393af1eda647ed3d75739e4e0acb250a6b1eb277cf7f8fe449557
+  languageName: node
+  linkType: hard
+
+"minizlib@npm:^3.0.1, minizlib@npm:^3.1.0":
+  version: 3.1.0
+  resolution: "minizlib@npm:3.1.0"
+  dependencies:
+    minipass: "npm:^7.1.2"
+  checksum: 10c0/5aad75ab0090b8266069c9aabe582c021ae53eb33c6c691054a13a45db3b4f91a7fb1bd79151e6b4e9e9a86727b522527c0a06ec7d45206b745d54cd3097bcec
+  languageName: node
+  linkType: hard
+
+"mkdirp@npm:^0.5.3":
+  version: 0.5.6
+  resolution: "mkdirp@npm:0.5.6"
+  dependencies:
+    minimist: "npm:^1.2.6"
+  bin:
+    mkdirp: bin/cmd.js
+  checksum: 10c0/e2e2be789218807b58abced04e7b49851d9e46e88a2f9539242cc8a92c9b5c3a0b9bab360bd3014e02a140fc4fbc58e31176c408b493f8a2a6f4986bd7527b01
+  languageName: node
+  linkType: hard
+
+"mlly@npm:^1.7.3, mlly@npm:^1.7.4":
+  version: 1.8.0
+  resolution: "mlly@npm:1.8.0"
+  dependencies:
+    acorn: "npm:^8.15.0"
+    pathe: "npm:^2.0.3"
+    pkg-types: "npm:^1.3.1"
+    ufo: "npm:^1.6.1"
+  checksum: 10c0/f174b844ae066c71e9b128046677868e2e28694f0bbeeffbe760b2a9d8ff24de0748d0fde6fabe706700c1d2e11d3c0d7a53071b5ea99671592fac03364604ab
+  languageName: node
+  linkType: hard
+
+"moment@npm:~2.30.1":
+  version: 2.30.1
+  resolution: "moment@npm:2.30.1"
+  checksum: 10c0/865e4279418c6de666fca7786607705fd0189d8a7b7624e2e56be99290ac846f90878a6f602e34b4e0455c549b85385b1baf9966845962b313699e7cb847543a
+  languageName: node
+  linkType: hard
+
+"mrmime@npm:^2.0.0":
+  version: 2.0.1
+  resolution: "mrmime@npm:2.0.1"
+  checksum: 10c0/af05afd95af202fdd620422f976ad67dc18e6ee29beb03dd1ce950ea6ef664de378e44197246df4c7cdd73d47f2e7143a6e26e473084b9e4aa2095c0ad1e1761
+  languageName: node
+  linkType: hard
+
+"ms@npm:^2.1.1, ms@npm:^2.1.3":
+  version: 2.1.3
+  resolution: "ms@npm:2.1.3"
+  checksum: 10c0/d924b57e7312b3b63ad21fc5b3dc0af5e78d61a1fc7cfb5457edaf26326bf62be5307cc87ffb6862ef1c2b33b0233cdb5d4f01c4c958cc0d660948b65a287a48
+  languageName: node
+  linkType: hard
+
+"nanoid@npm:^3.3.11":
+  version: 3.3.11
+  resolution: "nanoid@npm:3.3.11"
+  bin:
+    nanoid: bin/nanoid.cjs
+  checksum: 10c0/40e7f70b3d15f725ca072dfc4f74e81fcf1fbb02e491cf58ac0c79093adc9b0a73b152bcde57df4b79cd097e13023d7504acb38404a4da7bc1cd8e887b82fe0b
+  languageName: node
+  linkType: hard
+
+"nanoid@npm:^4.0.2":
+  version: 4.0.2
+  resolution: "nanoid@npm:4.0.2"
+  bin:
+    nanoid: bin/nanoid.js
+  checksum: 10c0/3fec62f422bc4727918eda0e7aa43e9cbb2e759be72813a0587b9dac99727d3c7ad972efce7f4f1d4cb5c7c554136a1ec3b1043d1d91d28d818d6acbe98200e5
+  languageName: node
+  linkType: hard
+
+"natural-compare@npm:^1.4.0":
+  version: 1.4.0
+  resolution: "natural-compare@npm:1.4.0"
+  checksum: 10c0/f5f9a7974bfb28a91afafa254b197f0f22c684d4a1731763dda960d2c8e375b36c7d690e0d9dc8fba774c537af14a7e979129bca23d88d052fbeb9466955e447
+  languageName: node
+  linkType: hard
+
+"negotiator@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "negotiator@npm:1.0.0"
+  checksum: 10c0/4c559dd52669ea48e1914f9d634227c561221dd54734070791f999c52ed0ff36e437b2e07d5c1f6e32909fc625fe46491c16e4a8f0572567d4dd15c3a4fda04b
+  languageName: node
+  linkType: hard
+
+"node-gyp@npm:latest":
+  version: 11.5.0
+  resolution: "node-gyp@npm:11.5.0"
+  dependencies:
+    env-paths: "npm:^2.2.0"
+    exponential-backoff: "npm:^3.1.1"
+    graceful-fs: "npm:^4.2.6"
+    make-fetch-happen: "npm:^14.0.3"
+    nopt: "npm:^8.0.0"
+    proc-log: "npm:^5.0.0"
+    semver: "npm:^7.3.5"
+    tar: "npm:^7.4.3"
+    tinyglobby: "npm:^0.2.12"
+    which: "npm:^5.0.0"
+  bin:
+    node-gyp: bin/node-gyp.js
+  checksum: 10c0/31ff49586991b38287bb15c3d529dd689cfc32f992eed9e6997b9d712d5d21fe818a8b1bbfe3b76a7e33765c20210c5713212f4aa329306a615b87d8a786da3a
+  languageName: node
+  linkType: hard
+
+"node-releases@npm:^2.0.26":
+  version: 2.0.27
+  resolution: "node-releases@npm:2.0.27"
+  checksum: 10c0/f1e6583b7833ea81880627748d28a3a7ff5703d5409328c216ae57befbced10ce2c991bea86434e8ec39003bd017f70481e2e5f8c1f7e0a7663241f81d6e00e2
+  languageName: node
+  linkType: hard
+
+"node-sarif-builder@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "node-sarif-builder@npm:2.0.3"
+  dependencies:
+    "@types/sarif": "npm:^2.1.4"
+    fs-extra: "npm:^10.0.0"
+  checksum: 10c0/328821b645d46a256197c6f8a17f3eb9c53f1af3416184a3d2b354e28d595d2f216380b573ccbd2dd769eaac70e5d020b731f32dc66b8782af0e403723e5ed5f
+  languageName: node
+  linkType: hard
+
+"nopt@npm:^8.0.0":
+  version: 8.1.0
+  resolution: "nopt@npm:8.1.0"
+  dependencies:
+    abbrev: "npm:^3.0.0"
+  bin:
+    nopt: bin/nopt.js
+  checksum: 10c0/62e9ea70c7a3eb91d162d2c706b6606c041e4e7b547cbbb48f8b3695af457dd6479904d7ace600856bf923dd8d1ed0696f06195c8c20f02ac87c1da0e1d315ef
+  languageName: node
+  linkType: hard
+
+"normalize-package-data@npm:^3.0.2":
+  version: 3.0.3
+  resolution: "normalize-package-data@npm:3.0.3"
+  dependencies:
+    hosted-git-info: "npm:^4.0.1"
+    is-core-module: "npm:^2.5.0"
+    semver: "npm:^7.3.4"
+    validate-npm-package-license: "npm:^3.0.1"
+  checksum: 10c0/e5d0f739ba2c465d41f77c9d950e291ea4af78f8816ddb91c5da62257c40b76d8c83278b0d08ffbcd0f187636ebddad20e181e924873916d03e6e5ea2ef026be
+  languageName: node
+  linkType: hard
+
+"normalize-path@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "normalize-path@npm:3.0.0"
+  checksum: 10c0/e008c8142bcc335b5e38cf0d63cfd39d6cf2d97480af9abdbe9a439221fd4d749763bab492a8ee708ce7a194bb00c9da6d0a115018672310850489137b3da046
+  languageName: node
+  linkType: hard
+
+"normalize-range@npm:^0.1.2":
+  version: 0.1.2
+  resolution: "normalize-range@npm:0.1.2"
+  checksum: 10c0/bf39b73a63e0a42ad1a48c2bd1bda5a07ede64a7e2567307a407674e595bcff0fa0d57e8e5f1e7fa5e91000797c7615e13613227aaaa4d6d6e87f5bd5cc95de6
+  languageName: node
+  linkType: hard
+
+"npm-run-path@npm:^4.0.0":
+  version: 4.0.1
+  resolution: "npm-run-path@npm:4.0.1"
+  dependencies:
+    path-key: "npm:^3.0.0"
+  checksum: 10c0/6f9353a95288f8455cf64cbeb707b28826a7f29690244c1e4bb61ec573256e021b6ad6651b394eb1ccfd00d6ec50147253aba2c5fe58a57ceb111fad62c519ac
+  languageName: node
+  linkType: hard
+
+"npm-run-path@npm:^5.1.0":
+  version: 5.3.0
+  resolution: "npm-run-path@npm:5.3.0"
+  dependencies:
+    path-key: "npm:^4.0.0"
+  checksum: 10c0/124df74820c40c2eb9a8612a254ea1d557ddfab1581c3e751f825e3e366d9f00b0d76a3c94ecd8398e7f3eee193018622677e95816e8491f0797b21e30b2deba
+  languageName: node
+  linkType: hard
+
+"object-assign@npm:^4.1.1":
+  version: 4.1.1
+  resolution: "object-assign@npm:4.1.1"
+  checksum: 10c0/1f4df9945120325d041ccf7b86f31e8bcc14e73d29171e37a7903050e96b81323784ec59f93f102ec635bcf6fa8034ba3ea0a8c7e69fa202b87ae3b6cec5a414
+  languageName: node
+  linkType: hard
+
+"object-inspect@npm:^1.13.3, object-inspect@npm:^1.13.4":
+  version: 1.13.4
+  resolution: "object-inspect@npm:1.13.4"
+  checksum: 10c0/d7f8711e803b96ea3191c745d6f8056ce1f2496e530e6a19a0e92d89b0fa3c76d910c31f0aa270432db6bd3b2f85500a376a83aaba849a8d518c8845b3211692
+  languageName: node
+  linkType: hard
+
+"object-keys@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "object-keys@npm:1.1.1"
+  checksum: 10c0/b11f7ccdbc6d406d1f186cdadb9d54738e347b2692a14439ca5ac70c225fa6db46db809711b78589866d47b25fc3e8dee0b4c722ac751e11180f9380e3d8601d
+  languageName: node
+  linkType: hard
+
+"object.assign@npm:^4.1.7":
+  version: 4.1.7
+  resolution: "object.assign@npm:4.1.7"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.3"
+    define-properties: "npm:^1.2.1"
+    es-object-atoms: "npm:^1.0.0"
+    has-symbols: "npm:^1.1.0"
+    object-keys: "npm:^1.1.1"
+  checksum: 10c0/3b2732bd860567ea2579d1567525168de925a8d852638612846bd8082b3a1602b7b89b67b09913cbb5b9bd6e95923b2ae73580baa9d99cb4e990564e8cbf5ddc
+  languageName: node
+  linkType: hard
+
+"object.fromentries@npm:^2.0.6, object.fromentries@npm:^2.0.8":
+  version: 2.0.8
+  resolution: "object.fromentries@npm:2.0.8"
+  dependencies:
+    call-bind: "npm:^1.0.7"
+    define-properties: "npm:^1.2.1"
+    es-abstract: "npm:^1.23.2"
+    es-object-atoms: "npm:^1.0.0"
+  checksum: 10c0/cd4327e6c3369cfa805deb4cbbe919bfb7d3aeebf0bcaba291bb568ea7169f8f8cdbcabe2f00b40db0c20cd20f08e11b5f3a5a36fb7dd3fe04850c50db3bf83b
+  languageName: node
+  linkType: hard
+
+"object.groupby@npm:^1.0.0, object.groupby@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "object.groupby@npm:1.0.3"
+  dependencies:
+    call-bind: "npm:^1.0.7"
+    define-properties: "npm:^1.2.1"
+    es-abstract: "npm:^1.23.2"
+  checksum: 10c0/60d0455c85c736fbfeda0217d1a77525956f76f7b2495edeca9e9bbf8168a45783199e77b894d30638837c654d0cc410e0e02cbfcf445bc8de71c3da1ede6a9c
+  languageName: node
+  linkType: hard
+
+"object.values@npm:^1.1.6, object.values@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "object.values@npm:1.2.1"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.3"
+    define-properties: "npm:^1.2.1"
+    es-object-atoms: "npm:^1.0.0"
+  checksum: 10c0/3c47814fdc64842ae3d5a74bc9d06bdd8d21563c04d9939bf6716a9c00596a4ebc342552f8934013d1ec991c74e3671b26710a0c51815f0b603795605ab6b2c9
+  languageName: node
+  linkType: hard
+
+"once@npm:^1.3.0, once@npm:^1.3.1, once@npm:^1.4.0":
+  version: 1.4.0
+  resolution: "once@npm:1.4.0"
+  dependencies:
+    wrappy: "npm:1"
+  checksum: 10c0/5d48aca287dfefabd756621c5dfce5c91a549a93e9fdb7b8246bc4c4790aa2ec17b34a260530474635147aeb631a2dcc8b32c613df0675f96041cbb8244517d0
+  languageName: node
+  linkType: hard
+
+"onetime@npm:^5.1.0":
+  version: 5.1.2
+  resolution: "onetime@npm:5.1.2"
+  dependencies:
+    mimic-fn: "npm:^2.1.0"
+  checksum: 10c0/ffcef6fbb2692c3c40749f31ea2e22677a876daea92959b8a80b521d95cca7a668c884d8b2045d1d8ee7d56796aa405c405462af112a1477594cc63531baeb8f
+  languageName: node
+  linkType: hard
+
+"onetime@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "onetime@npm:6.0.0"
+  dependencies:
+    mimic-fn: "npm:^4.0.0"
+  checksum: 10c0/4eef7c6abfef697dd4479345a4100c382d73c149d2d56170a54a07418c50816937ad09500e1ed1e79d235989d073a9bade8557122aee24f0576ecde0f392bb6c
+  languageName: node
+  linkType: hard
+
+"optionator@npm:^0.9.3":
+  version: 0.9.4
+  resolution: "optionator@npm:0.9.4"
+  dependencies:
+    deep-is: "npm:^0.1.3"
+    fast-levenshtein: "npm:^2.0.6"
+    levn: "npm:^0.4.1"
+    prelude-ls: "npm:^1.2.1"
+    type-check: "npm:^0.4.0"
+    word-wrap: "npm:^1.2.5"
+  checksum: 10c0/4afb687a059ee65b61df74dfe87d8d6815cd6883cb8b3d5883a910df72d0f5d029821f37025e4bccf4048873dbdb09acc6d303d27b8f76b1a80dd5a7d5334675
+  languageName: node
+  linkType: hard
+
+"own-keys@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "own-keys@npm:1.0.1"
+  dependencies:
+    get-intrinsic: "npm:^1.2.6"
+    object-keys: "npm:^1.1.1"
+    safe-push-apply: "npm:^1.0.0"
+  checksum: 10c0/6dfeb3455bff92ec3f16a982d4e3e65676345f6902d9f5ded1d8265a6318d0200ce461956d6d1c70053c7fe9f9fe65e552faac03f8140d37ef0fdd108e67013a
+  languageName: node
+  linkType: hard
+
+"p-limit@npm:^2.0.0":
+  version: 2.3.0
+  resolution: "p-limit@npm:2.3.0"
+  dependencies:
+    p-try: "npm:^2.0.0"
+  checksum: 10c0/8da01ac53efe6a627080fafc127c873da40c18d87b3f5d5492d465bb85ec7207e153948df6b9cbaeb130be70152f874229b8242ee2be84c0794082510af97f12
+  languageName: node
+  linkType: hard
+
+"p-limit@npm:^3.0.2":
+  version: 3.1.0
+  resolution: "p-limit@npm:3.1.0"
+  dependencies:
+    yocto-queue: "npm:^0.1.0"
+  checksum: 10c0/9db675949dbdc9c3763c89e748d0ef8bdad0afbb24d49ceaf4c46c02c77d30db4e0652ed36d0a0a7a95154335fab810d95c86153105bb73b3a90448e2bb14e1a
+  languageName: node
+  linkType: hard
+
+"p-limit@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "p-limit@npm:5.0.0"
+  dependencies:
+    yocto-queue: "npm:^1.0.0"
+  checksum: 10c0/574e93b8895a26e8485eb1df7c4b58a1a6e8d8ae41b1750cc2cc440922b3d306044fc6e9a7f74578a883d46802d9db72b30f2e612690fcef838c173261b1ed83
+  languageName: node
+  linkType: hard
+
+"p-locate@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "p-locate@npm:3.0.0"
+  dependencies:
+    p-limit: "npm:^2.0.0"
+  checksum: 10c0/7b7f06f718f19e989ce6280ed4396fb3c34dabdee0df948376483032f9d5ec22fdf7077ec942143a75827bb85b11da72016497fc10dac1106c837ed593969ee8
+  languageName: node
+  linkType: hard
+
+"p-locate@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "p-locate@npm:5.0.0"
+  dependencies:
+    p-limit: "npm:^3.0.2"
+  checksum: 10c0/2290d627ab7903b8b70d11d384fee714b797f6040d9278932754a6860845c4d3190603a0772a663c8cb5a7b21d1b16acb3a6487ebcafa9773094edc3dfe6009a
+  languageName: node
+  linkType: hard
+
+"p-map@npm:^7.0.2":
+  version: 7.0.3
+  resolution: "p-map@npm:7.0.3"
+  checksum: 10c0/46091610da2b38ce47bcd1d8b4835a6fa4e832848a6682cf1652bc93915770f4617afc844c10a77d1b3e56d2472bb2d5622353fa3ead01a7f42b04fc8e744a5c
+  languageName: node
+  linkType: hard
+
+"p-try@npm:^2.0.0":
+  version: 2.2.0
+  resolution: "p-try@npm:2.2.0"
+  checksum: 10c0/c36c19907734c904b16994e6535b02c36c2224d433e01a2f1ab777237f4d86e6289fd5fd464850491e940379d4606ed850c03e0f9ab600b0ebddb511312e177f
+  languageName: node
+  linkType: hard
+
+"package-json-from-dist@npm:^1.0.0":
+  version: 1.0.1
+  resolution: "package-json-from-dist@npm:1.0.1"
+  checksum: 10c0/62ba2785eb655fec084a257af34dbe24292ab74516d6aecef97ef72d4897310bc6898f6c85b5cd22770eaa1ce60d55a0230e150fb6a966e3ecd6c511e23d164b
+  languageName: node
+  linkType: hard
+
+"package-name-regex@npm:~2.0.6":
+  version: 2.0.6
+  resolution: "package-name-regex@npm:2.0.6"
+  checksum: 10c0/f0d2446983d9e4fcd21e983a38b30d5d4728f7e3613392c455ba00e3b6ddfbde12b91955c8f4e15a7f72851bd619af4832313eae4b52aedb88cf84024a5224a3
+  languageName: node
+  linkType: hard
+
+"parent-module@npm:^1.0.0":
+  version: 1.0.1
+  resolution: "parent-module@npm:1.0.1"
+  dependencies:
+    callsites: "npm:^3.0.0"
+  checksum: 10c0/c63d6e80000d4babd11978e0d3fee386ca7752a02b035fd2435960ffaa7219dc42146f07069fb65e6e8bf1caef89daf9af7535a39bddf354d78bf50d8294f556
+  languageName: node
+  linkType: hard
+
+"parse-imports@npm:^2.1.1":
+  version: 2.2.1
+  resolution: "parse-imports@npm:2.2.1"
+  dependencies:
+    es-module-lexer: "npm:^1.5.3"
+    slashes: "npm:^3.0.12"
+  checksum: 10c0/bc541ce4ef2ff77d53247de39a956e0ee7a1a4b9b175c3e0f898222fe7994595f011491154db4ed408cbaf5049ede9d0b6624125565be208e973a54420cbe069
+  languageName: node
+  linkType: hard
+
+"parse-json@npm:^5.2.0":
+  version: 5.2.0
+  resolution: "parse-json@npm:5.2.0"
+  dependencies:
+    "@babel/code-frame": "npm:^7.0.0"
+    error-ex: "npm:^1.3.1"
+    json-parse-even-better-errors: "npm:^2.3.0"
+    lines-and-columns: "npm:^1.1.6"
+  checksum: 10c0/77947f2253005be7a12d858aedbafa09c9ae39eb4863adf330f7b416ca4f4a08132e453e08de2db46459256fb66afaac5ee758b44fe6541b7cdaf9d252e59585
+  languageName: node
+  linkType: hard
+
+"parse5@npm:^7.1.2":
+  version: 7.3.0
+  resolution: "parse5@npm:7.3.0"
+  dependencies:
+    entities: "npm:^6.0.0"
+  checksum: 10c0/7fd2e4e247e85241d6f2a464d0085eed599a26d7b0a5233790c49f53473232eb85350e8133344d9b3fd58b89339e7ad7270fe1f89d28abe50674ec97b87f80b5
+  languageName: node
+  linkType: hard
+
+"path-exists@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "path-exists@npm:3.0.0"
+  checksum: 10c0/17d6a5664bc0a11d48e2b2127d28a0e58822c6740bde30403f08013da599182289c56518bec89407e3f31d3c2b6b296a4220bc3f867f0911fee6952208b04167
+  languageName: node
+  linkType: hard
+
+"path-exists@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "path-exists@npm:4.0.0"
+  checksum: 10c0/8c0bd3f5238188197dc78dced15207a4716c51cc4e3624c44fc97acf69558f5ebb9a2afff486fe1b4ee148e0c133e96c5e11a9aa5c48a3006e3467da070e5e1b
+  languageName: node
+  linkType: hard
+
+"path-is-absolute@npm:^1.0.0":
+  version: 1.0.1
+  resolution: "path-is-absolute@npm:1.0.1"
+  checksum: 10c0/127da03c82172a2a50099cddbf02510c1791fc2cc5f7713ddb613a56838db1e8168b121a920079d052e0936c23005562059756d653b7c544c53185efe53be078
+  languageName: node
+  linkType: hard
+
+"path-key@npm:^3.0.0, path-key@npm:^3.1.0":
+  version: 3.1.1
+  resolution: "path-key@npm:3.1.1"
+  checksum: 10c0/748c43efd5a569c039d7a00a03b58eecd1d75f3999f5a28303d75f521288df4823bc057d8784eb72358b2895a05f29a070bc9f1f17d28226cc4e62494cc58c4c
+  languageName: node
+  linkType: hard
+
+"path-key@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "path-key@npm:4.0.0"
+  checksum: 10c0/794efeef32863a65ac312f3c0b0a99f921f3e827ff63afa5cb09a377e202c262b671f7b3832a4e64731003fa94af0263713962d317b9887bd1e0c48a342efba3
+  languageName: node
+  linkType: hard
+
+"path-parse@npm:^1.0.7":
+  version: 1.0.7
+  resolution: "path-parse@npm:1.0.7"
+  checksum: 10c0/11ce261f9d294cc7a58d6a574b7f1b935842355ec66fba3c3fd79e0f036462eaf07d0aa95bb74ff432f9afef97ce1926c720988c6a7451d8a584930ae7de86e1
+  languageName: node
+  linkType: hard
+
+"path-scurry@npm:^1.11.1":
+  version: 1.11.1
+  resolution: "path-scurry@npm:1.11.1"
+  dependencies:
+    lru-cache: "npm:^10.2.0"
+    minipass: "npm:^5.0.0 || ^6.0.2 || ^7.0.0"
+  checksum: 10c0/32a13711a2a505616ae1cc1b5076801e453e7aae6ac40ab55b388bb91b9d0547a52f5aaceff710ea400205f18691120d4431e520afbe4266b836fadede15872d
+  languageName: node
+  linkType: hard
+
+"path-type@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "path-type@npm:4.0.0"
+  checksum: 10c0/666f6973f332f27581371efaf303fd6c272cc43c2057b37aa99e3643158c7e4b2626549555d88626e99ea9e046f82f32e41bbde5f1508547e9a11b149b52387c
+  languageName: node
+  linkType: hard
+
+"pathe@npm:^1.1.1":
+  version: 1.1.2
+  resolution: "pathe@npm:1.1.2"
+  checksum: 10c0/64ee0a4e587fb0f208d9777a6c56e4f9050039268faaaaecd50e959ef01bf847b7872785c36483fa5cdcdbdfdb31fef2ff222684d4fc21c330ab60395c681897
+  languageName: node
+  linkType: hard
+
+"pathe@npm:^2.0.1, pathe@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "pathe@npm:2.0.3"
+  checksum: 10c0/c118dc5a8b5c4166011b2b70608762e260085180bb9e33e80a50dcdb1e78c010b1624f4280c492c92b05fc276715a4c357d1f9edc570f8f1b3d90b6839ebaca1
+  languageName: node
+  linkType: hard
+
+"pathval@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "pathval@npm:1.1.1"
+  checksum: 10c0/f63e1bc1b33593cdf094ed6ff5c49c1c0dc5dc20a646ca9725cc7fe7cd9995002d51d5685b9b2ec6814342935748b711bafa840f84c0bb04e38ff40a335c94dc
+  languageName: node
+  linkType: hard
+
+"picocolors@npm:^0.2.1":
+  version: 0.2.1
+  resolution: "picocolors@npm:0.2.1"
+  checksum: 10c0/98a83c77912c80aea0fc518aec184768501bfceafa490714b0f43eda9c52e372b844ce0a591e822bbfe5df16dcf366be7cbdb9534d39cf54a80796340371ee17
+  languageName: node
+  linkType: hard
+
+"picocolors@npm:^1.0.0, picocolors@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "picocolors@npm:1.1.1"
+  checksum: 10c0/e2e3e8170ab9d7c7421969adaa7e1b31434f789afb9b3f115f6b96d91945041ac3ceb02e9ec6fe6510ff036bcc0bf91e69a1772edc0b707e12b19c0f2d6bcf58
+  languageName: node
+  linkType: hard
+
+"picomatch@npm:^2.3.1":
+  version: 2.3.1
+  resolution: "picomatch@npm:2.3.1"
+  checksum: 10c0/26c02b8d06f03206fc2ab8d16f19960f2ff9e81a658f831ecb656d8f17d9edc799e8364b1f4a7873e89d9702dff96204be0fa26fe4181f6843f040f819dac4be
+  languageName: node
+  linkType: hard
+
+"picomatch@npm:^4.0.3":
+  version: 4.0.3
+  resolution: "picomatch@npm:4.0.3"
+  checksum: 10c0/9582c951e95eebee5434f59e426cddd228a7b97a0161a375aed4be244bd3fe8e3a31b846808ea14ef2c8a2527a6eeab7b3946a67d5979e81694654f939473ae2
+  languageName: node
+  linkType: hard
+
+"pify@npm:^4.0.1":
+  version: 4.0.1
+  resolution: "pify@npm:4.0.1"
+  checksum: 10c0/6f9d404b0d47a965437403c9b90eca8bb2536407f03de165940e62e72c8c8b75adda5516c6b9b23675a5877cc0bcac6bdfb0ef0e39414cd2476d5495da40e7cf
+  languageName: node
+  linkType: hard
+
+"pirates@npm:^4.0.6":
+  version: 4.0.7
+  resolution: "pirates@npm:4.0.7"
+  checksum: 10c0/a51f108dd811beb779d58a76864bbd49e239fa40c7984cd11596c75a121a8cc789f1c8971d8bb15f0dbf9d48b76c05bb62fcbce840f89b688c0fa64b37e8478a
+  languageName: node
+  linkType: hard
+
+"pkg-dir@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "pkg-dir@npm:3.0.0"
+  dependencies:
+    find-up: "npm:^3.0.0"
+  checksum: 10c0/902a3d0c1f8ac43b1795fa1ba6ffeb37dfd53c91469e969790f6ed5e29ff2bdc50b63ba6115dc056d2efb4a040aa2446d512b3804bdafdf302f734fb3ec21847
+  languageName: node
+  linkType: hard
+
+"pkg-types@npm:^1.2.1, pkg-types@npm:^1.3.1":
+  version: 1.3.1
+  resolution: "pkg-types@npm:1.3.1"
+  dependencies:
+    confbox: "npm:^0.1.8"
+    mlly: "npm:^1.7.4"
+    pathe: "npm:^2.0.1"
+  checksum: 10c0/19e6cb8b66dcc66c89f2344aecfa47f2431c988cfa3366bdfdcfb1dd6695f87dcce37fbd90fe9d1605e2f4440b77f391e83c23255347c35cf84e7fd774d7fcea
+  languageName: node
+  linkType: hard
+
+"playwright-core@npm:1.56.1":
+  version: 1.56.1
+  resolution: "playwright-core@npm:1.56.1"
+  bin:
+    playwright-core: cli.js
+  checksum: 10c0/ffd40142b99c68678b387445d5b42f1fee4ab0b65d983058c37f342e5629f9cdbdac0506ea80a0dfd41a8f9f13345bad54e9a8c35826ef66dc765f4eb3db8da7
+  languageName: node
+  linkType: hard
+
+"playwright@npm:1.56.1":
+  version: 1.56.1
+  resolution: "playwright@npm:1.56.1"
+  dependencies:
+    fsevents: "npm:2.3.2"
+    playwright-core: "npm:1.56.1"
+  dependenciesMeta:
+    fsevents:
+      optional: true
+  bin:
+    playwright: cli.js
+  checksum: 10c0/8e9965aede86df0f4722063385748498977b219630a40a10d1b82b8bd8d4d4e9b6b65ecbfa024331a30800163161aca292fb6dd7446c531a1ad25f4155625ab4
+  languageName: node
+  linkType: hard
+
+"possible-typed-array-names@npm:^1.0.0":
+  version: 1.1.0
+  resolution: "possible-typed-array-names@npm:1.1.0"
+  checksum: 10c0/c810983414142071da1d644662ce4caebce890203eb2bc7bf119f37f3fe5796226e117e6cca146b521921fa6531072674174a3325066ac66fce089a53e1e5196
+  languageName: node
+  linkType: hard
+
+"postcss-apply@npm:^0.12.0":
+  version: 0.12.0
+  resolution: "postcss-apply@npm:0.12.0"
+  dependencies:
+    balanced-match: "npm:^1.0.0"
+    postcss: "npm:^7.0.14"
+  checksum: 10c0/3e999e16e5c76ed6b79c286f742fa425cdbc88675de5327b61e889147f556b457eb477da15e5b5d868638786ae63b2047ea2a44e769d5dfe7125f7636e85dca5
+  languageName: node
+  linkType: hard
+
+"postcss-attribute-case-insensitive@npm:^6.0.2":
+  version: 6.0.3
+  resolution: "postcss-attribute-case-insensitive@npm:6.0.3"
+  dependencies:
+    postcss-selector-parser: "npm:^6.0.13"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/6161a625356db17ea23daa50797e23fa830a15629fa45e7438b5ac72a389f81ba51088503c5893a941d34d287857882867199584c5f03bf7762258c74570f456
+  languageName: node
+  linkType: hard
+
+"postcss-clamp@npm:^4.1.0":
+  version: 4.1.0
+  resolution: "postcss-clamp@npm:4.1.0"
+  dependencies:
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4.6
+  checksum: 10c0/701261026b38a4c27b3c3711635fac96005f36d3270adb76dbdb1eebc950fc841db45283ee66068a7121565592e9d7967d5534e15b6e4dd266afcabf9eafa905
+  languageName: node
+  linkType: hard
+
+"postcss-color-functional-notation@npm:^5.1.0":
+  version: 5.1.0
+  resolution: "postcss-color-functional-notation@npm:5.1.0"
+  dependencies:
+    "@csstools/postcss-progressive-custom-properties": "npm:^2.3.0"
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/e13dd243a1f07de23129c5739d34a2fa10ceb0ccaf31815aef7f2a469c5e349365e0bf3dbbe452a96147ca8a852e0d00226906f16ed847d5fe5e4a215f624227
+  languageName: node
+  linkType: hard
+
+"postcss-color-hex-alpha@npm:^9.0.2":
+  version: 9.0.4
+  resolution: "postcss-color-hex-alpha@npm:9.0.4"
+  dependencies:
+    "@csstools/utilities": "npm:^1.0.0"
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/57b5cfe17e0b659d5444f267c485462b8b25f6ab087b810c7dd44662af4828e1e8f9c4a9169b8635a4755509ca7c0f3463c2e96444764c4e6ff9f4036aad05e5
+  languageName: node
+  linkType: hard
+
+"postcss-color-rebeccapurple@npm:^8.0.2":
+  version: 8.0.2
+  resolution: "postcss-color-rebeccapurple@npm:8.0.2"
+  dependencies:
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/4d86f776a4e6119a5e2fbf95859fa220578368122fa7278c56dee17602a9bf7be81b5cc91d8c66d323822d04b85bd72e7a1cf45d7783ccc2cc34a05134f1dacf
+  languageName: node
+  linkType: hard
+
+"postcss-custom-media@npm:^9.1.5":
+  version: 9.1.5
+  resolution: "postcss-custom-media@npm:9.1.5"
+  dependencies:
+    "@csstools/cascade-layer-name-parser": "npm:^1.0.2"
+    "@csstools/css-parser-algorithms": "npm:^2.2.0"
+    "@csstools/css-tokenizer": "npm:^2.1.1"
+    "@csstools/media-query-list-parser": "npm:^2.1.1"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/157cfdb793e40435b5171a745182586184b90afdf057d03d1c3a36395f4176b7d87642ddcb71adc879324364c5f8fa1b7a2365226bb284848cd51afa0577a4d3
+  languageName: node
+  linkType: hard
+
+"postcss-custom-properties@npm:^13.2.0":
+  version: 13.3.12
+  resolution: "postcss-custom-properties@npm:13.3.12"
+  dependencies:
+    "@csstools/cascade-layer-name-parser": "npm:^1.0.13"
+    "@csstools/css-parser-algorithms": "npm:^2.7.1"
+    "@csstools/css-tokenizer": "npm:^2.4.1"
+    "@csstools/utilities": "npm:^1.0.0"
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/6af9f6ac94a6ac887749cd38d4586349f6aca29269ebfdb837019a3ba0130032f0ff4899b431b5c348f4ac79a7b16fb7300a256514a6a68e32a63489c18a70e7
+  languageName: node
+  linkType: hard
+
+"postcss-custom-selectors@npm:^7.1.3":
+  version: 7.1.12
+  resolution: "postcss-custom-selectors@npm:7.1.12"
+  dependencies:
+    "@csstools/cascade-layer-name-parser": "npm:^1.0.13"
+    "@csstools/css-parser-algorithms": "npm:^2.7.1"
+    "@csstools/css-tokenizer": "npm:^2.4.1"
+    postcss-selector-parser: "npm:^6.1.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/78a7930e4f97c42b544f00c06272264432d47f9df777684b57673bb971b7ab49d5d6fb9289a5a869125e7e50dcd0cad65cf8846501253084b73a42ffab41b2c5
+  languageName: node
+  linkType: hard
+
+"postcss-dir-pseudo-class@npm:^7.0.2":
+  version: 7.0.2
+  resolution: "postcss-dir-pseudo-class@npm:7.0.2"
+  dependencies:
+    postcss-selector-parser: "npm:^6.0.10"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/2d3c50f14b463cf975c03e2b258cd6ecb37bbbb21c02e3cd11ee1cb53e203868f73bec95c680e6452ae72b14b21a3548c8be98a2b46ff6e390048d172496b293
+  languageName: node
+  linkType: hard
+
+"postcss-double-position-gradients@npm:^4.0.4":
+  version: 4.0.4
+  resolution: "postcss-double-position-gradients@npm:4.0.4"
+  dependencies:
+    "@csstools/postcss-progressive-custom-properties": "npm:^2.3.0"
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/2fab552fd2cb30e4840c3135ad81464aed47b364c3270096668ad2ce77534de72d4ed04313ab60edffe77ad2793ba40ac48c2361ba6c94b19ca1461d63aa422c
+  languageName: node
+  linkType: hard
+
+"postcss-focus-visible@npm:^8.0.2":
+  version: 8.0.2
+  resolution: "postcss-focus-visible@npm:8.0.2"
+  dependencies:
+    postcss-selector-parser: "npm:^6.0.10"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/4a6691e00336cb1d638387a34e994eb7f51aaeb6e76f89f02501cf9afe8f0933be1f1d219d1afb1cfab228f385b9ee9f9360e70c58674f852c6b759bfb57246d
+  languageName: node
+  linkType: hard
+
+"postcss-focus-within@npm:^7.0.2":
+  version: 7.0.2
+  resolution: "postcss-focus-within@npm:7.0.2"
+  dependencies:
+    postcss-selector-parser: "npm:^6.0.10"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/3512f2f820e91db053799e60c451a547cc62d1467ff914e51aff9135b851ed72d2754cc0b6ce8c82b8bb34333434bdd72ecb7027739ba2786fb7be29af6263c0
+  languageName: node
+  linkType: hard
+
+"postcss-font-variant@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "postcss-font-variant@npm:5.0.0"
+  peerDependencies:
+    postcss: ^8.1.0
+  checksum: 10c0/ccc96460cf6a52b5439c26c9a5ea0589882e46161e3c2331d4353de7574448f5feef667d1a68f7f39b9fe3ee75d85957383ae82bbfcf87c3162c7345df4a444e
+  languageName: node
+  linkType: hard
+
+"postcss-gap-properties@npm:^4.0.1":
+  version: 4.0.1
+  resolution: "postcss-gap-properties@npm:4.0.1"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/0bb1181ab790168198fcbf58442ddce499536e98f014ad56759c60d417ed2f2aa0bca7bccba1404c88de277e66c903180175952b4fed9cfb02037a87db856e5e
+  languageName: node
+  linkType: hard
+
+"postcss-image-set-function@npm:^5.0.2":
+  version: 5.0.2
+  resolution: "postcss-image-set-function@npm:5.0.2"
+  dependencies:
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/4c0e8f91be093099e2a8a49165cf2a096552c2013bf8316678507457ee5995ee0215bc037fe90f8d90e0c68787279f28a75f14d2ee4dc3a1a5f5c977a212ed30
+  languageName: node
+  linkType: hard
+
+"postcss-initial@npm:^4.0.1":
+  version: 4.0.1
+  resolution: "postcss-initial@npm:4.0.1"
+  peerDependencies:
+    postcss: ^8.0.0
+  checksum: 10c0/a1db8350c31c5a23064c1e0d18cf6530bb96a6532d11e9caf1c632796b4ad48cb58ff17331bf0a5e3a360c4be1819e489cd1faeb3afc77711d333a0ee4f07819
+  languageName: node
+  linkType: hard
+
+"postcss-lab-function@npm:^5.2.3":
+  version: 5.2.3
+  resolution: "postcss-lab-function@npm:5.2.3"
+  dependencies:
+    "@csstools/css-color-parser": "npm:^1.2.0"
+    "@csstools/css-parser-algorithms": "npm:^2.1.1"
+    "@csstools/css-tokenizer": "npm:^2.1.1"
+    "@csstools/postcss-progressive-custom-properties": "npm:^2.3.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/4eaf85e82d7361ce1b85d0f8adfb16f5c0409f6d21f6ed7b187e4f8de63be85aebf0da9ed43e51787fc4a4ae810b2534af06220a0408bca520442ab86866fc69
+  languageName: node
+  linkType: hard
+
+"postcss-logical@npm:^6.2.0":
+  version: 6.2.0
+  resolution: "postcss-logical@npm:6.2.0"
+  dependencies:
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/8b16bbcb803e1a7da56ef450a037c09e8a0c92d85034fdebe053c3adebfaf94375c0db97cb754e96796450912571e29bc7812a6b8c58b43a8fa40c2376b4ed3d
+  languageName: node
+  linkType: hard
+
+"postcss-nested@npm:4.1.2":
+  version: 4.1.2
+  resolution: "postcss-nested@npm:4.1.2"
+  dependencies:
+    postcss: "npm:^7.0.14"
+    postcss-selector-parser: "npm:^5.0.0"
+  checksum: 10c0/10c4242bb303cd9d22deb59101c6c6c65577885fc83e6e3e95e38908aa9f3e447a3635f65707b71f0de9c1fbf6d135c4f687f569278e084f4cd5a6bfb9399c21
+  languageName: node
+  linkType: hard
+
+"postcss-nesting@npm:^11.3.0":
+  version: 11.3.0
+  resolution: "postcss-nesting@npm:11.3.0"
+  dependencies:
+    "@csstools/selector-specificity": "npm:^2.0.0"
+    postcss-selector-parser: "npm:^6.0.10"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/7fa66a2f62f4098954366027b9da86db69d0f5ffff233336da0285f8a7f03c3f0136ad75774242e1c22ffdcb64887d5855bcfc0deac333538ecd03dfd66122af
+  languageName: node
+  linkType: hard
+
+"postcss-opacity-percentage@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "postcss-opacity-percentage@npm:2.0.0"
+  peerDependencies:
+    postcss: ^8.2
+  checksum: 10c0/f031f3281060c4c0ede8f9a5832f65a3d8c2a1896ff324c41de42016e092635f0e0abee07545b01db93dc430a9741674a1d09c377c6c01cd8c2f4be65f889161
+  languageName: node
+  linkType: hard
+
+"postcss-overflow-shorthand@npm:^4.0.1":
+  version: 4.0.1
+  resolution: "postcss-overflow-shorthand@npm:4.0.1"
+  dependencies:
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/3683577e6ac7b79eb52b29ac4d056814df1cca7ea970196e3973263bcffb32b69858f39e44804c56e6d6ba61df98b0ba3bb6a6430f15015c4681534ebd59d76f
+  languageName: node
+  linkType: hard
+
+"postcss-page-break@npm:^3.0.4":
+  version: 3.0.4
+  resolution: "postcss-page-break@npm:3.0.4"
+  peerDependencies:
+    postcss: ^8
+  checksum: 10c0/eaaf4d8922b35f2acd637eb059f7e2510b24d65eb8f31424799dd5a98447b6ef010b41880c26e78f818e00f842295638ec75f89d5d489067f53e3dd3db74a00f
+  languageName: node
+  linkType: hard
+
+"postcss-place@npm:^8.0.1":
+  version: 8.0.1
+  resolution: "postcss-place@npm:8.0.1"
+  dependencies:
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/f15c608cb9b8314449d5be144789088c1bd436631f58c865399b26bc71a76a7021d7e4f1e206b141cc4071a1cac7bb645eb33eb0655667424b3423ae29fc1803
+  languageName: node
+  linkType: hard
+
+"postcss-preset-env@npm:^8.3.0":
+  version: 8.5.1
+  resolution: "postcss-preset-env@npm:8.5.1"
+  dependencies:
+    "@csstools/postcss-cascade-layers": "npm:^3.0.1"
+    "@csstools/postcss-color-function": "npm:^2.2.3"
+    "@csstools/postcss-color-mix-function": "npm:^1.0.3"
+    "@csstools/postcss-font-format-keywords": "npm:^2.0.2"
+    "@csstools/postcss-gradients-interpolation-method": "npm:^3.0.6"
+    "@csstools/postcss-hwb-function": "npm:^2.2.2"
+    "@csstools/postcss-ic-unit": "npm:^2.0.4"
+    "@csstools/postcss-is-pseudo-class": "npm:^3.2.1"
+    "@csstools/postcss-logical-float-and-clear": "npm:^1.0.1"
+    "@csstools/postcss-logical-resize": "npm:^1.0.1"
+    "@csstools/postcss-logical-viewport-units": "npm:^1.0.3"
+    "@csstools/postcss-media-minmax": "npm:^1.0.4"
+    "@csstools/postcss-media-queries-aspect-ratio-number-values": "npm:^1.0.4"
+    "@csstools/postcss-nested-calc": "npm:^2.0.2"
+    "@csstools/postcss-normalize-display-values": "npm:^2.0.1"
+    "@csstools/postcss-oklab-function": "npm:^2.2.3"
+    "@csstools/postcss-progressive-custom-properties": "npm:^2.3.0"
+    "@csstools/postcss-relative-color-syntax": "npm:^1.0.2"
+    "@csstools/postcss-scope-pseudo-class": "npm:^2.0.2"
+    "@csstools/postcss-stepped-value-functions": "npm:^2.1.1"
+    "@csstools/postcss-text-decoration-shorthand": "npm:^2.2.4"
+    "@csstools/postcss-trigonometric-functions": "npm:^2.1.1"
+    "@csstools/postcss-unset-value": "npm:^2.0.1"
+    autoprefixer: "npm:^10.4.14"
+    browserslist: "npm:^4.21.9"
+    css-blank-pseudo: "npm:^5.0.2"
+    css-has-pseudo: "npm:^5.0.2"
+    css-prefers-color-scheme: "npm:^8.0.2"
+    cssdb: "npm:^7.6.0"
+    postcss-attribute-case-insensitive: "npm:^6.0.2"
+    postcss-clamp: "npm:^4.1.0"
+    postcss-color-functional-notation: "npm:^5.1.0"
+    postcss-color-hex-alpha: "npm:^9.0.2"
+    postcss-color-rebeccapurple: "npm:^8.0.2"
+    postcss-custom-media: "npm:^9.1.5"
+    postcss-custom-properties: "npm:^13.2.0"
+    postcss-custom-selectors: "npm:^7.1.3"
+    postcss-dir-pseudo-class: "npm:^7.0.2"
+    postcss-double-position-gradients: "npm:^4.0.4"
+    postcss-focus-visible: "npm:^8.0.2"
+    postcss-focus-within: "npm:^7.0.2"
+    postcss-font-variant: "npm:^5.0.0"
+    postcss-gap-properties: "npm:^4.0.1"
+    postcss-image-set-function: "npm:^5.0.2"
+    postcss-initial: "npm:^4.0.1"
+    postcss-lab-function: "npm:^5.2.3"
+    postcss-logical: "npm:^6.2.0"
+    postcss-nesting: "npm:^11.3.0"
+    postcss-opacity-percentage: "npm:^2.0.0"
+    postcss-overflow-shorthand: "npm:^4.0.1"
+    postcss-page-break: "npm:^3.0.4"
+    postcss-place: "npm:^8.0.1"
+    postcss-pseudo-class-any-link: "npm:^8.0.2"
+    postcss-replace-overflow-wrap: "npm:^4.0.0"
+    postcss-selector-not: "npm:^7.0.1"
+    postcss-value-parser: "npm:^4.2.0"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/ee8f6b05a3082d592e3ec5ddd8a3a638d618d3b97cf0a22a03f19cfdf55cdbb4aa1d28e0c82b005884d26f92a32b0b77d30782ac1d9f19fe43de96df92c15c06
+  languageName: node
+  linkType: hard
+
+"postcss-pseudo-class-any-link@npm:^8.0.2":
+  version: 8.0.2
+  resolution: "postcss-pseudo-class-any-link@npm:8.0.2"
+  dependencies:
+    postcss-selector-parser: "npm:^6.0.10"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/682b70275e4b3c76341b2287e37a03ebbf07aa9bfb626ee9156c65c7dc5a39be5e197265121197a44dde04ff09f4663df2077a1cedbf783f14778723de539b24
+  languageName: node
+  linkType: hard
+
+"postcss-replace-overflow-wrap@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "postcss-replace-overflow-wrap@npm:4.0.0"
+  peerDependencies:
+    postcss: ^8.0.3
+  checksum: 10c0/451361b714528cd3632951256ef073769cde725a46cda642a6864f666fb144921fa55e614aec1bcf5946f37d6ffdcca3b932b76f3d997c07b076e8db152b128d
+  languageName: node
+  linkType: hard
+
+"postcss-resolve-nested-selector@npm:^0.1.1":
+  version: 0.1.6
+  resolution: "postcss-resolve-nested-selector@npm:0.1.6"
+  checksum: 10c0/84213a2bccce481b1569c595a3c547b25c6ef1cca839fbd6c82c12ab407559966e968613c7454b573aa54f38cfd7e900c1fd603f0efc9f51939ab9f93f115455
+  languageName: node
+  linkType: hard
+
+"postcss-safe-parser@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "postcss-safe-parser@npm:6.0.0"
+  peerDependencies:
+    postcss: ^8.3.3
+  checksum: 10c0/5b0997b63de6ab4afb4b718a52dd7902e465c21d1f2e516762bcb59047787459b4dc5713132f6a19c9c8c483043b20b8a380a55fb61152ee66cbffcddf3b57f0
+  languageName: node
+  linkType: hard
+
+"postcss-selector-not@npm:^7.0.1":
+  version: 7.0.2
+  resolution: "postcss-selector-not@npm:7.0.2"
+  dependencies:
+    postcss-selector-parser: "npm:^6.0.13"
+  peerDependencies:
+    postcss: ^8.4
+  checksum: 10c0/624b6e516d37d43406ff1414b3413fe7a5dc34eccadd6a6082fe7df13c5c2fab3e244af33ff0916f9be0a4f7db91d1c22102f5166d7a6e6595e7c00e11e20281
+  languageName: node
+  linkType: hard
+
+"postcss-selector-parser@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "postcss-selector-parser@npm:5.0.0"
+  dependencies:
+    cssesc: "npm:^2.0.0"
+    indexes-of: "npm:^1.0.1"
+    uniq: "npm:^1.0.1"
+  checksum: 10c0/4f5773963d16f4e1dfce64032ffab2e7fba3239d3a545ee00316f68ccf49f609c1a7b141d9ad1eb68b34690382c6d116636731c7849bafe1930dc4bb6ef5aa18
+  languageName: node
+  linkType: hard
+
+"postcss-selector-parser@npm:^6.0.10, postcss-selector-parser@npm:^6.0.13, postcss-selector-parser@npm:^6.1.0":
+  version: 6.1.2
+  resolution: "postcss-selector-parser@npm:6.1.2"
+  dependencies:
+    cssesc: "npm:^3.0.0"
+    util-deprecate: "npm:^1.0.2"
+  checksum: 10c0/523196a6bd8cf660bdf537ad95abd79e546d54180f9afb165a4ab3e651ac705d0f8b8ce6b3164fb9e3279ce482c5f751a69eb2d3a1e8eb0fd5e82294fb3ef13e
+  languageName: node
+  linkType: hard
+
+"postcss-value-parser@npm:^4.2.0":
+  version: 4.2.0
+  resolution: "postcss-value-parser@npm:4.2.0"
+  checksum: 10c0/f4142a4f56565f77c1831168e04e3effd9ffcc5aebaf0f538eee4b2d465adfd4b85a44257bb48418202a63806a7da7fe9f56c330aebb3cac898e46b4cbf49161
+  languageName: node
+  linkType: hard
+
+"postcss@npm:^7.0.14":
+  version: 7.0.39
+  resolution: "postcss@npm:7.0.39"
+  dependencies:
+    picocolors: "npm:^0.2.1"
+    source-map: "npm:^0.6.1"
+  checksum: 10c0/fd27ee808c0d02407582cccfad4729033e2b439d56cd45534fb39aaad308bb35a290f3b7db5f2394980e8756f9381b458a625618550808c5ff01a125f51efc53
+  languageName: node
+  linkType: hard
+
+"postcss@npm:^8.4.27, postcss@npm:^8.4.28, postcss@npm:^8.4.43":
+  version: 8.5.6
+  resolution: "postcss@npm:8.5.6"
+  dependencies:
+    nanoid: "npm:^3.3.11"
+    picocolors: "npm:^1.1.1"
+    source-map-js: "npm:^1.2.1"
+  checksum: 10c0/5127cc7c91ed7a133a1b7318012d8bfa112da9ef092dddf369ae699a1f10ebbd89b1b9f25f3228795b84585c72aabd5ced5fc11f2ba467eedf7b081a66fad024
+  languageName: node
+  linkType: hard
+
+"prelude-ls@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "prelude-ls@npm:1.2.1"
+  checksum: 10c0/b00d617431e7886c520a6f498a2e14c75ec58f6d93ba48c3b639cf241b54232d90daa05d83a9e9b9fef6baa63cb7e1e4602c2372fea5bc169668401eb127d0cd
+  languageName: node
+  linkType: hard
+
+"pretty-format@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "pretty-format@npm:29.7.0"
+  dependencies:
+    "@jest/schemas": "npm:^29.6.3"
+    ansi-styles: "npm:^5.0.0"
+    react-is: "npm:^18.0.0"
+  checksum: 10c0/edc5ff89f51916f036c62ed433506b55446ff739358de77207e63e88a28ca2894caac6e73dcb68166a606e51c8087d32d400473e6a9fdd2dbe743f46c9c0276f
+  languageName: node
+  linkType: hard
+
+"proc-log@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "proc-log@npm:5.0.0"
+  checksum: 10c0/bbe5edb944b0ad63387a1d5b1911ae93e05ce8d0f60de1035b218cdcceedfe39dbd2c697853355b70f1a090f8f58fe90da487c85216bf9671f9499d1a897e9e3
+  languageName: node
+  linkType: hard
+
+"promise-retry@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "promise-retry@npm:2.0.1"
+  dependencies:
+    err-code: "npm:^2.0.2"
+    retry: "npm:^0.12.0"
+  checksum: 10c0/9c7045a1a2928094b5b9b15336dcd2a7b1c052f674550df63cc3f36cd44028e5080448175b6f6ca32b642de81150f5e7b1a98b728f15cb069f2dd60ac2616b96
+  languageName: node
+  linkType: hard
+
+"promise@npm:^7.0.1":
+  version: 7.3.1
+  resolution: "promise@npm:7.3.1"
+  dependencies:
+    asap: "npm:~2.0.3"
+  checksum: 10c0/742e5c0cc646af1f0746963b8776299701ad561ce2c70b49365d62c8db8ea3681b0a1bf0d4e2fe07910bf72f02d39e51e8e73dc8d7503c3501206ac908be107f
+  languageName: node
+  linkType: hard
+
+"psl@npm:^1.1.33":
+  version: 1.15.0
+  resolution: "psl@npm:1.15.0"
+  dependencies:
+    punycode: "npm:^2.3.1"
+  checksum: 10c0/d8d45a99e4ca62ca12ac3c373e63d80d2368d38892daa40cfddaa1eb908be98cd549ac059783ef3a56cfd96d57ae8e2fd9ae53d1378d90d42bc661ff924e102a
+  languageName: node
+  linkType: hard
+
+"pug-attrs@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "pug-attrs@npm:3.0.0"
+  dependencies:
+    constantinople: "npm:^4.0.1"
+    js-stringify: "npm:^1.0.2"
+    pug-runtime: "npm:^3.0.0"
+  checksum: 10c0/28178e91c05e8eb9130861c78dccc61eae3e1610931346065bd32ad0b08b023a8dcf2470c3b2409ba45a5098d6d7ed15687717e91cf77770c6381a18626e5194
+  languageName: node
+  linkType: hard
+
+"pug-code-gen@npm:^3.0.3":
+  version: 3.0.3
+  resolution: "pug-code-gen@npm:3.0.3"
+  dependencies:
+    constantinople: "npm:^4.0.1"
+    doctypes: "npm:^1.1.0"
+    js-stringify: "npm:^1.0.2"
+    pug-attrs: "npm:^3.0.0"
+    pug-error: "npm:^2.1.0"
+    pug-runtime: "npm:^3.0.1"
+    void-elements: "npm:^3.1.0"
+    with: "npm:^7.0.0"
+  checksum: 10c0/517a93930dbc80bc7fa5f60ff324229a07cc5ab70ed9d344ce105e2fe24de68db5121c8457a9ba99cdc8d48dd18779dd34956ebfcab009b3c1c6843a3cade109
+  languageName: node
+  linkType: hard
+
+"pug-error@npm:^2.0.0, pug-error@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "pug-error@npm:2.1.0"
+  checksum: 10c0/bbce339b17fab9890de84975c0cd8723a847bf65f35653d3ebcf77018e8ad91529d56e978ab80f4c64c9f4f07ef9e56e7a9fda3be44249c344a93ba11fccff79
+  languageName: node
+  linkType: hard
+
+"pug-filters@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "pug-filters@npm:4.0.0"
+  dependencies:
+    constantinople: "npm:^4.0.1"
+    jstransformer: "npm:1.0.0"
+    pug-error: "npm:^2.0.0"
+    pug-walk: "npm:^2.0.0"
+    resolve: "npm:^1.15.1"
+  checksum: 10c0/7ddd62f5eb97f5242858bd56d93ffed387fef3742210a53770c980020cf91a34384b84b7fc8f0de185b43dfa77de2c4d0f63f575a4c5b3887fdef4e64b8d559d
+  languageName: node
+  linkType: hard
+
+"pug-lexer@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "pug-lexer@npm:5.0.1"
+  dependencies:
+    character-parser: "npm:^2.2.0"
+    is-expression: "npm:^4.0.0"
+    pug-error: "npm:^2.0.0"
+  checksum: 10c0/24195a5681953ab91c6a3ccd80a643f760dddb65e2f266bf8ccba145018ba0271536efe1572de2c2224163eb00873c2f1df0ad7ea7aa8bcbf79a66b586ca8435
+  languageName: node
+  linkType: hard
+
+"pug-linker@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "pug-linker@npm:4.0.0"
+  dependencies:
+    pug-error: "npm:^2.0.0"
+    pug-walk: "npm:^2.0.0"
+  checksum: 10c0/db754ff34cdd4ba9d9e2d9535cce2a74178f2172e848a5fa6381907cb5bfaa0d39d4cc3eb29893d35fc1c417e83ae3cfd434640ba7d3b635c63199104fae976c
+  languageName: node
+  linkType: hard
+
+"pug-load@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "pug-load@npm:3.0.0"
+  dependencies:
+    object-assign: "npm:^4.1.1"
+    pug-walk: "npm:^2.0.0"
+  checksum: 10c0/2a7659dfaf9872dd25d851f85e4c27fa447d907b1db3540030cd844614159ff181e067d8f2bedf90eb6b5b1ff03747253859ecbbb822e40f4834b15591d4e108
+  languageName: node
+  linkType: hard
+
+"pug-parser@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "pug-parser@npm:6.0.0"
+  dependencies:
+    pug-error: "npm:^2.0.0"
+    token-stream: "npm:1.0.0"
+  checksum: 10c0/faa6cec43afdeb2705eb8c68dfdb2e65836238df8043ae55295ffb72450b8c7a990ea1be60adbde19f58988b9e1d18a84ea42453e2c4f104d0031f78fda737b2
+  languageName: node
+  linkType: hard
+
+"pug-runtime@npm:^3.0.0, pug-runtime@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "pug-runtime@npm:3.0.1"
+  checksum: 10c0/0db8166d2e17695a6941d1de81dcb21c8a52921299b1e03bf6a0a3d2b0036b51cf98101b3937b731c745e8d3e0268cb0b728c02f61a80a25fcfaa15c594fb1be
+  languageName: node
+  linkType: hard
+
+"pug-strip-comments@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "pug-strip-comments@npm:2.0.0"
+  dependencies:
+    pug-error: "npm:^2.0.0"
+  checksum: 10c0/ca498adedaeba51dd836b20129bbd161e2d5a397a2baaa553b1e74e888caa2258dcd7326396fc6f8fed8c7b7f906cfebc4c386ccbee8888a27b2ca0d4d86d206
+  languageName: node
+  linkType: hard
+
+"pug-walk@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "pug-walk@npm:2.0.0"
+  checksum: 10c0/005d63177bcf057f5a618b182f6d4600afb039200b07a381a0d89288a2b3126e763a0a6c40b758eab0731c8e63cad1bbcb46d96803b9ae9cfc879f6ef5a0f8f4
+  languageName: node
+  linkType: hard
+
+"pug@npm:^3.0.3":
+  version: 3.0.3
+  resolution: "pug@npm:3.0.3"
+  dependencies:
+    pug-code-gen: "npm:^3.0.3"
+    pug-filters: "npm:^4.0.0"
+    pug-lexer: "npm:^5.0.1"
+    pug-linker: "npm:^4.0.0"
+    pug-load: "npm:^3.0.0"
+    pug-parser: "npm:^6.0.0"
+    pug-runtime: "npm:^3.0.1"
+    pug-strip-comments: "npm:^2.0.0"
+  checksum: 10c0/bda53d3a6deea1d348cd5ab17427c77f3d74165510ad16f4fd182cc63618ad09388ecda317d17122ee890c8a68f9a54b96221fce7f44a332e463fdbb10a9d1e2
+  languageName: node
+  linkType: hard
+
+"pump@npm:^3.0.0":
+  version: 3.0.3
+  resolution: "pump@npm:3.0.3"
+  dependencies:
+    end-of-stream: "npm:^1.1.0"
+    once: "npm:^1.3.1"
+  checksum: 10c0/ada5cdf1d813065bbc99aa2c393b8f6beee73b5de2890a8754c9f488d7323ffd2ca5f5a0943b48934e3fcbd97637d0337369c3c631aeb9614915db629f1c75c9
+  languageName: node
+  linkType: hard
+
+"punycode@npm:^2.1.0, punycode@npm:^2.1.1, punycode@npm:^2.3.1":
+  version: 2.3.1
+  resolution: "punycode@npm:2.3.1"
+  checksum: 10c0/14f76a8206bc3464f794fb2e3d3cc665ae416c01893ad7a02b23766eb07159144ee612ad67af5e84fa4479ccfe67678c4feb126b0485651b302babf66f04f9e9
+  languageName: node
+  linkType: hard
+
+"querystringify@npm:^2.1.1":
+  version: 2.2.0
+  resolution: "querystringify@npm:2.2.0"
+  checksum: 10c0/3258bc3dbdf322ff2663619afe5947c7926a6ef5fb78ad7d384602974c467fadfc8272af44f5eb8cddd0d011aae8fabf3a929a8eee4b86edcc0a21e6bd10f9aa
+  languageName: node
+  linkType: hard
+
+"queue-microtask@npm:^1.2.2":
+  version: 1.2.3
+  resolution: "queue-microtask@npm:1.2.3"
+  checksum: 10c0/900a93d3cdae3acd7d16f642c29a642aea32c2026446151f0778c62ac089d4b8e6c986811076e1ae180a694cedf077d453a11b58ff0a865629a4f82ab558e102
+  languageName: node
+  linkType: hard
+
+"quick-lru@npm:^5.1.1":
+  version: 5.1.1
+  resolution: "quick-lru@npm:5.1.1"
+  checksum: 10c0/a24cba5da8cec30d70d2484be37622580f64765fb6390a928b17f60cd69e8dbd32a954b3ff9176fa1b86d86ff2ba05252fae55dc4d40d0291c60412b0ad096da
+  languageName: node
+  linkType: hard
+
+"react-is@npm:^18.0.0":
+  version: 18.3.1
+  resolution: "react-is@npm:18.3.1"
+  checksum: 10c0/f2f1e60010c683479e74c63f96b09fb41603527cd131a9959e2aee1e5a8b0caf270b365e5ca77d4a6b18aae659b60a86150bb3979073528877029b35aecd2072
+  languageName: node
+  linkType: hard
+
+"read-pkg-up@npm:^8.0.0":
+  version: 8.0.0
+  resolution: "read-pkg-up@npm:8.0.0"
+  dependencies:
+    find-up: "npm:^5.0.0"
+    read-pkg: "npm:^6.0.0"
+    type-fest: "npm:^1.0.1"
+  checksum: 10c0/cf3905ccbe5cd602f23192cc7ca65ed17561bab117eadb9aed817441d5bfc6b9a11215c2a3e9505f501d046818f3c4180dbea61fa83c42083e0b4e407d5cc745
+  languageName: node
+  linkType: hard
+
+"read-pkg@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "read-pkg@npm:6.0.0"
+  dependencies:
+    "@types/normalize-package-data": "npm:^2.4.0"
+    normalize-package-data: "npm:^3.0.2"
+    parse-json: "npm:^5.2.0"
+    type-fest: "npm:^1.0.1"
+  checksum: 10c0/b51ee5eed75324f4fac34c9a40b5e4b403de4c532242be01959c9bbdb1ff9db1c6c2aefaba569622fec49d1ead866e97ba856ab145f6e11039b11f7bec1318ba
+  languageName: node
+  linkType: hard
+
+"redent@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "redent@npm:4.0.0"
+  dependencies:
+    indent-string: "npm:^5.0.0"
+    strip-indent: "npm:^4.0.0"
+  checksum: 10c0/a9b640c8f4b2b5b26a1a908706475ff404dd50a97d6f094bc3c59717be922622927cc7d601d4ae2857d897ad243fd979bd76d751a0481cee8be7024e5fb4c662
+  languageName: node
+  linkType: hard
+
+"refa@npm:^0.12.0, refa@npm:^0.12.1":
+  version: 0.12.1
+  resolution: "refa@npm:0.12.1"
+  dependencies:
+    "@eslint-community/regexpp": "npm:^4.8.0"
+  checksum: 10c0/5c2f3dc5421f73aba44ec3d67bad58f36ff921dc13b0a921e1784c0510cf26be6d4e14010955a71607e67ff23a815f3ac30b337d06b5a2e8914417b67626c900
+  languageName: node
+  linkType: hard
+
+"reflect.getprototypeof@npm:^1.0.6, reflect.getprototypeof@npm:^1.0.9":
+  version: 1.0.10
+  resolution: "reflect.getprototypeof@npm:1.0.10"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    define-properties: "npm:^1.2.1"
+    es-abstract: "npm:^1.23.9"
+    es-errors: "npm:^1.3.0"
+    es-object-atoms: "npm:^1.0.0"
+    get-intrinsic: "npm:^1.2.7"
+    get-proto: "npm:^1.0.1"
+    which-builtin-type: "npm:^1.2.1"
+  checksum: 10c0/7facec28c8008876f8ab98e80b7b9cb4b1e9224353fd4756dda5f2a4ab0d30fa0a5074777c6df24e1e0af463a2697513b0a11e548d99cf52f21f7bc6ba48d3ac
+  languageName: node
+  linkType: hard
+
+"regexp-ast-analysis@npm:^0.7.0":
+  version: 0.7.1
+  resolution: "regexp-ast-analysis@npm:0.7.1"
+  dependencies:
+    "@eslint-community/regexpp": "npm:^4.8.0"
+    refa: "npm:^0.12.1"
+  checksum: 10c0/1b0e6d66e1e619b42a0e7f62b4c9983d0ce69d94fc759802c02272cbab8abd2e0d5b94186472de4e7c4baaf5826ca674d3c7c083615e39c4be55d1ff9d12c823
+  languageName: node
+  linkType: hard
+
+"regexp.prototype.flags@npm:^1.5.4":
+  version: 1.5.4
+  resolution: "regexp.prototype.flags@npm:1.5.4"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    define-properties: "npm:^1.2.1"
+    es-errors: "npm:^1.3.0"
+    get-proto: "npm:^1.0.1"
+    gopd: "npm:^1.2.0"
+    set-function-name: "npm:^2.0.2"
+  checksum: 10c0/83b88e6115b4af1c537f8dabf5c3744032cb875d63bc05c288b1b8c0ef37cbe55353f95d8ca817e8843806e3e150b118bc624e4279b24b4776b4198232735a77
+  languageName: node
+  linkType: hard
+
+"repeat-string@npm:^1.0.0":
+  version: 1.6.1
+  resolution: "repeat-string@npm:1.6.1"
+  checksum: 10c0/87fa21bfdb2fbdedc44b9a5b118b7c1239bdd2c2c1e42742ef9119b7d412a5137a1d23f1a83dc6bb686f4f27429ac6f542e3d923090b44181bafa41e8ac0174d
+  languageName: node
+  linkType: hard
+
+"reprism@npm:^0.0.11":
+  version: 0.0.11
+  resolution: "reprism@npm:0.0.11"
+  checksum: 10c0/d2221217566132f92a25254047ebba14fe82b159ca30fd460b262497d3a6bc8103900835bc9220931c4ce892cc08d073f63c168f908414f4a971c7bc7f27cb99
+  languageName: node
+  linkType: hard
+
+"require-from-string@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "require-from-string@npm:2.0.2"
+  checksum: 10c0/aaa267e0c5b022fc5fd4eef49d8285086b15f2a1c54b28240fdf03599cbd9c26049fee3eab894f2e1f6ca65e513b030a7c264201e3f005601e80c49fb2937ce2
+  languageName: node
+  linkType: hard
+
+"requires-port@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "requires-port@npm:1.0.0"
+  checksum: 10c0/b2bfdd09db16c082c4326e573a82c0771daaf7b53b9ce8ad60ea46aa6e30aaf475fe9b164800b89f93b748d2c234d8abff945d2551ba47bf5698e04cd7713267
+  languageName: node
+  linkType: hard
+
+"resolve-from@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "resolve-from@npm:4.0.0"
+  checksum: 10c0/8408eec31a3112ef96e3746c37be7d64020cda07c03a920f5024e77290a218ea758b26ca9529fd7b1ad283947f34b2291c1c0f6aa0ed34acfdda9c6014c8d190
+  languageName: node
+  linkType: hard
+
+"resolve-from@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "resolve-from@npm:5.0.0"
+  checksum: 10c0/b21cb7f1fb746de8107b9febab60095187781137fd803e6a59a76d421444b1531b641bba5857f5dc011974d8a5c635d61cec49e6bd3b7fc20e01f0fafc4efbf2
+  languageName: node
+  linkType: hard
+
+"resolve-pkg-maps@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "resolve-pkg-maps@npm:1.0.0"
+  checksum: 10c0/fb8f7bbe2ca281a73b7ef423a1cbc786fb244bd7a95cbe5c3fba25b27d327150beca8ba02f622baea65919a57e061eb5005204daa5f93ed590d9b77463a567ab
+  languageName: node
+  linkType: hard
+
+"resolve@npm:^1.15.1, resolve@npm:^1.22.2, resolve@npm:^1.22.3, resolve@npm:^1.22.4, resolve@npm:^1.3.2":
+  version: 1.22.11
+  resolution: "resolve@npm:1.22.11"
+  dependencies:
+    is-core-module: "npm:^2.16.1"
+    path-parse: "npm:^1.0.7"
+    supports-preserve-symlinks-flag: "npm:^1.0.0"
+  bin:
+    resolve: bin/resolve
+  checksum: 10c0/f657191507530f2cbecb5815b1ee99b20741ea6ee02a59c57028e9ec4c2c8d7681afcc35febbd554ac0ded459db6f2d8153382c53a2f266cee2575e512674409
+  languageName: node
+  linkType: hard
+
+"resolve@patch:resolve@npm%3A^1.15.1#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.22.2#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.22.3#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.22.4#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.3.2#optional!builtin<compat/resolve>":
+  version: 1.22.11
+  resolution: "resolve@patch:resolve@npm%3A1.22.11#optional!builtin<compat/resolve>::version=1.22.11&hash=c3c19d"
+  dependencies:
+    is-core-module: "npm:^2.16.1"
+    path-parse: "npm:^1.0.7"
+    supports-preserve-symlinks-flag: "npm:^1.0.0"
+  bin:
+    resolve: bin/resolve
+  checksum: 10c0/ee5b182f2e37cb1165465e58c6abc797fec0a80b5ba3231607beb4677db0c9291ac010c47cf092b6daa2b7f518d69a0e21888e7e2b633f68d501a874212a8c63
+  languageName: node
+  linkType: hard
+
+"retry@npm:^0.12.0":
+  version: 0.12.0
+  resolution: "retry@npm:0.12.0"
+  checksum: 10c0/59933e8501727ba13ad73ef4a04d5280b3717fd650408460c987392efe9d7be2040778ed8ebe933c5cbd63da3dcc37919c141ef8af0a54a6e4fca5a2af177bfe
+  languageName: node
+  linkType: hard
+
+"reusify@npm:^1.0.4":
+  version: 1.1.0
+  resolution: "reusify@npm:1.1.0"
+  checksum: 10c0/4eff0d4a5f9383566c7d7ec437b671cc51b25963bd61bf127c3f3d3f68e44a026d99b8d2f1ad344afff8d278a8fe70a8ea092650a716d22287e8bef7126bb2fa
+  languageName: node
+  linkType: hard
+
+"rimraf@npm:^3.0.2":
+  version: 3.0.2
+  resolution: "rimraf@npm:3.0.2"
+  dependencies:
+    glob: "npm:^7.1.3"
+  bin:
+    rimraf: bin.js
+  checksum: 10c0/9cb7757acb489bd83757ba1a274ab545eafd75598a9d817e0c3f8b164238dd90eba50d6b848bd4dcc5f3040912e882dc7ba71653e35af660d77b25c381d402e8
+  languageName: node
+  linkType: hard
+
+"rollup-plugin-license@npm:^3.0.1":
+  version: 3.6.0
+  resolution: "rollup-plugin-license@npm:3.6.0"
+  dependencies:
+    commenting: "npm:~1.1.0"
+    fdir: "npm:^6.4.3"
+    lodash: "npm:~4.17.21"
+    magic-string: "npm:~0.30.0"
+    moment: "npm:~2.30.1"
+    package-name-regex: "npm:~2.0.6"
+    spdx-expression-validate: "npm:~2.0.0"
+    spdx-satisfies: "npm:~5.0.1"
+  peerDependencies:
+    rollup: ^1.0.0 || ^2.0.0 || ^3.0.0 || ^4.0.0
+  checksum: 10c0/4f6966615093f330132092d245a20da58a25ee5094a2561251de1af9f5db1b3dbb9c7f1c315a40441047bcc1b21fb1971091066992299e0040b613540e53c7c2
+  languageName: node
+  linkType: hard
+
+"rollup@npm:^3.27.1":
+  version: 3.29.5
+  resolution: "rollup@npm:3.29.5"
+  dependencies:
+    fsevents: "npm:~2.3.2"
+  dependenciesMeta:
+    fsevents:
+      optional: true
+  bin:
+    rollup: dist/bin/rollup
+  checksum: 10c0/a1fa26f21f0d6cf93b6d05ea284ad5854905b585f28a14c27d439b0f9b859cba13ea25f376303d86770e59b4686bedc52b4706e57442514f0414c6fd3c5b8e71
+  languageName: node
+  linkType: hard
+
+"rollup@npm:^4.20.0":
+  version: 4.53.2
+  resolution: "rollup@npm:4.53.2"
+  dependencies:
+    "@rollup/rollup-android-arm-eabi": "npm:4.53.2"
+    "@rollup/rollup-android-arm64": "npm:4.53.2"
+    "@rollup/rollup-darwin-arm64": "npm:4.53.2"
+    "@rollup/rollup-darwin-x64": "npm:4.53.2"
+    "@rollup/rollup-freebsd-arm64": "npm:4.53.2"
+    "@rollup/rollup-freebsd-x64": "npm:4.53.2"
+    "@rollup/rollup-linux-arm-gnueabihf": "npm:4.53.2"
+    "@rollup/rollup-linux-arm-musleabihf": "npm:4.53.2"
+    "@rollup/rollup-linux-arm64-gnu": "npm:4.53.2"
+    "@rollup/rollup-linux-arm64-musl": "npm:4.53.2"
+    "@rollup/rollup-linux-loong64-gnu": "npm:4.53.2"
+    "@rollup/rollup-linux-ppc64-gnu": "npm:4.53.2"
+    "@rollup/rollup-linux-riscv64-gnu": "npm:4.53.2"
+    "@rollup/rollup-linux-riscv64-musl": "npm:4.53.2"
+    "@rollup/rollup-linux-s390x-gnu": "npm:4.53.2"
+    "@rollup/rollup-linux-x64-gnu": "npm:4.53.2"
+    "@rollup/rollup-linux-x64-musl": "npm:4.53.2"
+    "@rollup/rollup-openharmony-arm64": "npm:4.53.2"
+    "@rollup/rollup-win32-arm64-msvc": "npm:4.53.2"
+    "@rollup/rollup-win32-ia32-msvc": "npm:4.53.2"
+    "@rollup/rollup-win32-x64-gnu": "npm:4.53.2"
+    "@rollup/rollup-win32-x64-msvc": "npm:4.53.2"
+    "@types/estree": "npm:1.0.8"
+    fsevents: "npm:~2.3.2"
+  dependenciesMeta:
+    "@rollup/rollup-android-arm-eabi":
+      optional: true
+    "@rollup/rollup-android-arm64":
+      optional: true
+    "@rollup/rollup-darwin-arm64":
+      optional: true
+    "@rollup/rollup-darwin-x64":
+      optional: true
+    "@rollup/rollup-freebsd-arm64":
+      optional: true
+    "@rollup/rollup-freebsd-x64":
+      optional: true
+    "@rollup/rollup-linux-arm-gnueabihf":
+      optional: true
+    "@rollup/rollup-linux-arm-musleabihf":
+      optional: true
+    "@rollup/rollup-linux-arm64-gnu":
+      optional: true
+    "@rollup/rollup-linux-arm64-musl":
+      optional: true
+    "@rollup/rollup-linux-loong64-gnu":
+      optional: true
+    "@rollup/rollup-linux-ppc64-gnu":
+      optional: true
+    "@rollup/rollup-linux-riscv64-gnu":
+      optional: true
+    "@rollup/rollup-linux-riscv64-musl":
+      optional: true
+    "@rollup/rollup-linux-s390x-gnu":
+      optional: true
+    "@rollup/rollup-linux-x64-gnu":
+      optional: true
+    "@rollup/rollup-linux-x64-musl":
+      optional: true
+    "@rollup/rollup-openharmony-arm64":
+      optional: true
+    "@rollup/rollup-win32-arm64-msvc":
+      optional: true
+    "@rollup/rollup-win32-ia32-msvc":
+      optional: true
+    "@rollup/rollup-win32-x64-gnu":
+      optional: true
+    "@rollup/rollup-win32-x64-msvc":
+      optional: true
+    fsevents:
+      optional: true
+  bin:
+    rollup: dist/bin/rollup
+  checksum: 10c0/427216da71c1ce7fefb0bef75f94c301afd858ac27e35898e098c2da5977325fa54c2edda867caf9675c8abfa8d8d94efa99c482fa04f5cd91f3a740112d4f4f
+  languageName: node
+  linkType: hard
+
+"rrweb-cssom@npm:^0.6.0":
+  version: 0.6.0
+  resolution: "rrweb-cssom@npm:0.6.0"
+  checksum: 10c0/3d9d90d53c2349ea9c8509c2690df5a4ef930c9cf8242aeb9425d4046f09d712bb01047e00da0e1c1dab5db35740b3d78fd45c3e7272f75d3724a563f27c30a3
+  languageName: node
+  linkType: hard
+
+"rrweb-cssom@npm:^0.8.0":
+  version: 0.8.0
+  resolution: "rrweb-cssom@npm:0.8.0"
+  checksum: 10c0/56f2bfd56733adb92c0b56e274c43f864b8dd48784d6fe946ef5ff8d438234015e59ad837fc2ad54714b6421384141c1add4eb569e72054e350d1f8a50b8ac7b
+  languageName: node
+  linkType: hard
+
+"run-parallel@npm:^1.1.9":
+  version: 1.2.0
+  resolution: "run-parallel@npm:1.2.0"
+  dependencies:
+    queue-microtask: "npm:^1.2.2"
+  checksum: 10c0/200b5ab25b5b8b7113f9901bfe3afc347e19bb7475b267d55ad0eb86a62a46d77510cb0f232507c9e5d497ebda569a08a9867d0d14f57a82ad5564d991588b39
+  languageName: node
+  linkType: hard
+
+"safe-array-concat@npm:^1.1.3":
+  version: 1.1.3
+  resolution: "safe-array-concat@npm:1.1.3"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.2"
+    get-intrinsic: "npm:^1.2.6"
+    has-symbols: "npm:^1.1.0"
+    isarray: "npm:^2.0.5"
+  checksum: 10c0/43c86ffdddc461fb17ff8a17c5324f392f4868f3c7dd2c6a5d9f5971713bc5fd755667212c80eab9567595f9a7509cc2f83e590ddaebd1bd19b780f9c79f9a8d
+  languageName: node
+  linkType: hard
+
+"safe-push-apply@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "safe-push-apply@npm:1.0.0"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    isarray: "npm:^2.0.5"
+  checksum: 10c0/831f1c9aae7436429e7862c7e46f847dfe490afac20d0ee61bae06108dbf5c745a0de3568ada30ccdd3eeb0864ca8331b2eef703abd69bfea0745b21fd320750
+  languageName: node
+  linkType: hard
+
+"safe-regex-test@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "safe-regex-test@npm:1.1.0"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    es-errors: "npm:^1.3.0"
+    is-regex: "npm:^1.2.1"
+  checksum: 10c0/f2c25281bbe5d39cddbbce7f86fca5ea9b3ce3354ea6cd7c81c31b006a5a9fff4286acc5450a3b9122c56c33eba69c56b9131ad751457b2b4a585825e6a10665
+  languageName: node
+  linkType: hard
+
+"safer-buffer@npm:>= 2.1.2 < 3.0.0":
+  version: 2.1.2
+  resolution: "safer-buffer@npm:2.1.2"
+  checksum: 10c0/7e3c8b2e88a1841c9671094bbaeebd94448111dd90a81a1f606f3f67708a6ec57763b3b47f06da09fc6054193e0e6709e77325415dc8422b04497a8070fa02d4
+  languageName: node
+  linkType: hard
+
+"saxes@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "saxes@npm:6.0.0"
+  dependencies:
+    xmlchars: "npm:^2.2.0"
+  checksum: 10c0/3847b839f060ef3476eb8623d099aa502ad658f5c40fd60c105ebce86d244389b0d76fcae30f4d0c728d7705ceb2f7e9b34bb54717b6a7dbedaf5dad2d9a4b74
+  languageName: node
+  linkType: hard
+
+"scslre@npm:0.3.0":
+  version: 0.3.0
+  resolution: "scslre@npm:0.3.0"
+  dependencies:
+    "@eslint-community/regexpp": "npm:^4.8.0"
+    refa: "npm:^0.12.0"
+    regexp-ast-analysis: "npm:^0.7.0"
+  checksum: 10c0/47eb72cf913693b453b7622dfee26871b4c408169874b31b8a1f3de8f41698e6dbacd7565fccc8d24cd2fd30f53c21f16995a7f9072e8b25cd938a6c3a750c3c
+  languageName: node
+  linkType: hard
+
+"semver@npm:7.7.2":
+  version: 7.7.2
+  resolution: "semver@npm:7.7.2"
+  bin:
+    semver: bin/semver.js
+  checksum: 10c0/aca305edfbf2383c22571cb7714f48cadc7ac95371b4b52362fb8eeffdfbc0de0669368b82b2b15978f8848f01d7114da65697e56cd8c37b0dab8c58e543f9ea
+  languageName: node
+  linkType: hard
+
+"semver@npm:^5.3.0, semver@npm:^5.6.0":
+  version: 5.7.2
+  resolution: "semver@npm:5.7.2"
+  bin:
+    semver: bin/semver
+  checksum: 10c0/e4cf10f86f168db772ae95d86ba65b3fd6c5967c94d97c708ccb463b778c2ee53b914cd7167620950fc07faf5a564e6efe903836639e512a1aa15fbc9667fa25
+  languageName: node
+  linkType: hard
+
+"semver@npm:^6.3.1":
+  version: 6.3.1
+  resolution: "semver@npm:6.3.1"
+  bin:
+    semver: bin/semver.js
+  checksum: 10c0/e3d79b609071caa78bcb6ce2ad81c7966a46a7431d9d58b8800cfa9cb6a63699b3899a0e4bcce36167a284578212d9ae6942b6929ba4aa5015c079a67751d42d
+  languageName: node
+  linkType: hard
+
+"semver@npm:^7.0.0, semver@npm:^7.3.4, semver@npm:^7.3.5, semver@npm:^7.5.3, semver@npm:^7.5.4, semver@npm:^7.6.3":
+  version: 7.7.3
+  resolution: "semver@npm:7.7.3"
+  bin:
+    semver: bin/semver.js
+  checksum: 10c0/4afe5c986567db82f44c8c6faef8fe9df2a9b1d98098fc1721f57c696c4c21cebd572f297fc21002f81889492345b8470473bc6f4aff5fb032a6ea59ea2bc45e
+  languageName: node
+  linkType: hard
+
+"set-function-length@npm:^1.2.2":
+  version: 1.2.2
+  resolution: "set-function-length@npm:1.2.2"
+  dependencies:
+    define-data-property: "npm:^1.1.4"
+    es-errors: "npm:^1.3.0"
+    function-bind: "npm:^1.1.2"
+    get-intrinsic: "npm:^1.2.4"
+    gopd: "npm:^1.0.1"
+    has-property-descriptors: "npm:^1.0.2"
+  checksum: 10c0/82850e62f412a258b71e123d4ed3873fa9377c216809551192bb6769329340176f109c2eeae8c22a8d386c76739855f78e8716515c818bcaef384b51110f0f3c
+  languageName: node
+  linkType: hard
+
+"set-function-name@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "set-function-name@npm:2.0.2"
+  dependencies:
+    define-data-property: "npm:^1.1.4"
+    es-errors: "npm:^1.3.0"
+    functions-have-names: "npm:^1.2.3"
+    has-property-descriptors: "npm:^1.0.2"
+  checksum: 10c0/fce59f90696c450a8523e754abb305e2b8c73586452619c2bad5f7bf38c7b6b4651895c9db895679c5bef9554339cf3ef1c329b66ece3eda7255785fbe299316
+  languageName: node
+  linkType: hard
+
+"set-proto@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "set-proto@npm:1.0.0"
+  dependencies:
+    dunder-proto: "npm:^1.0.1"
+    es-errors: "npm:^1.3.0"
+    es-object-atoms: "npm:^1.0.0"
+  checksum: 10c0/ca5c3ccbba479d07c30460e367e66337cec825560b11e8ba9c5ebe13a2a0d6021ae34eddf94ff3dfe17a3104dc1f191519cb6c48378b503e5c3f36393938776a
+  languageName: node
+  linkType: hard
+
+"shallow-clone@npm:^3.0.0":
+  version: 3.0.1
+  resolution: "shallow-clone@npm:3.0.1"
+  dependencies:
+    kind-of: "npm:^6.0.2"
+  checksum: 10c0/7bab09613a1b9f480c85a9823aebec533015579fa055ba6634aa56ba1f984380670eaf33b8217502931872aa1401c9fcadaa15f9f604d631536df475b05bcf1e
+  languageName: node
+  linkType: hard
+
+"shebang-command@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "shebang-command@npm:2.0.0"
+  dependencies:
+    shebang-regex: "npm:^3.0.0"
+  checksum: 10c0/a41692e7d89a553ef21d324a5cceb5f686d1f3c040759c50aab69688634688c5c327f26f3ecf7001ebfd78c01f3c7c0a11a7c8bfd0a8bc9f6240d4f40b224e4e
+  languageName: node
+  linkType: hard
+
+"shebang-regex@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "shebang-regex@npm:3.0.0"
+  checksum: 10c0/1dbed0726dd0e1152a92696c76c7f06084eb32a90f0528d11acd764043aacf76994b2fb30aa1291a21bd019d6699164d048286309a278855ee7bec06cf6fb690
+  languageName: node
+  linkType: hard
+
+"side-channel-list@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "side-channel-list@npm:1.0.0"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    object-inspect: "npm:^1.13.3"
+  checksum: 10c0/644f4ac893456c9490ff388bf78aea9d333d5e5bfc64cfb84be8f04bf31ddc111a8d4b83b85d7e7e8a7b845bc185a9ad02c052d20e086983cf59f0be517d9b3d
+  languageName: node
+  linkType: hard
+
+"side-channel-map@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "side-channel-map@npm:1.0.1"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    es-errors: "npm:^1.3.0"
+    get-intrinsic: "npm:^1.2.5"
+    object-inspect: "npm:^1.13.3"
+  checksum: 10c0/010584e6444dd8a20b85bc926d934424bd809e1a3af941cace229f7fdcb751aada0fb7164f60c2e22292b7fa3c0ff0bce237081fd4cdbc80de1dc68e95430672
+  languageName: node
+  linkType: hard
+
+"side-channel-weakmap@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "side-channel-weakmap@npm:1.0.2"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    es-errors: "npm:^1.3.0"
+    get-intrinsic: "npm:^1.2.5"
+    object-inspect: "npm:^1.13.3"
+    side-channel-map: "npm:^1.0.1"
+  checksum: 10c0/71362709ac233e08807ccd980101c3e2d7efe849edc51455030327b059f6c4d292c237f94dc0685031dd11c07dd17a68afde235d6cf2102d949567f98ab58185
+  languageName: node
+  linkType: hard
+
+"side-channel@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "side-channel@npm:1.1.0"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    object-inspect: "npm:^1.13.3"
+    side-channel-list: "npm:^1.0.0"
+    side-channel-map: "npm:^1.0.1"
+    side-channel-weakmap: "npm:^1.0.2"
+  checksum: 10c0/cb20dad41eb032e6c24c0982e1e5a24963a28aa6122b4f05b3f3d6bf8ae7fd5474ef382c8f54a6a3ab86e0cac4d41a23bd64ede3970e5bfb50326ba02a7996e6
+  languageName: node
+  linkType: hard
+
+"siginfo@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "siginfo@npm:2.0.0"
+  checksum: 10c0/3def8f8e516fbb34cb6ae415b07ccc5d9c018d85b4b8611e3dc6f8be6d1899f693a4382913c9ed51a06babb5201639d76453ab297d1c54a456544acf5c892e34
+  languageName: node
+  linkType: hard
+
+"signal-exit@npm:^3.0.2":
+  version: 3.0.7
+  resolution: "signal-exit@npm:3.0.7"
+  checksum: 10c0/25d272fa73e146048565e08f3309d5b942c1979a6f4a58a8c59d5fa299728e9c2fcd1a759ec870863b1fd38653670240cd420dad2ad9330c71f36608a6a1c912
+  languageName: node
+  linkType: hard
+
+"signal-exit@npm:^4.0.1, signal-exit@npm:^4.1.0":
+  version: 4.1.0
+  resolution: "signal-exit@npm:4.1.0"
+  checksum: 10c0/41602dce540e46d599edba9d9860193398d135f7ff72cab629db5171516cfae628d21e7bfccde1bbfdf11c48726bc2a6d1a8fb8701125852fbfda7cf19c6aa83
+  languageName: node
+  linkType: hard
+
+"sirv@npm:^2.0.4":
+  version: 2.0.4
+  resolution: "sirv@npm:2.0.4"
+  dependencies:
+    "@polka/url": "npm:^1.0.0-next.24"
+    mrmime: "npm:^2.0.0"
+    totalist: "npm:^3.0.0"
+  checksum: 10c0/68f8ee857f6a9415e9c07a1f31c7c561df8d5f1b1ba79bee3de583fa37da8718def5309f6b1c6e2c3ef77de45d74f5e49efc7959214443aa92d42e9c99180a4e
+  languageName: node
+  linkType: hard
+
+"slash@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "slash@npm:3.0.0"
+  checksum: 10c0/e18488c6a42bdfd4ac5be85b2ced3ccd0224773baae6ad42cfbb9ec74fc07f9fa8396bd35ee638084ead7a2a0818eb5e7151111544d4731ce843019dab4be47b
+  languageName: node
+  linkType: hard
+
+"slashes@npm:^3.0.12":
+  version: 3.0.12
+  resolution: "slashes@npm:3.0.12"
+  checksum: 10c0/71ca2a1fcd1ab6814b0fdb8cf9c33a3d54321deec2aa8d173510f0086880201446021a9b9e6a18561f7c472b69a2145977c6a8fb9c53a8ff7be31778f203d175
+  languageName: node
+  linkType: hard
+
+"slice-ansi@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "slice-ansi@npm:4.0.0"
+  dependencies:
+    ansi-styles: "npm:^4.0.0"
+    astral-regex: "npm:^2.0.0"
+    is-fullwidth-code-point: "npm:^3.0.0"
+  checksum: 10c0/6c25678db1270d4793e0327620f1e0f9f5bea4630123f51e9e399191bc52c87d6e6de53ed33538609e5eacbd1fab769fae00f3705d08d029f02102a540648918
+  languageName: node
+  linkType: hard
+
+"smart-buffer@npm:^4.2.0":
+  version: 4.2.0
+  resolution: "smart-buffer@npm:4.2.0"
+  checksum: 10c0/a16775323e1404dd43fabafe7460be13a471e021637bc7889468eb45ce6a6b207261f454e4e530a19500cc962c4cc5348583520843b363f4193cee5c00e1e539
+  languageName: node
+  linkType: hard
+
+"socks-proxy-agent@npm:^8.0.3":
+  version: 8.0.5
+  resolution: "socks-proxy-agent@npm:8.0.5"
+  dependencies:
+    agent-base: "npm:^7.1.2"
+    debug: "npm:^4.3.4"
+    socks: "npm:^2.8.3"
+  checksum: 10c0/5d2c6cecba6821389aabf18728325730504bf9bb1d9e342e7987a5d13badd7a98838cc9a55b8ed3cb866ad37cc23e1086f09c4d72d93105ce9dfe76330e9d2a6
+  languageName: node
+  linkType: hard
+
+"socks@npm:^2.8.3":
+  version: 2.8.7
+  resolution: "socks@npm:2.8.7"
+  dependencies:
+    ip-address: "npm:^10.0.1"
+    smart-buffer: "npm:^4.2.0"
+  checksum: 10c0/2805a43a1c4bcf9ebf6e018268d87b32b32b06fbbc1f9282573583acc155860dc361500f89c73bfbb157caa1b4ac78059eac0ef15d1811eb0ca75e0bdadbc9d2
+  languageName: node
+  linkType: hard
+
+"source-map-js@npm:^1.0.1, source-map-js@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "source-map-js@npm:1.2.1"
+  checksum: 10c0/7bda1fc4c197e3c6ff17de1b8b2c20e60af81b63a52cb32ec5a5d67a20a7d42651e2cb34ebe93833c5a2a084377e17455854fee3e21e7925c64a51b6a52b0faf
+  languageName: node
+  linkType: hard
+
+"source-map-support@npm:^0.5.16":
+  version: 0.5.21
+  resolution: "source-map-support@npm:0.5.21"
+  dependencies:
+    buffer-from: "npm:^1.0.0"
+    source-map: "npm:^0.6.0"
+  checksum: 10c0/9ee09942f415e0f721d6daad3917ec1516af746a8120bba7bb56278707a37f1eb8642bde456e98454b8a885023af81a16e646869975f06afc1a711fb90484e7d
+  languageName: node
+  linkType: hard
+
+"source-map@npm:^0.6.0, source-map@npm:^0.6.1":
+  version: 0.6.1
+  resolution: "source-map@npm:0.6.1"
+  checksum: 10c0/ab55398007c5e5532957cb0beee2368529618ac0ab372d789806f5718123cc4367d57de3904b4e6a4170eb5a0b0f41373066d02ca0735a0c4d75c7d328d3e011
+  languageName: node
+  linkType: hard
+
+"spark-md5@npm:^3.0.2":
+  version: 3.0.2
+  resolution: "spark-md5@npm:3.0.2"
+  checksum: 10c0/3fd11735eac5e7d60d6006d99ac0a055f148a89e9baf5f0b51ac103022dec30556b44190b37f6737ca50f81e8e50dc13e724f9edf6290c412ff5ab2101ce7780
+  languageName: node
+  linkType: hard
+
+"spdx-compare@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "spdx-compare@npm:1.0.0"
+  dependencies:
+    array-find-index: "npm:^1.0.2"
+    spdx-expression-parse: "npm:^3.0.0"
+    spdx-ranges: "npm:^2.0.0"
+  checksum: 10c0/39d584129b00eaf0bb314984e5d662e511980c1fc6c4eb1d80677044a7b2b9cc3f84f6838695cf988807bf81ea0fce7438e33b0ee54fa87d302635bd143b7fc7
+  languageName: node
+  linkType: hard
+
+"spdx-correct@npm:^3.0.0":
+  version: 3.2.0
+  resolution: "spdx-correct@npm:3.2.0"
+  dependencies:
+    spdx-expression-parse: "npm:^3.0.0"
+    spdx-license-ids: "npm:^3.0.0"
+  checksum: 10c0/49208f008618b9119208b0dadc9208a3a55053f4fd6a0ae8116861bd22696fc50f4142a35ebfdb389e05ccf2de8ad142573fefc9e26f670522d899f7b2fe7386
+  languageName: node
+  linkType: hard
+
+"spdx-exceptions@npm:^2.1.0":
+  version: 2.5.0
+  resolution: "spdx-exceptions@npm:2.5.0"
+  checksum: 10c0/37217b7762ee0ea0d8b7d0c29fd48b7e4dfb94096b109d6255b589c561f57da93bf4e328c0290046115961b9209a8051ad9f525e48d433082fc79f496a4ea940
+  languageName: node
+  linkType: hard
+
+"spdx-expression-parse@npm:^3.0.0":
+  version: 3.0.1
+  resolution: "spdx-expression-parse@npm:3.0.1"
+  dependencies:
+    spdx-exceptions: "npm:^2.1.0"
+    spdx-license-ids: "npm:^3.0.0"
+  checksum: 10c0/6f8a41c87759fa184a58713b86c6a8b028250f158159f1d03ed9d1b6ee4d9eefdc74181c8ddc581a341aa971c3e7b79e30b59c23b05d2436d5de1c30bdef7171
+  languageName: node
+  linkType: hard
+
+"spdx-expression-parse@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "spdx-expression-parse@npm:4.0.0"
+  dependencies:
+    spdx-exceptions: "npm:^2.1.0"
+    spdx-license-ids: "npm:^3.0.0"
+  checksum: 10c0/965c487e77f4fb173f1c471f3eef4eb44b9f0321adc7f93d95e7620da31faa67d29356eb02523cd7df8a7fc1ec8238773cdbf9e45bd050329d2b26492771b736
+  languageName: node
+  linkType: hard
+
+"spdx-expression-validate@npm:~2.0.0":
+  version: 2.0.0
+  resolution: "spdx-expression-validate@npm:2.0.0"
+  dependencies:
+    spdx-expression-parse: "npm:^3.0.0"
+  checksum: 10c0/fd1e8555e034be72c3a52bd306d04e6035e5d257bea6d39a77d391d236700d32a4647bd1391fc1eaa50c22a67aba6d1004a7569af02e499c8a3afda0bcdb6144
+  languageName: node
+  linkType: hard
+
+"spdx-license-ids@npm:^3.0.0":
+  version: 3.0.22
+  resolution: "spdx-license-ids@npm:3.0.22"
+  checksum: 10c0/4a85e44c2ccfc06eebe63239193f526508ebec1abc7cf7bca8ee43923755636234395447c2c87f40fb672cf580a9c8e684513a676bfb2da3d38a4983684bbb38
+  languageName: node
+  linkType: hard
+
+"spdx-ranges@npm:^2.0.0":
+  version: 2.1.1
+  resolution: "spdx-ranges@npm:2.1.1"
+  checksum: 10c0/2d6bf9ec8e0f509c1a119361ff784f0bfa8ebbd8cfbc8e10f79579def54af060bb5058b36372f19770e659051082c451145c1284d2980419a720675accdb4a3d
+  languageName: node
+  linkType: hard
+
+"spdx-satisfies@npm:~5.0.1":
+  version: 5.0.1
+  resolution: "spdx-satisfies@npm:5.0.1"
+  dependencies:
+    spdx-compare: "npm:^1.0.0"
+    spdx-expression-parse: "npm:^3.0.0"
+    spdx-ranges: "npm:^2.0.0"
+  checksum: 10c0/47bf163108e64fe4c179a5e2f8dc5fd4ece1665739fc61eae3157a9d4b9b2eb389df7f645223192557659155dda9071ceaa3dfd06ecab65cc3862032c20f2e61
+  languageName: node
+  linkType: hard
+
+"sprintf-js@npm:~1.0.2":
+  version: 1.0.3
+  resolution: "sprintf-js@npm:1.0.3"
+  checksum: 10c0/ecadcfe4c771890140da5023d43e190b7566d9cf8b2d238600f31bec0fc653f328da4450eb04bd59a431771a8e9cc0e118f0aa3974b683a4981b4e07abc2a5bb
+  languageName: node
+  linkType: hard
+
+"ssri@npm:^12.0.0":
+  version: 12.0.0
+  resolution: "ssri@npm:12.0.0"
+  dependencies:
+    minipass: "npm:^7.0.3"
+  checksum: 10c0/caddd5f544b2006e88fa6b0124d8d7b28208b83c72d7672d5ade44d794525d23b540f3396108c4eb9280dcb7c01f0bef50682f5b4b2c34291f7c5e211fd1417d
+  languageName: node
+  linkType: hard
+
+"stackback@npm:0.0.2":
+  version: 0.0.2
+  resolution: "stackback@npm:0.0.2"
+  checksum: 10c0/89a1416668f950236dd5ac9f9a6b2588e1b9b62b1b6ad8dff1bfc5d1a15dbf0aafc9b52d2226d00c28dffff212da464eaeebfc6b7578b9d180cef3e3782c5983
+  languageName: node
+  linkType: hard
+
+"std-env@npm:^3.5.0":
+  version: 3.10.0
+  resolution: "std-env@npm:3.10.0"
+  checksum: 10c0/1814927a45004d36dde6707eaf17552a546769bc79a6421be2c16ce77d238158dfe5de30910b78ec30d95135cc1c59ea73ee22d2ca170f8b9753f84da34c427f
+  languageName: node
+  linkType: hard
+
+"stop-iteration-iterator@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "stop-iteration-iterator@npm:1.1.0"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    internal-slot: "npm:^1.1.0"
+  checksum: 10c0/de4e45706bb4c0354a4b1122a2b8cc45a639e86206807ce0baf390ee9218d3ef181923fa4d2b67443367c491aa255c5fbaa64bb74648e3c5b48299928af86c09
+  languageName: node
+  linkType: hard
+
+"string-width-cjs@npm:string-width@^4.2.0, string-width@npm:^4.1.0, string-width@npm:^4.2.0, string-width@npm:^4.2.3":
+  version: 4.2.3
+  resolution: "string-width@npm:4.2.3"
+  dependencies:
+    emoji-regex: "npm:^8.0.0"
+    is-fullwidth-code-point: "npm:^3.0.0"
+    strip-ansi: "npm:^6.0.1"
+  checksum: 10c0/1e525e92e5eae0afd7454086eed9c818ee84374bb80328fc41217ae72ff5f065ef1c9d7f72da41de40c75fa8bb3dee63d92373fd492c84260a552c636392a47b
+  languageName: node
+  linkType: hard
+
+"string-width@npm:^5.0.1, string-width@npm:^5.1.2":
+  version: 5.1.2
+  resolution: "string-width@npm:5.1.2"
+  dependencies:
+    eastasianwidth: "npm:^0.2.0"
+    emoji-regex: "npm:^9.2.2"
+    strip-ansi: "npm:^7.0.1"
+  checksum: 10c0/ab9c4264443d35b8b923cbdd513a089a60de339216d3b0ed3be3ba57d6880e1a192b70ae17225f764d7adbf5994e9bb8df253a944736c15a0240eff553c678ca
+  languageName: node
+  linkType: hard
+
+"string.prototype.trim@npm:^1.2.10":
+  version: 1.2.10
+  resolution: "string.prototype.trim@npm:1.2.10"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.2"
+    define-data-property: "npm:^1.1.4"
+    define-properties: "npm:^1.2.1"
+    es-abstract: "npm:^1.23.5"
+    es-object-atoms: "npm:^1.0.0"
+    has-property-descriptors: "npm:^1.0.2"
+  checksum: 10c0/8a8854241c4b54a948e992eb7dd6b8b3a97185112deb0037a134f5ba57541d8248dd610c966311887b6c2fd1181a3877bffb14d873ce937a344535dabcc648f8
+  languageName: node
+  linkType: hard
+
+"string.prototype.trimend@npm:^1.0.9":
+  version: 1.0.9
+  resolution: "string.prototype.trimend@npm:1.0.9"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.2"
+    define-properties: "npm:^1.2.1"
+    es-object-atoms: "npm:^1.0.0"
+  checksum: 10c0/59e1a70bf9414cb4c536a6e31bef5553c8ceb0cf44d8b4d0ed65c9653358d1c64dd0ec203b100df83d0413bbcde38b8c5d49e14bc4b86737d74adc593a0d35b6
+  languageName: node
+  linkType: hard
+
+"string.prototype.trimstart@npm:^1.0.8":
+  version: 1.0.8
+  resolution: "string.prototype.trimstart@npm:1.0.8"
+  dependencies:
+    call-bind: "npm:^1.0.7"
+    define-properties: "npm:^1.2.1"
+    es-object-atoms: "npm:^1.0.0"
+  checksum: 10c0/d53af1899959e53c83b64a5fd120be93e067da740e7e75acb433849aa640782fb6c7d4cd5b84c954c84413745a3764df135a8afeb22908b86a835290788d8366
+  languageName: node
+  linkType: hard
+
+"strip-ansi-cjs@npm:strip-ansi@^6.0.1, strip-ansi@npm:^6.0.0, strip-ansi@npm:^6.0.1":
+  version: 6.0.1
+  resolution: "strip-ansi@npm:6.0.1"
+  dependencies:
+    ansi-regex: "npm:^5.0.1"
+  checksum: 10c0/1ae5f212a126fe5b167707f716942490e3933085a5ff6c008ab97ab2f272c8025d3aa218b7bd6ab25729ca20cc81cddb252102f8751e13482a5199e873680952
+  languageName: node
+  linkType: hard
+
+"strip-ansi@npm:^7.0.1":
+  version: 7.1.2
+  resolution: "strip-ansi@npm:7.1.2"
+  dependencies:
+    ansi-regex: "npm:^6.0.1"
+  checksum: 10c0/0d6d7a023de33368fd042aab0bf48f4f4077abdfd60e5393e73c7c411e85e1b3a83507c11af2e656188511475776215df9ca589b4da2295c9455cc399ce1858b
+  languageName: node
+  linkType: hard
+
+"strip-bom@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "strip-bom@npm:3.0.0"
+  checksum: 10c0/51201f50e021ef16672593d7434ca239441b7b760e905d9f33df6e4f3954ff54ec0e0a06f100d028af0982d6f25c35cd5cda2ce34eaebccd0250b8befb90d8f1
+  languageName: node
+  linkType: hard
+
+"strip-final-newline@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "strip-final-newline@npm:2.0.0"
+  checksum: 10c0/bddf8ccd47acd85c0e09ad7375409d81653f645fda13227a9d459642277c253d877b68f2e5e4d819fe75733b0e626bac7e954c04f3236f6d196f79c94fa4a96f
+  languageName: node
+  linkType: hard
+
+"strip-final-newline@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "strip-final-newline@npm:3.0.0"
+  checksum: 10c0/a771a17901427bac6293fd416db7577e2bc1c34a19d38351e9d5478c3c415f523f391003b42ed475f27e33a78233035df183525395f731d3bfb8cdcbd4da08ce
+  languageName: node
+  linkType: hard
+
+"strip-indent@npm:^4.0.0":
+  version: 4.1.1
+  resolution: "strip-indent@npm:4.1.1"
+  checksum: 10c0/5b23dd5934be0ef6b6fe1b802887f83e56ad9dcd9f6c3896a637da2c6c3a6da3fdf3e51354a98e6cccb6f1c41863e7b9b9deaa348639dfd35f71f3549edb4dff
+  languageName: node
+  linkType: hard
+
+"strip-json-comments@npm:^3.1.1":
+  version: 3.1.1
+  resolution: "strip-json-comments@npm:3.1.1"
+  checksum: 10c0/9681a6257b925a7fa0f285851c0e613cc934a50661fa7bb41ca9cbbff89686bb4a0ee366e6ecedc4daafd01e83eee0720111ab294366fe7c185e935475ebcecd
+  languageName: node
+  linkType: hard
+
+"strip-literal@npm:^2.0.0":
+  version: 2.1.1
+  resolution: "strip-literal@npm:2.1.1"
+  dependencies:
+    js-tokens: "npm:^9.0.1"
+  checksum: 10c0/66a7353f5ba1ae6a4fb2805b4aba228171847200640083117c41512692e6b2c020e18580402984f55c0ae69c30f857f9a55abd672863e4ca8fdb463fdf93ba19
+  languageName: node
+  linkType: hard
+
+"style-search@npm:^0.1.0":
+  version: 0.1.0
+  resolution: "style-search@npm:0.1.0"
+  checksum: 10c0/9e5cb735e5dc4fc2f8c61bebdf211d5352f1cf01511a64da12bb726a01e8c6948c50d357eb8fd7893d44b4e3189655bdddcf8ab338f9d508fe89a8942c650b14
+  languageName: node
+  linkType: hard
+
+"stylelint@npm:^15.4.0":
+  version: 15.11.0
+  resolution: "stylelint@npm:15.11.0"
+  dependencies:
+    "@csstools/css-parser-algorithms": "npm:^2.3.1"
+    "@csstools/css-tokenizer": "npm:^2.2.0"
+    "@csstools/media-query-list-parser": "npm:^2.1.4"
+    "@csstools/selector-specificity": "npm:^3.0.0"
+    balanced-match: "npm:^2.0.0"
+    colord: "npm:^2.9.3"
+    cosmiconfig: "npm:^8.2.0"
+    css-functions-list: "npm:^3.2.1"
+    css-tree: "npm:^2.3.1"
+    debug: "npm:^4.3.4"
+    fast-glob: "npm:^3.3.1"
+    fastest-levenshtein: "npm:^1.0.16"
+    file-entry-cache: "npm:^7.0.0"
+    global-modules: "npm:^2.0.0"
+    globby: "npm:^11.1.0"
+    globjoin: "npm:^0.1.4"
+    html-tags: "npm:^3.3.1"
+    ignore: "npm:^5.2.4"
+    import-lazy: "npm:^4.0.0"
+    imurmurhash: "npm:^0.1.4"
+    is-plain-object: "npm:^5.0.0"
+    known-css-properties: "npm:^0.29.0"
+    mathml-tag-names: "npm:^2.1.3"
+    meow: "npm:^10.1.5"
+    micromatch: "npm:^4.0.5"
+    normalize-path: "npm:^3.0.0"
+    picocolors: "npm:^1.0.0"
+    postcss: "npm:^8.4.28"
+    postcss-resolve-nested-selector: "npm:^0.1.1"
+    postcss-safe-parser: "npm:^6.0.0"
+    postcss-selector-parser: "npm:^6.0.13"
+    postcss-value-parser: "npm:^4.2.0"
+    resolve-from: "npm:^5.0.0"
+    string-width: "npm:^4.2.3"
+    strip-ansi: "npm:^6.0.1"
+    style-search: "npm:^0.1.0"
+    supports-hyperlinks: "npm:^3.0.0"
+    svg-tags: "npm:^1.0.0"
+    table: "npm:^6.8.1"
+    write-file-atomic: "npm:^5.0.1"
+  bin:
+    stylelint: bin/stylelint.mjs
+  checksum: 10c0/2d88b7293e308b7e418c14ba4130777b1a28b214304957f03b41a6dc8e00005266caf47479f718a6ec5e572cb52e903ca34aabf3febbe3a3ae32fff6b018d9fd
+  languageName: node
+  linkType: hard
+
+"supports-color@npm:^5.3.0":
+  version: 5.5.0
+  resolution: "supports-color@npm:5.5.0"
+  dependencies:
+    has-flag: "npm:^3.0.0"
+  checksum: 10c0/6ae5ff319bfbb021f8a86da8ea1f8db52fac8bd4d499492e30ec17095b58af11f0c55f8577390a749b1c4dde691b6a0315dab78f5f54c9b3d83f8fb5905c1c05
+  languageName: node
+  linkType: hard
+
+"supports-color@npm:^7.0.0, supports-color@npm:^7.1.0":
+  version: 7.2.0
+  resolution: "supports-color@npm:7.2.0"
+  dependencies:
+    has-flag: "npm:^4.0.0"
+  checksum: 10c0/afb4c88521b8b136b5f5f95160c98dee7243dc79d5432db7efc27efb219385bbc7d9427398e43dd6cc730a0f87d5085ce1652af7efbe391327bc0a7d0f7fc124
+  languageName: node
+  linkType: hard
+
+"supports-hyperlinks@npm:^3.0.0":
+  version: 3.2.0
+  resolution: "supports-hyperlinks@npm:3.2.0"
+  dependencies:
+    has-flag: "npm:^4.0.0"
+    supports-color: "npm:^7.0.0"
+  checksum: 10c0/bca527f38d4c45bc95d6a24225944675746c515ddb91e2456d00ae0b5c537658e9dd8155b996b191941b0c19036195a098251304b9082bbe00cd1781f3cd838e
+  languageName: node
+  linkType: hard
+
+"supports-preserve-symlinks-flag@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "supports-preserve-symlinks-flag@npm:1.0.0"
+  checksum: 10c0/6c4032340701a9950865f7ae8ef38578d8d7053f5e10518076e6554a9381fa91bd9c6850193695c141f32b21f979c985db07265a758867bac95de05f7d8aeb39
+  languageName: node
+  linkType: hard
+
+"svg-tags@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "svg-tags@npm:1.0.0"
+  checksum: 10c0/5867e29e8f431bf7aecf5a244d1af5725f80a1086187dbc78f26d8433b5e96b8fe9361aeb10d1699ff483b9afec785a10916b9312fe9d734d1a7afd48226c954
+  languageName: node
+  linkType: hard
+
+"symbol-tree@npm:^3.2.4":
+  version: 3.2.4
+  resolution: "symbol-tree@npm:3.2.4"
+  checksum: 10c0/dfbe201ae09ac6053d163578778c53aa860a784147ecf95705de0cd23f42c851e1be7889241495e95c37cabb058edb1052f141387bef68f705afc8f9dd358509
+  languageName: node
+  linkType: hard
+
+"synckit@npm:^0.9.1":
+  version: 0.9.3
+  resolution: "synckit@npm:0.9.3"
+  dependencies:
+    "@pkgr/core": "npm:^0.1.0"
+    tslib: "npm:^2.6.2"
+  checksum: 10c0/3f2ecd7e04d5ca846ccb005017bb4be15982602b90d0ae3facf92f73837a81657b0a666d81713b23cfe25c28f26aaaabb385c59856c39c3710dba9f389cd8321
+  languageName: node
+  linkType: hard
+
+"table@npm:^6.8.1":
+  version: 6.9.0
+  resolution: "table@npm:6.9.0"
+  dependencies:
+    ajv: "npm:^8.0.1"
+    lodash.truncate: "npm:^4.4.2"
+    slice-ansi: "npm:^4.0.0"
+    string-width: "npm:^4.2.3"
+    strip-ansi: "npm:^6.0.1"
+  checksum: 10c0/35646185712bb65985fbae5975dda46696325844b78735f95faefae83e86df0a265277819a3e67d189de6e858c509b54e66ca3958ffd51bde56ef1118d455bf4
+  languageName: node
+  linkType: hard
+
+"tar@npm:^7.4.3":
+  version: 7.5.2
+  resolution: "tar@npm:7.5.2"
+  dependencies:
+    "@isaacs/fs-minipass": "npm:^4.0.0"
+    chownr: "npm:^3.0.0"
+    minipass: "npm:^7.1.2"
+    minizlib: "npm:^3.1.0"
+    yallist: "npm:^5.0.0"
+  checksum: 10c0/a7d8b801139b52f93a7e34830db0de54c5aa45487c7cb551f6f3d44a112c67f1cb8ffdae856b05fd4f17b1749911f1c26f1e3a23bbe0279e17fd96077f13f467
+  languageName: node
+  linkType: hard
+
+"text-table@npm:^0.2.0":
+  version: 0.2.0
+  resolution: "text-table@npm:0.2.0"
+  checksum: 10c0/02805740c12851ea5982686810702e2f14369a5f4c5c40a836821e3eefc65ffeec3131ba324692a37608294b0fd8c1e55a2dd571ffed4909822787668ddbee5c
+  languageName: node
+  linkType: hard
+
+"tinybench@npm:^2.5.1":
+  version: 2.9.0
+  resolution: "tinybench@npm:2.9.0"
+  checksum: 10c0/c3500b0f60d2eb8db65250afe750b66d51623057ee88720b7f064894a6cb7eb93360ca824a60a31ab16dab30c7b1f06efe0795b352e37914a9d4bad86386a20c
+  languageName: node
+  linkType: hard
+
+"tinyglobby@npm:^0.2.12":
+  version: 0.2.15
+  resolution: "tinyglobby@npm:0.2.15"
+  dependencies:
+    fdir: "npm:^6.5.0"
+    picomatch: "npm:^4.0.3"
+  checksum: 10c0/869c31490d0d88eedb8305d178d4c75e7463e820df5a9b9d388291daf93e8b1eb5de1dad1c1e139767e4269fe75f3b10d5009b2cc14db96ff98986920a186844
+  languageName: node
+  linkType: hard
+
+"tinypool@npm:^0.8.3":
+  version: 0.8.4
+  resolution: "tinypool@npm:0.8.4"
+  checksum: 10c0/779c790adcb0316a45359652f4b025958c1dff5a82460fe49f553c864309b12ad732c8288be52f852973bc76317f5e7b3598878aee0beb8a33322c0e72c4a66c
+  languageName: node
+  linkType: hard
+
+"tinyspy@npm:^2.2.0":
+  version: 2.2.1
+  resolution: "tinyspy@npm:2.2.1"
+  checksum: 10c0/0b4cfd07c09871e12c592dfa7b91528124dc49a4766a0b23350638c62e6a483d5a2a667de7e6282246c0d4f09996482ddaacbd01f0c05b7ed7e0f79d32409bdc
+  languageName: node
+  linkType: hard
+
+"to-regex-range@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "to-regex-range@npm:5.0.1"
+  dependencies:
+    is-number: "npm:^7.0.0"
+  checksum: 10c0/487988b0a19c654ff3e1961b87f471702e708fa8a8dd02a298ef16da7206692e8552a0250e8b3e8759270f62e9d8314616f6da274734d3b558b1fc7b7724e892
+  languageName: node
+  linkType: hard
+
+"token-stream@npm:1.0.0":
+  version: 1.0.0
+  resolution: "token-stream@npm:1.0.0"
+  checksum: 10c0/c1924a89686fc035d579cbe856da12306571d5fe7408eeeebe80df7c25c5cc644b8ae102d5cbc0f085d0e105f391d1a48dc0e568520434c5b444ea6c7de2b822
+  languageName: node
+  linkType: hard
+
+"totalist@npm:^3.0.0":
+  version: 3.0.1
+  resolution: "totalist@npm:3.0.1"
+  checksum: 10c0/4bb1fadb69c3edbef91c73ebef9d25b33bbf69afe1e37ce544d5f7d13854cda15e47132f3e0dc4cafe300ddb8578c77c50a65004d8b6e97e77934a69aa924863
+  languageName: node
+  linkType: hard
+
+"tough-cookie@npm:^4.1.3":
+  version: 4.1.4
+  resolution: "tough-cookie@npm:4.1.4"
+  dependencies:
+    psl: "npm:^1.1.33"
+    punycode: "npm:^2.1.1"
+    universalify: "npm:^0.2.0"
+    url-parse: "npm:^1.5.3"
+  checksum: 10c0/aca7ff96054f367d53d1e813e62ceb7dd2eda25d7752058a74d64b7266fd07be75908f3753a32ccf866a2f997604b414cfb1916d6e7f69bc64d9d9939b0d6c45
+  languageName: node
+  linkType: hard
+
+"tr46@npm:^5.1.0":
+  version: 5.1.1
+  resolution: "tr46@npm:5.1.1"
+  dependencies:
+    punycode: "npm:^2.3.1"
+  checksum: 10c0/ae270e194d52ec67ebd695c1a42876e0f19b96e4aca2ab464ab1d9d17dc3acd3e18764f5034c93897db73421563be27c70c98359c4501136a497e46deda5d5ec
+  languageName: node
+  linkType: hard
+
+"trim-newlines@npm:^4.0.2":
+  version: 4.1.1
+  resolution: "trim-newlines@npm:4.1.1"
+  checksum: 10c0/70e60e652305efd0dda1f2bce1a5edc9bb5834a2e00d05dfde178715ec48faa8264a2bc1a7efc593b7936d03f6d42c398616329eef44b7bd5070180a02056981
+  languageName: node
+  linkType: hard
+
+"ts-api-utils@npm:^1.0.1":
+  version: 1.4.3
+  resolution: "ts-api-utils@npm:1.4.3"
+  peerDependencies:
+    typescript: ">=4.2.0"
+  checksum: 10c0/e65dc6e7e8141140c23e1dc94984bf995d4f6801919c71d6dc27cf0cd51b100a91ffcfe5217626193e5bea9d46831e8586febdc7e172df3f1091a7384299e23a
+  languageName: node
+  linkType: hard
+
+"tsconfig-paths@npm:^3.14.2, tsconfig-paths@npm:^3.15.0":
+  version: 3.15.0
+  resolution: "tsconfig-paths@npm:3.15.0"
+  dependencies:
+    "@types/json5": "npm:^0.0.29"
+    json5: "npm:^1.0.2"
+    minimist: "npm:^1.2.6"
+    strip-bom: "npm:^3.0.0"
+  checksum: 10c0/5b4f301a2b7a3766a986baf8fc0e177eb80bdba6e396792ff92dc23b5bca8bb279fc96517dcaaef63a3b49bebc6c4c833653ec58155780bc906bdbcf7dda0ef5
+  languageName: node
+  linkType: hard
+
+"tslib@npm:^1.13.0, tslib@npm:^1.8.1":
+  version: 1.14.1
+  resolution: "tslib@npm:1.14.1"
+  checksum: 10c0/69ae09c49eea644bc5ebe1bca4fa4cc2c82b7b3e02f43b84bd891504edf66dbc6b2ec0eef31a957042de2269139e4acff911e6d186a258fb14069cd7f6febce2
+  languageName: node
+  linkType: hard
+
+"tslib@npm:^2.3.1, tslib@npm:^2.6.2":
+  version: 2.8.1
+  resolution: "tslib@npm:2.8.1"
+  checksum: 10c0/9c4759110a19c53f992d9aae23aac5ced636e99887b51b9e61def52611732872ff7668757d4e4c61f19691e36f4da981cd9485e869b4a7408d689f6bf1f14e62
+  languageName: node
+  linkType: hard
+
+"tslint@npm:^6.1.1":
+  version: 6.1.3
+  resolution: "tslint@npm:6.1.3"
+  dependencies:
+    "@babel/code-frame": "npm:^7.0.0"
+    builtin-modules: "npm:^1.1.1"
+    chalk: "npm:^2.3.0"
+    commander: "npm:^2.12.1"
+    diff: "npm:^4.0.1"
+    glob: "npm:^7.1.1"
+    js-yaml: "npm:^3.13.1"
+    minimatch: "npm:^3.0.4"
+    mkdirp: "npm:^0.5.3"
+    resolve: "npm:^1.3.2"
+    semver: "npm:^5.3.0"
+    tslib: "npm:^1.13.0"
+    tsutils: "npm:^2.29.0"
+  peerDependencies:
+    typescript: ">=2.3.0-dev || >=2.4.0-dev || >=2.5.0-dev || >=2.6.0-dev || >=2.7.0-dev || >=2.8.0-dev || >=2.9.0-dev || >=3.0.0-dev || >= 3.1.0-dev || >= 3.2.0-dev || >= 4.0.0-dev"
+  bin:
+    tslint: bin/tslint
+  checksum: 10c0/04717de06d187ee46ffa99e28af80f1b5a2edbec051e32b43ca681da625a61e94e5eb9ebb638fafe07975fb3536760ffd772f76c57134db723a9ecff6aeac380
+  languageName: node
+  linkType: hard
+
+"tsutils@npm:^2.29.0":
+  version: 2.29.0
+  resolution: "tsutils@npm:2.29.0"
+  dependencies:
+    tslib: "npm:^1.8.1"
+  peerDependencies:
+    typescript: ">=2.1.0 || >=2.1.0-dev || >=2.2.0-dev || >=2.3.0-dev || >=2.4.0-dev || >=2.5.0-dev || >=2.6.0-dev || >=2.7.0-dev || >=2.8.0-dev || >=2.9.0-dev || >= 3.0.0-dev || >= 3.1.0-dev"
+  checksum: 10c0/e37794513526dbf1cf960414d0a65b956ad319dbc93171bccfe08e3fece1eea35b4e130153f41d917a0f28ecac04f3ca78e9a99c4bddc64a5f225925abc0cf14
+  languageName: node
+  linkType: hard
+
+"tsutils@npm:^3.21.0":
+  version: 3.21.0
+  resolution: "tsutils@npm:3.21.0"
+  dependencies:
+    tslib: "npm:^1.8.1"
+  peerDependencies:
+    typescript: ">=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta"
+  checksum: 10c0/02f19e458ec78ead8fffbf711f834ad8ecd2cc6ade4ec0320790713dccc0a412b99e7fd907c4cda2a1dc602c75db6f12e0108e87a5afad4b2f9e90a24cabd5a2
+  languageName: node
+  linkType: hard
+
+"type-check@npm:^0.4.0, type-check@npm:~0.4.0":
+  version: 0.4.0
+  resolution: "type-check@npm:0.4.0"
+  dependencies:
+    prelude-ls: "npm:^1.2.1"
+  checksum: 10c0/7b3fd0ed43891e2080bf0c5c504b418fbb3e5c7b9708d3d015037ba2e6323a28152ec163bcb65212741fa5d2022e3075ac3c76440dbd344c9035f818e8ecee58
+  languageName: node
+  linkType: hard
+
+"type-detect@npm:^4.0.0, type-detect@npm:^4.1.0":
+  version: 4.1.0
+  resolution: "type-detect@npm:4.1.0"
+  checksum: 10c0/df8157ca3f5d311edc22885abc134e18ff8ffbc93d6a9848af5b682730ca6a5a44499259750197250479c5331a8a75b5537529df5ec410622041650a7f293e2a
+  languageName: node
+  linkType: hard
+
+"type-fest@npm:^0.20.2":
+  version: 0.20.2
+  resolution: "type-fest@npm:0.20.2"
+  checksum: 10c0/dea9df45ea1f0aaa4e2d3bed3f9a0bfe9e5b2592bddb92eb1bf06e50bcf98dbb78189668cd8bc31a0511d3fc25539b4cd5c704497e53e93e2d40ca764b10bfc3
+  languageName: node
+  linkType: hard
+
+"type-fest@npm:^1.0.1, type-fest@npm:^1.2.1, type-fest@npm:^1.2.2":
+  version: 1.4.0
+  resolution: "type-fest@npm:1.4.0"
+  checksum: 10c0/a3c0f4ee28ff6ddf800d769eafafcdeab32efa38763c1a1b8daeae681920f6e345d7920bf277245235561d8117dab765cb5f829c76b713b4c9de0998a5397141
+  languageName: node
+  linkType: hard
+
+"typed-array-buffer@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "typed-array-buffer@npm:1.0.3"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    es-errors: "npm:^1.3.0"
+    is-typed-array: "npm:^1.1.14"
+  checksum: 10c0/1105071756eb248774bc71646bfe45b682efcad93b55532c6ffa4518969fb6241354e4aa62af679ae83899ec296d69ef88f1f3763657cdb3a4d29321f7b83079
+  languageName: node
+  linkType: hard
+
+"typed-array-byte-length@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "typed-array-byte-length@npm:1.0.3"
+  dependencies:
+    call-bind: "npm:^1.0.8"
+    for-each: "npm:^0.3.3"
+    gopd: "npm:^1.2.0"
+    has-proto: "npm:^1.2.0"
+    is-typed-array: "npm:^1.1.14"
+  checksum: 10c0/6ae083c6f0354f1fce18b90b243343b9982affd8d839c57bbd2c174a5d5dc71be9eb7019ffd12628a96a4815e7afa85d718d6f1e758615151d5f35df841ffb3e
+  languageName: node
+  linkType: hard
+
+"typed-array-byte-offset@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "typed-array-byte-offset@npm:1.0.4"
+  dependencies:
+    available-typed-arrays: "npm:^1.0.7"
+    call-bind: "npm:^1.0.8"
+    for-each: "npm:^0.3.3"
+    gopd: "npm:^1.2.0"
+    has-proto: "npm:^1.2.0"
+    is-typed-array: "npm:^1.1.15"
+    reflect.getprototypeof: "npm:^1.0.9"
+  checksum: 10c0/3d805b050c0c33b51719ee52de17c1cd8e6a571abdf0fffb110e45e8dd87a657e8b56eee94b776b13006d3d347a0c18a730b903cf05293ab6d92e99ff8f77e53
+  languageName: node
+  linkType: hard
+
+"typed-array-length@npm:^1.0.7":
+  version: 1.0.7
+  resolution: "typed-array-length@npm:1.0.7"
+  dependencies:
+    call-bind: "npm:^1.0.7"
+    for-each: "npm:^0.3.3"
+    gopd: "npm:^1.0.1"
+    is-typed-array: "npm:^1.1.13"
+    possible-typed-array-names: "npm:^1.0.0"
+    reflect.getprototypeof: "npm:^1.0.6"
+  checksum: 10c0/e38f2ae3779584c138a2d8adfa8ecf749f494af3cd3cdafe4e688ce51418c7d2c5c88df1bd6be2bbea099c3f7cea58c02ca02ed438119e91f162a9de23f61295
+  languageName: node
+  linkType: hard
+
+"typescript@npm:5.0.3":
+  version: 5.0.3
+  resolution: "typescript@npm:5.0.3"
+  bin:
+    tsc: bin/tsc
+    tsserver: bin/tsserver
+  checksum: 10c0/13221c7f7dd2aa9cf8ac2fb1b5ca3825ff3d97a43b4656fd22ca36c0ec30179643b5157d620c3e4af9d3fc9234a571bd3ea175624b3d37c494d7ed159b038df2
+  languageName: node
+  linkType: hard
+
+"typescript@npm:>=5":
+  version: 5.9.3
+  resolution: "typescript@npm:5.9.3"
+  bin:
+    tsc: bin/tsc
+    tsserver: bin/tsserver
+  checksum: 10c0/6bd7552ce39f97e711db5aa048f6f9995b53f1c52f7d8667c1abdc1700c68a76a308f579cd309ce6b53646deb4e9a1be7c813a93baaf0a28ccd536a30270e1c5
+  languageName: node
+  linkType: hard
+
+"typescript@patch:typescript@npm%3A5.0.3#optional!builtin<compat/typescript>":
+  version: 5.0.3
+  resolution: "typescript@patch:typescript@npm%3A5.0.3#optional!builtin<compat/typescript>::version=5.0.3&hash=b5f058"
+  bin:
+    tsc: bin/tsc
+    tsserver: bin/tsserver
+  checksum: 10c0/381de1b58d2deb6443cc7d23365b4db36de8360dfc4f4d295ca2fdb0e01687711fb541478838fb9326da315baf6967d616c745d990f2c362036b337a12b18255
+  languageName: node
+  linkType: hard
+
+"typescript@patch:typescript@npm%3A>=5#optional!builtin<compat/typescript>":
+  version: 5.9.3
+  resolution: "typescript@patch:typescript@npm%3A5.9.3#optional!builtin<compat/typescript>::version=5.9.3&hash=5786d5"
+  bin:
+    tsc: bin/tsc
+    tsserver: bin/tsserver
+  checksum: 10c0/ad09fdf7a756814dce65bc60c1657b40d44451346858eea230e10f2e95a289d9183b6e32e5c11e95acc0ccc214b4f36289dcad4bf1886b0adb84d711d336a430
+  languageName: node
+  linkType: hard
+
+"ufo@npm:^1.6.1":
+  version: 1.6.1
+  resolution: "ufo@npm:1.6.1"
+  checksum: 10c0/5a9f041e5945fba7c189d5410508cbcbefef80b253ed29aa2e1f8a2b86f4bd51af44ee18d4485e6d3468c92be9bf4a42e3a2b72dcaf27ce39ce947ec994f1e6b
+  languageName: node
+  linkType: hard
+
+"unbox-primitive@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "unbox-primitive@npm:1.1.0"
+  dependencies:
+    call-bound: "npm:^1.0.3"
+    has-bigints: "npm:^1.0.2"
+    has-symbols: "npm:^1.1.0"
+    which-boxed-primitive: "npm:^1.1.1"
+  checksum: 10c0/7dbd35ab02b0e05fe07136c72cb9355091242455473ec15057c11430129bab38b7b3624019b8778d02a881c13de44d63cd02d122ee782fb519e1de7775b5b982
+  languageName: node
+  linkType: hard
+
+"undici-types@npm:~5.26.4":
+  version: 5.26.5
+  resolution: "undici-types@npm:5.26.5"
+  checksum: 10c0/bb673d7876c2d411b6eb6c560e0c571eef4a01c1c19925175d16e3a30c4c428181fb8d7ae802a261f283e4166a0ac435e2f505743aa9e45d893f9a3df017b501
+  languageName: node
+  linkType: hard
+
+"uniq@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "uniq@npm:1.0.1"
+  checksum: 10c0/369dca4a07fdd8de9e48378b9d4b6861722ca71d5f496e91687916bd4b48b8cf3d6db1677be1b40eea63bc6d4728efb4b4e0bd7a89c5fd2d23e7a2cff8009c7a
+  languageName: node
+  linkType: hard
+
+"unique-filename@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "unique-filename@npm:4.0.0"
+  dependencies:
+    unique-slug: "npm:^5.0.0"
+  checksum: 10c0/38ae681cceb1408ea0587b6b01e29b00eee3c84baee1e41fd5c16b9ed443b80fba90c40e0ba69627e30855570a34ba8b06702d4a35035d4b5e198bf5a64c9ddc
+  languageName: node
+  linkType: hard
+
+"unique-slug@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "unique-slug@npm:5.0.0"
+  dependencies:
+    imurmurhash: "npm:^0.1.4"
+  checksum: 10c0/d324c5a44887bd7e105ce800fcf7533d43f29c48757ac410afd42975de82cc38ea2035c0483f4de82d186691bf3208ef35c644f73aa2b1b20b8e651be5afd293
+  languageName: node
+  linkType: hard
+
+"universalify@npm:^0.2.0":
+  version: 0.2.0
+  resolution: "universalify@npm:0.2.0"
+  checksum: 10c0/cedbe4d4ca3967edf24c0800cfc161c5a15e240dac28e3ce575c689abc11f2c81ccc6532c8752af3b40f9120fb5e454abecd359e164f4f6aa44c29cd37e194fe
+  languageName: node
+  linkType: hard
+
+"universalify@npm:^2.0.0":
+  version: 2.0.1
+  resolution: "universalify@npm:2.0.1"
+  checksum: 10c0/73e8ee3809041ca8b818efb141801a1004e3fc0002727f1531f4de613ea281b494a40909596dae4a042a4fb6cd385af5d4db2e137b1362e0e91384b828effd3a
+  languageName: node
+  linkType: hard
+
+"update-browserslist-db@npm:^1.1.4":
+  version: 1.1.4
+  resolution: "update-browserslist-db@npm:1.1.4"
+  dependencies:
+    escalade: "npm:^3.2.0"
+    picocolors: "npm:^1.1.1"
+  peerDependencies:
+    browserslist: ">= 4.21.0"
+  bin:
+    update-browserslist-db: cli.js
+  checksum: 10c0/db0c9aaecf1258a6acda5e937fc27a7996ccca7a7580a1b4aa8bba6a9b0e283e5e65c49ebbd74ec29288ef083f1b88d4da13e3d4d326c1e5fc55bf72d7390702
+  languageName: node
+  linkType: hard
+
+"uri-js@npm:^4.2.2":
+  version: 4.4.1
+  resolution: "uri-js@npm:4.4.1"
+  dependencies:
+    punycode: "npm:^2.1.0"
+  checksum: 10c0/4ef57b45aa820d7ac6496e9208559986c665e49447cb072744c13b66925a362d96dd5a46c4530a6b8e203e5db5fe849369444440cb22ecfc26c679359e5dfa3c
+  languageName: node
+  linkType: hard
+
+"url-parse@npm:^1.5.3":
+  version: 1.5.10
+  resolution: "url-parse@npm:1.5.10"
+  dependencies:
+    querystringify: "npm:^2.1.1"
+    requires-port: "npm:^1.0.0"
+  checksum: 10c0/bd5aa9389f896974beb851c112f63b466505a04b4807cea2e5a3b7092f6fbb75316f0491ea84e44f66fed55f1b440df5195d7e3a8203f64fcefa19d182f5be87
+  languageName: node
+  linkType: hard
+
+"util-deprecate@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "util-deprecate@npm:1.0.2"
+  checksum: 10c0/41a5bdd214df2f6c3ecf8622745e4a366c4adced864bc3c833739791aeeeb1838119af7daed4ba36428114b5c67dcda034a79c882e97e43c03e66a4dd7389942
+  languageName: node
+  linkType: hard
+
+"validate-npm-package-license@npm:^3.0.1":
+  version: 3.0.4
+  resolution: "validate-npm-package-license@npm:3.0.4"
+  dependencies:
+    spdx-correct: "npm:^3.0.0"
+    spdx-expression-parse: "npm:^3.0.0"
+  checksum: 10c0/7b91e455a8de9a0beaa9fe961e536b677da7f48c9a493edf4d4d4a87fd80a7a10267d438723364e432c2fcd00b5650b5378275cded362383ef570276e6312f4f
+  languageName: node
+  linkType: hard
+
+"vite-node@npm:1.6.1":
+  version: 1.6.1
+  resolution: "vite-node@npm:1.6.1"
+  dependencies:
+    cac: "npm:^6.7.14"
+    debug: "npm:^4.3.4"
+    pathe: "npm:^1.1.1"
+    picocolors: "npm:^1.0.0"
+    vite: "npm:^5.0.0"
+  bin:
+    vite-node: vite-node.mjs
+  checksum: 10c0/4d96da9f11bd0df8b60c46e65a740edaad7dd2d1aff3cdb3da5714ea8c10b5f2683111b60bfe45545c7e8c1f33e7e8a5095573d5e9ba55f50a845233292c2e02
+  languageName: node
+  linkType: hard
+
+"vite-plugin-css-injected-by-js@npm:^3.1.0":
+  version: 3.5.2
+  resolution: "vite-plugin-css-injected-by-js@npm:3.5.2"
+  peerDependencies:
+    vite: ">2.0.0-0"
+  checksum: 10c0/5c6a2434d4f302640a4bfc7695d56cf83eca03a4f89f05820057fedd8a2e788186105942360d19808042872ba0970ed6b1c04cd02337bbe67d8321993a464c04
+  languageName: node
+  linkType: hard
+
+"vite@npm:^4.2.1":
+  version: 4.5.14
+  resolution: "vite@npm:4.5.14"
+  dependencies:
+    esbuild: "npm:^0.18.10"
+    fsevents: "npm:~2.3.2"
+    postcss: "npm:^8.4.27"
+    rollup: "npm:^3.27.1"
+  peerDependencies:
+    "@types/node": ">= 14"
+    less: "*"
+    lightningcss: ^1.21.0
+    sass: "*"
+    stylus: "*"
+    sugarss: "*"
+    terser: ^5.4.0
+  dependenciesMeta:
+    fsevents:
+      optional: true
+  peerDependenciesMeta:
+    "@types/node":
+      optional: true
+    less:
+      optional: true
+    lightningcss:
+      optional: true
+    sass:
+      optional: true
+    stylus:
+      optional: true
+    sugarss:
+      optional: true
+    terser:
+      optional: true
+  bin:
+    vite: bin/vite.js
+  checksum: 10c0/58fdbb7e14650f78ebe290bb67f873900b914cee906c7367ad1c9786fb323ec60c3f085447341953b5e411a17703f86ed33723b31f98778d94f0ead06370b306
+  languageName: node
+  linkType: hard
+
+"vite@npm:^5.0.0":
+  version: 5.4.21
+  resolution: "vite@npm:5.4.21"
+  dependencies:
+    esbuild: "npm:^0.21.3"
+    fsevents: "npm:~2.3.3"
+    postcss: "npm:^8.4.43"
+    rollup: "npm:^4.20.0"
+  peerDependencies:
+    "@types/node": ^18.0.0 || >=20.0.0
+    less: "*"
+    lightningcss: ^1.21.0
+    sass: "*"
+    sass-embedded: "*"
+    stylus: "*"
+    sugarss: "*"
+    terser: ^5.4.0
+  dependenciesMeta:
+    fsevents:
+      optional: true
+  peerDependenciesMeta:
+    "@types/node":
+      optional: true
+    less:
+      optional: true
+    lightningcss:
+      optional: true
+    sass:
+      optional: true
+    sass-embedded:
+      optional: true
+    stylus:
+      optional: true
+    sugarss:
+      optional: true
+    terser:
+      optional: true
+  bin:
+    vite: bin/vite.js
+  checksum: 10c0/468336a1409f728b464160cbf02672e72271fb688d0e605e776b74a89d27e1029509eef3a3a6c755928d8011e474dbf234824d054d07960be5f23cd176bc72de
+  languageName: node
+  linkType: hard
+
+"vitest@npm:^1.0.0":
+  version: 1.6.1
+  resolution: "vitest@npm:1.6.1"
+  dependencies:
+    "@vitest/expect": "npm:1.6.1"
+    "@vitest/runner": "npm:1.6.1"
+    "@vitest/snapshot": "npm:1.6.1"
+    "@vitest/spy": "npm:1.6.1"
+    "@vitest/utils": "npm:1.6.1"
+    acorn-walk: "npm:^8.3.2"
+    chai: "npm:^4.3.10"
+    debug: "npm:^4.3.4"
+    execa: "npm:^8.0.1"
+    local-pkg: "npm:^0.5.0"
+    magic-string: "npm:^0.30.5"
+    pathe: "npm:^1.1.1"
+    picocolors: "npm:^1.0.0"
+    std-env: "npm:^3.5.0"
+    strip-literal: "npm:^2.0.0"
+    tinybench: "npm:^2.5.1"
+    tinypool: "npm:^0.8.3"
+    vite: "npm:^5.0.0"
+    vite-node: "npm:1.6.1"
+    why-is-node-running: "npm:^2.2.2"
+  peerDependencies:
+    "@edge-runtime/vm": "*"
+    "@types/node": ^18.0.0 || >=20.0.0
+    "@vitest/browser": 1.6.1
+    "@vitest/ui": 1.6.1
+    happy-dom: "*"
+    jsdom: "*"
+  peerDependenciesMeta:
+    "@edge-runtime/vm":
+      optional: true
+    "@types/node":
+      optional: true
+    "@vitest/browser":
+      optional: true
+    "@vitest/ui":
+      optional: true
+    happy-dom:
+      optional: true
+    jsdom:
+      optional: true
+  bin:
+    vitest: vitest.mjs
+  checksum: 10c0/511d27d7f697683964826db2fad7ac303f9bc7eeb59d9422111dc488371ccf1f9eed47ac3a80eb47ca86b7242228ba5ca9cc3613290830d0e916973768cac215
+  languageName: node
+  linkType: hard
+
+"void-elements@npm:^3.1.0":
+  version: 3.1.0
+  resolution: "void-elements@npm:3.1.0"
+  checksum: 10c0/0b8686f9f9aa44012e9bd5eabf287ae0cde409b9a2854c5a2335cb83920c957668ac5876e3f0d158dd424744ac411a7270e64128556b451ed3bec875ef18534d
+  languageName: node
+  linkType: hard
+
+"w3c-xmlserializer@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "w3c-xmlserializer@npm:5.0.0"
+  dependencies:
+    xml-name-validator: "npm:^5.0.0"
+  checksum: 10c0/8712774c1aeb62dec22928bf1cdfd11426c2c9383a1a63f2bcae18db87ca574165a0fbe96b312b73652149167ac6c7f4cf5409f2eb101d9c805efe0e4bae798b
+  languageName: node
+  linkType: hard
+
+"webidl-conversions@npm:^7.0.0":
+  version: 7.0.0
+  resolution: "webidl-conversions@npm:7.0.0"
+  checksum: 10c0/228d8cb6d270c23b0720cb2d95c579202db3aaf8f633b4e9dd94ec2000a04e7e6e43b76a94509cdb30479bd00ae253ab2371a2da9f81446cc313f89a4213a2c4
+  languageName: node
+  linkType: hard
+
+"whatwg-encoding@npm:^3.1.1":
+  version: 3.1.1
+  resolution: "whatwg-encoding@npm:3.1.1"
+  dependencies:
+    iconv-lite: "npm:0.6.3"
+  checksum: 10c0/273b5f441c2f7fda3368a496c3009edbaa5e43b71b09728f90425e7f487e5cef9eb2b846a31bd760dd8077739c26faf6b5ca43a5f24033172b003b72cf61a93e
+  languageName: node
+  linkType: hard
+
+"whatwg-mimetype@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "whatwg-mimetype@npm:4.0.0"
+  checksum: 10c0/a773cdc8126b514d790bdae7052e8bf242970cebd84af62fb2f35a33411e78e981f6c0ab9ed1fe6ec5071b09d5340ac9178e05b52d35a9c4bcf558ba1b1551df
+  languageName: node
+  linkType: hard
+
+"whatwg-url@npm:^14.0.0":
+  version: 14.2.0
+  resolution: "whatwg-url@npm:14.2.0"
+  dependencies:
+    tr46: "npm:^5.1.0"
+    webidl-conversions: "npm:^7.0.0"
+  checksum: 10c0/f746fc2f4c906607d09537de1227b13f9494c171141e5427ed7d2c0dd0b6a48b43d8e71abaae57d368d0c06b673fd8ec63550b32ad5ed64990c7b0266c2b4272
+  languageName: node
+  linkType: hard
+
+"which-boxed-primitive@npm:^1.1.0, which-boxed-primitive@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "which-boxed-primitive@npm:1.1.1"
+  dependencies:
+    is-bigint: "npm:^1.1.0"
+    is-boolean-object: "npm:^1.2.1"
+    is-number-object: "npm:^1.1.1"
+    is-string: "npm:^1.1.1"
+    is-symbol: "npm:^1.1.1"
+  checksum: 10c0/aceea8ede3b08dede7dce168f3883323f7c62272b49801716e8332ff750e7ae59a511ae088840bc6874f16c1b7fd296c05c949b0e5b357bfe3c431b98c417abe
+  languageName: node
+  linkType: hard
+
+"which-builtin-type@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "which-builtin-type@npm:1.2.1"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    function.prototype.name: "npm:^1.1.6"
+    has-tostringtag: "npm:^1.0.2"
+    is-async-function: "npm:^2.0.0"
+    is-date-object: "npm:^1.1.0"
+    is-finalizationregistry: "npm:^1.1.0"
+    is-generator-function: "npm:^1.0.10"
+    is-regex: "npm:^1.2.1"
+    is-weakref: "npm:^1.0.2"
+    isarray: "npm:^2.0.5"
+    which-boxed-primitive: "npm:^1.1.0"
+    which-collection: "npm:^1.0.2"
+    which-typed-array: "npm:^1.1.16"
+  checksum: 10c0/8dcf323c45e5c27887800df42fbe0431d0b66b1163849bb7d46b5a730ad6a96ee8bfe827d078303f825537844ebf20c02459de41239a0a9805e2fcb3cae0d471
+  languageName: node
+  linkType: hard
+
+"which-collection@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "which-collection@npm:1.0.2"
+  dependencies:
+    is-map: "npm:^2.0.3"
+    is-set: "npm:^2.0.3"
+    is-weakmap: "npm:^2.0.2"
+    is-weakset: "npm:^2.0.3"
+  checksum: 10c0/3345fde20964525a04cdf7c4a96821f85f0cc198f1b2ecb4576e08096746d129eb133571998fe121c77782ac8f21cbd67745a3d35ce100d26d4e684c142ea1f2
+  languageName: node
+  linkType: hard
+
+"which-typed-array@npm:^1.1.16, which-typed-array@npm:^1.1.19":
+  version: 1.1.19
+  resolution: "which-typed-array@npm:1.1.19"
+  dependencies:
+    available-typed-arrays: "npm:^1.0.7"
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.4"
+    for-each: "npm:^0.3.5"
+    get-proto: "npm:^1.0.1"
+    gopd: "npm:^1.2.0"
+    has-tostringtag: "npm:^1.0.2"
+  checksum: 10c0/702b5dc878addafe6c6300c3d0af5983b175c75fcb4f2a72dfc3dd38d93cf9e89581e4b29c854b16ea37e50a7d7fca5ae42ece5c273d8060dcd603b2404bbb3f
+  languageName: node
+  linkType: hard
+
+"which@npm:^1.3.1":
+  version: 1.3.1
+  resolution: "which@npm:1.3.1"
+  dependencies:
+    isexe: "npm:^2.0.0"
+  bin:
+    which: ./bin/which
+  checksum: 10c0/e945a8b6bbf6821aaaef7f6e0c309d4b615ef35699576d5489b4261da9539f70393c6b2ce700ee4321c18f914ebe5644bc4631b15466ffbaad37d83151f6af59
+  languageName: node
+  linkType: hard
+
+"which@npm:^2.0.1, which@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "which@npm:2.0.2"
+  dependencies:
+    isexe: "npm:^2.0.0"
+  bin:
+    node-which: ./bin/node-which
+  checksum: 10c0/66522872a768b60c2a65a57e8ad184e5372f5b6a9ca6d5f033d4b0dc98aff63995655a7503b9c0a2598936f532120e81dd8cc155e2e92ed662a2b9377cc4374f
+  languageName: node
+  linkType: hard
+
+"which@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "which@npm:5.0.0"
+  dependencies:
+    isexe: "npm:^3.1.1"
+  bin:
+    node-which: bin/which.js
+  checksum: 10c0/e556e4cd8b7dbf5df52408c9a9dd5ac6518c8c5267c8953f5b0564073c66ed5bf9503b14d876d0e9c7844d4db9725fb0dcf45d6e911e17e26ab363dc3965ae7b
+  languageName: node
+  linkType: hard
+
+"why-is-node-running@npm:^2.2.2":
+  version: 2.3.0
+  resolution: "why-is-node-running@npm:2.3.0"
+  dependencies:
+    siginfo: "npm:^2.0.0"
+    stackback: "npm:0.0.2"
+  bin:
+    why-is-node-running: cli.js
+  checksum: 10c0/1cde0b01b827d2cf4cb11db962f3958b9175d5d9e7ac7361d1a7b0e2dc6069a263e69118bd974c4f6d0a890ef4eedfe34cf3d5167ec14203dbc9a18620537054
+  languageName: node
+  linkType: hard
+
+"with@npm:^7.0.0":
+  version: 7.0.2
+  resolution: "with@npm:7.0.2"
+  dependencies:
+    "@babel/parser": "npm:^7.9.6"
+    "@babel/types": "npm:^7.9.6"
+    assert-never: "npm:^1.2.1"
+    babel-walk: "npm:3.0.0-canary-5"
+  checksum: 10c0/99289e49afc4b1776afae0ef85e84cfa775e8e07464d2b9853a31b0822347031d1cf77f287d25adc8c3f81e4fa68f4ee31526a9c95d4981ba08a1fe24dee111a
+  languageName: node
+  linkType: hard
+
+"word-wrap@npm:^1.2.5":
+  version: 1.2.5
+  resolution: "word-wrap@npm:1.2.5"
+  checksum: 10c0/e0e4a1ca27599c92a6ca4c32260e8a92e8a44f4ef6ef93f803f8ed823f486e0889fc0b93be4db59c8d51b3064951d25e43d434e95dc8c960cc3a63d65d00ba20
+  languageName: node
+  linkType: hard
+
+"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0":
+  version: 7.0.0
+  resolution: "wrap-ansi@npm:7.0.0"
+  dependencies:
+    ansi-styles: "npm:^4.0.0"
+    string-width: "npm:^4.1.0"
+    strip-ansi: "npm:^6.0.0"
+  checksum: 10c0/d15fc12c11e4cbc4044a552129ebc75ee3f57aa9c1958373a4db0292d72282f54373b536103987a4a7594db1ef6a4f10acf92978f79b98c49306a4b58c77d4da
+  languageName: node
+  linkType: hard
+
+"wrap-ansi@npm:^8.1.0":
+  version: 8.1.0
+  resolution: "wrap-ansi@npm:8.1.0"
+  dependencies:
+    ansi-styles: "npm:^6.1.0"
+    string-width: "npm:^5.0.1"
+    strip-ansi: "npm:^7.0.1"
+  checksum: 10c0/138ff58a41d2f877eae87e3282c0630fc2789012fc1af4d6bd626eeb9a2f9a65ca92005e6e69a75c7b85a68479fe7443c7dbe1eb8fbaa681a4491364b7c55c60
+  languageName: node
+  linkType: hard
+
+"wrappy@npm:1":
+  version: 1.0.2
+  resolution: "wrappy@npm:1.0.2"
+  checksum: 10c0/56fece1a4018c6a6c8e28fbc88c87e0fbf4ea8fd64fc6c63b18f4acc4bd13e0ad2515189786dd2c30d3eec9663d70f4ecf699330002f8ccb547e4a18231fc9f0
+  languageName: node
+  linkType: hard
+
+"write-file-atomic@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "write-file-atomic@npm:5.0.1"
+  dependencies:
+    imurmurhash: "npm:^0.1.4"
+    signal-exit: "npm:^4.0.1"
+  checksum: 10c0/e8c850a8e3e74eeadadb8ad23c9d9d63e4e792bd10f4836ed74189ef6e996763959f1249c5650e232f3c77c11169d239cbfc8342fc70f3fe401407d23810505d
+  languageName: node
+  linkType: hard
+
+"ws@npm:^8.16.0":
+  version: 8.18.3
+  resolution: "ws@npm:8.18.3"
+  peerDependencies:
+    bufferutil: ^4.0.1
+    utf-8-validate: ">=5.0.2"
+  peerDependenciesMeta:
+    bufferutil:
+      optional: true
+    utf-8-validate:
+      optional: true
+  checksum: 10c0/eac918213de265ef7cb3d4ca348b891a51a520d839aa51cdb8ca93d4fa7ff9f6ccb339ccee89e4075324097f0a55157c89fa3f7147bde9d8d7e90335dc087b53
+  languageName: node
+  linkType: hard
+
+"xml-name-validator@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "xml-name-validator@npm:5.0.0"
+  checksum: 10c0/3fcf44e7b73fb18be917fdd4ccffff3639373c7cb83f8fc35df6001fecba7942f1dbead29d91ebb8315e2f2ff786b508f0c9dc0215b6353f9983c6b7d62cb1f5
+  languageName: node
+  linkType: hard
+
+"xmlchars@npm:^2.2.0":
+  version: 2.2.0
+  resolution: "xmlchars@npm:2.2.0"
+  checksum: 10c0/b64b535861a6f310c5d9bfa10834cf49127c71922c297da9d4d1b45eeaae40bf9b4363275876088fbe2667e5db028d2cd4f8ee72eed9bede840a67d57dab7593
+  languageName: node
+  linkType: hard
+
+"yallist@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "yallist@npm:4.0.0"
+  checksum: 10c0/2286b5e8dbfe22204ab66e2ef5cc9bbb1e55dfc873bbe0d568aa943eb255d131890dfd5bf243637273d31119b870f49c18fcde2c6ffbb7a7a092b870dc90625a
+  languageName: node
+  linkType: hard
+
+"yallist@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "yallist@npm:5.0.0"
+  checksum: 10c0/a499c81ce6d4a1d260d4ea0f6d49ab4da09681e32c3f0472dee16667ed69d01dae63a3b81745a24bd78476ec4fcf856114cb4896ace738e01da34b2c42235416
+  languageName: node
+  linkType: hard
+
+"yargs-parser@npm:^20.2.9":
+  version: 20.2.9
+  resolution: "yargs-parser@npm:20.2.9"
+  checksum: 10c0/0685a8e58bbfb57fab6aefe03c6da904a59769bd803a722bb098bd5b0f29d274a1357762c7258fb487512811b8063fb5d2824a3415a0a4540598335b3b086c72
+  languageName: node
+  linkType: hard
+
+"yocto-queue@npm:^0.1.0":
+  version: 0.1.0
+  resolution: "yocto-queue@npm:0.1.0"
+  checksum: 10c0/dceb44c28578b31641e13695d200d34ec4ab3966a5729814d5445b194933c096b7ced71494ce53a0e8820685d1d010df8b2422e5bf2cdea7e469d97ffbea306f
+  languageName: node
+  linkType: hard
+
+"yocto-queue@npm:^1.0.0":
+  version: 1.2.1
+  resolution: "yocto-queue@npm:1.2.1"
+  checksum: 10c0/5762caa3d0b421f4bdb7a1926b2ae2189fc6e4a14469258f183600028eb16db3e9e0306f46e8ebf5a52ff4b81a881f22637afefbef5399d6ad440824e9b27f9f
+  languageName: node
+  linkType: hard