@contentful/field-editor-rich-text 3.3.5 → 3.4.0

package/dist/field-editor-rich-text.esm.js

@@ -2,7 +2,7 @@ import React__default, { createContext, useContext, useMemo, useState, useEffect
 import { MissingEntityCard, WrappedAssetCard, useEntity, useEntityLoader, WrappedEntryCard, ScheduledIconWithTooltip, EntityProvider, getScheduleTooltipContent } from '@contentful/field-editor-reference';
 import { entityHelpers, ModalDialogLauncher, FieldConnector } from '@contentful/field-editor-shared';
 import { BLOCKS, INLINES, TEXT_CONTAINERS, HEADINGS, LIST_ITEM_BLOCKS, MARKS, CONTAINERS, TOP_LEVEL_BLOCKS, VOID_BLOCKS, EMPTY_DOCUMENT } from '@contentful/rich-text-types';
-import { usePlateEditorRef, usePlateEditorState, toggleNodeType, getText, getAbove, removeMark, setMarks, isMarkActive, getNodes, setNodes, isAncestorEmpty, match, getLastChildPath, wrapNodes, getPluginType, unwrapNodes, isCollapsed, isRangeAcrossBlocks, ELEMENT_DEFAULT, findNode, getParent, getBlockAbove, isSelectionAtBlockStart, isSelectionAtBlockEnd, isFirstChild, insertNodes, moveChildren, isBlockAboveEmpty, mockPlugin, deleteFragment, toggleMark, someHtmlElement, KEY_DESERIALIZE_HTML, hasSingleChild, isLastChild, someNode, getChildren as getChildren$1, unsetNodes, queryNode, createDeserializeHtmlPlugin, createDeserializeAstPlugin, createPlateEditor, getPlateSelectors, getPlateActions, Plate } from '@udecode/plate-core';
+import { usePlateEditorRef, usePlateEditorState, getPlateSelectors as getPlateSelectors$1, withoutNormalizing as withoutNormalizing$1, createPlateEditor as createPlateEditor$1, blurEditor as blurEditor$1, toSlatePoint, mockPlugin as mockPlugin$1, focusEditor as focusEditor$1, selectEditor as selectEditor$1, getNodeEntries as getNodeEntries$1, isMarkActive as isMarkActive$1, getAboveNode as getAboveNode$1, getRange as getRange$1, isText as isText$1, isElement as isElement$1, getEditorString, getBlockAbove as getBlockAbove$1, getParentNode as getParentNode$1, getLastChildPath as getLastChildPath$1, someHtmlElement as someHtmlElement$1, isCollapsed, isInline as isInline$2, isEndPoint as isEndPoint$1, getPointAfter as getPointAfter$1, isFirstChild as isFirstChild$1, getNodeEntry as getNodeEntry$1, isEditor as isEditor$1, isEditorReadOnly as isEditorReadOnly$1, isRangeAcrossBlocks as isRangeAcrossBlocks$1, getPluginType as getPluginType$1, getCommonNode as getCommonNode$1, findNode as findNode$1, isBlock, match as match$1, isAncestorEmpty as isAncestorEmpty$1, isLastChild, getPointBefore as getPointBefore$1, queryNode as queryNode$1, isNode as isNode$1, getEndPoint as getEndPoint$1, getChildren as getChildren$1, findNodePath as findNodePath$1, getLastNodeByLevel as getLastNodeByLevel$1, createPathRef as createPathRef$1, getNodeTexts as getNodeTexts$1, isSelectionAtBlockStart as isSelectionAtBlockStart$1, getNodeChildren as getNodeChildren$1, isExpanded, isSelectionAtBlockEnd as isSelectionAtBlockEnd$1, someNode as someNode$1, getStartPoint as getStartPoint$1, getMarks as getMarks$1, wrapNodes as wrapNodes$1, insertNodes as insertNodes$1, unhangRange as unhangRange$1, setSelection as setSelection$1, unsetNodes as unsetNodes$1, removeMark as removeMark$1, addMark as addMark$1, removeNodes as removeNodes$1, unwrapNodes as unwrapNodes$1, liftNodes as liftNodes$1, select as select$1, toggleMark as toggleMark$1, normalizeEditor, setNodes as setNodes$1, toggleNodeType as toggleNodeType$1, deleteText as deleteText$1, deleteFragment as deleteFragment$1, splitNodes as splitNodes$1, moveSelection as moveSelection$1, insertText as insertText$1, collapseSelection as collapseSelection$1, moveChildren as moveChildren$1, moveNodes as moveNodes$1, ELEMENT_DEFAULT as ELEMENT_DEFAULT$1, isBlockAboveEmpty, KEY_DESERIALIZE_HTML, hasSingleChild, createDeserializeHtmlPlugin, createDeserializeAstPlugin, getPlateActions, Plate } from '@udecode/plate-core';
 import { css, cx } from 'emotion';
 import areEqual from 'fast-deep-equal';
 import noop from 'lodash-es/noop';
@@ -14,20 +14,20 @@ import { ScreenReaderOnly, Popover, SectionHeading, Stack, Flex, AssetCard, Entr
 import { Portal } from '@contentful/f36-utils';
 import constate from 'constate';
 import isHotkey from 'is-hotkey';
-import { Text, Element, Editor, Transforms, Range, Path, Node, Point } from 'slate';
-import { ReactEditor, useSelected, useReadOnly, useFocused } from 'slate-react';
+import { Path, Range, Text, Node, Element, Point } from 'slate';
 import find from 'lodash-es/find';
 import flow from 'lodash-es/flow';
 import get from 'lodash-es/get';
 import tokens from '@contentful/f36-tokens';
-import { AssetIcon, EmbeddedEntryBlockIcon, ClockIcon, EmbeddedEntryInlineIcon, ChevronDownIcon, HorizontalRuleIcon, LinkIcon, ListBulletedIcon, ListNumberedIcon, FormatBoldIcon, CodeIcon, FormatItalicIcon, FormatUnderlinedIcon, SuperscriptIcon, SubscriptIcon, QuoteIcon, TableIcon, PlusIcon, MoreHorizontalIcon } from '@contentful/f36-icons';
+import { useSelected, useReadOnly as useReadOnly$1, useFocused } from 'slate-react';
+import { AssetIcon, EmbeddedEntryBlockIcon, ClockIcon, EmbeddedEntryInlineIcon, ChevronDownIcon, HorizontalRuleIcon, LinkIcon, ListBulletedIcon, ListNumberedIcon, FormatBoldIcon, CodeIcon, FormatItalicIcon, SubscriptIcon, SuperscriptIcon, FormatUnderlinedIcon, QuoteIcon, TableIcon, PlusIcon, MoreHorizontalIcon } from '@contentful/f36-icons';
 import { getListTypes, ELEMENT_LIC, getListItemEntry, isListNested, moveListItemUp, ELEMENT_LI, unwrapList as unwrapList$1, removeFirstListItem, removeListItem, deleteForwardList, deleteFragmentList, normalizeList, createListPlugin as createListPlugin$1, ELEMENT_UL, ELEMENT_OL } from '@udecode/plate-list';
 import castArray from 'lodash-es/castArray';
-import { createBoldPlugin as createBoldPlugin$1, createCodePlugin as createCodePlugin$1, createItalicPlugin as createItalicPlugin$1, createUnderlinePlugin as createUnderlinePlugin$1, createSuperscriptPlugin as createSuperscriptPlugin$1, createSubscriptPlugin as createSubscriptPlugin$1 } from '@udecode/plate-basic-marks';
+import { createBoldPlugin as createBoldPlugin$1, createCodePlugin as createCodePlugin$1, createItalicPlugin as createItalicPlugin$1, createSubscriptPlugin as createSubscriptPlugin$1, createSuperscriptPlugin as createSuperscriptPlugin$1, createUnderlinePlugin as createUnderlinePlugin$1 } from '@udecode/plate-basic-marks';
 import isPlainObject from 'is-plain-obj';
 import { createParagraphPlugin as createParagraphPlugin$1 } from '@udecode/plate-paragraph';
 import { createSelectOnBackspacePlugin as createSelectOnBackspacePlugin$1 } from '@udecode/plate-select';
-import { ELEMENT_TABLE, ELEMENT_TR, getEmptyRowNode, ELEMENT_TD, ELEMENT_TH, getEmptyCellNode, insertTable, deleteRow, deleteColumn, deleteTable, onKeyDownTable as onKeyDownTable$1, getTableCellEntry, createTablePlugin as createTablePlugin$1, withTable } from '@udecode/plate-table';
+import { getEmptyRowNode, getEmptyCellNode, ELEMENT_TABLE, ELEMENT_TH, ELEMENT_TR, ELEMENT_TD, deleteRow, deleteColumn, deleteTable, onKeyDownTable as onKeyDownTable$1, getTableEntries, createTablePlugin as createTablePlugin$1, withTable } from '@udecode/plate-table';
 import { toContentfulDocument, toSlatejsDocument } from '@contentful/contentful-slatejs-adapter';
 import { documentToPlainTextString } from '@contentful/rich-text-plain-text-renderer';
 import { createTrailingBlockPlugin } from '@udecode/plate-trailing-block';
@@ -276,6 +276,43 @@ function useContentfulEditorRef(id) {
   return editor;
 }
 
+var createPlateEditor = function createPlateEditor(options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  return createPlateEditor$1(options);
+};
+var withoutNormalizing = function withoutNormalizing(editor, fn) {
+  return withoutNormalizing$1(editor, fn);
+};
+var focusEditor = function focusEditor(editor, target) {
+  focusEditor$1(editor, target);
+};
+var blurEditor = function blurEditor(editor) {
+  blurEditor$1(editor);
+};
+var selectEditor = function selectEditor(editor, opts) {
+  selectEditor$1(editor, opts);
+};
+var fromDOMPoint = function fromDOMPoint(editor, domPoint, opts) {
+  if (opts === void 0) {
+    opts = {
+      exactMatch: false,
+      suppressThrow: false
+    };
+  }
+
+  return toSlatePoint(editor, domPoint, opts);
+};
+var mockPlugin = function mockPlugin(plugin) {
+  return mockPlugin$1( // TODO check if there is a way around this ugly casting
+  plugin);
+};
+var getPlateSelectors = function getPlateSelectors(id) {
+  return getPlateSelectors$1(id);
+};
+
 var createSoftBreakPlugin = function createSoftBreakPlugin() {
   return createSoftBreakPlugin$1({
     then: function then(editor) {
@@ -465,14 +502,280 @@ var useCommandList = function useCommandList(commandItems, container) {
   };
 };
 
+/**
+ * Get text content at location
+ */
+
+var getText = function getText(editor, at) {
+  return getEditorString(editor, at);
+};
+var isText = function isText(value) {
+  return isText$1(value);
+};
+var getEndPoint = function getEndPoint(editor, at) {
+  return getEndPoint$1(editor, at);
+};
+var getStartPoint = function getStartPoint(editor, at) {
+  return getStartPoint$1(editor, at);
+};
+var isNode = function isNode(value) {
+  return isNode$1(value);
+};
+var isSelectionAtBlockEnd = function isSelectionAtBlockEnd(editor, options) {
+  return isSelectionAtBlockEnd$1(editor, options);
+};
+var isSelectionAtBlockStart = function isSelectionAtBlockStart(editor, options) {
+  return isSelectionAtBlockStart$1(editor, options);
+};
+var getBlockAbove = function getBlockAbove(editor, options) {
+  return getBlockAbove$1(editor, options);
+};
+var getNodeEntry = function getNodeEntry(editor, at, options) {
+  return getNodeEntry$1(editor, at, options);
+};
+var getNodeEntries = function getNodeEntries(editor, options) {
+  return getNodeEntries$1(editor, options);
+}; // TODO: Ancestor may not be the correct type for root
+
+var getNodeChildren = function getNodeChildren(root, path, options) {
+  return getNodeChildren$1(root, path, options);
+};
+var getParentNode = function getParentNode(editor, at, options) {
+  return getParentNode$1(editor, at, options);
+};
+var someNode = function someNode(editor, options) {
+  return someNode$1(editor, options);
+};
+var getChildren = function getChildren(entry) {
+  // Node.children crashes when given a text node
+  if (Text.isText(entry[0])) {
+    return [];
+  }
+
+  return getChildren$1(entry);
+};
+var isFirstChild = function isFirstChild(path) {
+  return isFirstChild$1(path);
+};
+var getDescendantNodeByPath = function getDescendantNodeByPath(root, path) {
+  // @ts-expect-error
+  return Node.get(root, path);
+};
+var isRangeCollapsed = function isRangeCollapsed(range) {
+  return isCollapsed(range);
+}; // TODO: simplify
+
+var isRangeAcrossBlocks = function isRangeAcrossBlocks(editor, options) {
+  return isRangeAcrossBlocks$1(editor, options);
+};
+var isRangeExpanded = function isRangeExpanded(range) {
+  return isExpanded(range);
+};
+var getRange = function getRange(editor, at, to) {
+  return getRange$1(editor, at, to);
+};
+var getRangeEdges = function getRangeEdges(range) {
+  return Range.edges(range);
+};
+var getRangeStart = function getRangeStart(range) {
+  return Range.start(range);
+};
+var getRangeEnd = function getRangeEnd(range) {
+  return Range.end(range);
+};
+var getAboveNode = function getAboveNode(editor, opts) {
+  return getAboveNode$1(editor, opts);
+};
+var getCommonNode = function getCommonNode(root, path, another) {
+  return getCommonNode$1(root, path, another);
+};
+var getNodeTexts = function getNodeTexts(root, opts) {
+  return getNodeTexts$1(root, opts);
+};
+var findNode = function findNode(editor, options) {
+  return findNode$1(editor, options);
+};
+var isMarkActive = function isMarkActive(editor, type) {
+  return isMarkActive$1(editor, type);
+};
+var getMarks = function getMarks(editor) {
+  return getMarks$1(editor);
+};
+var isEditor = function isEditor(value) {
+  return isEditor$1(value);
+};
+var isEditorReadOnly = function isEditorReadOnly(editor) {
+  return isEditorReadOnly$1(editor);
+};
+var isElement = function isElement(value) {
+  return isElement$1(value);
+};
+var isBlockNode = function isBlockNode(editor, value) {
+  return isBlock(editor, value);
+};
+var findNodePath = function findNodePath(editor, node) {
+  return findNodePath$1(editor, node);
+};
+var isAncestorPath = function isAncestorPath(path, another) {
+  return Path.isAncestor(path, another);
+};
+var isAncestorEmpty = function isAncestorEmpty(editor, node) {
+  return isAncestorEmpty$1(editor, node);
+};
+var getParentPath = function getParentPath(path) {
+  return Path.parent(path);
+};
+var getNextPath = function getNextPath(path) {
+  return Path.next(path);
+};
+var getPreviousPath = function getPreviousPath(path) {
+  return Path.previous(path);
+};
+var getLastChildPath = function getLastChildPath(nodeEntry) {
+  return getLastChildPath$1(nodeEntry);
+};
+var getPathLevels = function getPathLevels(path, options) {
+  return Path.levels(path, options);
+};
+var isFirstChildPath = function isFirstChildPath(path) {
+  return isFirstChild$1(path);
+};
+var isLastChildPath = function isLastChildPath(entry, childPath) {
+  return isLastChild(entry, childPath);
+};
+var matchNode = function matchNode(node, path, fn) {
+  return match$1(node, path, fn);
+};
+var someHtmlElement = function someHtmlElement(rootNode, predicate) {
+  return someHtmlElement$1(rootNode, predicate);
+};
+var getPointBefore = function getPointBefore(editor, at, options) {
+  return getPointBefore$1(editor, at, options);
+};
+var getPointAfter = function getPointAfter(editor, at, options) {
+  return getPointAfter$1(editor, at, options);
+};
+var isEndPoint = function isEndPoint(editor, point, at) {
+  return isEndPoint$1(editor, point, at);
+};
+var isInline = function isInline(editor, value) {
+  return isInline$2(editor, value);
+};
+var queryNode = function queryNode(entry, options) {
+  return queryNode$1(entry, options);
+};
+var getPluginType = function getPluginType(editor, key) {
+  return getPluginType$1(editor, key);
+};
+var createPathRef = function createPathRef(editor, at) {
+  return createPathRef$1(editor, at);
+};
+var match = function match(obj, path, predicate) {
+  return match$1(obj, path, predicate);
+};
+var getLastNodeByLevel = function getLastNodeByLevel(editor, level) {
+  return getLastNodeByLevel$1(editor, level);
+};
+
+/**
+ * Apply editor normalization rules
+ */
+
+var normalize = function normalize(editor, options) {
+  if (options === void 0) {
+    options = {
+      force: true
+    };
+  }
+
+  return normalizeEditor(editor, options);
+};
+/**
+ * Set the selection to a location
+ */
+
+var setSelection = function setSelection(editor, props) {
+  return setSelection$1(editor, props);
+};
+var select = function select(editor, location) {
+  return select$1(editor, location);
+};
+var moveSelection = function moveSelection(editor, options) {
+  return moveSelection$1(editor, options);
+};
+var moveChildren = function moveChildren(editor, options) {
+  return moveChildren$1(editor, options);
+};
+var collapseSelection = function collapseSelection(editor, options) {
+  return collapseSelection$1(editor, options);
+};
+var setNodes = function setNodes(editor, attrs, opts) {
+  setNodes$1(editor, attrs, opts);
+};
+var unsetNodes = function unsetNodes(editor, props, options) {
+  unsetNodes$1(editor, props, options);
+};
+var insertNodes = function insertNodes(editor, nodes, opts) {
+  return insertNodes$1(editor, nodes, opts);
+};
+var splitNodes = function splitNodes(editor, options) {
+  return splitNodes$1(editor, options);
+};
+var liftNodes = function liftNodes(editor, options) {
+  return liftNodes$1(editor, options);
+};
+var unwrapNodes = function unwrapNodes(editor, options) {
+  return unwrapNodes$1(editor, options);
+};
+var wrapNodes = function wrapNodes(editor, element, options) {
+  return wrapNodes$1(editor, element, options);
+};
+var toggleNodeType = function toggleNodeType(editor, options, editorOptions) {
+  toggleNodeType$1(editor, options, editorOptions);
+};
+var removeMark = function removeMark(editor, type, at) {
+  removeMark$1(editor, {
+    key: type,
+    at: at
+  });
+};
+var unhangRange = function unhangRange(editor, range, options) {
+  return unhangRange$1(editor, range, options);
+};
+var toggleMark = function toggleMark(editor, options) {
+  return toggleMark$1(editor, options);
+};
+var addMark = function addMark(editor, type, value) {
+  if (value === void 0) {
+    value = true;
+  }
+
+  addMark$1(editor, type, value);
+};
+var insertText = function insertText(editor, text, options) {
+  return insertText$1(editor, text, options);
+};
+var deleteText = function deleteText(editor, opts) {
+  deleteText$1(editor, opts);
+};
+var removeNodes = function removeNodes(editor, opts) {
+  removeNodes$1(editor, opts);
+};
+var moveNodes = function moveNodes(editor, opts) {
+  moveNodes$1(editor, opts);
+};
+var deleteFragment = function deleteFragment(editor, options) {
+  return deleteFragment$1(editor, options);
+};
+
 var IS_SAFARI = typeof navigator !== 'undefined' && /*#__PURE__*/ /Version\/[\d.]+.*Safari/.test(navigator.userAgent);
 var IS_CHROME = /*#__PURE__*/ /(?!Chrom.*OPR)Chrom(?:e|ium)\/([0-9.]+)(:?\s|$)/.test(navigator.userAgent);
 
 var LINK_TYPES = [INLINES.HYPERLINK, INLINES.ENTRY_HYPERLINK, INLINES.ASSET_HYPERLINK];
 function isBlockSelected(editor, type) {
-  var _Array$from = Array.from(Editor.nodes(editor, {
+  var _Array$from = Array.from(getNodeEntries(editor, {
     match: function match(node) {
-      return Element.isElement(node) && node.type === type;
+      return isElement(node) && node.type === type;
     }
   })),
       match = _Array$from[0];
@@ -490,7 +793,7 @@ function getNodeEntryFromSelection(editor, nodeTypeOrTypes, path) {
   var nodeTypes = Array.isArray(nodeTypeOrTypes) ? nodeTypeOrTypes : [nodeTypeOrTypes];
 
   for (var i = 0; i < path.length; i++) {
-    var nodeEntry = Editor.node(editor, path.slice(0, i + 1));
+    var nodeEntry = getNodeEntry(editor, path.slice(0, i + 1));
     if (nodeTypes.includes(nodeEntry[0].type)) return nodeEntry;
   }
 
@@ -505,13 +808,13 @@ function isNodeTypeSelected(editor, nodeType) {
   return !!node;
 }
 function moveToTheNextLine(editor) {
-  Transforms.move(editor, {
+  moveSelection(editor, {
     distance: 1,
     unit: 'line'
   });
 }
 function moveToTheNextChar(editor) {
-  Transforms.move(editor, {
+  moveSelection(editor, {
     distance: 1,
     unit: 'offset'
   });
@@ -525,11 +828,11 @@ function insertEmptyParagraph(editor, options) {
     data: {},
     isVoid: false
   };
-  Transforms.insertNodes(editor, emptyParagraph, options);
+  insertNodes(editor, emptyParagraph, options);
 }
 function getElementFromCurrentSelection(editor) {
   if (!editor.selection) return [];
-  return Array.from(Editor.nodes(editor, {
+  return Array.from(getNodeEntries(editor, {
     /**
      * editor.select is a Range, which includes anchor and focus, the beginning and the end of a selection
      * when using only editor.selection.focus, we might get only the end of the selection, or where the text cursor is
@@ -537,7 +840,7 @@ function getElementFromCurrentSelection(editor) {
      **/
     at: editor.selection,
     match: function match(node) {
-      return Element.isElement(node);
+      return isElement(node);
     }
   })).flat();
 }
@@ -566,9 +869,9 @@ function isLinkActive(editor) {
     return false;
   }
 
-  var _Array$from2 = Array.from(Editor.nodes(editor, {
+  var _Array$from2 = Array.from(getNodeEntries(editor, {
     match: function match(node) {
-      return !Editor.isEditor(node) && Element.isElement(node) && LINK_TYPES.includes(node.type);
+      return !isEditor(node) && isElement(node) && LINK_TYPES.includes(node.type);
     }
   })),
       link = _Array$from2[0];
@@ -577,9 +880,9 @@ function isLinkActive(editor) {
 } // TODO: move to hyperlink plugin
 
 function unwrapLink(editor) {
-  Transforms.unwrapNodes(editor, {
+  unwrapNodes(editor, {
     match: function match(node) {
-      return !Editor.isEditor(node) && Element.isElement(node) && LINK_TYPES.includes(node.type);
+      return !isEditor(node) && isElement(node) && LINK_TYPES.includes(node.type);
     }
   });
 } // TODO: move to hyperlink plugin
@@ -596,7 +899,7 @@ function wrapLink(editor, _ref) {
   }
 
   var selection = editor.selection;
-  var isCollapsed = selection && Range.isCollapsed(selection);
+  var isCollapsed = selection && isRangeCollapsed(selection);
   var link = {
     type: type,
     data: {},
@@ -619,41 +922,41 @@ function wrapLink(editor, _ref) {
 
 
   if (path) {
-    Transforms.setNodes(editor, link, {
+    setNodes(editor, link, {
       at: path
     });
-    Transforms.insertText(editor, text, {
+    insertText(editor, text, {
       at: path
     });
-    Transforms.select(editor, path);
+    select(editor, path);
   } else if (isCollapsed) {
-    Transforms.insertNodes(editor, link);
+    insertNodes(editor, link);
   } else {
-    Transforms.wrapNodes(editor, link, {
+    wrapNodes(editor, link, {
       split: true
     });
-    Transforms["delete"](editor);
-    Transforms.insertText(editor, text);
-    Transforms.collapse(editor, {
+    deleteText(editor);
+    insertText(editor, text);
+    collapseSelection(editor, {
       edge: 'end'
     });
   }
 }
 function getAncestorPathFromSelection(editor) {
   if (!editor.selection) return undefined;
-  return Path.levels(editor.selection.focus.path).find(function (level) {
+  return getPathLevels(editor.selection.focus.path).find(function (level) {
     return level.length === 1;
   });
 }
 var INLINE_TYPES = /*#__PURE__*/Object.values(INLINES);
 var isInlineOrText = function isInlineOrText(node) {
   // either text or inline elements
-  return Text.isText(node) || Element.isElement(node) && INLINE_TYPES.includes(node.type);
+  return isText(node) || isElement(node) && INLINE_TYPES.includes(node.type);
 };
 var focus = function focus(editor) {
   var x = window.scrollX;
   var y = window.scrollY;
-  ReactEditor.focus(editor); // Safari has issues with `editor.focus({ preventScroll: true })`, it ignores the option `preventScroll`
+  focusEditor(editor); // Safari has issues with `editor.focus({ preventScroll: true })`, it ignores the option `preventScroll`
 
   if (IS_SAFARI) {
     setTimeout(function () {
@@ -664,7 +967,7 @@ var focus = function focus(editor) {
 function toggleElement(editor, options, editorOptions) {
   toggleNodeType(editor, options, editorOptions); // We must reset `data` from one element to another
 
-  Transforms.setNodes(editor, {
+  setNodes(editor, {
     data: {}
   });
 }
@@ -1573,35 +1876,32 @@ function insertBlock(editor, nodeType, entity) {
   var hasText = editor.selection && !!getText(editor, editor.selection.focus.path);
 
   if (hasText) {
-    Transforms.insertNodes(editor, linkedEntityBlock);
+    insertNodes(editor, linkedEntityBlock);
   } else {
-    Transforms.setNodes(editor, linkedEntityBlock);
+    setNodes(editor, linkedEntityBlock);
   }
 
   focus(editor);
 }
 
 var removeCommand = function removeCommand(editor) {
-  var _getAbove = getAbove(editor),
-      path = _getAbove[1];
+  var _getAboveNode = getAboveNode(editor),
+      path = _getAboveNode[1];
 
-  var range = Editor.range(editor, path);
-  Transforms.select(editor, range.focus.path);
-  removeMark(editor, {
-    key: COMMAND_PROMPT,
-    at: range
-  });
-  Transforms["delete"](editor);
+  var range = getRange(editor, path);
+  select(editor, range.focus.path);
+  removeMark(editor, COMMAND_PROMPT, range);
+  deleteText(editor);
 };
 
 var removeQuery = function removeQuery(editor) {
-  var _getAbove2 = getAbove(editor),
-      path = _getAbove2[1];
+  var _getAboveNode2 = getAboveNode(editor),
+      path = _getAboveNode2[1];
 
-  var range = Editor.range(editor, path);
+  var range = getRange(editor, path);
 
   if (range.focus.offset - range.anchor.offset > 1) {
-    Transforms["delete"](editor, {
+    deleteText(editor, {
       at: range.focus,
       distance: range.focus.offset - 1,
       reverse: true
@@ -1642,7 +1942,7 @@ var useCommands = function useCommands(sdk, query, editor) {
                       var selection = editor.selection;
                       editor.insertSoftBreak();
                       insertBlock(editor, BLOCKS.EMBEDDED_ENTRY, entry.entry);
-                      Transforms.select(editor, selection);
+                      select(editor, selection);
                       editor.tracking.onCommandPaletteAction('insert', {
                         nodeType: BLOCKS.EMBEDDED_ENTRY
                       });
@@ -1677,7 +1977,7 @@ var useCommands = function useCommands(sdk, query, editor) {
                   callback: function callback() {
                     var inlineNode = createInlineEntryNode(entry.id);
                     removeCommand(editor);
-                    Transforms.insertNodes(editor, inlineNode);
+                    insertNodes(editor, inlineNode);
                     editor.insertText('');
                     editor.tracking.onCommandPaletteAction('insert', {
                       nodeType: INLINES.EMBEDDED_ENTRY
@@ -1726,7 +2026,7 @@ var useCommands = function useCommands(sdk, query, editor) {
                         var selection = editor.selection;
                         editor.insertSoftBreak();
                         insertBlock(editor, BLOCKS.EMBEDDED_ASSET, asset.entity);
-                        Transforms.select(editor, selection);
+                        select(editor, selection);
                         editor.tracking.onCommandPaletteAction('insert', {
                           nodeType: BLOCKS.EMBEDDED_ASSET
                         });
@@ -2008,42 +2308,36 @@ var createOnKeyDown = function createOnKeyDown() {
   return function (editor) {
     return function (event) {
       if (isHotkey('/', event)) {
-        var _setMarks;
-
-        setMarks(editor, (_setMarks = {}, _setMarks[COMMAND_PROMPT] = true, _setMarks));
+        addMark(editor, COMMAND_PROMPT);
         editor.tracking.onCommandPaletteAction('openRichTextCommandPalette');
       }
 
       var isActive = isMarkActive(editor, COMMAND_PROMPT);
 
-      if (isActive) {
-        if (isHotkey('enter', event)) {
-          event.preventDefault();
-        } else if (isHotkey('backspace', event)) {
-          var _getAbove = getAbove(editor),
-              path = _getAbove[1];
+      if (!isActive) {
+        return;
+      }
 
-          var range = Editor.range(editor, path); // if it is the last character in the command string
+      if (isHotkey('enter', event)) {
+        return event.preventDefault();
+      }
 
-          if (range.focus.offset - range.anchor.offset === 1) {
-            removeMark(editor, {
-              key: COMMAND_PROMPT,
-              at: range
-            });
-          }
-        } else if (isHotkey('escape', event)) {
-          var _getAbove2 = getAbove(editor),
-              _path = _getAbove2[1];
+      var _getAboveNode = getAboveNode(editor),
+          path = _getAboveNode[1];
 
-          var _range = Editor.range(editor, _path);
+      var range = getRange(editor, path);
 
-          removeMark(editor, {
-            key: COMMAND_PROMPT,
-            at: _range
-          });
-          editor.tracking.onCommandPaletteAction('cancelRichTextCommandPalette');
+      if (isHotkey('backspace', event)) {
+        // if it is the last character in the command string
+        if (range.focus.offset - range.anchor.offset === 1) {
+          removeMark(editor, COMMAND_PROMPT, range);
         }
       }
+
+      if (isHotkey('escape', event)) {
+        removeMark(editor, COMMAND_PROMPT, range);
+        editor.tracking.onCommandPaletteAction('cancelRichTextCommandPalette');
+      }
     };
   };
 };
@@ -2089,9 +2383,9 @@ function createDragAndDropPlugin() {
       // If true, the next handlers will be skipped.
       onDrop: function onDrop(editor) {
         return function (event) {
-          var _Array$from = Array.from(getNodes(editor, {
+          var _Array$from = Array.from(getNodeEntries(editor, {
             match: function match(node) {
-              return DRAGGABLE_TYPES.includes(node == null ? void 0 : node.type);
+              return DRAGGABLE_TYPES.includes(node.type);
             }
           })),
               draggingBlock = _Array$from[0];
@@ -2135,7 +2429,7 @@ function withLinkTracking(Component) {
   return function ComponentWithTracking(props) {
     var editor = useContentfulEditorRef();
     var onEntityFetchComplete = React__default.useCallback(function () {
-      return editor.tracking.onViewportAction('linkRendered');
+      return editor == null ? void 0 : editor.tracking.onViewportAction('linkRendered');
     }, [editor]);
     return /*#__PURE__*/React__default.createElement(Component, _extends({}, props, {
       onEntityFetchComplete: onEntityFetchComplete
@@ -2293,7 +2587,7 @@ function LinkedEntityBlock(props) {
   var isSelected = useSelected();
   var editor = useContentfulEditor();
   var sdk = useSdkContext();
-  var isDisabled = useReadOnly();
+  var isDisabled = useReadOnly$1();
   var _element$data$target$ = element.data.target.sys,
       entityId = _element$data$target$.id,
       entityType = _element$data$target$.linkType;
@@ -2305,8 +2599,8 @@ function LinkedEntityBlock(props) {
   }, [sdk, entityId, entityType]);
   var handleRemoveClick = React__default.useCallback(function () {
     if (!editor) return;
-    var pathToElement = ReactEditor.findPath(editor, element);
-    Transforms.removeNodes(editor, {
+    var pathToElement = findNodePath(editor, element);
+    removeNodes(editor, {
       at: pathToElement
     });
   }, [editor, element]);
@@ -2416,7 +2710,7 @@ function getEntityTypeFromRichTextNode(nodeType) {
 
 function selectEntityAndInsert(_x, _x2, _x3, _x4) {
   return _selectEntityAndInsert.apply(this, arguments);
-}
+} // TODO: incorporate this logic inside the trailingParagraph plugin instead
 
 function _selectEntityAndInsert() {
   _selectEntityAndInsert = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(nodeType, sdk, editor, logAction) {
@@ -2452,7 +2746,7 @@ function _selectEntityAndInsert() {
             return _context.abrupt("return");
 
           case 12:
-            Transforms.select(editor, selection);
+            select(editor, selection);
             insertBlock$1(editor, nodeType, entity);
             ensureFollowingParagraph(editor);
             logAction('insert', {
@@ -2470,37 +2764,25 @@ function _selectEntityAndInsert() {
 }
 
 function ensureFollowingParagraph(editor) {
-  /*
-     If the new block isn't followed by a sibling paragraph we insert a new empty one
-   */
-  var next = Editor.next(editor);
-
-  if (!next) {
-    return insertEmptyParagraph(editor);
-  }
+  var _lastNode$0$type;
 
-  var parent = Editor.above(editor, {
-    voids: false,
-    match: function match(e) {
-      return !Element.isElement(e) || ![BLOCKS.EMBEDDED_ASSET, BLOCKS.EMBEDDED_ENTRY].includes(e.type);
+  var entityBlock = getAboveNode(editor, {
+    match: {
+      type: [BLOCKS.EMBEDDED_ASSET, BLOCKS.EMBEDDED_ENTRY]
     }
   });
 
-  if (Editor.isEditor(parent)) {
-    // at level 0, a following paragraph is handled by the tralingParagraph plugin
-    moveToTheNextChar(editor);
+  if (!entityBlock) {
     return;
   }
 
-  var paragraph = Editor.above(editor, {
-    at: next[1],
-    match: function match(e) {
-      return Element.isElement(e) && TEXT_CONTAINERS.includes(e.type);
-    }
-  });
+  var level = entityBlock[1].length - 1;
+  var lastNode = getLastNodeByLevel(editor, level);
+  var isTextContainer = TEXT_CONTAINERS.includes((_lastNode$0$type = lastNode == null ? void 0 : lastNode[0].type) != null ? _lastNode$0$type : ''); // If the new block isn't followed by a sibling text container (e.g. paragraph)
+  // we insert a new empty one. Level 0 is handled by the trailingParagraph plugin
 
-  if (!paragraph || !parent || !Path.isChild(paragraph[1], parent[1])) {
-    return insertEmptyParagraph(editor);
+  if (level !== 0 && !isTextContainer) {
+    insertEmptyParagraph(editor);
   }
 
   moveToTheNextChar(editor);
@@ -2532,9 +2814,9 @@ function insertBlock$1(editor, nodeType, entity) {
   var hasText = editor.selection && !!getText(editor, editor.selection.focus.path);
 
   if (hasText) {
-    Transforms.insertNodes(editor, linkedEntityBlock);
+    insertNodes(editor, linkedEntityBlock);
   } else {
-    Transforms.setNodes(editor, linkedEntityBlock);
+    setNodes(editor, linkedEntityBlock);
   }
 
   focus(editor);
@@ -2559,11 +2841,20 @@ function EmbeddedEntityBlockToolbarIcon(_ref) {
           switch (_context.prev = _context.next) {
             case 0:
               event.preventDefault();
+
+              if (editor) {
+                _context.next = 3;
+                break;
+              }
+
+              return _context.abrupt("return");
+
+            case 3:
               onClose();
-              _context.next = 4;
+              _context.next = 6;
               return selectEntityAndInsert(nodeType, sdk, editor, editor.tracking.onToolbarAction);
 
-            case 4:
+            case 6:
             case "end":
               return _context.stop();
           }
@@ -2623,7 +2914,7 @@ function getWithEmbeddedEntityEvents(nodeType, sdk) {
 
         if (isDelete || isBackspace) {
           event.preventDefault();
-          Transforms.removeNodes(editor, {
+          removeNodes(editor, {
             at: pathToSelectedElement
           });
         }
@@ -2822,7 +3113,7 @@ function EmbeddedEntityInline(props) {
   var sdk = useSdkContext();
   var isSelected = useSelected();
   var entryId = props.element.data.target.sys.id;
-  var isDisabled = useReadOnly();
+  var isDisabled = useReadOnly$1();
 
   function handleEditClick() {
     return sdk.navigator.openEntry(entryId, {
@@ -2832,8 +3123,8 @@ function EmbeddedEntityInline(props) {
 
   function handleRemoveClick() {
     if (!editor) return;
-    var pathToElement = ReactEditor.findPath(editor, props.element);
-    Transforms.removeNodes(editor, {
+    var pathToElement = findNodePath(editor, props.element);
+    removeNodes(editor, {
       at: pathToElement
     });
   }
@@ -2902,8 +3193,8 @@ function _selectEntityAndInsert$1() {
 
             return _context2.abrupt("return", new Promise(function (resolve) {
               setTimeout(function () {
-                Transforms.setSelection(editor, selection);
-                Transforms.insertNodes(editor, inlineEntryNode);
+                setSelection(editor, selection);
+                insertNodes(editor, inlineEntryNode);
                 resolve();
               }, 0);
             }));
@@ -3114,7 +3405,7 @@ function ToolbarHeadingButton(props) {
 }
 
 function extractNodes(editor, path, match) {
-  return Array.from(getNodes(editor, {
+  return Array.from(getNodeEntries(editor, {
     match: match,
     at: path,
     mode: 'lowest'
@@ -3140,7 +3431,7 @@ function extractParagraphs(editor, path) {
 
 var transformRemove = function transformRemove(editor, _ref) {
   var path = _ref[1];
-  Transforms.removeNodes(editor, {
+  removeNodes(editor, {
     at: path
   });
 };
@@ -3148,20 +3439,20 @@ var transformParagraphs = function transformParagraphs(editor, entry) {
   var path = entry[1];
   var nodes = extractParagraphs(editor, path);
   transformRemove(editor, entry);
-  Transforms.insertNodes(editor, nodes, {
+  insertNodes(editor, nodes, {
     at: path
   });
 };
 var transformUnwrap = function transformUnwrap(editor, _ref2) {
   var path = _ref2[1];
-  Transforms.unwrapNodes(editor, {
+  unwrapNodes(editor, {
     at: path
   });
 };
 var transformWrapIn = function transformWrapIn(type) {
   return function (editor, _ref3) {
     var path = _ref3[1];
-    Transforms.wrapNodes(editor, {
+    wrapNodes(editor, {
       type: type,
       data: {},
       children: []
@@ -3172,7 +3463,7 @@ var transformWrapIn = function transformWrapIn(type) {
 };
 var transformLift = function transformLift(editor, _ref4) {
   var path = _ref4[1];
-  Transforms.liftNodes(editor, {
+  liftNodes(editor, {
     at: path
   });
 };
@@ -3251,7 +3542,7 @@ var createHeadingPlugin = function createHeadingPlugin() {
             // insertBreak implementation
             filter: function filter(_ref3) {
               var path = _ref3[1];
-              return !getAbove(editor, {
+              return !getAboveNode(editor, {
                 at: path,
                 match: {
                   type: BLOCKS.LIST_ITEM
@@ -3351,7 +3642,7 @@ function withHrEvents(editor) {
 
       if (isBackspace || isDelete) {
         event.preventDefault();
-        Transforms.removeNodes(editor, {
+        removeNodes(editor, {
           at: pathToSelectedHr
         });
       }
@@ -3372,7 +3663,7 @@ function ToolbarHrButton(props) {
       isVoid: true
     };
     var hasText = !!getText(editor, editor.selection.focus.path);
-    hasText ? Transforms.insertNodes(editor, hr) : setNodes(editor, hr); // Move focus to the next paragraph (added by TrailingParagraph plugin)
+    hasText ? insertNodes(editor, hr) : setNodes(editor, hr); // Move focus to the next paragraph (added by TrailingParagraph plugin)
 
     moveToTheNextLine(editor);
     focus(editor);
@@ -3658,7 +3949,7 @@ function _addOrEditLink() {
       while (1) {
         switch (_context3.prev = _context3.next) {
           case 0:
-            isReadOnly = ReactEditor.isReadOnly(editor);
+            isReadOnly = isEditorReadOnly(editor);
             selectionBeforeBlur = editor.selection ? _extends({}, editor.selection) : undefined;
 
             if (!(!targetPath && !selectionBeforeBlur)) {
@@ -3673,13 +3964,13 @@ function _addOrEditLink() {
 
             if (node && path) {
               linkType = node.type;
-              linkText = Editor.string(editor, path);
+              linkText = getText(editor, path);
               linkTarget = node.data.uri || '';
               linkEntity = node.data.target;
             }
 
             selectionAfterFocus = targetPath != null ? targetPath : selectionBeforeBlur;
-            currentLinkText = linkText || (editor.selection ? Editor.string(editor, editor.selection) : '');
+            currentLinkText = linkText || (editor.selection ? getText(editor, editor.selection) : '');
             isEditing = Boolean(node && path);
             logAction(isEditing ? 'openEditHyperlinkDialog' : 'openCreateHyperlinkDialog');
             _context3.next = 12;
@@ -3704,7 +3995,7 @@ function _addOrEditLink() {
 
           case 12:
             data = _context3.sent;
-            Transforms.select(editor, selectionAfterFocus);
+            select(editor, selectionAfterFocus);
 
             if (data) {
               _context3.next = 18;
@@ -3717,7 +4008,7 @@ function _addOrEditLink() {
 
           case 18:
             text = data.linkText, url = data.linkTarget, type = data.linkType, target = data.linkEntity;
-            Editor.withoutNormalizing(editor, function () {
+            withoutNormalizing(editor, function () {
               insertLink(editor, {
                 text: text,
                 url: url,
@@ -3794,8 +4085,9 @@ function ToolbarHyperlinkButton(props) {
 }
 
 var hasText = function hasText(editor, entry) {
-  var node = entry[0];
-  return !isAncestorEmpty(editor, node) && Node.string(node).trim() !== '';
+  var node = entry[0],
+      path = entry[1];
+  return !isAncestorEmpty$1(editor, node) && getText(editor, path).trim() !== '';
 };
 
 function truncate(str, length) {
@@ -3986,11 +4278,11 @@ function EntityHyperlink(props) {
     event.preventDefault();
     event.stopPropagation();
     if (!editor) return;
-    var p = ReactEditor.toSlatePoint(editor, [event.target, 0], {
-      exactMatch: false,
-      suppressThrow: false
-    });
-    addOrEditLink(editor, sdk, editor.tracking.onViewportAction, p.path);
+    var p = fromDOMPoint(editor, [event.target, 0]);
+
+    if (p) {
+      addOrEditLink(editor, sdk, editor.tracking.onViewportAction, p.path);
+    }
   }
 
   return /*#__PURE__*/createElement(Tooltip, {
@@ -4016,11 +4308,11 @@ function UrlHyperlink(props) {
     event.preventDefault();
     event.stopPropagation();
     if (!editor) return;
-    var p = ReactEditor.toSlatePoint(editor, [event.target, 0], {
+    var p = fromDOMPoint(editor, [event.target, 0], {
       exactMatch: false,
       suppressThrow: false
     });
-    addOrEditLink(editor, sdk, editor.tracking.onViewportAction, p.path);
+    addOrEditLink(editor, sdk, editor.tracking.onViewportAction, p == null ? void 0 : p.path);
   }
 
   return /*#__PURE__*/createElement(Tooltip, {
@@ -4192,24 +4484,25 @@ var moveListItemDown = function moveListItemDown(editor, _ref) {
   var previousListItemPath;
 
   try {
-    previousListItemPath = Path.previous(listItemPath);
+    previousListItemPath = getPreviousPath(listItemPath);
   } catch (e) {
     return;
   } // Previous sibling is the new parent
 
 
-  var previousSiblingItem = Editor.node(editor, previousListItemPath);
+  var previousSiblingItem = getNodeEntry(editor, previousListItemPath);
 
   if (previousSiblingItem) {
     var previousPath = previousSiblingItem[1];
-    var subList = Array.from(Node.children(editor, previousPath)).find(function (_ref2) {
-      var n = _ref2[0];
-      return match(n, {
+    var subList = Array.from(getNodeChildren(editor, previousPath)).find(function (_ref2) {
+      var n = _ref2[0],
+          path = _ref2[1];
+      return match(n, path, {
         type: getListTypes(editor)
       });
     });
-    var newPath = Path.next(getLastChildPath(subList != null ? subList : previousSiblingItem));
-    Editor.withoutNormalizing(editor, function () {
+    var newPath = getNextPath(getLastChildPath(subList != null ? subList : previousSiblingItem));
+    withoutNormalizing(editor, function () {
       if (!subList) {
         // Create new sub-list
         wrapNodes(editor, {
@@ -4222,7 +4515,7 @@ var moveListItemDown = function moveListItemDown(editor, _ref) {
       } // Move the current item to the sub-list
 
 
-      Transforms.moveNodes(editor, {
+      moveNodes(editor, {
         at: listItemPath,
         to: newPath
       });
@@ -4243,7 +4536,7 @@ var moveListItems = function moveListItems(editor, _temp) {
       _ref$at = _ref.at,
       at = _ref$at === void 0 ? (_editor$selection = editor.selection) != null ? _editor$selection : undefined : _ref$at;
 
-  var _nodes = getNodes(editor, {
+  var _nodes = getNodeEntries(editor, {
     at: at,
     match: {
       type: getPluginType(editor, ELEMENT_LIC)
@@ -4258,19 +4551,19 @@ var moveListItems = function moveListItems(editor, _temp) {
 
   lics.forEach(function (lic) {
     var licPath = lic[1];
-    var liPath = Path.parent(licPath);
+    var liPath = getParentPath(licPath);
     var isAncestor = highestLicPaths.some(function (path) {
-      var highestLiPath = Path.parent(path);
-      return Path.isAncestor(highestLiPath, liPath);
+      var highestLiPath = getParentPath(path);
+      return isAncestorPath(highestLiPath, liPath);
     });
 
     if (!isAncestor) {
       highestLicPaths.push(licPath);
-      highestLicPathRefs.push(Editor.pathRef(editor, licPath));
+      highestLicPathRefs.push(createPathRef(editor, licPath));
     }
   });
   var licPathRefsToMove = increase ? highestLicPathRefs : highestLicPathRefs.reverse();
-  Editor.withoutNormalizing(editor, function () {
+  withoutNormalizing(editor, function () {
     licPathRefsToMove.forEach(function (licPathRef) {
       var licPath = licPathRef.unref();
       if (!licPath) return;
@@ -4291,16 +4584,18 @@ var moveListItems = function moveListItems(editor, _temp) {
   });
 };
 
+var ELEMENT_DEFAULT = ELEMENT_DEFAULT$1;
+
 /**
  * Credit: Modified version of Plate's list plugin
  * See: https://github.com/udecode/plate/blob/main/packages/nodes/list
  */
 
 function hasUnliftedListItems(editor, at) {
-  return Editor.nodes(editor, {
+  return getNodeEntries(editor, {
     at: at,
     match: function match(node, path) {
-      return Element.isElement(node) && node.type === BLOCKS.LIST_ITEM && path.length >= 2;
+      return isElement(node) && node.type === BLOCKS.LIST_ITEM && path.length >= 2;
     }
   }).next().done;
 }
@@ -4309,13 +4604,13 @@ var unwrapList = function unwrapList(editor, _temp) {
   var _ref = _temp === void 0 ? {} : _temp,
       at = _ref.at;
 
-  Editor.withoutNormalizing(editor, function () {
+  withoutNormalizing(editor, function () {
     do {
       // lift list items to the root level
-      Transforms.liftNodes(editor, {
+      liftNodes(editor, {
         at: at,
         match: function match(node) {
-          return Element.isElement(node) && node.type === BLOCKS.LIST_ITEM;
+          return isElement(node) && node.type === BLOCKS.LIST_ITEM;
         },
         mode: 'lowest'
       });
@@ -4335,12 +4630,12 @@ var unwrapList = function unwrapList(editor, _temp) {
 var listTypes = [BLOCKS.UL_LIST, BLOCKS.OL_LIST];
 var toggleList = function toggleList(editor, _ref) {
   var type = _ref.type;
-  return Editor.withoutNormalizing(editor, function () {
+  return withoutNormalizing(editor, function () {
     if (!editor.selection) {
       return;
     }
 
-    if (isCollapsed(editor.selection) || !isRangeAcrossBlocks(editor)) {
+    if (isRangeCollapsed(editor.selection) || !isRangeAcrossBlocks(editor)) {
       // selection is collapsed
       var res = getListItemEntry(editor);
 
@@ -4367,7 +4662,7 @@ var toggleList = function toggleList(editor, _ref) {
           data: {}
         };
         wrapNodes(editor, _list);
-        var nodes = [].concat(getNodes(editor, {
+        var nodes = [].concat(getNodeEntries(editor, {
           match: {
             type: getPluginType(editor, ELEMENT_DEFAULT)
           }
@@ -4388,29 +4683,31 @@ var toggleList = function toggleList(editor, _ref) {
       }
     } else {
       // selection is a range
-      var _Range$edges = Range.edges(editor.selection),
-          startPoint = _Range$edges[0],
-          endPoint = _Range$edges[1];
+      var _getRangeEdges = getRangeEdges(editor.selection),
+          startPoint = _getRangeEdges[0],
+          endPoint = _getRangeEdges[1];
 
-      var commonEntry = Node.common(editor, startPoint.path, endPoint.path);
+      var commonEntry = getCommonNode(editor, startPoint.path, endPoint.path);
 
       if (listTypes.includes(commonEntry[0].type) || commonEntry[0].type === BLOCKS.LIST_ITEM) {
         var listType = commonEntry[0].type;
 
         if (commonEntry[0].type === BLOCKS.LIST_ITEM) {
-          listType = Editor.parent(editor, commonEntry[1])[0].type;
+          var _getParentNode, _getParentNode$;
+
+          listType = (_getParentNode = getParentNode(editor, commonEntry[1])) == null ? void 0 : (_getParentNode$ = _getParentNode[0]) == null ? void 0 : _getParentNode$.type;
         }
 
         if (listType !== type) {
           var startList = findNode(editor, {
-            at: Range.start(editor.selection),
+            at: getRangeStart(editor.selection),
             match: {
               type: listTypes
             },
             mode: 'lowest'
           });
           var endList = findNode(editor, {
-            at: Range.end(editor.selection),
+            at: getRangeEnd(editor.selection),
             match: {
               type: listTypes
             },
@@ -4437,7 +4734,7 @@ var toggleList = function toggleList(editor, _ref) {
       } else {
         var rootPathLength = commonEntry[1].length;
 
-        var _nodes = Array.from(getNodes(editor, {
+        var _nodes = Array.from(getNodeEntries(editor, {
           mode: 'all'
         })).filter(function (_ref2) {
           var path = _ref2[1];
@@ -4485,7 +4782,7 @@ var onKeyDownList = function onKeyDownList(editor, _ref) {
       hotkey = _ref.options.hotkey;
   return function (e) {
     if (e.key === 'Tab' && editor.selection) {
-      var listSelected = getAbove(editor, {
+      var listSelected = getAboveNode(editor, {
         at: editor.selection,
         match: {
           type: type
@@ -4523,14 +4820,14 @@ var isList = function isList(node) {
 var hasListAsDirectParent = function hasListAsDirectParent(editor, _ref) {
   var path = _ref[1];
 
-  var _ref2 = getParent(editor, path) || [],
+  var _ref2 = getParentNode$1(editor, path) || [],
       parentNode = _ref2[0];
 
   return isList(parentNode);
 };
 
 var getNearestListAncestor = function getNearestListAncestor(editor, path) {
-  return getAbove(editor, {
+  return getAboveNode$1(editor, {
     at: path,
     mode: 'lowest',
     match: isList
@@ -4550,7 +4847,7 @@ var normalizeOrphanedListItem = function normalizeOrphanedListItem(editor, _ref3
       parentList = _getNearestListAncest[0];
 
   var parentListType = parentList == null ? void 0 : parentList.type;
-  Transforms.wrapNodes(editor, {
+  wrapNodes(editor, {
     type: parentListType || BLOCKS.UL_LIST,
     children: [],
     data: {}
@@ -4558,24 +4855,23 @@ var normalizeOrphanedListItem = function normalizeOrphanedListItem(editor, _ref3
     at: path
   });
 };
-var isNonEmptyListItem = function isNonEmptyListItem(editor, _ref4) {
-  var path = _ref4[1];
-  var listItemChildren = Array.from(Node.children(editor, path));
+var isNonEmptyListItem = function isNonEmptyListItem(_, entry) {
+  var listItemChildren = getChildren(entry);
   return listItemChildren.length !== 0;
 };
-var firstNodeIsNotList = function firstNodeIsNotList(_editor, _ref5) {
-  var node = _ref5[0];
+var firstNodeIsNotList = function firstNodeIsNotList(_editor, _ref4) {
+  var node = _ref4[0];
 
   if (node.children.length === 1) {
     var firstNode = node.children[0];
-    return !Text.isText(firstNode) && !isList(firstNode);
+    return !isText(firstNode) && !isList(firstNode);
   }
 
   return true;
 };
-var insertParagraphAsChild = function insertParagraphAsChild(editor, _ref6) {
-  var path = _ref6[1];
-  Transforms.insertNodes(editor, [{
+var insertParagraphAsChild = function insertParagraphAsChild(editor, _ref5) {
+  var path = _ref5[1];
+  insertNodes(editor, [{
     type: BLOCKS.PARAGRAPH,
     data: {},
     children: [{
@@ -4588,10 +4884,10 @@ var insertParagraphAsChild = function insertParagraphAsChild(editor, _ref6) {
 var replaceNodeWithListItems = function replaceNodeWithListItems(editor, entry) {
   var node = entry[0],
       path = entry[1];
-  Transforms.removeNodes(editor, {
+  removeNodes(editor, {
     at: path
   });
-  Transforms.insertNodes(editor, node.children[0].children, {
+  insertNodes(editor, node.children[0].children, {
     at: path
   });
 };
@@ -4602,12 +4898,12 @@ var isListTypeActive = function isListTypeActive(editor, type) {
     return false;
   }
 
-  if (Range.isExpanded(selection)) {
-    var _Range$edges = Range.edges(selection),
-        start = _Range$edges[0],
-        end = _Range$edges[1];
+  if (isRangeExpanded(selection)) {
+    var _getRangeEdges = getRangeEdges(selection),
+        start = _getRangeEdges[0],
+        end = _getRangeEdges[1];
 
-    var node = Node.common(editor, start.path, end.path);
+    var node = getCommonNode(editor, start.path, end.path);
 
     if (node[0].type === type) {
       return true;
@@ -4615,7 +4911,7 @@ var isListTypeActive = function isListTypeActive(editor, type) {
   } // Lists can be nested. Here, we take the list type at the lowest level
 
 
-  var listNode = getBlockAbove(editor, {
+  var listNode = getBlockAbove$1(editor, {
     match: {
       type: [BLOCKS.OL_LIST, BLOCKS.UL_LIST]
     },
@@ -4636,7 +4932,7 @@ var emptyListItemNode = function emptyListItemNode(editor, withChildren) {
   var children = [];
 
   if (withChildren) {
-    var marks = Editor.marks(editor) || {};
+    var marks = getMarks(editor) || {};
     children = [{
       type: BLOCKS.PARAGRAPH,
       data: {},
@@ -4663,7 +4959,7 @@ var insertListItem = function insertListItem(editor) {
   } // Naming it paragraph for simplicity but can be a heading as well
 
 
-  var paragraph = getAbove(editor, {
+  var paragraph = getAboveNode(editor, {
     match: {
       type: TEXT_CONTAINERS
     }
@@ -4674,7 +4970,7 @@ var insertListItem = function insertListItem(editor) {
   }
 
   var paragraphPath = paragraph[1];
-  var listItem = getParent(editor, paragraphPath);
+  var listItem = getParentNode(editor, paragraphPath);
 
   if (!listItem) {
     return false;
@@ -4688,7 +4984,7 @@ var insertListItem = function insertListItem(editor) {
   } // We are in a li>p (or heading)
 
 
-  Editor.withoutNormalizing(editor, function () {
+  withoutNormalizing(editor, function () {
     if (!editor.selection) {
       return;
     } // Check the cursor position in the current paragraph
@@ -4696,22 +4992,22 @@ var insertListItem = function insertListItem(editor) {
 
     var isAtStart = isSelectionAtBlockStart(editor);
     var isAtEnd = isSelectionAtBlockEnd(editor);
-    var isAtStartOfListItem = isAtStart && isFirstChild(paragraphPath);
+    var isAtStartOfListItem = isAtStart && isFirstChildPath(paragraphPath);
     var shouldSplit = !isAtStart && !isAtEnd; // Split the current paragraph content if necessary
 
     if (shouldSplit) {
-      Transforms.splitNodes(editor);
+      splitNodes(editor);
     } // Insert the new li
 
 
-    var newListItemPath = isAtStartOfListItem ? listItemPath : Path.next(listItemPath);
+    var newListItemPath = isAtStartOfListItem ? listItemPath : getNextPath(listItemPath);
     insertNodes(editor, // Add an empty paragraph to the new li if We will not move some
     // paragraphs over there.
     emptyListItemNode(editor, !shouldSplit), {
       at: newListItemPath
     }); // Move children *after* selection to the new li
 
-    var fromPath = isAtStart ? paragraphPath : Path.next(paragraphPath);
+    var fromPath = isAtStart ? paragraphPath : getNextPath(paragraphPath);
     var fromStartIndex = fromPath[fromPath.length - 1] || 0; // On split we don't add paragraph to the new li so we move
     // content to the very beginning. Otherwise, account for the empty
     // paragraph at the beginning by moving the content after
@@ -4727,8 +5023,8 @@ var insertListItem = function insertListItem(editor) {
     } // Move cursor to the start of the new li
 
 
-    Transforms.select(editor, newListItemPath);
-    Transforms.collapse(editor, {
+    select(editor, newListItemPath);
+    collapseSelection(editor, {
       edge: 'start'
     });
   }); // Returning True skips processing other editor.insertBreak handlers
@@ -4762,11 +5058,11 @@ var listBreak = function listBreak(editor) {
     }
   }
 
-  var didReset = onKeyDownResetNode(editor, mockPlugin({
+  var didReset = onKeyDownResetNode(editor, mockPlugin$1({
     options: {
       rules: [{
-        types: [getPluginType(editor, ELEMENT_LI)],
-        defaultType: getPluginType(editor, ELEMENT_DEFAULT),
+        types: [getPluginType$1(editor, ELEMENT_LI)],
+        defaultType: getPluginType$1(editor, ELEMENT_DEFAULT$1),
         predicate: function predicate() {
           return !moved && isBlockAboveEmpty(editor);
         },
@@ -4807,13 +5103,13 @@ var insertListBreak = function insertListBreak(editor) {
  */
 
 var getFirstAncestorOfType = function getFirstAncestorOfType(root, entry) {
-  var ancestor = Path.parent(entry[1]);
+  var ancestor = getParentPath(entry[1]);
 
-  while (Node.get(root, ancestor).type !== BLOCKS.LIST_ITEM) {
-    ancestor = Path.parent(ancestor);
+  while (getDescendantNodeByPath(root, ancestor).type !== BLOCKS.LIST_ITEM) {
+    ancestor = getParentPath(ancestor);
   }
 
-  return [Node.get(root, ancestor), ancestor];
+  return [getDescendantNodeByPath(root, ancestor), ancestor];
 };
 
 var isListRoot = function isListRoot(node) {
@@ -4831,9 +5127,9 @@ var trimList = function trimList(listRoot) {
     return [listRoot];
   }
 
-  var textEntries = Array.from(Node.texts(listRoot));
+  var textEntries = Array.from(getNodeTexts(listRoot));
   var commonAncestorEntry = textEntries.reduce(function (commonAncestor, textEntry) {
-    return Path.isAncestor(commonAncestor[1], textEntry[1]) ? commonAncestor : Node.common(listRoot, textEntry[1], commonAncestor[1]);
+    return isAncestorPath(commonAncestor[1], textEntry[1]) ? commonAncestor : getCommonNode(listRoot, textEntry[1], commonAncestor[1]);
   }, // any list item would do, we grab the first one
   getFirstAncestorOfType(listRoot, textEntries[0]));
   return isListRoot(commonAncestorEntry[0]) ? commonAncestorEntry[0].children : [commonAncestorEntry[0]];
@@ -4874,7 +5170,7 @@ var insertListFragment = function insertListFragment(editor) {
       return;
     }
 
-    var liEntry = findNode(editor, {
+    var liEntry = findNode$1(editor, {
       match: {
         type: BLOCKS.LIST_ITEM
       },
@@ -4886,7 +5182,7 @@ var insertListFragment = function insertListFragment(editor) {
         return trimList(node);
       })));
       var firstBlockIndex = nodes.findIndex(function (node) {
-        return Editor.isBlock(editor, node);
+        return isBlockNode(editor, node);
       });
 
       if (firstBlockIndex < 0) {
@@ -4898,11 +5194,11 @@ var insertListFragment = function insertListFragment(editor) {
       // after a text or inline element occurrence will be unwrapped for
       // some reason.
 
-      Transforms.insertNodes(editor, inlines, {
+      insertNodes(editor, inlines, {
         at: editor.selection,
         select: true
       });
-      return Transforms.insertNodes(editor, blocks, {
+      return insertNodes(editor, blocks, {
         at: editor.selection,
         select: true
       });
@@ -4932,7 +5228,7 @@ var deleteBackwardList = function deleteBackwardList(editor, unit) {
         return node.type === BLOCKS.LIST_ITEM;
       }
     })) {
-      Editor.withoutNormalizing(editor, function () {
+      withoutNormalizing(editor, function () {
         moved = removeFirstListItem(editor, {
           list: list,
           listItem: listItem
@@ -4945,7 +5241,9 @@ var deleteBackwardList = function deleteBackwardList(editor, unit) {
         if (moved) return;
 
         if (isFirstChild(listItem[1]) && !isListNested(editor, list[1])) {
-          onKeyDownResetNode(editor, mockPlugin({
+          onKeyDownResetNode(editor, // TODO look into this
+          // @ts-expect-error
+          mockPlugin({
             options: {
               rules: [{
                 types: [BLOCKS.LIST_ITEM],
@@ -4965,6 +5263,8 @@ var deleteBackwardList = function deleteBackwardList(editor, unit) {
         }
 
         deleteFragment(editor, {
+          // FIXME: see if we can remove unit
+          // @ts-expect-error
           unit: unit,
           reverse: true
         });
@@ -5002,7 +5302,7 @@ var withList = function withList(editor) {
   };
 
   editor.insertBreak = insertListBreak(editor);
-  editor.insertFragment = insertListFragment(editor); // TODO: replace with Normalizer rules
+  editor.insertFragment = insertListFragment(editor); // TODO: replace with our own Normalizer rules
 
   editor.normalizeNode = normalizeList(editor, {
     validLiChildrenTypes: validLiChildrenTypes
@@ -5293,42 +5593,44 @@ var createItalicPlugin = function createItalicPlugin() {
   });
 };
 
-var ToolbarUnderlineButton = /*#__PURE__*/createMarkToolbarButton({
-  title: 'Underline',
-  mark: MARKS.UNDERLINE,
-  icon: /*#__PURE__*/createElement(FormatUnderlinedIcon, null)
+var styles$g = {
+  subscript: /*#__PURE__*/css({
+    verticalAlign: 'sub',
+    fontSize: 'smaller'
+  })
+};
+var ToolbarSubscriptButton = /*#__PURE__*/createMarkToolbarButton({
+  title: 'Subscript',
+  mark: MARKS.SUBSCRIPT,
+  icon: /*#__PURE__*/createElement(SubscriptIcon, {
+    viewBox: "0 0 23 18"
+  })
 });
-function Underline(props) {
-  return /*#__PURE__*/createElement("u", _extends({}, props.attributes), props.children);
+var ToolbarDropdownSubscriptButton = /*#__PURE__*/createMarkToolbarButton({
+  title: 'Subscript',
+  mark: MARKS.SUBSCRIPT
+});
+function Subscript(props) {
+  return /*#__PURE__*/createElement("sub", _extends({}, props.attributes, {
+    className: styles$g.subscript
+  }), props.children);
 }
-var createUnderlinePlugin = function createUnderlinePlugin() {
-  return createUnderlinePlugin$1({
-    type: MARKS.UNDERLINE,
-    component: Underline,
-    options: {
-      hotkey: ['mod+u']
-    },
+var createSubscriptPlugin = function createSubscriptPlugin() {
+  return createSubscriptPlugin$1({
+    type: MARKS.SUBSCRIPT,
+    component: Subscript,
     handlers: {
-      onKeyDown: buildMarkEventHandler(MARKS.UNDERLINE)
+      onKeyDown: buildMarkEventHandler(MARKS.SUBSCRIPT)
     },
     deserializeHtml: {
       rules: [{
-        validNodeName: ['U']
-      }, {
-        validStyle: {
-          textDecoration: ['underline']
-        }
-      }],
-      query: function query(el) {
-        return !someHtmlElement(el, function (node) {
-          return node.style.textDecoration === 'none';
-        });
-      }
+        validNodeName: ['SUB']
+      }]
     }
   });
 };
 
-var styles$g = {
+var styles$h = {
   superscript: /*#__PURE__*/css({
     verticalAlign: 'super',
     fontSize: 'smaller'
@@ -5345,7 +5647,7 @@ var ToolbarDropdownSuperscriptButton = /*#__PURE__*/createMarkToolbarButton({
 });
 function Superscript(props) {
   return /*#__PURE__*/createElement("sup", _extends({}, props.attributes, {
-    className: styles$g.superscript
+    className: styles$h.superscript
   }), props.children);
 }
 var createSuperscriptPlugin = function createSuperscriptPlugin() {
@@ -5363,39 +5665,37 @@ var createSuperscriptPlugin = function createSuperscriptPlugin() {
   });
 };
 
-var styles$h = {
-  subscript: /*#__PURE__*/css({
-    verticalAlign: 'sub',
-    fontSize: 'smaller'
-  })
-};
-var ToolbarSubscriptButton = /*#__PURE__*/createMarkToolbarButton({
-  title: 'Subscript',
-  mark: MARKS.SUBSCRIPT,
-  icon: /*#__PURE__*/createElement(SubscriptIcon, {
-    viewBox: "0 0 23 18"
-  })
-});
-var ToolbarDropdownSubscriptButton = /*#__PURE__*/createMarkToolbarButton({
-  title: 'Subscript',
-  mark: MARKS.SUBSCRIPT
+var ToolbarUnderlineButton = /*#__PURE__*/createMarkToolbarButton({
+  title: 'Underline',
+  mark: MARKS.UNDERLINE,
+  icon: /*#__PURE__*/createElement(FormatUnderlinedIcon, null)
 });
-function Subscript(props) {
-  return /*#__PURE__*/createElement("sub", _extends({}, props.attributes, {
-    className: styles$h.subscript
-  }), props.children);
+function Underline(props) {
+  return /*#__PURE__*/createElement("u", _extends({}, props.attributes), props.children);
 }
-var createSubscriptPlugin = function createSubscriptPlugin() {
-  return createSubscriptPlugin$1({
-    type: MARKS.SUBSCRIPT,
-    component: Subscript,
+var createUnderlinePlugin = function createUnderlinePlugin() {
+  return createUnderlinePlugin$1({
+    type: MARKS.UNDERLINE,
+    component: Underline,
+    options: {
+      hotkey: ['mod+u']
+    },
     handlers: {
-      onKeyDown: buildMarkEventHandler(MARKS.SUBSCRIPT)
+      onKeyDown: buildMarkEventHandler(MARKS.UNDERLINE)
     },
     deserializeHtml: {
       rules: [{
-        validNodeName: ['SUB']
-      }]
+        validNodeName: ['U']
+      }, {
+        validStyle: {
+          textDecoration: ['underline']
+        }
+      }],
+      query: function query(el) {
+        return !someHtmlElement(el, function (node) {
+          return node.style.textDecoration === 'none';
+        });
+      }
     }
   });
 };
@@ -5407,7 +5707,7 @@ var createMarksPlugin = function createMarksPlugin() {
   };
 };
 
-var isInline = function isInline(node) {
+var isInline$1 = function isInline(node) {
   return INLINE_TYPES.includes(node.type);
 };
 
@@ -5419,13 +5719,13 @@ var isTextContainer = function isTextContainer(node) {
 
 var baseRules = [{
   // Wrap orphaned text nodes in a paragraph
-  match: Text.isText,
+  match: isText,
   validNode: function validNode(editor, _ref) {
-    var _getParent;
+    var _getParentNode;
 
     var path = _ref[1];
-    var parent = (_getParent = getParent(editor, path)) == null ? void 0 : _getParent[0];
-    return !!parent && (isTextContainer(parent) || isInline(parent) || editor.isVoid(parent));
+    var parent = (_getParentNode = getParentNode(editor, path)) == null ? void 0 : _getParentNode[0];
+    return !!parent && (isTextContainer(parent) || isInline$1(parent) || editor.isVoid(parent));
   },
   transform: function transform(editor, entry) {
     return transformWrapIn(BLOCKS.PARAGRAPH)(editor, entry);
@@ -5436,10 +5736,10 @@ var baseRules = [{
     type: INLINE_TYPES
   },
   validNode: function validNode(editor, _ref2) {
-    var _getParent2;
+    var _getParentNode2;
 
     var path = _ref2[1];
-    var parent = (_getParent2 = getParent(editor, path)) == null ? void 0 : _getParent2[0];
+    var parent = (_getParentNode2 = getParentNode(editor, path)) == null ? void 0 : _getParentNode2[0];
     return !!parent && isTextContainer(parent);
   },
   transform: /*#__PURE__*/transformWrapIn(BLOCKS.PARAGRAPH)
@@ -5457,19 +5757,9 @@ var NormalizerError = /*#__PURE__*/function (_Error) {
 var createValidatorFromTypes = function createValidatorFromTypes(types) {
   return function (_, _ref) {
     var node = _ref[0];
-    return Element.isElement(node) && types.includes(node.type);
+    return isElement(node) && types.includes(node.type);
   };
 };
-var getChildren = function getChildren(editor, _ref2) {
-  var node = _ref2[0],
-      path = _ref2[1];
-
-  if (Text.isText(node)) {
-    return [];
-  }
-
-  return Array.from(Node.children(editor, path));
-};
 var createTransformerFromObject = function createTransformerFromObject(transforms) {
   // A default transformer must always be provided
   var fallback = transforms['default'];
@@ -5480,7 +5770,7 @@ var createTransformerFromObject = function createTransformerFromObject(transform
 
   return function (editor, entry) {
     var node = entry[0];
-    var key = Element.isElement(node) ? node.type : 'default';
+    var key = isElement(node) ? node.type : 'default';
     var transformer = transforms[key] || fallback;
     return transformer(editor, entry);
   };
@@ -5510,7 +5800,7 @@ var withNormalizer = function withNormalizer(editor) {
 
       if (!rule.match) {
         rule.match = {
-          type: getPluginType(editor, p.key)
+          type: getPluginType$1(editor, p.key)
         };
       } // Conditional transformation e.g.
       // {
@@ -5548,22 +5838,23 @@ var withNormalizer = function withNormalizer(editor) {
 
 
   var _transform = function _transform(tr, entry) {
-    Editor.withoutNormalizing(editor, function () {
+    withoutNormalizing(editor, function () {
       tr(editor, entry);
     });
   };
 
-  var normalizeNode = editor.normalizeNode;
+  var normalizeNode = editor.normalizeNode; // @ts-expect-error
 
   editor.normalizeNode = function (entry) {
-    var node = entry[0];
-    var children = getChildren(editor, entry); // The order of validNode rules Vs validChildren doesn't matter. Slate
+    var node = entry[0],
+        path = entry[1];
+    var children = getChildren(entry); // The order of validNode rules Vs validChildren doesn't matter. Slate
     // will always perform normalization in a depth-first fashion.
 
     for (var _iterator2 = _createForOfIteratorHelperLoose(rules), _step2; !(_step2 = _iterator2()).done;) {
       var rule = _step2.value;
 
-      if (!match(node, rule.match)) {
+      if (!matchNode(node, path, rule.match)) {
         continue;
       } // Normalize node
 
@@ -5605,7 +5896,6 @@ var withNormalizer = function withNormalizer(editor) {
 var createNormalizerPlugin = function createNormalizerPlugin() {
   return {
     key: 'NormalizerPlugin',
-    // @ts-expect-error
     withOverrides: withNormalizer
   };
 };
@@ -5846,7 +6136,7 @@ function Quote(props) {
  */
 
 var shouldResetQuoteOnBackspace = function shouldResetQuoteOnBackspace(editor) {
-  var container = getAbove(editor, {
+  var container = getAboveNode(editor, {
     match: {
       type: TEXT_CONTAINERS
     },
@@ -5885,11 +6175,11 @@ function toggleQuote(editor, logAction) {
   logAction == null ? void 0 : logAction(isActive ? 'remove' : 'insert', {
     nodeType: BLOCKS.QUOTE
   });
-  Editor.withoutNormalizing(editor, function () {
+  withoutNormalizing(editor, function () {
     if (!editor.selection) return;
-    Transforms.unwrapNodes(editor, {
+    unwrapNodes(editor, {
       match: function match(node) {
-        return Element.isElement(node) && node.type === BLOCKS.QUOTE;
+        return isElement(node) && node.type === BLOCKS.QUOTE;
       },
       split: true
     });
@@ -5900,7 +6190,7 @@ function toggleQuote(editor, logAction) {
         data: {},
         children: []
       };
-      Transforms.wrapNodes(editor, quote);
+      wrapNodes(editor, quote);
     }
   });
 }
@@ -5921,12 +6211,12 @@ var withQuote = function withQuote(editor) {
   editor.insertFragment = function (fragment) {
     var startingNode = fragment.length && fragment[0];
     var startsWithBlockquote = Element.isElement(startingNode) && startingNode.type === BLOCKS.QUOTE;
-    var containerEntry = getAbove(editor, {
+    var containerEntry = getAboveNode(editor, {
       match: {
         type: TEXT_CONTAINERS
       }
     });
-    var containerIsNotEmpty = containerEntry && Node.string(containerEntry[0]) !== '';
+    var containerIsNotEmpty = containerEntry && getText(editor, containerEntry[1]) !== '';
 
     if (startsWithBlockquote && containerIsNotEmpty) {
       var selection = editor.selection;
@@ -5937,22 +6227,22 @@ var withQuote = function withQuote(editor) {
 
 
       if (isContentSelected(selection)) {
-        Transforms["delete"](editor, {
+        deleteText(editor, {
           at: selection
         });
       } // get the cursor entry again, it may be different after deletion
 
 
-      var _containerEntry = getAbove(editor, {
+      var _containerEntry = getAboveNode(editor, {
         match: {
           type: TEXT_CONTAINERS
         }
       });
 
-      var _containerIsNotEmpty = _containerEntry && Node.string(_containerEntry[0]) !== '';
+      var _containerIsNotEmpty = _containerEntry && getText(editor, _containerEntry[1]) !== '';
 
       if (_containerIsNotEmpty) {
-        Transforms.insertNodes(editor, fragment);
+        insertNodes(editor, fragment);
         return;
       }
     }
@@ -6027,15 +6317,17 @@ var createSelectOnBackspacePlugin = function createSelectOnBackspacePlugin() {
   });
 };
 
+var useReadOnly = useReadOnly$1;
+
 var addRow = function addRow(editor, getNextRowPath) {
   if (someNode(editor, {
     match: {
-      type: getPluginType(editor, ELEMENT_TABLE)
+      type: BLOCKS.TABLE
     }
   })) {
-    var currentRowItem = getAbove(editor, {
+    var currentRowItem = getAboveNode(editor, {
       match: {
-        type: getPluginType(editor, ELEMENT_TR)
+        type: BLOCKS.TABLE_ROW
       }
     });
 
@@ -6043,8 +6335,7 @@ var addRow = function addRow(editor, getNextRowPath) {
       var currentRowElem = currentRowItem[0],
           currentRowPath = currentRowItem[1];
       var nextRowPath = getNextRowPath(currentRowPath);
-      insertNodes(editor, // @ts-expect-error
-      getEmptyRowNode(editor, {
+      insertNodes(editor, getEmptyRowNode(editor, {
         header: false,
         colCount: currentRowElem.children.length
       }), {
@@ -6053,14 +6344,14 @@ var addRow = function addRow(editor, getNextRowPath) {
         select: true
       }); // Select the first cell in the current row
 
-      Transforms.select(editor, Editor.start(editor, nextRowPath));
+      select(editor, getStartPoint(editor, nextRowPath));
     }
   }
 };
 
 var addRowBelow = function addRowBelow(editor) {
   addRow(editor, function (currentRowPath) {
-    return Path.next(currentRowPath);
+    return getNextPath(currentRowPath);
   });
 };
 var addRowAbove = function addRowAbove(editor) {
@@ -6075,17 +6366,17 @@ var addColumn = function addColumn(editor, _ref, getNextCellPath) {
 
   if (someNode(editor, {
     match: {
-      type: getPluginType(editor, ELEMENT_TABLE)
+      type: BLOCKS.TABLE
     }
   })) {
-    var currentCellItem = getAbove(editor, {
+    var currentCellItem = getAboveNode(editor, {
       match: {
-        type: [getPluginType(editor, ELEMENT_TD), getPluginType(editor, ELEMENT_TH)]
+        type: [BLOCKS.TABLE_HEADER_CELL, BLOCKS.TABLE_CELL]
       }
     });
-    var currentTableItem = getAbove(editor, {
+    var currentTableItem = getAboveNode(editor, {
       match: {
-        type: getPluginType(editor, ELEMENT_TABLE)
+        type: BLOCKS.TABLE
       }
     });
 
@@ -6095,8 +6386,7 @@ var addColumn = function addColumn(editor, _ref, getNextCellPath) {
       var replacePathPos = newCellPath.length - 2;
       currentTableItem[0].children.forEach(function (_, rowIdx) {
         newCellPath[replacePathPos] = rowIdx;
-        insertNodes(editor, // @ts-expect-error
-        getEmptyCellNode(editor, {
+        insertNodes(editor, getEmptyCellNode(editor, {
           header: header && rowIdx === 0
         }), {
           at: newCellPath,
@@ -6110,7 +6400,7 @@ var addColumn = function addColumn(editor, _ref, getNextCellPath) {
 
 var addColumnRight = function addColumnRight(editor, options) {
   addColumn(editor, options, function (currentCellPath) {
-    return Path.next(currentCellPath);
+    return getNextPath(currentCellPath);
   });
 };
 var addColumnLeft = function addColumnLeft(editor, options) {
@@ -6120,7 +6410,7 @@ var addColumnLeft = function addColumnLeft(editor, options) {
 };
 
 var setHeader = function setHeader(editor, enable) {
-  var tableItem = getAbove(editor, {
+  var tableItem = getAboveNode(editor, {
     match: {
       type: BLOCKS.TABLE
     }
@@ -6130,13 +6420,13 @@ var setHeader = function setHeader(editor, enable) {
     return;
   }
 
-  var firstRow = getChildren$1(tableItem)[0];
+  var firstRow = getChildren(tableItem)[0];
 
   if (!firstRow) {
     return;
   }
 
-  getChildren$1(firstRow).forEach(function (_ref) {
+  getChildren(firstRow).forEach(function (_ref) {
     var path = _ref[1];
     setNodes(editor, {
       type: enable ? BLOCKS.TABLE_HEADER_CELL : BLOCKS.TABLE_CELL
@@ -6147,9 +6437,30 @@ var setHeader = function setHeader(editor, enable) {
 };
 
 function insertTableAndFocusFirstCell(editor) {
-  insertTable(editor, {
-    header: true
-  });
+  var table = {
+    type: BLOCKS.TABLE,
+    data: {},
+    children: [getEmptyRowNode(editor, {
+      colCount: 2,
+      header: true
+    }), getEmptyRowNode(editor, {
+      colCount: 2
+    })]
+  };
+  insertNodes(editor, table);
+
+  if (editor.selection) {
+    var tableEntry = getBlockAbove(editor, {
+      match: {
+        type: BLOCKS.TABLE
+      }
+    });
+    if (!tableEntry) return;
+    selectEditor(editor, {
+      at: getStartPoint(editor, tableEntry[1])
+    });
+  }
+
   replaceEmptyParagraphWithTable(editor);
 }
 function isTableActive(editor) {
@@ -6159,7 +6470,7 @@ function isTableActive(editor) {
   });
 }
 function isTableHeaderEnabled(editor) {
-  var tableItem = getAbove(editor, {
+  var tableItem = getAboveNode(editor, {
     match: {
       type: BLOCKS.TABLE
     }
@@ -6169,30 +6480,30 @@ function isTableHeaderEnabled(editor) {
     return false;
   }
 
-  var firstRow = getChildren$1(tableItem)[0];
+  var firstRow = getChildren(tableItem)[0];
 
   if (!firstRow) {
     return false;
   }
 
-  return getChildren$1(firstRow).every(function (_ref) {
+  return getChildren(firstRow).every(function (_ref) {
     var node = _ref[0];
     return node.type === BLOCKS.TABLE_HEADER_CELL;
   });
 }
 function replaceEmptyParagraphWithTable(editor) {
   var tablePath = getAncestorPathFromSelection(editor);
-  if (!tablePath || isFirstChild(tablePath)) return;
-  var previousPath = Path.previous(tablePath);
+  if (!tablePath || isFirstChildPath(tablePath)) return;
+  var previousPath = getPreviousPath(tablePath);
   if (!previousPath) return;
 
-  var _Editor$nodes = Editor.nodes(editor, {
+  var _getNodeEntries = getNodeEntries(editor, {
     at: previousPath,
     match: function match(node) {
       return node.type === BLOCKS.PARAGRAPH;
     }
   }),
-      nodes = _Editor$nodes[0];
+      nodes = _getNodeEntries[0];
 
   if (!nodes) return;
   var previousNode = nodes[0];
@@ -6200,12 +6511,12 @@ function replaceEmptyParagraphWithTable(editor) {
 
   if (isPreviousNodeTextEmpty) {
     // Switch table with previous empty paragraph
-    Transforms.moveNodes(editor, {
+    moveNodes(editor, {
       at: tablePath,
       to: previousPath
     }); // Remove previous paragraph that now is under the table
 
-    Transforms.removeNodes(editor, {
+    removeNodes(editor, {
       at: tablePath
     });
   }
@@ -6217,21 +6528,19 @@ function replaceEmptyParagraphWithTable(editor) {
  * normalization cycles.
  */
 
-var getNoOfMissingTableCellsInRow = function getNoOfMissingTableCellsInRow(editor, _ref2) {
-  var rowPath = _ref2[1];
-  var parent = getParent(editor, rowPath); // This is ensured by normalization. The error is here just in case
+var getNoOfMissingTableCellsInRow = function getNoOfMissingTableCellsInRow(editor, rowEntry) {
+  var rowPath = rowEntry[1];
+  var parent = getParentNode(editor, rowPath); // This is ensured by normalization. The error is here just in case
 
   if (!parent) {
     throw new Error('table rows must be wrapped in a table node');
-  }
+  } // The longest table row determines its width
 
-  var tablePath = parent[1]; // The longest table row determines its width
 
-  var tableWidth = Math.max.apply(Math, Array.from(Node.children(editor, tablePath)).map(function (_ref3) {
-    var path = _ref3[1];
-    return Array.from(Node.children(editor, path)).length;
+  var tableWidth = Math.max.apply(Math, getChildren(parent).map(function (entry) {
+    return getChildren(entry).length;
   }));
-  var rowWidth = Array.from(Node.children(editor, rowPath)).length;
+  var rowWidth = getChildren(rowEntry).length;
   return tableWidth - rowWidth;
 };
 var createEmptyTableCells = function createEmptyTableCells(count) {
@@ -6248,12 +6557,11 @@ var createEmptyTableCells = function createEmptyTableCells(count) {
   };
   return new Array(count).fill(emptyTableCell);
 };
-var isNotEmpty = function isNotEmpty(editor, _ref4) {
-  var path = _ref4[1];
-  return Array.from(Node.children(editor, path)).length !== 0;
+var isNotEmpty = function isNotEmpty(_, entry) {
+  return getChildren(entry).length !== 0;
 };
 var isTable = function isTable(node) {
-  return Element.isElement(node) && node.type === BLOCKS.TABLE;
+  return isElement(node) && node.type === BLOCKS.TABLE;
 };
 
 var styles$j = {
@@ -6294,7 +6602,7 @@ var TableActions = function TableActions() {
       return false;
     }
 
-    var headerCell = getAbove(editor, {
+    var headerCell = getAboveNode(editor, {
       match: {
         type: BLOCKS.TABLE_HEADER_CELL
       }
@@ -6317,7 +6625,7 @@ var TableActions = function TableActions() {
       if (!(editor != null && editor.selection)) return;
       close();
       var tableSize = getCurrentTableSize(editor);
-      Editor.withoutNormalizing(editor, function () {
+      withoutNormalizing(editor, function () {
         cb(editor, {
           header: isHeaderEnabled
         });
@@ -6419,7 +6727,7 @@ var Table = function Table(props) {
 var trimUnnecessaryTableWrapper = function trimUnnecessaryTableWrapper(node) {
   var _node$children, _row$children;
 
-  if (!Element.isElement(node)) {
+  if (!isElement(node)) {
     return [node];
   } // must be a table with a single row
 
@@ -6469,20 +6777,21 @@ var insertTableFragment = function insertTableFragment(editor) {
 var onKeyDownTable = function onKeyDownTable(editor, plugin) {
   var defaultHandler = onKeyDownTable$1(editor, plugin);
   return function (event) {
-    // This fixes `Cannot resolve a Slate point from DOM point: [object HTMLDivElement]` when typing while the cursor is before table
+    // This fixes `Cannot resolve a Slate point from DOM point:
+    // [object HTMLDivElement]` when typing while the cursor is before table
     var windowSelection = window.getSelection();
 
     if (windowSelection) {
       var _windowSelection$anch, _windowSelection$anch2;
 
       // @ts-expect-error
-      var blockType = (_windowSelection$anch = windowSelection.anchorNode.attributes) == null ? void 0 : (_windowSelection$anch2 = _windowSelection$anch['data-block-type']) == null ? void 0 : _windowSelection$anch2.value; // this attribute comes from `plugins/Table/components/Table.tsx`
-
+      // this attribute comes from `plugins/Table/components/Table.tsx`
+      var blockType = (_windowSelection$anch = windowSelection.anchorNode.attributes) == null ? void 0 : (_windowSelection$anch2 = _windowSelection$anch['data-block-type']) == null ? void 0 : _windowSelection$anch2.value;
       var isBeforeTable = blockType === BLOCKS.TABLE;
 
       if (isBeforeTable) {
         if (event.key === 'Enter') {
-          var above = getAbove(editor, {
+          var above = getAboveNode(editor, {
             match: {
               type: BLOCKS.TABLE
             }
@@ -6504,15 +6813,15 @@ var onKeyDownTable = function onKeyDownTable(editor, plugin) {
 
 
     if (event.key === 'Tab' && !event.shiftKey) {
-      var res = getTableCellEntry(editor, {});
+      event.preventDefault();
+      var entry = getTableEntries(editor, {});
 
-      if (res) {
-        event.preventDefault();
-        var tableElement = res.tableElement,
-            tableRow = res.tableRow,
-            tableCell = res.tableCell;
-        var isLastCell = isLastChild(tableRow, tableCell[1]);
-        var isLastRow = isLastChild(tableElement, tableRow[1]);
+      if (entry) {
+        var table = entry.table,
+            row = entry.row,
+            cell = entry.cell;
+        var isLastCell = isLastChildPath(row, cell[1]);
+        var isLastRow = isLastChildPath(table, row[1]);
 
         if (isLastRow && isLastCell) {
           addRowBelow(editor); // skip default handler
@@ -6525,7 +6834,7 @@ var onKeyDownTable = function onKeyDownTable(editor, plugin) {
     }
 
     if (event.key === 'Escape') {
-      ReactEditor.blur(editor);
+      blurEditor(editor);
     }
   };
 };
@@ -6808,7 +7117,7 @@ var withInvalidCellChildrenTracking = function withInvalidCellChildrenTracking(t
   return function (editor, childEntry) {
     var node = childEntry[0];
 
-    if (Element.isElement(node)) {
+    if (isElement(node)) {
       var _editor$tracking;
 
       (_editor$tracking = editor.tracking) == null ? void 0 : _editor$tracking.onViewportAction('invalidTablePaste', {
@@ -6826,11 +7135,16 @@ var createTablePlugin = function createTablePlugin() {
   return createTablePlugin$1({
     type: BLOCKS.TABLE,
     handlers: {
+      // @ts-expect-error
       onKeyDown: onKeyDownTable
     },
     withOverrides: function withOverrides(editor, plugin) {
-      // injects important fixes from plate's original table plugin
-      withTable(editor, plugin);
+      var normalizeNode = editor.normalizeNode; // injects important fixes from plate's original table plugin
+
+      withTable(editor, plugin); // Resets all normalization rules added by @udecode/plate-table as
+      // they conflict with our own
+
+      editor.normalizeNode = normalizeNode;
       addTableTrackingEvents(editor);
       editor.insertFragment = insertTableFragment(editor);
       return editor;
@@ -6844,6 +7158,8 @@ var createTablePlugin = function createTablePlugin() {
         // Move to root level unless nested
         validNode: function validNode(editor, _ref) {
           var path = _ref[1];
+          // Nested tables are handled by another normalization
+          // rule in a the table cell level
           var isNestedTable = !!getBlockAbove(editor, {
             at: path,
             match: {
@@ -6868,10 +7184,10 @@ var createTablePlugin = function createTablePlugin() {
       }, {
         // Parent must be a table
         validNode: function validNode(editor, _ref2) {
-          var _getParent;
+          var _getParentNode;
 
           var path = _ref2[1];
-          var parent = (_getParent = getParent(editor, path)) == null ? void 0 : _getParent[0];
+          var parent = (_getParentNode = getParentNode(editor, path)) == null ? void 0 : _getParentNode[0];
           return parent && parent.type === BLOCKS.TABLE;
         },
         transform: transformWrapIn(BLOCKS.TABLE)
@@ -6882,8 +7198,8 @@ var createTablePlugin = function createTablePlugin() {
         },
         transform: function transform(editor, entry) {
           var howMany = getNoOfMissingTableCellsInRow(editor, entry);
-          var at = Path.next(getLastChildPath(entry));
-          Transforms.insertNodes(editor, createEmptyTableCells(howMany), {
+          var at = getNextPath(getLastChildPath(entry));
+          insertNodes(editor, createEmptyTableCells(howMany), {
             at: at
           });
         }
@@ -6948,7 +7264,7 @@ function ToolbarTableButton(props) {
     testId: "table-toolbar-button",
     onClick: handleClick,
     // TODO: active state looks off since the button will be disabled. Do we still need it?
-    isActive: isActive,
+    isActive: !!isActive,
     isDisabled: props.isDisabled
   }, /*#__PURE__*/createElement(TableIcon, null));
 }
@@ -6970,7 +7286,7 @@ function createTextPlugin(restrictedMarks) {
             return;
           }
 
-          Transforms.setSelection(editor, Editor.unhangRange(editor, editor.selection));
+          setSelection(editor, unhangRange(editor, editor.selection));
         };
       }
     },
@@ -6986,19 +7302,19 @@ function createTextPlugin(restrictedMarks) {
         var selection = editor.selection; // If the cursor is at the end of an inline, move it outside
         // before inserting
 
-        if (selection && Range.isCollapsed(selection)) {
-          var _Editor$above;
+        if (selection && isRangeCollapsed(selection)) {
+          var _getAboveNode;
 
-          var inlinePath = (_Editor$above = Editor.above(editor, {
+          var inlinePath = (_getAboveNode = getAboveNode(editor, {
             match: function match(n) {
-              return Editor.isInline(editor, n);
+              return isInline(editor, n);
             },
             mode: 'highest'
-          })) == null ? void 0 : _Editor$above[1];
+          })) == null ? void 0 : _getAboveNode[1];
 
-          if (inlinePath && Editor.isEnd(editor, selection.anchor, inlinePath)) {
-            var point = Editor.after(editor, inlinePath);
-            Transforms.setSelection(editor, {
+          if (inlinePath && isEndPoint(editor, selection.anchor, inlinePath)) {
+            var point = getPointAfter(editor, inlinePath);
+            setSelection(editor, {
               anchor: point,
               focus: point
             });
@@ -7024,7 +7340,7 @@ function createTextPlugin(restrictedMarks) {
       return editor;
     },
     normalizer: [{
-      match: Text.isText,
+      match: isText,
       transform: function transform(editor, _ref) {
         var path = _ref[1];
         unsetNodes(editor, restrictedMarks, {
@@ -7042,7 +7358,7 @@ function createTextPlugin(restrictedMarks) {
 }
 
 function deleteEmptyParagraph(unit, editor, deleteFunction) {
-  var entry = getAbove(editor, {
+  var entry = getAboveNode(editor, {
     match: {
       type: TEXT_CONTAINERS
     }
@@ -7057,15 +7373,15 @@ function deleteEmptyParagraph(unit, editor, deleteFunction) {
     var hasSiblings = editor.children.length > 1; // prevent editor from losing focus
 
     if (isTextEmpty && isRootLevel && hasSiblings) {
-      Transforms.removeNodes(editor, {
+      removeNodes(editor, {
         at: path
       });
-      var prevNode = Editor.before(editor, editor.selection, {
+      var prevNode = getPointBefore(editor, editor.selection, {
         unit: unit
       });
 
       if (prevNode) {
-        var _Editor$nodes = Editor.nodes(editor, {
+        var _getNodeEntries = getNodeEntries(editor, {
           match: function match(node) {
             return queryNode([node, prevNode.path], {
               allow: [BLOCKS.EMBEDDED_ASSET, BLOCKS.EMBEDDED_ENTRY, BLOCKS.HR]
@@ -7073,10 +7389,10 @@ function deleteEmptyParagraph(unit, editor, deleteFunction) {
           },
           at: prevNode
         }),
-            prevCell = _Editor$nodes[0];
+            prevCell = _getNodeEntries[0];
 
         if (prevCell) {
-          Transforms.select(editor, prevNode);
+          select(editor, prevNode);
         }
       }
     } else {
@@ -7113,7 +7429,7 @@ function fixPasteAsPlainText(editor) {
       }
 
       if (split) {
-        Transforms.splitNodes(editor, {
+        splitNodes(editor, {
           always: true
         });
       }
@@ -7147,7 +7463,7 @@ var createVoidsPlugin = function createVoidsPlugin() {
         filter: function filter(_ref) {
           var node = _ref[0],
               path = _ref[1];
-          return isRootLevel(path) && isFirstChild(path) && !!node.isVoid;
+          return isRootLevel(path) && isFirstChildPath(path) && !!node.isVoid;
         }
       }
     }, {
@@ -7160,7 +7476,7 @@ var createVoidsPlugin = function createVoidsPlugin() {
         filter: function filter(_ref2) {
           var node = _ref2[0],
               path = _ref2[1];
-          return !(isRootLevel(path) && isFirstChild(path)) && !!node.isVoid;
+          return !(isRootLevel(path) && isFirstChildPath(path)) && !!node.isVoid;
         }
       }
     }]
@@ -7247,7 +7563,7 @@ var hasContent = function hasContent(doc) {
 
 var setEditorContent = function setEditorContent(editor, nodes) {
   // Replaces editor content while keeping change history
-  Editor.withoutNormalizing(editor, function () {
+  withoutNormalizing(editor, function () {
     var children = [].concat(editor.children);
     children.forEach(function (node) {
       return editor.apply({
@@ -7258,9 +7574,9 @@ var setEditorContent = function setEditorContent(editor, nodes) {
     });
 
     if (nodes) {
-      var nodesArray = Node.isNode(nodes) ? [nodes] : nodes;
+      var nodesArray = isNode(nodes) ? [nodes] : nodes;
       nodesArray.forEach(function (node, i) {
-        return editor.apply({
+        editor.apply({
           type: 'insert_node',
           path: [i],
           node: node
@@ -7268,10 +7584,10 @@ var setEditorContent = function setEditorContent(editor, nodes) {
       });
     }
 
-    var point = Editor.end(editor, []);
+    var point = getEndPoint(editor, []);
 
     if (point) {
-      Transforms.select(editor, point);
+      select(editor, point);
     }
   });
 };
@@ -7291,7 +7607,7 @@ var documentToEditorValue = function documentToEditorValue(doc) {
 var normalizeEditorValue = function normalizeEditorValue(value, options) {
   var editor = createPlateEditor(options);
   editor.children = value;
-  Editor.normalize(editor, {
+  normalize(editor, {
     force: true
   });
   return editor.children;
@@ -7399,7 +7715,7 @@ var EmbedEntityWidget = function EmbedEntityWidget(_ref) {
     nodeType: BLOCKS.EMBEDDED_ENTRY,
     onClose: onCloseEntityDropdown
   }), inlineEntryEmbedEnabled && /*#__PURE__*/React__default.createElement(ToolbarEmbeddedEntityInlineButton, {
-    isDisabled: !!isDisabled || isLinkActive(editor),
+    isDisabled: !!isDisabled || Boolean(isLinkActive(editor)),
     onClose: onCloseEntityDropdown
   }), blockAssetEmbedEnabled && /*#__PURE__*/React__default.createElement(EmbeddedEntityBlockToolbarIcon, {
     isDisabled: !!isDisabled,
@@ -7457,7 +7773,7 @@ var Dropdown = function Dropdown(_ref) {
   var sdk = _ref.sdk,
       isDisabled = _ref.isDisabled;
   var editor = useContentfulEditor();
-  var isActive = isMarkActive(editor, MARKS.SUPERSCRIPT) || isMarkActive(editor, MARKS.SUBSCRIPT) || isMarkActive(editor, MARKS.CODE);
+  var isActive = editor && (isMarkActive(editor, MARKS.SUPERSCRIPT) || isMarkActive(editor, MARKS.SUBSCRIPT) || isMarkActive(editor, MARKS.CODE));
   return /*#__PURE__*/React__default.createElement(Menu, null, /*#__PURE__*/React__default.createElement(Menu.Trigger, null, /*#__PURE__*/React__default.createElement("span", null, /*#__PURE__*/React__default.createElement(IconButton, {
     size: "small",
     className: styles$l.toolbarBtn,
@@ -7611,7 +7927,7 @@ var useOnValueChanged = function useOnValueChanged(_ref) {
     }, 500);
   }, [handler]);
   return useCallback(function (value) {
-    var editor = getPlateSelectors(editorId).editor();
+    var editor = getPlateSelectors$1(editorId).editor();
 
     if (!editor) {
       throw new Error('Editor change callback called but editor not defined. Editor id: ' + editorId);
@@ -7684,7 +8000,9 @@ var ConnectedRichTextEditor = function ConnectedRichTextEditor(props) {
       return;
     }
 
-    getPlateActions(id).value(normalizeEditorValue(documentToEditorValue(props.value), {
+    getPlateActions(id).value( // FIXME: fix types here
+    // @ts-expect-error
+    normalizeEditorValue(documentToEditorValue(props.value), {
       plugins: plugins,
       disableCorePlugins: disableCorePlugins
     }));
@@ -7704,12 +8022,13 @@ var ConnectedRichTextEditor = function ConnectedRichTextEditor(props) {
       className: classNames,
       readOnly: props.isDisabled
     },
-    onChange: onValueChanged
-  }, !props.isToolbarHidden && /*#__PURE__*/React__default.createElement(StickyToolbarWrapper, {
-    isDisabled: props.isDisabled
-  }, /*#__PURE__*/React__default.createElement(Toolbar, {
-    isDisabled: props.isDisabled
-  }))))));
+    onChange: onValueChanged,
+    firstChildren: !props.isToolbarHidden && /*#__PURE__*/React__default.createElement(StickyToolbarWrapper, {
+      isDisabled: props.isDisabled
+    }, /*#__PURE__*/React__default.createElement(Toolbar, {
+      isDisabled: props.isDisabled
+    }))
+  }))));
 };
 
 var RichTextEditor = function RichTextEditor(props) {