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

package/dist/field-editor-rich-text.cjs.development.js

@@ -9,7 +9,7 @@ var React__default = _interopDefault(React);
 var fieldEditorReference = require('@contentful/field-editor-reference');
 var fieldEditorShared = require('@contentful/field-editor-shared');
 var Contentful = require('@contentful/rich-text-types');
-var plateCore = require('@udecode/plate-core');
+var p = require('@udecode/plate-core');
 var emotion = require('emotion');
 var areEqual = _interopDefault(require('fast-deep-equal'));
 var noop = _interopDefault(require('lodash/noop'));
@@ -21,12 +21,12 @@ var f36Components = require('@contentful/f36-components');
 var f36Utils = require('@contentful/f36-utils');
 var constate = _interopDefault(require('constate'));
 var isHotkey = _interopDefault(require('is-hotkey'));
-var slate = require('slate');
-var Slate = require('slate-react');
+var s = require('slate');
 var find = _interopDefault(require('lodash/find'));
 var flow = _interopDefault(require('lodash/flow'));
 var get = _interopDefault(require('lodash/get'));
 var tokens = _interopDefault(require('@contentful/f36-tokens'));
+var Slate = require('slate-react');
 var f36Icons = require('@contentful/f36-icons');
 var plateList = require('@udecode/plate-list');
 var castArray = _interopDefault(require('lodash/castArray'));
@@ -273,16 +273,53 @@ function useContentfulEditorId(id) {
 
 function useContentfulEditor(id) {
   var editorId = useContentfulEditorId(id);
-  var editor = plateCore.usePlateEditorState(editorId);
+  var editor = p.usePlateEditorState(editorId);
   return editor;
 } // This doesn't re-render when the value changes
 
 function useContentfulEditorRef(id) {
   var editorId = useContentfulEditorId(id);
-  var editor = plateCore.usePlateEditorRef(editorId);
+  var editor = p.usePlateEditorRef(editorId);
   return editor;
 }
 
+var createPlateEditor = function createPlateEditor(options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  return p.createPlateEditor(options);
+};
+var withoutNormalizing = function withoutNormalizing(editor, fn) {
+  return p.withoutNormalizing(editor, fn);
+};
+var focusEditor = function focusEditor(editor, target) {
+  p.focusEditor(editor, target);
+};
+var blurEditor = function blurEditor(editor) {
+  p.blurEditor(editor);
+};
+var selectEditor = function selectEditor(editor, opts) {
+  p.selectEditor(editor, opts);
+};
+var fromDOMPoint = function fromDOMPoint(editor, domPoint, opts) {
+  if (opts === void 0) {
+    opts = {
+      exactMatch: false,
+      suppressThrow: false
+    };
+  }
+
+  return p.toSlatePoint(editor, domPoint, opts);
+};
+var mockPlugin = function mockPlugin(plugin) {
+  return p.mockPlugin( // TODO check if there is a way around this ugly casting
+  plugin);
+};
+var getPlateSelectors = function getPlateSelectors(id) {
+  return p.getPlateSelectors(id);
+};
+
 var createSoftBreakPlugin = function createSoftBreakPlugin() {
   return plateBreak.createSoftBreakPlugin({
     then: function then(editor) {
@@ -472,14 +509,280 @@ var useCommandList = function useCommandList(commandItems, container) {
   };
 };
 
+/**
+ * Get text content at location
+ */
+
+var getText = function getText(editor, at) {
+  return p.getEditorString(editor, at);
+};
+var isText = function isText(value) {
+  return p.isText(value);
+};
+var getEndPoint = function getEndPoint(editor, at) {
+  return p.getEndPoint(editor, at);
+};
+var getStartPoint = function getStartPoint(editor, at) {
+  return p.getStartPoint(editor, at);
+};
+var isNode = function isNode(value) {
+  return p.isNode(value);
+};
+var isSelectionAtBlockEnd = function isSelectionAtBlockEnd(editor, options) {
+  return p.isSelectionAtBlockEnd(editor, options);
+};
+var isSelectionAtBlockStart = function isSelectionAtBlockStart(editor, options) {
+  return p.isSelectionAtBlockStart(editor, options);
+};
+var getBlockAbove = function getBlockAbove(editor, options) {
+  return p.getBlockAbove(editor, options);
+};
+var getNodeEntry = function getNodeEntry(editor, at, options) {
+  return p.getNodeEntry(editor, at, options);
+};
+var getNodeEntries = function getNodeEntries(editor, options) {
+  return p.getNodeEntries(editor, options);
+}; // TODO: Ancestor may not be the correct type for root
+
+var getNodeChildren = function getNodeChildren(root, path, options) {
+  return p.getNodeChildren(root, path, options);
+};
+var getParentNode = function getParentNode(editor, at, options) {
+  return p.getParentNode(editor, at, options);
+};
+var someNode = function someNode(editor, options) {
+  return p.someNode(editor, options);
+};
+var getChildren = function getChildren(entry) {
+  // Node.children crashes when given a text node
+  if (s.Text.isText(entry[0])) {
+    return [];
+  }
+
+  return p.getChildren(entry);
+};
+var isFirstChild = function isFirstChild(path) {
+  return p.isFirstChild(path);
+};
+var getDescendantNodeByPath = function getDescendantNodeByPath(root, path) {
+  // @ts-expect-error
+  return s.Node.get(root, path);
+};
+var isRangeCollapsed = function isRangeCollapsed(range) {
+  return p.isCollapsed(range);
+}; // TODO: simplify
+
+var isRangeAcrossBlocks = function isRangeAcrossBlocks(editor, options) {
+  return p.isRangeAcrossBlocks(editor, options);
+};
+var isRangeExpanded = function isRangeExpanded(range) {
+  return p.isExpanded(range);
+};
+var getRange = function getRange(editor, at, to) {
+  return p.getRange(editor, at, to);
+};
+var getRangeEdges = function getRangeEdges(range) {
+  return s.Range.edges(range);
+};
+var getRangeStart = function getRangeStart(range) {
+  return s.Range.start(range);
+};
+var getRangeEnd = function getRangeEnd(range) {
+  return s.Range.end(range);
+};
+var getAboveNode = function getAboveNode(editor, opts) {
+  return p.getAboveNode(editor, opts);
+};
+var getCommonNode = function getCommonNode(root, path, another) {
+  return p.getCommonNode(root, path, another);
+};
+var getNodeTexts = function getNodeTexts(root, opts) {
+  return p.getNodeTexts(root, opts);
+};
+var findNode = function findNode(editor, options) {
+  return p.findNode(editor, options);
+};
+var isMarkActive = function isMarkActive(editor, type) {
+  return p.isMarkActive(editor, type);
+};
+var getMarks = function getMarks(editor) {
+  return p.getMarks(editor);
+};
+var isEditor = function isEditor(value) {
+  return p.isEditor(value);
+};
+var isEditorReadOnly = function isEditorReadOnly(editor) {
+  return p.isEditorReadOnly(editor);
+};
+var isElement = function isElement(value) {
+  return p.isElement(value);
+};
+var isBlockNode = function isBlockNode(editor, value) {
+  return p.isBlock(editor, value);
+};
+var findNodePath = function findNodePath(editor, node) {
+  return p.findNodePath(editor, node);
+};
+var isAncestorPath = function isAncestorPath(path, another) {
+  return s.Path.isAncestor(path, another);
+};
+var isAncestorEmpty = function isAncestorEmpty(editor, node) {
+  return p.isAncestorEmpty(editor, node);
+};
+var getParentPath = function getParentPath(path) {
+  return s.Path.parent(path);
+};
+var getNextPath = function getNextPath(path) {
+  return s.Path.next(path);
+};
+var getPreviousPath = function getPreviousPath(path) {
+  return s.Path.previous(path);
+};
+var getLastChildPath = function getLastChildPath(nodeEntry) {
+  return p.getLastChildPath(nodeEntry);
+};
+var getPathLevels = function getPathLevels(path, options) {
+  return s.Path.levels(path, options);
+};
+var isFirstChildPath = function isFirstChildPath(path) {
+  return p.isFirstChild(path);
+};
+var isLastChildPath = function isLastChildPath(entry, childPath) {
+  return p.isLastChild(entry, childPath);
+};
+var matchNode = function matchNode(node, path, fn) {
+  return p.match(node, path, fn);
+};
+var someHtmlElement = function someHtmlElement(rootNode, predicate) {
+  return p.someHtmlElement(rootNode, predicate);
+};
+var getPointBefore = function getPointBefore(editor, at, options) {
+  return p.getPointBefore(editor, at, options);
+};
+var getPointAfter = function getPointAfter(editor, at, options) {
+  return p.getPointAfter(editor, at, options);
+};
+var isEndPoint = function isEndPoint(editor, point, at) {
+  return p.isEndPoint(editor, point, at);
+};
+var isInline = function isInline(editor, value) {
+  return p.isInline(editor, value);
+};
+var queryNode = function queryNode(entry, options) {
+  return p.queryNode(entry, options);
+};
+var getPluginType = function getPluginType(editor, key) {
+  return p.getPluginType(editor, key);
+};
+var createPathRef = function createPathRef(editor, at) {
+  return p.createPathRef(editor, at);
+};
+var match = function match(obj, path, predicate) {
+  return p.match(obj, path, predicate);
+};
+var getLastNodeByLevel = function getLastNodeByLevel(editor, level) {
+  return p.getLastNodeByLevel(editor, level);
+};
+
+/**
+ * Apply editor normalization rules
+ */
+
+var normalize = function normalize(editor, options) {
+  if (options === void 0) {
+    options = {
+      force: true
+    };
+  }
+
+  return p.normalizeEditor(editor, options);
+};
+/**
+ * Set the selection to a location
+ */
+
+var setSelection = function setSelection(editor, props) {
+  return p.setSelection(editor, props);
+};
+var select = function select(editor, location) {
+  return p.select(editor, location);
+};
+var moveSelection = function moveSelection(editor, options) {
+  return p.moveSelection(editor, options);
+};
+var moveChildren = function moveChildren(editor, options) {
+  return p.moveChildren(editor, options);
+};
+var collapseSelection = function collapseSelection(editor, options) {
+  return p.collapseSelection(editor, options);
+};
+var setNodes = function setNodes(editor, attrs, opts) {
+  p.setNodes(editor, attrs, opts);
+};
+var unsetNodes = function unsetNodes(editor, props, options) {
+  p.unsetNodes(editor, props, options);
+};
+var insertNodes = function insertNodes(editor, nodes, opts) {
+  return p.insertNodes(editor, nodes, opts);
+};
+var splitNodes = function splitNodes(editor, options) {
+  return p.splitNodes(editor, options);
+};
+var liftNodes = function liftNodes(editor, options) {
+  return p.liftNodes(editor, options);
+};
+var unwrapNodes = function unwrapNodes(editor, options) {
+  return p.unwrapNodes(editor, options);
+};
+var wrapNodes = function wrapNodes(editor, element, options) {
+  return p.wrapNodes(editor, element, options);
+};
+var toggleNodeType = function toggleNodeType(editor, options, editorOptions) {
+  p.toggleNodeType(editor, options, editorOptions);
+};
+var removeMark = function removeMark(editor, type, at) {
+  p.removeMark(editor, {
+    key: type,
+    at: at
+  });
+};
+var unhangRange = function unhangRange(editor, range, options) {
+  return p.unhangRange(editor, range, options);
+};
+var toggleMark = function toggleMark(editor, options) {
+  return p.toggleMark(editor, options);
+};
+var addMark = function addMark(editor, type, value) {
+  if (value === void 0) {
+    value = true;
+  }
+
+  p.addMark(editor, type, value);
+};
+var insertText = function insertText(editor, text, options) {
+  return p.insertText(editor, text, options);
+};
+var deleteText = function deleteText(editor, opts) {
+  p.deleteText(editor, opts);
+};
+var removeNodes = function removeNodes(editor, opts) {
+  p.removeNodes(editor, opts);
+};
+var moveNodes = function moveNodes(editor, opts) {
+  p.moveNodes(editor, opts);
+};
+var deleteFragment = function deleteFragment(editor, options) {
+  return p.deleteFragment(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 = [Contentful.INLINES.HYPERLINK, Contentful.INLINES.ENTRY_HYPERLINK, Contentful.INLINES.ASSET_HYPERLINK];
 function isBlockSelected(editor, type) {
-  var _Array$from = Array.from(slate.Editor.nodes(editor, {
+  var _Array$from = Array.from(getNodeEntries(editor, {
     match: function match(node) {
-      return slate.Element.isElement(node) && node.type === type;
+      return isElement(node) && node.type === type;
     }
   })),
       match = _Array$from[0];
@@ -497,7 +800,7 @@ function getNodeEntryFromSelection(editor, nodeTypeOrTypes, path) {
   var nodeTypes = Array.isArray(nodeTypeOrTypes) ? nodeTypeOrTypes : [nodeTypeOrTypes];
 
   for (var i = 0; i < path.length; i++) {
-    var nodeEntry = slate.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;
   }
 
@@ -512,13 +815,13 @@ function isNodeTypeSelected(editor, nodeType) {
   return !!node;
 }
 function moveToTheNextLine(editor) {
-  slate.Transforms.move(editor, {
+  moveSelection(editor, {
     distance: 1,
     unit: 'line'
   });
 }
 function moveToTheNextChar(editor) {
-  slate.Transforms.move(editor, {
+  moveSelection(editor, {
     distance: 1,
     unit: 'offset'
   });
@@ -532,11 +835,11 @@ function insertEmptyParagraph(editor, options) {
     data: {},
     isVoid: false
   };
-  slate.Transforms.insertNodes(editor, emptyParagraph, options);
+  insertNodes(editor, emptyParagraph, options);
 }
 function getElementFromCurrentSelection(editor) {
   if (!editor.selection) return [];
-  return Array.from(slate.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
@@ -544,7 +847,7 @@ function getElementFromCurrentSelection(editor) {
      **/
     at: editor.selection,
     match: function match(node) {
-      return slate.Element.isElement(node);
+      return isElement(node);
     }
   })).flat();
 }
@@ -573,9 +876,9 @@ function isLinkActive(editor) {
     return false;
   }
 
-  var _Array$from2 = Array.from(slate.Editor.nodes(editor, {
+  var _Array$from2 = Array.from(getNodeEntries(editor, {
     match: function match(node) {
-      return !slate.Editor.isEditor(node) && slate.Element.isElement(node) && LINK_TYPES.includes(node.type);
+      return !isEditor(node) && isElement(node) && LINK_TYPES.includes(node.type);
     }
   })),
       link = _Array$from2[0];
@@ -584,9 +887,9 @@ function isLinkActive(editor) {
 } // TODO: move to hyperlink plugin
 
 function unwrapLink(editor) {
-  slate.Transforms.unwrapNodes(editor, {
+  unwrapNodes(editor, {
     match: function match(node) {
-      return !slate.Editor.isEditor(node) && slate.Element.isElement(node) && LINK_TYPES.includes(node.type);
+      return !isEditor(node) && isElement(node) && LINK_TYPES.includes(node.type);
     }
   });
 } // TODO: move to hyperlink plugin
@@ -603,7 +906,7 @@ function wrapLink(editor, _ref) {
   }
 
   var selection = editor.selection;
-  var isCollapsed = selection && slate.Range.isCollapsed(selection);
+  var isCollapsed = selection && isRangeCollapsed(selection);
   var link = {
     type: type,
     data: {},
@@ -626,41 +929,41 @@ function wrapLink(editor, _ref) {
 
 
   if (path) {
-    slate.Transforms.setNodes(editor, link, {
+    setNodes(editor, link, {
       at: path
     });
-    slate.Transforms.insertText(editor, text, {
+    insertText(editor, text, {
       at: path
     });
-    slate.Transforms.select(editor, path);
+    select(editor, path);
   } else if (isCollapsed) {
-    slate.Transforms.insertNodes(editor, link);
+    insertNodes(editor, link);
   } else {
-    slate.Transforms.wrapNodes(editor, link, {
+    wrapNodes(editor, link, {
       split: true
     });
-    slate.Transforms["delete"](editor);
-    slate.Transforms.insertText(editor, text);
-    slate.Transforms.collapse(editor, {
+    deleteText(editor);
+    insertText(editor, text);
+    collapseSelection(editor, {
       edge: 'end'
     });
   }
 }
 function getAncestorPathFromSelection(editor) {
   if (!editor.selection) return undefined;
-  return slate.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(Contentful.INLINES);
 var isInlineOrText = function isInlineOrText(node) {
   // either text or inline elements
-  return slate.Text.isText(node) || slate.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;
-  Slate.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 () {
@@ -669,9 +972,9 @@ var focus = function focus(editor) {
   }
 };
 function toggleElement(editor, options, editorOptions) {
-  plateCore.toggleNodeType(editor, options, editorOptions); // We must reset `data` from one element to another
+  toggleNodeType(editor, options, editorOptions); // We must reset `data` from one element to another
 
-  slate.Transforms.setNodes(editor, {
+  setNodes(editor, {
     data: {}
   });
 }
@@ -1577,38 +1880,35 @@ var createNode = function createNode(nodeType, entity) {
 function insertBlock(editor, nodeType, entity) {
   if (!(editor != null && editor.selection)) return;
   var linkedEntityBlock = createNode(nodeType, entity);
-  var hasText = editor.selection && !!plateCore.getText(editor, editor.selection.focus.path);
+  var hasText = editor.selection && !!getText(editor, editor.selection.focus.path);
 
   if (hasText) {
-    slate.Transforms.insertNodes(editor, linkedEntityBlock);
+    insertNodes(editor, linkedEntityBlock);
   } else {
-    slate.Transforms.setNodes(editor, linkedEntityBlock);
+    setNodes(editor, linkedEntityBlock);
   }
 
   focus(editor);
 }
 
 var removeCommand = function removeCommand(editor) {
-  var _getAbove = plateCore.getAbove(editor),
-      path = _getAbove[1];
+  var _getAboveNode = getAboveNode(editor),
+      path = _getAboveNode[1];
 
-  var range = slate.Editor.range(editor, path);
-  slate.Transforms.select(editor, range.focus.path);
-  plateCore.removeMark(editor, {
-    key: COMMAND_PROMPT,
-    at: range
-  });
-  slate.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 = plateCore.getAbove(editor),
-      path = _getAbove2[1];
+  var _getAboveNode2 = getAboveNode(editor),
+      path = _getAboveNode2[1];
 
-  var range = slate.Editor.range(editor, path);
+  var range = getRange(editor, path);
 
   if (range.focus.offset - range.anchor.offset > 1) {
-    slate.Transforms["delete"](editor, {
+    deleteText(editor, {
       at: range.focus,
       distance: range.focus.offset - 1,
       reverse: true
@@ -1649,7 +1949,7 @@ var useCommands = function useCommands(sdk, query, editor) {
                       var selection = editor.selection;
                       editor.insertSoftBreak();
                       insertBlock(editor, Contentful.BLOCKS.EMBEDDED_ENTRY, entry.entry);
-                      slate.Transforms.select(editor, selection);
+                      select(editor, selection);
                       editor.tracking.onCommandPaletteAction('insert', {
                         nodeType: Contentful.BLOCKS.EMBEDDED_ENTRY
                       });
@@ -1684,7 +1984,7 @@ var useCommands = function useCommands(sdk, query, editor) {
                   callback: function callback() {
                     var inlineNode = createInlineEntryNode(entry.id);
                     removeCommand(editor);
-                    slate.Transforms.insertNodes(editor, inlineNode);
+                    insertNodes(editor, inlineNode);
                     editor.insertText('');
                     editor.tracking.onCommandPaletteAction('insert', {
                       nodeType: Contentful.INLINES.EMBEDDED_ENTRY
@@ -1733,7 +2033,7 @@ var useCommands = function useCommands(sdk, query, editor) {
                         var selection = editor.selection;
                         editor.insertSoftBreak();
                         insertBlock(editor, Contentful.BLOCKS.EMBEDDED_ASSET, asset.entity);
-                        slate.Transforms.select(editor, selection);
+                        select(editor, selection);
                         editor.tracking.onCommandPaletteAction('insert', {
                           nodeType: Contentful.BLOCKS.EMBEDDED_ASSET
                         });
@@ -2015,42 +2315,36 @@ var createOnKeyDown = function createOnKeyDown() {
   return function (editor) {
     return function (event) {
       if (isHotkey('/', event)) {
-        var _setMarks;
-
-        plateCore.setMarks(editor, (_setMarks = {}, _setMarks[COMMAND_PROMPT] = true, _setMarks));
+        addMark(editor, COMMAND_PROMPT);
         editor.tracking.onCommandPaletteAction('openRichTextCommandPalette');
       }
 
-      var isActive = plateCore.isMarkActive(editor, COMMAND_PROMPT);
+      var isActive = isMarkActive(editor, COMMAND_PROMPT);
 
-      if (isActive) {
-        if (isHotkey('enter', event)) {
-          event.preventDefault();
-        } else if (isHotkey('backspace', event)) {
-          var _getAbove = plateCore.getAbove(editor),
-              path = _getAbove[1];
+      if (!isActive) {
+        return;
+      }
 
-          var range = slate.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) {
-            plateCore.removeMark(editor, {
-              key: COMMAND_PROMPT,
-              at: range
-            });
-          }
-        } else if (isHotkey('escape', event)) {
-          var _getAbove2 = plateCore.getAbove(editor),
-              _path = _getAbove2[1];
+      var _getAboveNode = getAboveNode(editor),
+          path = _getAboveNode[1];
 
-          var _range = slate.Editor.range(editor, _path);
+      var range = getRange(editor, path);
 
-          plateCore.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');
+      }
     };
   };
 };
@@ -2096,9 +2390,9 @@ function createDragAndDropPlugin() {
       // If true, the next handlers will be skipped.
       onDrop: function onDrop(editor) {
         return function (event) {
-          var _Array$from = Array.from(plateCore.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];
@@ -2142,7 +2436,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
@@ -2312,8 +2606,8 @@ function LinkedEntityBlock(props) {
   }, [sdk, entityId, entityType]);
   var handleRemoveClick = React__default.useCallback(function () {
     if (!editor) return;
-    var pathToElement = Slate.ReactEditor.findPath(editor, element);
-    slate.Transforms.removeNodes(editor, {
+    var pathToElement = findNodePath(editor, element);
+    removeNodes(editor, {
       at: pathToElement
     });
   }, [editor, element]);
@@ -2423,7 +2717,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) {
@@ -2459,7 +2753,7 @@ function _selectEntityAndInsert() {
             return _context.abrupt("return");
 
           case 12:
-            slate.Transforms.select(editor, selection);
+            select(editor, selection);
             insertBlock$1(editor, nodeType, entity);
             ensureFollowingParagraph(editor);
             logAction('insert', {
@@ -2477,37 +2771,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 = slate.Editor.next(editor);
+  var _lastNode$0$type;
 
-  if (!next) {
-    return insertEmptyParagraph(editor);
-  }
-
-  var parent = slate.Editor.above(editor, {
-    voids: false,
-    match: function match(e) {
-      return !slate.Element.isElement(e) || ![Contentful.BLOCKS.EMBEDDED_ASSET, Contentful.BLOCKS.EMBEDDED_ENTRY].includes(e.type);
+  var entityBlock = getAboveNode(editor, {
+    match: {
+      type: [Contentful.BLOCKS.EMBEDDED_ASSET, Contentful.BLOCKS.EMBEDDED_ENTRY]
     }
   });
 
-  if (slate.Editor.isEditor(parent)) {
-    // at level 0, a following paragraph is handled by the tralingParagraph plugin
-    moveToTheNextChar(editor);
+  if (!entityBlock) {
     return;
   }
 
-  var paragraph = slate.Editor.above(editor, {
-    at: next[1],
-    match: function match(e) {
-      return slate.Element.isElement(e) && Contentful.TEXT_CONTAINERS.includes(e.type);
-    }
-  });
+  var level = entityBlock[1].length - 1;
+  var lastNode = getLastNodeByLevel(editor, level);
+  var isTextContainer = Contentful.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 || !slate.Path.isChild(paragraph[1], parent[1])) {
-    return insertEmptyParagraph(editor);
+  if (level !== 0 && !isTextContainer) {
+    insertEmptyParagraph(editor);
   }
 
   moveToTheNextChar(editor);
@@ -2536,12 +2818,12 @@ var createNode$1 = function createNode(nodeType, entity) {
 function insertBlock$1(editor, nodeType, entity) {
   if (!(editor != null && editor.selection)) return;
   var linkedEntityBlock = createNode$1(nodeType, entity);
-  var hasText = editor.selection && !!plateCore.getText(editor, editor.selection.focus.path);
+  var hasText = editor.selection && !!getText(editor, editor.selection.focus.path);
 
   if (hasText) {
-    slate.Transforms.insertNodes(editor, linkedEntityBlock);
+    insertNodes(editor, linkedEntityBlock);
   } else {
-    slate.Transforms.setNodes(editor, linkedEntityBlock);
+    setNodes(editor, linkedEntityBlock);
   }
 
   focus(editor);
@@ -2566,11 +2848,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();
           }
@@ -2630,7 +2921,7 @@ function getWithEmbeddedEntityEvents(nodeType, sdk) {
 
         if (isDelete || isBackspace) {
           event.preventDefault();
-          slate.Transforms.removeNodes(editor, {
+          removeNodes(editor, {
             at: pathToSelectedElement
           });
         }
@@ -2839,8 +3130,8 @@ function EmbeddedEntityInline(props) {
 
   function handleRemoveClick() {
     if (!editor) return;
-    var pathToElement = Slate.ReactEditor.findPath(editor, props.element);
-    slate.Transforms.removeNodes(editor, {
+    var pathToElement = findNodePath(editor, props.element);
+    removeNodes(editor, {
       at: pathToElement
     });
   }
@@ -2909,8 +3200,8 @@ function _selectEntityAndInsert$1() {
 
             return _context2.abrupt("return", new Promise(function (resolve) {
               setTimeout(function () {
-                slate.Transforms.setSelection(editor, selection);
-                slate.Transforms.insertNodes(editor, inlineEntryNode);
+                setSelection(editor, selection);
+                insertNodes(editor, inlineEntryNode);
                 resolve();
               }, 0);
             }));
@@ -3121,7 +3412,7 @@ function ToolbarHeadingButton(props) {
 }
 
 function extractNodes(editor, path, match) {
-  return Array.from(plateCore.getNodes(editor, {
+  return Array.from(getNodeEntries(editor, {
     match: match,
     at: path,
     mode: 'lowest'
@@ -3147,7 +3438,7 @@ function extractParagraphs(editor, path) {
 
 var transformRemove = function transformRemove(editor, _ref) {
   var path = _ref[1];
-  slate.Transforms.removeNodes(editor, {
+  removeNodes(editor, {
     at: path
   });
 };
@@ -3155,20 +3446,20 @@ var transformParagraphs = function transformParagraphs(editor, entry) {
   var path = entry[1];
   var nodes = extractParagraphs(editor, path);
   transformRemove(editor, entry);
-  slate.Transforms.insertNodes(editor, nodes, {
+  insertNodes(editor, nodes, {
     at: path
   });
 };
 var transformUnwrap = function transformUnwrap(editor, _ref2) {
   var path = _ref2[1];
-  slate.Transforms.unwrapNodes(editor, {
+  unwrapNodes(editor, {
     at: path
   });
 };
 var transformWrapIn = function transformWrapIn(type) {
   return function (editor, _ref3) {
     var path = _ref3[1];
-    slate.Transforms.wrapNodes(editor, {
+    wrapNodes(editor, {
       type: type,
       data: {},
       children: []
@@ -3179,7 +3470,7 @@ var transformWrapIn = function transformWrapIn(type) {
 };
 var transformLift = function transformLift(editor, _ref4) {
   var path = _ref4[1];
-  slate.Transforms.liftNodes(editor, {
+  liftNodes(editor, {
     at: path
   });
 };
@@ -3258,12 +3549,12 @@ var createHeadingPlugin = function createHeadingPlugin() {
             // insertBreak implementation
             filter: function filter(_ref3) {
               var path = _ref3[1];
-              return !plateCore.getAbove(editor, {
+              return !getAboveNode(editor, {
                 at: path,
                 match: {
                   type: Contentful.BLOCKS.LIST_ITEM
                 }
-              }) && !plateCore.isMarkActive(editor, COMMAND_PROMPT);
+              }) && !isMarkActive(editor, COMMAND_PROMPT);
             }
           }
         }]
@@ -3358,7 +3649,7 @@ function withHrEvents(editor) {
 
       if (isBackspace || isDelete) {
         event.preventDefault();
-        slate.Transforms.removeNodes(editor, {
+        removeNodes(editor, {
           at: pathToSelectedHr
         });
       }
@@ -3378,8 +3669,8 @@ function ToolbarHrButton(props) {
       }],
       isVoid: true
     };
-    var hasText = !!plateCore.getText(editor, editor.selection.focus.path);
-    hasText ? slate.Transforms.insertNodes(editor, hr) : plateCore.setNodes(editor, hr); // Move focus to the next paragraph (added by TrailingParagraph plugin)
+    var hasText = !!getText(editor, editor.selection.focus.path);
+    hasText ? insertNodes(editor, hr) : setNodes(editor, hr); // Move focus to the next paragraph (added by TrailingParagraph plugin)
 
     moveToTheNextLine(editor);
     focus(editor);
@@ -3665,7 +3956,7 @@ function _addOrEditLink() {
       while (1) {
         switch (_context3.prev = _context3.next) {
           case 0:
-            isReadOnly = Slate.ReactEditor.isReadOnly(editor);
+            isReadOnly = isEditorReadOnly(editor);
             selectionBeforeBlur = editor.selection ? _extends({}, editor.selection) : undefined;
 
             if (!(!targetPath && !selectionBeforeBlur)) {
@@ -3680,13 +3971,13 @@ function _addOrEditLink() {
 
             if (node && path) {
               linkType = node.type;
-              linkText = slate.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 ? slate.Editor.string(editor, editor.selection) : '');
+            currentLinkText = linkText || (editor.selection ? getText(editor, editor.selection) : '');
             isEditing = Boolean(node && path);
             logAction(isEditing ? 'openEditHyperlinkDialog' : 'openCreateHyperlinkDialog');
             _context3.next = 12;
@@ -3711,7 +4002,7 @@ function _addOrEditLink() {
 
           case 12:
             data = _context3.sent;
-            slate.Transforms.select(editor, selectionAfterFocus);
+            select(editor, selectionAfterFocus);
 
             if (data) {
               _context3.next = 18;
@@ -3724,7 +4015,7 @@ function _addOrEditLink() {
 
           case 18:
             text = data.linkText, url = data.linkTarget, type = data.linkType, target = data.linkEntity;
-            slate.Editor.withoutNormalizing(editor, function () {
+            withoutNormalizing(editor, function () {
               insertLink(editor, {
                 text: text,
                 url: url,
@@ -3801,8 +4092,9 @@ function ToolbarHyperlinkButton(props) {
 }
 
 var hasText = function hasText(editor, entry) {
-  var node = entry[0];
-  return !plateCore.isAncestorEmpty(editor, node) && slate.Node.string(node).trim() !== '';
+  var node = entry[0],
+      path = entry[1];
+  return !p.isAncestorEmpty(editor, node) && getText(editor, path).trim() !== '';
 };
 
 function truncate(str, length) {
@@ -3993,11 +4285,11 @@ function EntityHyperlink(props) {
     event.preventDefault();
     event.stopPropagation();
     if (!editor) return;
-    var p = Slate.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__*/React.createElement(f36Components.Tooltip, {
@@ -4023,11 +4315,11 @@ function UrlHyperlink(props) {
     event.preventDefault();
     event.stopPropagation();
     if (!editor) return;
-    var p = Slate.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__*/React.createElement(f36Components.Tooltip, {
@@ -4199,27 +4491,28 @@ var moveListItemDown = function moveListItemDown(editor, _ref) {
   var previousListItemPath;
 
   try {
-    previousListItemPath = slate.Path.previous(listItemPath);
+    previousListItemPath = getPreviousPath(listItemPath);
   } catch (e) {
     return;
   } // Previous sibling is the new parent
 
 
-  var previousSiblingItem = slate.Editor.node(editor, previousListItemPath);
+  var previousSiblingItem = getNodeEntry(editor, previousListItemPath);
 
   if (previousSiblingItem) {
     var previousPath = previousSiblingItem[1];
-    var subList = Array.from(slate.Node.children(editor, previousPath)).find(function (_ref2) {
-      var n = _ref2[0];
-      return plateCore.match(n, {
+    var subList = Array.from(getNodeChildren(editor, previousPath)).find(function (_ref2) {
+      var n = _ref2[0],
+          path = _ref2[1];
+      return match(n, path, {
         type: plateList.getListTypes(editor)
       });
     });
-    var newPath = slate.Path.next(plateCore.getLastChildPath(subList != null ? subList : previousSiblingItem));
-    slate.Editor.withoutNormalizing(editor, function () {
+    var newPath = getNextPath(getLastChildPath(subList != null ? subList : previousSiblingItem));
+    withoutNormalizing(editor, function () {
       if (!subList) {
         // Create new sub-list
-        plateCore.wrapNodes(editor, {
+        wrapNodes(editor, {
           type: listNode.type,
           children: [],
           data: {}
@@ -4229,7 +4522,7 @@ var moveListItemDown = function moveListItemDown(editor, _ref) {
       } // Move the current item to the sub-list
 
 
-      slate.Transforms.moveNodes(editor, {
+      moveNodes(editor, {
         at: listItemPath,
         to: newPath
       });
@@ -4250,10 +4543,10 @@ 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 = plateCore.getNodes(editor, {
+  var _nodes = getNodeEntries(editor, {
     at: at,
     match: {
-      type: plateCore.getPluginType(editor, plateList.ELEMENT_LIC)
+      type: getPluginType(editor, plateList.ELEMENT_LIC)
     }
   }); // Get the selected lic
 
@@ -4265,19 +4558,19 @@ var moveListItems = function moveListItems(editor, _temp) {
 
   lics.forEach(function (lic) {
     var licPath = lic[1];
-    var liPath = slate.Path.parent(licPath);
+    var liPath = getParentPath(licPath);
     var isAncestor = highestLicPaths.some(function (path) {
-      var highestLiPath = slate.Path.parent(path);
-      return slate.Path.isAncestor(highestLiPath, liPath);
+      var highestLiPath = getParentPath(path);
+      return isAncestorPath(highestLiPath, liPath);
     });
 
     if (!isAncestor) {
       highestLicPaths.push(licPath);
-      highestLicPathRefs.push(slate.Editor.pathRef(editor, licPath));
+      highestLicPathRefs.push(createPathRef(editor, licPath));
     }
   });
   var licPathRefsToMove = increase ? highestLicPathRefs : highestLicPathRefs.reverse();
-  slate.Editor.withoutNormalizing(editor, function () {
+  withoutNormalizing(editor, function () {
     licPathRefsToMove.forEach(function (licPathRef) {
       var licPath = licPathRef.unref();
       if (!licPath) return;
@@ -4298,16 +4591,18 @@ var moveListItems = function moveListItems(editor, _temp) {
   });
 };
 
+var ELEMENT_DEFAULT = p.ELEMENT_DEFAULT;
+
 /**
  * Credit: Modified version of Plate's list plugin
  * See: https://github.com/udecode/plate/blob/main/packages/nodes/list
  */
 
 function hasUnliftedListItems(editor, at) {
-  return slate.Editor.nodes(editor, {
+  return getNodeEntries(editor, {
     at: at,
     match: function match(node, path) {
-      return slate.Element.isElement(node) && node.type === Contentful.BLOCKS.LIST_ITEM && path.length >= 2;
+      return isElement(node) && node.type === Contentful.BLOCKS.LIST_ITEM && path.length >= 2;
     }
   }).next().done;
 }
@@ -4316,20 +4611,20 @@ var unwrapList = function unwrapList(editor, _temp) {
   var _ref = _temp === void 0 ? {} : _temp,
       at = _ref.at;
 
-  slate.Editor.withoutNormalizing(editor, function () {
+  withoutNormalizing(editor, function () {
     do {
       // lift list items to the root level
-      slate.Transforms.liftNodes(editor, {
+      liftNodes(editor, {
         at: at,
         match: function match(node) {
-          return slate.Element.isElement(node) && node.type === Contentful.BLOCKS.LIST_ITEM;
+          return isElement(node) && node.type === Contentful.BLOCKS.LIST_ITEM;
         },
         mode: 'lowest'
       });
     } while (!hasUnliftedListItems(editor, at)); // finally unwrap all lifted items
 
 
-    plateCore.unwrapNodes(editor, {
+    unwrapNodes(editor, {
       at: at,
       match: {
         type: Contentful.BLOCKS.LIST_ITEM
@@ -4342,12 +4637,12 @@ var unwrapList = function unwrapList(editor, _temp) {
 var listTypes = [Contentful.BLOCKS.UL_LIST, Contentful.BLOCKS.OL_LIST];
 var toggleList = function toggleList(editor, _ref) {
   var type = _ref.type;
-  return slate.Editor.withoutNormalizing(editor, function () {
+  return withoutNormalizing(editor, function () {
     if (!editor.selection) {
       return;
     }
 
-    if (plateCore.isCollapsed(editor.selection) || !plateCore.isRangeAcrossBlocks(editor)) {
+    if (isRangeCollapsed(editor.selection) || !isRangeAcrossBlocks(editor)) {
       // selection is collapsed
       var res = plateList.getListItemEntry(editor);
 
@@ -4355,7 +4650,7 @@ var toggleList = function toggleList(editor, _ref) {
         var list = res.list;
 
         if (list[0].type !== type) {
-          plateCore.setNodes(editor, {
+          setNodes(editor, {
             type: type
           }, {
             at: editor.selection,
@@ -4373,10 +4668,10 @@ var toggleList = function toggleList(editor, _ref) {
           children: [],
           data: {}
         };
-        plateCore.wrapNodes(editor, _list);
-        var nodes = [].concat(plateCore.getNodes(editor, {
+        wrapNodes(editor, _list);
+        var nodes = [].concat(getNodeEntries(editor, {
           match: {
-            type: plateCore.getPluginType(editor, plateCore.ELEMENT_DEFAULT)
+            type: getPluginType(editor, ELEMENT_DEFAULT)
           }
         }));
         var listItem = {
@@ -4388,36 +4683,38 @@ var toggleList = function toggleList(editor, _ref) {
         for (var _iterator = _createForOfIteratorHelperLoose(nodes), _step; !(_step = _iterator()).done;) {
           var _step$value = _step.value,
               path = _step$value[1];
-          plateCore.wrapNodes(editor, listItem, {
+          wrapNodes(editor, listItem, {
             at: path
           });
         }
       }
     } else {
       // selection is a range
-      var _Range$edges = slate.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 = slate.Node.common(editor, startPoint.path, endPoint.path);
+      var commonEntry = getCommonNode(editor, startPoint.path, endPoint.path);
 
       if (listTypes.includes(commonEntry[0].type) || commonEntry[0].type === Contentful.BLOCKS.LIST_ITEM) {
         var listType = commonEntry[0].type;
 
         if (commonEntry[0].type === Contentful.BLOCKS.LIST_ITEM) {
-          listType = slate.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 = plateCore.findNode(editor, {
-            at: slate.Range.start(editor.selection),
+          var startList = findNode(editor, {
+            at: getRangeStart(editor.selection),
             match: {
               type: listTypes
             },
             mode: 'lowest'
           });
-          var endList = plateCore.findNode(editor, {
-            at: slate.Range.end(editor.selection),
+          var endList = findNode(editor, {
+            at: getRangeEnd(editor.selection),
             match: {
               type: listTypes
             },
@@ -4429,7 +4726,7 @@ var toggleList = function toggleList(editor, _ref) {
           }
 
           var rangeLength = Math.min(startList[1].length, endList[1].length);
-          plateCore.setNodes(editor, {
+          setNodes(editor, {
             type: type
           }, {
             at: editor.selection,
@@ -4444,7 +4741,7 @@ var toggleList = function toggleList(editor, _ref) {
       } else {
         var rootPathLength = commonEntry[1].length;
 
-        var _nodes = Array.from(plateCore.getNodes(editor, {
+        var _nodes = Array.from(getNodeEntries(editor, {
           mode: 'all'
         })).filter(function (_ref2) {
           var path = _ref2[1];
@@ -4453,14 +4750,14 @@ var toggleList = function toggleList(editor, _ref) {
 
         _nodes.forEach(function (n) {
           if (listTypes.includes(n[0].type)) {
-            plateCore.setNodes(editor, {
+            setNodes(editor, {
               type: type
             }, {
               at: n[1]
             });
           } else {
-            plateCore.setNodes(editor, {
-              type: plateCore.getPluginType(editor, plateList.ELEMENT_LIC)
+            setNodes(editor, {
+              type: getPluginType(editor, plateList.ELEMENT_LIC)
             }, {
               at: n[1]
             });
@@ -4469,7 +4766,7 @@ var toggleList = function toggleList(editor, _ref) {
               children: [],
               data: {}
             };
-            plateCore.wrapNodes(editor, _listItem, {
+            wrapNodes(editor, _listItem, {
               at: n[1]
             });
             var _list2 = {
@@ -4477,7 +4774,7 @@ var toggleList = function toggleList(editor, _ref) {
               children: [],
               data: {}
             };
-            plateCore.wrapNodes(editor, _list2, {
+            wrapNodes(editor, _list2, {
               at: n[1]
             });
           }
@@ -4492,7 +4789,7 @@ var onKeyDownList = function onKeyDownList(editor, _ref) {
       hotkey = _ref.options.hotkey;
   return function (e) {
     if (e.key === 'Tab' && editor.selection) {
-      var listSelected = plateCore.getAbove(editor, {
+      var listSelected = getAboveNode(editor, {
         at: editor.selection,
         match: {
           type: type
@@ -4530,14 +4827,14 @@ var isList = function isList(node) {
 var hasListAsDirectParent = function hasListAsDirectParent(editor, _ref) {
   var path = _ref[1];
 
-  var _ref2 = plateCore.getParent(editor, path) || [],
+  var _ref2 = p.getParentNode(editor, path) || [],
       parentNode = _ref2[0];
 
   return isList(parentNode);
 };
 
 var getNearestListAncestor = function getNearestListAncestor(editor, path) {
-  return plateCore.getAbove(editor, {
+  return p.getAboveNode(editor, {
     at: path,
     mode: 'lowest',
     match: isList
@@ -4557,7 +4854,7 @@ var normalizeOrphanedListItem = function normalizeOrphanedListItem(editor, _ref3
       parentList = _getNearestListAncest[0];
 
   var parentListType = parentList == null ? void 0 : parentList.type;
-  slate.Transforms.wrapNodes(editor, {
+  wrapNodes(editor, {
     type: parentListType || Contentful.BLOCKS.UL_LIST,
     children: [],
     data: {}
@@ -4565,24 +4862,23 @@ var normalizeOrphanedListItem = function normalizeOrphanedListItem(editor, _ref3
     at: path
   });
 };
-var isNonEmptyListItem = function isNonEmptyListItem(editor, _ref4) {
-  var path = _ref4[1];
-  var listItemChildren = Array.from(slate.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 !slate.Text.isText(firstNode) && !isList(firstNode);
+    return !isText(firstNode) && !isList(firstNode);
   }
 
   return true;
 };
-var insertParagraphAsChild = function insertParagraphAsChild(editor, _ref6) {
-  var path = _ref6[1];
-  slate.Transforms.insertNodes(editor, [{
+var insertParagraphAsChild = function insertParagraphAsChild(editor, _ref5) {
+  var path = _ref5[1];
+  insertNodes(editor, [{
     type: Contentful.BLOCKS.PARAGRAPH,
     data: {},
     children: [{
@@ -4595,10 +4891,10 @@ var insertParagraphAsChild = function insertParagraphAsChild(editor, _ref6) {
 var replaceNodeWithListItems = function replaceNodeWithListItems(editor, entry) {
   var node = entry[0],
       path = entry[1];
-  slate.Transforms.removeNodes(editor, {
+  removeNodes(editor, {
     at: path
   });
-  slate.Transforms.insertNodes(editor, node.children[0].children, {
+  insertNodes(editor, node.children[0].children, {
     at: path
   });
 };
@@ -4609,12 +4905,12 @@ var isListTypeActive = function isListTypeActive(editor, type) {
     return false;
   }
 
-  if (slate.Range.isExpanded(selection)) {
-    var _Range$edges = slate.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 = slate.Node.common(editor, start.path, end.path);
+    var node = getCommonNode(editor, start.path, end.path);
 
     if (node[0].type === type) {
       return true;
@@ -4622,7 +4918,7 @@ var isListTypeActive = function isListTypeActive(editor, type) {
   } // Lists can be nested. Here, we take the list type at the lowest level
 
 
-  var listNode = plateCore.getBlockAbove(editor, {
+  var listNode = p.getBlockAbove(editor, {
     match: {
       type: [Contentful.BLOCKS.OL_LIST, Contentful.BLOCKS.UL_LIST]
     },
@@ -4643,7 +4939,7 @@ var emptyListItemNode = function emptyListItemNode(editor, withChildren) {
   var children = [];
 
   if (withChildren) {
-    var marks = slate.Editor.marks(editor) || {};
+    var marks = getMarks(editor) || {};
     children = [{
       type: Contentful.BLOCKS.PARAGRAPH,
       data: {},
@@ -4670,7 +4966,7 @@ var insertListItem = function insertListItem(editor) {
   } // Naming it paragraph for simplicity but can be a heading as well
 
 
-  var paragraph = plateCore.getAbove(editor, {
+  var paragraph = getAboveNode(editor, {
     match: {
       type: Contentful.TEXT_CONTAINERS
     }
@@ -4681,7 +4977,7 @@ var insertListItem = function insertListItem(editor) {
   }
 
   var paragraphPath = paragraph[1];
-  var listItem = plateCore.getParent(editor, paragraphPath);
+  var listItem = getParentNode(editor, paragraphPath);
 
   if (!listItem) {
     return false;
@@ -4695,30 +4991,30 @@ var insertListItem = function insertListItem(editor) {
   } // We are in a li>p (or heading)
 
 
-  slate.Editor.withoutNormalizing(editor, function () {
+  withoutNormalizing(editor, function () {
     if (!editor.selection) {
       return;
     } // Check the cursor position in the current paragraph
 
 
-    var isAtStart = plateCore.isSelectionAtBlockStart(editor);
-    var isAtEnd = plateCore.isSelectionAtBlockEnd(editor);
-    var isAtStartOfListItem = isAtStart && plateCore.isFirstChild(paragraphPath);
+    var isAtStart = isSelectionAtBlockStart(editor);
+    var isAtEnd = isSelectionAtBlockEnd(editor);
+    var isAtStartOfListItem = isAtStart && isFirstChildPath(paragraphPath);
     var shouldSplit = !isAtStart && !isAtEnd; // Split the current paragraph content if necessary
 
     if (shouldSplit) {
-      slate.Transforms.splitNodes(editor);
+      splitNodes(editor);
     } // Insert the new li
 
 
-    var newListItemPath = isAtStartOfListItem ? listItemPath : slate.Path.next(listItemPath);
-    plateCore.insertNodes(editor, // Add an empty paragraph to the new li if We will not move some
+    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 : slate.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
@@ -4726,7 +5022,7 @@ var insertListItem = function insertListItem(editor) {
     var toPath = newListItemPath.concat([shouldSplit ? 0 : 1]);
 
     if (!isAtStartOfListItem) {
-      plateCore.moveChildren(editor, {
+      moveChildren(editor, {
         at: listItemPath,
         to: toPath,
         fromStartIndex: fromStartIndex
@@ -4734,8 +5030,8 @@ var insertListItem = function insertListItem(editor) {
     } // Move cursor to the start of the new li
 
 
-    slate.Transforms.select(editor, newListItemPath);
-    slate.Transforms.collapse(editor, {
+    select(editor, newListItemPath);
+    collapseSelection(editor, {
       edge: 'start'
     });
   }); // Returning True skips processing other editor.insertBreak handlers
@@ -4760,7 +5056,7 @@ var listBreak = function listBreak(editor) {
         listItem = res.listItem;
     var childNode = listItem[0].children[0]; // If selected li is empty, move it up.
 
-    if (plateCore.isBlockAboveEmpty(editor) && listItem[0].children.length === 1 && Contentful.TEXT_CONTAINERS.includes(childNode.type)) {
+    if (p.isBlockAboveEmpty(editor) && listItem[0].children.length === 1 && Contentful.TEXT_CONTAINERS.includes(childNode.type)) {
       moved = plateList.moveListItemUp(editor, {
         list: list,
         listItem: listItem
@@ -4769,13 +5065,13 @@ var listBreak = function listBreak(editor) {
     }
   }
 
-  var didReset = plateResetNode.onKeyDownResetNode(editor, plateCore.mockPlugin({
+  var didReset = plateResetNode.onKeyDownResetNode(editor, p.mockPlugin({
     options: {
       rules: [{
-        types: [plateCore.getPluginType(editor, plateList.ELEMENT_LI)],
-        defaultType: plateCore.getPluginType(editor, plateCore.ELEMENT_DEFAULT),
+        types: [p.getPluginType(editor, plateList.ELEMENT_LI)],
+        defaultType: p.getPluginType(editor, p.ELEMENT_DEFAULT),
         predicate: function predicate() {
-          return !moved && plateCore.isBlockAboveEmpty(editor);
+          return !moved && p.isBlockAboveEmpty(editor);
         },
         onReset: function onReset(_editor) {
           return plateList.unwrapList(_editor);
@@ -4814,13 +5110,13 @@ var insertListBreak = function insertListBreak(editor) {
  */
 
 var getFirstAncestorOfType = function getFirstAncestorOfType(root, entry) {
-  var ancestor = slate.Path.parent(entry[1]);
+  var ancestor = getParentPath(entry[1]);
 
-  while (slate.Node.get(root, ancestor).type !== Contentful.BLOCKS.LIST_ITEM) {
-    ancestor = slate.Path.parent(ancestor);
+  while (getDescendantNodeByPath(root, ancestor).type !== Contentful.BLOCKS.LIST_ITEM) {
+    ancestor = getParentPath(ancestor);
   }
 
-  return [slate.Node.get(root, ancestor), ancestor];
+  return [getDescendantNodeByPath(root, ancestor), ancestor];
 };
 
 var isListRoot = function isListRoot(node) {
@@ -4838,9 +5134,9 @@ var trimList = function trimList(listRoot) {
     return [listRoot];
   }
 
-  var textEntries = Array.from(slate.Node.texts(listRoot));
+  var textEntries = Array.from(getNodeTexts(listRoot));
   var commonAncestorEntry = textEntries.reduce(function (commonAncestor, textEntry) {
-    return slate.Path.isAncestor(commonAncestor[1], textEntry[1]) ? commonAncestor : slate.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]];
@@ -4881,7 +5177,7 @@ var insertListFragment = function insertListFragment(editor) {
       return;
     }
 
-    var liEntry = plateCore.findNode(editor, {
+    var liEntry = p.findNode(editor, {
       match: {
         type: Contentful.BLOCKS.LIST_ITEM
       },
@@ -4893,7 +5189,7 @@ var insertListFragment = function insertListFragment(editor) {
         return trimList(node);
       })));
       var firstBlockIndex = nodes.findIndex(function (node) {
-        return slate.Editor.isBlock(editor, node);
+        return isBlockNode(editor, node);
       });
 
       if (firstBlockIndex < 0) {
@@ -4905,11 +5201,11 @@ var insertListFragment = function insertListFragment(editor) {
       // after a text or inline element occurrence will be unwrapped for
       // some reason.
 
-      slate.Transforms.insertNodes(editor, inlines, {
+      insertNodes(editor, inlines, {
         at: editor.selection,
         select: true
       });
-      return slate.Transforms.insertNodes(editor, blocks, {
+      return insertNodes(editor, blocks, {
         at: editor.selection,
         select: true
       });
@@ -4934,12 +5230,12 @@ var deleteBackwardList = function deleteBackwardList(editor, unit) {
     var list = res.list,
         listItem = res.listItem;
 
-    if (plateCore.isSelectionAtBlockStart(editor, {
+    if (isSelectionAtBlockStart(editor, {
       match: function match(node) {
         return node.type === Contentful.BLOCKS.LIST_ITEM;
       }
     })) {
-      slate.Editor.withoutNormalizing(editor, function () {
+      withoutNormalizing(editor, function () {
         moved = plateList.removeFirstListItem(editor, {
           list: list,
           listItem: listItem
@@ -4951,15 +5247,17 @@ var deleteBackwardList = function deleteBackwardList(editor, unit) {
         });
         if (moved) return;
 
-        if (plateCore.isFirstChild(listItem[1]) && !plateList.isListNested(editor, list[1])) {
-          plateResetNode.onKeyDownResetNode(editor, plateCore.mockPlugin({
+        if (isFirstChild(listItem[1]) && !plateList.isListNested(editor, list[1])) {
+          plateResetNode.onKeyDownResetNode(editor, // TODO look into this
+          // @ts-expect-error
+          mockPlugin({
             options: {
               rules: [{
                 types: [Contentful.BLOCKS.LIST_ITEM],
                 defaultType: Contentful.BLOCKS.PARAGRAPH,
                 hotkey: 'backspace',
                 predicate: function predicate() {
-                  return plateCore.isSelectionAtBlockStart(editor);
+                  return isSelectionAtBlockStart(editor);
                 },
                 onReset: function onReset(e) {
                   return unwrapList(e);
@@ -4971,7 +5269,9 @@ var deleteBackwardList = function deleteBackwardList(editor, unit) {
           return;
         }
 
-        plateCore.deleteFragment(editor, {
+        deleteFragment(editor, {
+          // FIXME: see if we can remove unit
+          // @ts-expect-error
           unit: unit,
           reverse: true
         });
@@ -5009,7 +5309,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 = plateList.normalizeList(editor, {
     validLiChildrenTypes: validLiChildrenTypes
@@ -5099,7 +5399,7 @@ function ToolbarListButton(props) {
 var toggleMarkAndDeactivateConflictingMarks = function toggleMarkAndDeactivateConflictingMarks(editor, mark) {
   var subs = [Contentful.MARKS.SUPERSCRIPT, Contentful.MARKS.SUBSCRIPT];
   var clear = subs.includes(mark) ? subs : [];
-  plateCore.toggleMark(editor, {
+  toggleMark(editor, {
     key: mark,
     clear: clear
   });
@@ -5110,7 +5410,7 @@ var buildMarkEventHandler = function buildMarkEventHandler(type) {
     return function (event) {
       if (editor.selection && hotkey && isHotkey(hotkey, event)) {
         event.preventDefault();
-        var isActive = plateCore.isMarkActive(editor, type);
+        var isActive = isMarkActive(editor, type);
         editor.tracking.onShortcutAction(isActive ? 'unmark' : 'mark', {
           markType: type
         });
@@ -5136,7 +5436,7 @@ var createMarkToolbarButton = function createMarkToolbarButton(_ref) {
     var editor = useContentfulEditor();
     var handleClick = React.useCallback(function () {
       if (!(editor != null && editor.selection)) return;
-      var isActive = plateCore.isMarkActive(editor, mark);
+      var isActive = isMarkActive(editor, mark);
       editor.tracking.onToolbarAction(isActive ? 'unmark' : 'mark', {
         markType: mark
       });
@@ -5151,7 +5451,7 @@ var createMarkToolbarButton = function createMarkToolbarButton(_ref) {
       return /*#__PURE__*/React.createElement(f36Components.Menu.Item, {
         onClick: handleClick,
         disabled: isDisabled,
-        className: emotion.cx((_cx = {}, _cx[styles$c.isActive] = plateCore.isMarkActive(editor, mark), _cx)),
+        className: emotion.cx((_cx = {}, _cx[styles$c.isActive] = isMarkActive(editor, mark), _cx)),
         testId: mark + "-toolbar-button"
       }, title);
     }
@@ -5160,7 +5460,7 @@ var createMarkToolbarButton = function createMarkToolbarButton(_ref) {
       title: title,
       testId: mark + "-toolbar-button",
       onClick: handleClick,
-      isActive: plateCore.isMarkActive(editor, mark),
+      isActive: isMarkActive(editor, mark),
       isDisabled: isDisabled
     }, icon);
   };
@@ -5208,7 +5508,7 @@ var createBoldPlugin = function createBoldPlugin() {
         }
       }],
       query: function query(el) {
-        return !isGoogleBoldWrapper(el) && !plateCore.someHtmlElement(el, function (node) {
+        return !isGoogleBoldWrapper(el) && !someHtmlElement(el, function (node) {
           return node.style.fontWeight === 'normal';
         });
       }
@@ -5292,7 +5592,7 @@ var createItalicPlugin = function createItalicPlugin() {
         }
       }],
       query: function query(el) {
-        return !plateCore.someHtmlElement(el, function (node) {
+        return !someHtmlElement(el, function (node) {
           return node.style.fontStyle === 'normal';
         });
       }
@@ -5300,42 +5600,44 @@ var createItalicPlugin = function createItalicPlugin() {
   });
 };
 
-var ToolbarUnderlineButton = /*#__PURE__*/createMarkToolbarButton({
-  title: 'Underline',
-  mark: Contentful.MARKS.UNDERLINE,
-  icon: /*#__PURE__*/React.createElement(f36Icons.FormatUnderlinedIcon, null)
+var styles$g = {
+  subscript: /*#__PURE__*/emotion.css({
+    verticalAlign: 'sub',
+    fontSize: 'smaller'
+  })
+};
+var ToolbarSubscriptButton = /*#__PURE__*/createMarkToolbarButton({
+  title: 'Subscript',
+  mark: Contentful.MARKS.SUBSCRIPT,
+  icon: /*#__PURE__*/React.createElement(f36Icons.SubscriptIcon, {
+    viewBox: "0 0 23 18"
+  })
 });
-function Underline(props) {
-  return /*#__PURE__*/React.createElement("u", _extends({}, props.attributes), props.children);
+var ToolbarDropdownSubscriptButton = /*#__PURE__*/createMarkToolbarButton({
+  title: 'Subscript',
+  mark: Contentful.MARKS.SUBSCRIPT
+});
+function Subscript(props) {
+  return /*#__PURE__*/React.createElement("sub", _extends({}, props.attributes, {
+    className: styles$g.subscript
+  }), props.children);
 }
-var createUnderlinePlugin = function createUnderlinePlugin() {
-  return plateBasicMarks.createUnderlinePlugin({
-    type: Contentful.MARKS.UNDERLINE,
-    component: Underline,
-    options: {
-      hotkey: ['mod+u']
-    },
+var createSubscriptPlugin = function createSubscriptPlugin() {
+  return plateBasicMarks.createSubscriptPlugin({
+    type: Contentful.MARKS.SUBSCRIPT,
+    component: Subscript,
     handlers: {
-      onKeyDown: buildMarkEventHandler(Contentful.MARKS.UNDERLINE)
+      onKeyDown: buildMarkEventHandler(Contentful.MARKS.SUBSCRIPT)
     },
     deserializeHtml: {
       rules: [{
-        validNodeName: ['U']
-      }, {
-        validStyle: {
-          textDecoration: ['underline']
-        }
-      }],
-      query: function query(el) {
-        return !plateCore.someHtmlElement(el, function (node) {
-          return node.style.textDecoration === 'none';
-        });
-      }
+        validNodeName: ['SUB']
+      }]
     }
   });
 };
 
-var styles$g = {
+var styles$h = {
   superscript: /*#__PURE__*/emotion.css({
     verticalAlign: 'super',
     fontSize: 'smaller'
@@ -5352,7 +5654,7 @@ var ToolbarDropdownSuperscriptButton = /*#__PURE__*/createMarkToolbarButton({
 });
 function Superscript(props) {
   return /*#__PURE__*/React.createElement("sup", _extends({}, props.attributes, {
-    className: styles$g.superscript
+    className: styles$h.superscript
   }), props.children);
 }
 var createSuperscriptPlugin = function createSuperscriptPlugin() {
@@ -5370,39 +5672,37 @@ var createSuperscriptPlugin = function createSuperscriptPlugin() {
   });
 };
 
-var styles$h = {
-  subscript: /*#__PURE__*/emotion.css({
-    verticalAlign: 'sub',
-    fontSize: 'smaller'
-  })
-};
-var ToolbarSubscriptButton = /*#__PURE__*/createMarkToolbarButton({
-  title: 'Subscript',
-  mark: Contentful.MARKS.SUBSCRIPT,
-  icon: /*#__PURE__*/React.createElement(f36Icons.SubscriptIcon, {
-    viewBox: "0 0 23 18"
-  })
-});
-var ToolbarDropdownSubscriptButton = /*#__PURE__*/createMarkToolbarButton({
-  title: 'Subscript',
-  mark: Contentful.MARKS.SUBSCRIPT
+var ToolbarUnderlineButton = /*#__PURE__*/createMarkToolbarButton({
+  title: 'Underline',
+  mark: Contentful.MARKS.UNDERLINE,
+  icon: /*#__PURE__*/React.createElement(f36Icons.FormatUnderlinedIcon, null)
 });
-function Subscript(props) {
-  return /*#__PURE__*/React.createElement("sub", _extends({}, props.attributes, {
-    className: styles$h.subscript
-  }), props.children);
+function Underline(props) {
+  return /*#__PURE__*/React.createElement("u", _extends({}, props.attributes), props.children);
 }
-var createSubscriptPlugin = function createSubscriptPlugin() {
-  return plateBasicMarks.createSubscriptPlugin({
-    type: Contentful.MARKS.SUBSCRIPT,
-    component: Subscript,
+var createUnderlinePlugin = function createUnderlinePlugin() {
+  return plateBasicMarks.createUnderlinePlugin({
+    type: Contentful.MARKS.UNDERLINE,
+    component: Underline,
+    options: {
+      hotkey: ['mod+u']
+    },
     handlers: {
-      onKeyDown: buildMarkEventHandler(Contentful.MARKS.SUBSCRIPT)
+      onKeyDown: buildMarkEventHandler(Contentful.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';
+        });
+      }
     }
   });
 };
@@ -5414,7 +5714,7 @@ var createMarksPlugin = function createMarksPlugin() {
   };
 };
 
-var isInline = function isInline(node) {
+var isInline$1 = function isInline(node) {
   return INLINE_TYPES.includes(node.type);
 };
 
@@ -5426,13 +5726,13 @@ var isTextContainer = function isTextContainer(node) {
 
 var baseRules = [{
   // Wrap orphaned text nodes in a paragraph
-  match: slate.Text.isText,
+  match: isText,
   validNode: function validNode(editor, _ref) {
-    var _getParent;
+    var _getParentNode;
 
     var path = _ref[1];
-    var parent = (_getParent = plateCore.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(Contentful.BLOCKS.PARAGRAPH)(editor, entry);
@@ -5443,10 +5743,10 @@ var baseRules = [{
     type: INLINE_TYPES
   },
   validNode: function validNode(editor, _ref2) {
-    var _getParent2;
+    var _getParentNode2;
 
     var path = _ref2[1];
-    var parent = (_getParent2 = plateCore.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(Contentful.BLOCKS.PARAGRAPH)
@@ -5464,19 +5764,9 @@ var NormalizerError = /*#__PURE__*/function (_Error) {
 var createValidatorFromTypes = function createValidatorFromTypes(types) {
   return function (_, _ref) {
     var node = _ref[0];
-    return slate.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 (slate.Text.isText(node)) {
-    return [];
-  }
-
-  return Array.from(slate.Node.children(editor, path));
-};
 var createTransformerFromObject = function createTransformerFromObject(transforms) {
   // A default transformer must always be provided
   var fallback = transforms['default'];
@@ -5487,7 +5777,7 @@ var createTransformerFromObject = function createTransformerFromObject(transform
 
   return function (editor, entry) {
     var node = entry[0];
-    var key = slate.Element.isElement(node) ? node.type : 'default';
+    var key = isElement(node) ? node.type : 'default';
     var transformer = transforms[key] || fallback;
     return transformer(editor, entry);
   };
@@ -5497,8 +5787,8 @@ var withNormalizer = function withNormalizer(editor) {
   var rules = baseRules; // Derive normalization rules from other plugin's configurations
 
   for (var _iterator = _createForOfIteratorHelperLoose(editor.plugins), _step; !(_step = _iterator()).done;) {
-    var p = _step.value;
-    var _rules = p.normalizer;
+    var p$1 = _step.value;
+    var _rules = p$1.normalizer;
 
     if (!_rules) {
       continue;
@@ -5510,14 +5800,14 @@ var withNormalizer = function withNormalizer(editor) {
       // Clone to avoid mutation bugs
       var rule = _extends({}, _rule);
 
-      if (!rule.match && !p.isElement) {
+      if (!rule.match && !p$1.isElement) {
         throw new NormalizerError('rule.match MUST be defined in a non-element plugin');
       } // By default we filter elements with given plugin type
 
 
       if (!rule.match) {
         rule.match = {
-          type: plateCore.getPluginType(editor, p.key)
+          type: p.getPluginType(editor, p$1.key)
         };
       } // Conditional transformation e.g.
       // {
@@ -5555,22 +5845,23 @@ var withNormalizer = function withNormalizer(editor) {
 
 
   var _transform = function _transform(tr, entry) {
-    slate.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 (!plateCore.match(node, rule.match)) {
+      if (!matchNode(node, path, rule.match)) {
         continue;
       } // Normalize node
 
@@ -5612,7 +5903,6 @@ var withNormalizer = function withNormalizer(editor) {
 var createNormalizerPlugin = function createNormalizerPlugin() {
   return {
     key: 'NormalizerPlugin',
-    // @ts-expect-error
     withOverrides: withNormalizer
   };
 };
@@ -5820,7 +6110,7 @@ var createPasteHTMLPlugin = function createPasteHTMLPlugin() {
       return editor;
     },
     inject: {
-      pluginsByKey: (_pluginsByKey = {}, _pluginsByKey[plateCore.KEY_DESERIALIZE_HTML] = {
+      pluginsByKey: (_pluginsByKey = {}, _pluginsByKey[p.KEY_DESERIALIZE_HTML] = {
         editor: {
           insertData: {
             format: 'text/html',
@@ -5853,7 +6143,7 @@ function Quote(props) {
  */
 
 var shouldResetQuoteOnBackspace = function shouldResetQuoteOnBackspace(editor) {
-  var container = plateCore.getAbove(editor, {
+  var container = getAboveNode(editor, {
     match: {
       type: Contentful.TEXT_CONTAINERS
     },
@@ -5864,11 +6154,11 @@ var shouldResetQuoteOnBackspace = function shouldResetQuoteOnBackspace(editor) {
     return false;
   }
 
-  if (!plateCore.isAncestorEmpty(editor, container[0])) {
+  if (!isAncestorEmpty(editor, container[0])) {
     return false;
   }
 
-  var quote = plateCore.getBlockAbove(editor, {
+  var quote = getBlockAbove(editor, {
     match: {
       type: Contentful.BLOCKS.QUOTE
     },
@@ -5879,7 +6169,7 @@ var shouldResetQuoteOnBackspace = function shouldResetQuoteOnBackspace(editor) {
     return false;
   }
 
-  if (plateCore.hasSingleChild(quote[0]) && plateCore.isLastChild(quote, container[1])) {
+  if (p.hasSingleChild(quote[0]) && p.isLastChild(quote, container[1])) {
     return true;
   }
 
@@ -5892,11 +6182,11 @@ function toggleQuote(editor, logAction) {
   logAction == null ? void 0 : logAction(isActive ? 'remove' : 'insert', {
     nodeType: Contentful.BLOCKS.QUOTE
   });
-  slate.Editor.withoutNormalizing(editor, function () {
+  withoutNormalizing(editor, function () {
     if (!editor.selection) return;
-    slate.Transforms.unwrapNodes(editor, {
+    unwrapNodes(editor, {
       match: function match(node) {
-        return slate.Element.isElement(node) && node.type === Contentful.BLOCKS.QUOTE;
+        return isElement(node) && node.type === Contentful.BLOCKS.QUOTE;
       },
       split: true
     });
@@ -5907,7 +6197,7 @@ function toggleQuote(editor, logAction) {
         data: {},
         children: []
       };
-      slate.Transforms.wrapNodes(editor, quote);
+      wrapNodes(editor, quote);
     }
   });
 }
@@ -5927,39 +6217,39 @@ var withQuote = function withQuote(editor) {
 
   editor.insertFragment = function (fragment) {
     var startingNode = fragment.length && fragment[0];
-    var startsWithBlockquote = slate.Element.isElement(startingNode) && startingNode.type === Contentful.BLOCKS.QUOTE;
-    var containerEntry = plateCore.getAbove(editor, {
+    var startsWithBlockquote = s.Element.isElement(startingNode) && startingNode.type === Contentful.BLOCKS.QUOTE;
+    var containerEntry = getAboveNode(editor, {
       match: {
         type: Contentful.TEXT_CONTAINERS
       }
     });
-    var containerIsNotEmpty = containerEntry && slate.Node.string(containerEntry[0]) !== '';
+    var containerIsNotEmpty = containerEntry && getText(editor, containerEntry[1]) !== '';
 
     if (startsWithBlockquote && containerIsNotEmpty) {
       var selection = editor.selection;
 
       var isContentSelected = function isContentSelected(selection) {
-        return !!selection && slate.Point.compare(selection.anchor, selection.focus) !== 0;
+        return !!selection && s.Point.compare(selection.anchor, selection.focus) !== 0;
       }; // if something is selected (highlighted) we replace the selection
 
 
       if (isContentSelected(selection)) {
-        slate.Transforms["delete"](editor, {
+        deleteText(editor, {
           at: selection
         });
       } // get the cursor entry again, it may be different after deletion
 
 
-      var _containerEntry = plateCore.getAbove(editor, {
+      var _containerEntry = getAboveNode(editor, {
         match: {
           type: Contentful.TEXT_CONTAINERS
         }
       });
 
-      var _containerIsNotEmpty = _containerEntry && slate.Node.string(_containerEntry[0]) !== '';
+      var _containerIsNotEmpty = _containerEntry && getText(editor, _containerEntry[1]) !== '';
 
       if (_containerIsNotEmpty) {
-        slate.Transforms.insertNodes(editor, fragment);
+        insertNodes(editor, fragment);
         return;
       }
     }
@@ -6034,15 +6324,17 @@ var createSelectOnBackspacePlugin = function createSelectOnBackspacePlugin() {
   });
 };
 
+var useReadOnly = Slate.useReadOnly;
+
 var addRow = function addRow(editor, getNextRowPath) {
-  if (plateCore.someNode(editor, {
+  if (someNode(editor, {
     match: {
-      type: plateCore.getPluginType(editor, plateTable.ELEMENT_TABLE)
+      type: Contentful.BLOCKS.TABLE
     }
   })) {
-    var currentRowItem = plateCore.getAbove(editor, {
+    var currentRowItem = getAboveNode(editor, {
       match: {
-        type: plateCore.getPluginType(editor, plateTable.ELEMENT_TR)
+        type: Contentful.BLOCKS.TABLE_ROW
       }
     });
 
@@ -6050,8 +6342,7 @@ var addRow = function addRow(editor, getNextRowPath) {
       var currentRowElem = currentRowItem[0],
           currentRowPath = currentRowItem[1];
       var nextRowPath = getNextRowPath(currentRowPath);
-      plateCore.insertNodes(editor, // @ts-expect-error
-      plateTable.getEmptyRowNode(editor, {
+      insertNodes(editor, plateTable.getEmptyRowNode(editor, {
         header: false,
         colCount: currentRowElem.children.length
       }), {
@@ -6060,14 +6351,14 @@ var addRow = function addRow(editor, getNextRowPath) {
         select: true
       }); // Select the first cell in the current row
 
-      slate.Transforms.select(editor, slate.Editor.start(editor, nextRowPath));
+      select(editor, getStartPoint(editor, nextRowPath));
     }
   }
 };
 
 var addRowBelow = function addRowBelow(editor) {
   addRow(editor, function (currentRowPath) {
-    return slate.Path.next(currentRowPath);
+    return getNextPath(currentRowPath);
   });
 };
 var addRowAbove = function addRowAbove(editor) {
@@ -6080,19 +6371,19 @@ var addRowAbove = function addRowAbove(editor) {
 var addColumn = function addColumn(editor, _ref, getNextCellPath) {
   var header = _ref.header;
 
-  if (plateCore.someNode(editor, {
+  if (someNode(editor, {
     match: {
-      type: plateCore.getPluginType(editor, plateTable.ELEMENT_TABLE)
+      type: Contentful.BLOCKS.TABLE
     }
   })) {
-    var currentCellItem = plateCore.getAbove(editor, {
+    var currentCellItem = getAboveNode(editor, {
       match: {
-        type: [plateCore.getPluginType(editor, plateTable.ELEMENT_TD), plateCore.getPluginType(editor, plateTable.ELEMENT_TH)]
+        type: [Contentful.BLOCKS.TABLE_HEADER_CELL, Contentful.BLOCKS.TABLE_CELL]
       }
     });
-    var currentTableItem = plateCore.getAbove(editor, {
+    var currentTableItem = getAboveNode(editor, {
       match: {
-        type: plateCore.getPluginType(editor, plateTable.ELEMENT_TABLE)
+        type: Contentful.BLOCKS.TABLE
       }
     });
 
@@ -6102,8 +6393,7 @@ var addColumn = function addColumn(editor, _ref, getNextCellPath) {
       var replacePathPos = newCellPath.length - 2;
       currentTableItem[0].children.forEach(function (_, rowIdx) {
         newCellPath[replacePathPos] = rowIdx;
-        plateCore.insertNodes(editor, // @ts-expect-error
-        plateTable.getEmptyCellNode(editor, {
+        insertNodes(editor, plateTable.getEmptyCellNode(editor, {
           header: header && rowIdx === 0
         }), {
           at: newCellPath,
@@ -6117,7 +6407,7 @@ var addColumn = function addColumn(editor, _ref, getNextCellPath) {
 
 var addColumnRight = function addColumnRight(editor, options) {
   addColumn(editor, options, function (currentCellPath) {
-    return slate.Path.next(currentCellPath);
+    return getNextPath(currentCellPath);
   });
 };
 var addColumnLeft = function addColumnLeft(editor, options) {
@@ -6127,7 +6417,7 @@ var addColumnLeft = function addColumnLeft(editor, options) {
 };
 
 var setHeader = function setHeader(editor, enable) {
-  var tableItem = plateCore.getAbove(editor, {
+  var tableItem = getAboveNode(editor, {
     match: {
       type: Contentful.BLOCKS.TABLE
     }
@@ -6137,15 +6427,15 @@ var setHeader = function setHeader(editor, enable) {
     return;
   }
 
-  var firstRow = plateCore.getChildren(tableItem)[0];
+  var firstRow = getChildren(tableItem)[0];
 
   if (!firstRow) {
     return;
   }
 
-  plateCore.getChildren(firstRow).forEach(function (_ref) {
+  getChildren(firstRow).forEach(function (_ref) {
     var path = _ref[1];
-    plateCore.setNodes(editor, {
+    setNodes(editor, {
       type: enable ? Contentful.BLOCKS.TABLE_HEADER_CELL : Contentful.BLOCKS.TABLE_CELL
     }, {
       at: path
@@ -6154,9 +6444,30 @@ var setHeader = function setHeader(editor, enable) {
 };
 
 function insertTableAndFocusFirstCell(editor) {
-  plateTable.insertTable(editor, {
-    header: true
-  });
+  var table = {
+    type: Contentful.BLOCKS.TABLE,
+    data: {},
+    children: [plateTable.getEmptyRowNode(editor, {
+      colCount: 2,
+      header: true
+    }), plateTable.getEmptyRowNode(editor, {
+      colCount: 2
+    })]
+  };
+  insertNodes(editor, table);
+
+  if (editor.selection) {
+    var tableEntry = getBlockAbove(editor, {
+      match: {
+        type: Contentful.BLOCKS.TABLE
+      }
+    });
+    if (!tableEntry) return;
+    selectEditor(editor, {
+      at: getStartPoint(editor, tableEntry[1])
+    });
+  }
+
   replaceEmptyParagraphWithTable(editor);
 }
 function isTableActive(editor) {
@@ -6166,7 +6477,7 @@ function isTableActive(editor) {
   });
 }
 function isTableHeaderEnabled(editor) {
-  var tableItem = plateCore.getAbove(editor, {
+  var tableItem = getAboveNode(editor, {
     match: {
       type: Contentful.BLOCKS.TABLE
     }
@@ -6176,43 +6487,43 @@ function isTableHeaderEnabled(editor) {
     return false;
   }
 
-  var firstRow = plateCore.getChildren(tableItem)[0];
+  var firstRow = getChildren(tableItem)[0];
 
   if (!firstRow) {
     return false;
   }
 
-  return plateCore.getChildren(firstRow).every(function (_ref) {
+  return getChildren(firstRow).every(function (_ref) {
     var node = _ref[0];
     return node.type === Contentful.BLOCKS.TABLE_HEADER_CELL;
   });
 }
 function replaceEmptyParagraphWithTable(editor) {
   var tablePath = getAncestorPathFromSelection(editor);
-  if (!tablePath || plateCore.isFirstChild(tablePath)) return;
-  var previousPath = slate.Path.previous(tablePath);
+  if (!tablePath || isFirstChildPath(tablePath)) return;
+  var previousPath = getPreviousPath(tablePath);
   if (!previousPath) return;
 
-  var _Editor$nodes = slate.Editor.nodes(editor, {
+  var _getNodeEntries = getNodeEntries(editor, {
     at: previousPath,
     match: function match(node) {
       return node.type === Contentful.BLOCKS.PARAGRAPH;
     }
   }),
-      nodes = _Editor$nodes[0];
+      nodes = _getNodeEntries[0];
 
   if (!nodes) return;
   var previousNode = nodes[0];
-  var isPreviousNodeTextEmpty = plateCore.isAncestorEmpty(editor, previousNode);
+  var isPreviousNodeTextEmpty = isAncestorEmpty(editor, previousNode);
 
   if (isPreviousNodeTextEmpty) {
     // Switch table with previous empty paragraph
-    slate.Transforms.moveNodes(editor, {
+    moveNodes(editor, {
       at: tablePath,
       to: previousPath
     }); // Remove previous paragraph that now is under the table
 
-    slate.Transforms.removeNodes(editor, {
+    removeNodes(editor, {
       at: tablePath
     });
   }
@@ -6224,21 +6535,19 @@ function replaceEmptyParagraphWithTable(editor) {
  * normalization cycles.
  */
 
-var getNoOfMissingTableCellsInRow = function getNoOfMissingTableCellsInRow(editor, _ref2) {
-  var rowPath = _ref2[1];
-  var parent = plateCore.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(slate.Node.children(editor, tablePath)).map(function (_ref3) {
-    var path = _ref3[1];
-    return Array.from(slate.Node.children(editor, path)).length;
+  var tableWidth = Math.max.apply(Math, getChildren(parent).map(function (entry) {
+    return getChildren(entry).length;
   }));
-  var rowWidth = Array.from(slate.Node.children(editor, rowPath)).length;
+  var rowWidth = getChildren(rowEntry).length;
   return tableWidth - rowWidth;
 };
 var createEmptyTableCells = function createEmptyTableCells(count) {
@@ -6255,12 +6564,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(slate.Node.children(editor, path)).length !== 0;
+var isNotEmpty = function isNotEmpty(_, entry) {
+  return getChildren(entry).length !== 0;
 };
 var isTable = function isTable(node) {
-  return slate.Element.isElement(node) && node.type === Contentful.BLOCKS.TABLE;
+  return isElement(node) && node.type === Contentful.BLOCKS.TABLE;
 };
 
 var styles$j = {
@@ -6280,7 +6588,7 @@ var getCurrentTableSize = function getCurrentTableSize(editor) {
 
 var TableActions = function TableActions() {
   var editor = useContentfulEditor();
-  var isDisabled = Slate.useReadOnly();
+  var isDisabled = useReadOnly();
 
   var _React$useState = React__default.useState(false),
       isOpen = _React$useState[0],
@@ -6301,7 +6609,7 @@ var TableActions = function TableActions() {
       return false;
     }
 
-    var headerCell = plateCore.getAbove(editor, {
+    var headerCell = getAboveNode(editor, {
       match: {
         type: Contentful.BLOCKS.TABLE_HEADER_CELL
       }
@@ -6324,7 +6632,7 @@ var TableActions = function TableActions() {
       if (!(editor != null && editor.selection)) return;
       close();
       var tableSize = getCurrentTableSize(editor);
-      slate.Editor.withoutNormalizing(editor, function () {
+      withoutNormalizing(editor, function () {
         cb(editor, {
           header: isHeaderEnabled
         });
@@ -6426,7 +6734,7 @@ var Table = function Table(props) {
 var trimUnnecessaryTableWrapper = function trimUnnecessaryTableWrapper(node) {
   var _node$children, _row$children;
 
-  if (!slate.Element.isElement(node)) {
+  if (!isElement(node)) {
     return [node];
   } // must be a table with a single row
 
@@ -6463,7 +6771,7 @@ var insertTableFragment = function insertTableFragment(editor) {
     var isTableFirstFragment = fragments.findIndex(function (fragment) {
       return isTable(fragment);
     }) === 0;
-    var currentLineHasText = plateCore.getText(editor, (_editor$selection = editor.selection) == null ? void 0 : _editor$selection.focus.path) !== '';
+    var currentLineHasText = getText(editor, (_editor$selection = editor.selection) == null ? void 0 : _editor$selection.focus.path) !== '';
 
     if (isInsertingTable && isTableFirstFragment && currentLineHasText) {
       insertEmptyParagraph(editor);
@@ -6476,20 +6784,21 @@ var insertTableFragment = function insertTableFragment(editor) {
 var onKeyDownTable = function onKeyDownTable(editor, plugin) {
   var defaultHandler = plateTable.onKeyDownTable(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 === Contentful.BLOCKS.TABLE;
 
       if (isBeforeTable) {
         if (event.key === 'Enter') {
-          var above = plateCore.getAbove(editor, {
+          var above = getAboveNode(editor, {
             match: {
               type: Contentful.BLOCKS.TABLE
             }
@@ -6511,15 +6820,15 @@ var onKeyDownTable = function onKeyDownTable(editor, plugin) {
 
 
     if (event.key === 'Tab' && !event.shiftKey) {
-      var res = plateTable.getTableCellEntry(editor, {});
+      event.preventDefault();
+      var entry = plateTable.getTableEntries(editor, {});
 
-      if (res) {
-        event.preventDefault();
-        var tableElement = res.tableElement,
-            tableRow = res.tableRow,
-            tableCell = res.tableCell;
-        var isLastCell = plateCore.isLastChild(tableRow, tableCell[1]);
-        var isLastRow = plateCore.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
@@ -6532,7 +6841,7 @@ var onKeyDownTable = function onKeyDownTable(editor, plugin) {
     }
 
     if (event.key === 'Escape') {
-      Slate.ReactEditor.blur(editor);
+      blurEditor(editor);
     }
   };
 };
@@ -6815,7 +7124,7 @@ var withInvalidCellChildrenTracking = function withInvalidCellChildrenTracking(t
   return function (editor, childEntry) {
     var node = childEntry[0];
 
-    if (slate.Element.isElement(node)) {
+    if (isElement(node)) {
       var _editor$tracking;
 
       (_editor$tracking = editor.tracking) == null ? void 0 : _editor$tracking.onViewportAction('invalidTablePaste', {
@@ -6833,11 +7142,16 @@ var createTablePlugin = function createTablePlugin() {
   return plateTable.createTablePlugin({
     type: Contentful.BLOCKS.TABLE,
     handlers: {
+      // @ts-expect-error
       onKeyDown: onKeyDownTable
     },
     withOverrides: function withOverrides(editor, plugin) {
-      // injects important fixes from plate's original table plugin
-      plateTable.withTable(editor, plugin);
+      var normalizeNode = editor.normalizeNode; // injects important fixes from plate's original table plugin
+
+      plateTable.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;
@@ -6851,7 +7165,9 @@ var createTablePlugin = function createTablePlugin() {
         // Move to root level unless nested
         validNode: function validNode(editor, _ref) {
           var path = _ref[1];
-          var isNestedTable = !!plateCore.getBlockAbove(editor, {
+          // Nested tables are handled by another normalization
+          // rule in a the table cell level
+          var isNestedTable = !!getBlockAbove(editor, {
             at: path,
             match: {
               type: [Contentful.BLOCKS.TABLE_CELL, Contentful.BLOCKS.TABLE_HEADER_CELL]
@@ -6875,10 +7191,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 = plateCore.getParent(editor, path)) == null ? void 0 : _getParent[0];
+          var parent = (_getParentNode = getParentNode(editor, path)) == null ? void 0 : _getParentNode[0];
           return parent && parent.type === Contentful.BLOCKS.TABLE;
         },
         transform: transformWrapIn(Contentful.BLOCKS.TABLE)
@@ -6889,8 +7205,8 @@ var createTablePlugin = function createTablePlugin() {
         },
         transform: function transform(editor, entry) {
           var howMany = getNoOfMissingTableCellsInRow(editor, entry);
-          var at = slate.Path.next(plateCore.getLastChildPath(entry));
-          slate.Transforms.insertNodes(editor, createEmptyTableCells(howMany), {
+          var at = getNextPath(getLastChildPath(entry));
+          insertNodes(editor, createEmptyTableCells(howMany), {
             at: at
           });
         }
@@ -6955,7 +7271,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__*/React.createElement(f36Icons.TableIcon, null));
 }
@@ -6977,7 +7293,7 @@ function createTextPlugin(restrictedMarks) {
             return;
           }
 
-          slate.Transforms.setSelection(editor, slate.Editor.unhangRange(editor, editor.selection));
+          setSelection(editor, unhangRange(editor, editor.selection));
         };
       }
     },
@@ -6993,19 +7309,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 && slate.Range.isCollapsed(selection)) {
-          var _Editor$above;
+        if (selection && isRangeCollapsed(selection)) {
+          var _getAboveNode;
 
-          var inlinePath = (_Editor$above = slate.Editor.above(editor, {
+          var inlinePath = (_getAboveNode = getAboveNode(editor, {
             match: function match(n) {
-              return slate.Editor.isInline(editor, n);
+              return isInline(editor, n);
             },
             mode: 'highest'
-          })) == null ? void 0 : _Editor$above[1];
+          })) == null ? void 0 : _getAboveNode[1];
 
-          if (inlinePath && slate.Editor.isEnd(editor, selection.anchor, inlinePath)) {
-            var point = slate.Editor.after(editor, inlinePath);
-            slate.Transforms.setSelection(editor, {
+          if (inlinePath && isEndPoint(editor, selection.anchor, inlinePath)) {
+            var point = getPointAfter(editor, inlinePath);
+            setSelection(editor, {
               anchor: point,
               focus: point
             });
@@ -7031,10 +7347,10 @@ function createTextPlugin(restrictedMarks) {
       return editor;
     },
     normalizer: [{
-      match: slate.Text.isText,
+      match: isText,
       transform: function transform(editor, _ref) {
         var path = _ref[1];
-        plateCore.unsetNodes(editor, restrictedMarks, {
+        unsetNodes(editor, restrictedMarks, {
           at: path
         });
       },
@@ -7049,7 +7365,7 @@ function createTextPlugin(restrictedMarks) {
 }
 
 function deleteEmptyParagraph(unit, editor, deleteFunction) {
-  var entry = plateCore.getAbove(editor, {
+  var entry = getAboveNode(editor, {
     match: {
       type: Contentful.TEXT_CONTAINERS
     }
@@ -7058,32 +7374,32 @@ function deleteEmptyParagraph(unit, editor, deleteFunction) {
   if (entry) {
     var paragraphOrHeading = entry[0],
         path = entry[1];
-    var isTextEmpty = plateCore.isAncestorEmpty(editor, paragraphOrHeading); // We ignore paragraphs/headings that are children of ul, ol, blockquote, tables, etc
+    var isTextEmpty = isAncestorEmpty(editor, paragraphOrHeading); // We ignore paragraphs/headings that are children of ul, ol, blockquote, tables, etc
 
     var isRootLevel = path.length === 1;
     var hasSiblings = editor.children.length > 1; // prevent editor from losing focus
 
     if (isTextEmpty && isRootLevel && hasSiblings) {
-      slate.Transforms.removeNodes(editor, {
+      removeNodes(editor, {
         at: path
       });
-      var prevNode = slate.Editor.before(editor, editor.selection, {
+      var prevNode = getPointBefore(editor, editor.selection, {
         unit: unit
       });
 
       if (prevNode) {
-        var _Editor$nodes = slate.Editor.nodes(editor, {
+        var _getNodeEntries = getNodeEntries(editor, {
           match: function match(node) {
-            return plateCore.queryNode([node, prevNode.path], {
+            return queryNode([node, prevNode.path], {
               allow: [Contentful.BLOCKS.EMBEDDED_ASSET, Contentful.BLOCKS.EMBEDDED_ENTRY, Contentful.BLOCKS.HR]
             });
           },
           at: prevNode
         }),
-            prevCell = _Editor$nodes[0];
+            prevCell = _getNodeEntries[0];
 
         if (prevCell) {
-          slate.Transforms.select(editor, prevNode);
+          select(editor, prevNode);
         }
       }
     } else {
@@ -7120,7 +7436,7 @@ function fixPasteAsPlainText(editor) {
       }
 
       if (split) {
-        slate.Transforms.splitNodes(editor, {
+        splitNodes(editor, {
           always: true
         });
       }
@@ -7154,7 +7470,7 @@ var createVoidsPlugin = function createVoidsPlugin() {
         filter: function filter(_ref) {
           var node = _ref[0],
               path = _ref[1];
-          return isRootLevel(path) && plateCore.isFirstChild(path) && !!node.isVoid;
+          return isRootLevel(path) && isFirstChildPath(path) && !!node.isVoid;
         }
       }
     }, {
@@ -7167,7 +7483,7 @@ var createVoidsPlugin = function createVoidsPlugin() {
         filter: function filter(_ref2) {
           var node = _ref2[0],
               path = _ref2[1];
-          return !(isRootLevel(path) && plateCore.isFirstChild(path)) && !!node.isVoid;
+          return !(isRootLevel(path) && isFirstChildPath(path)) && !!node.isVoid;
         }
       }
     }]
@@ -7176,7 +7492,7 @@ var createVoidsPlugin = function createVoidsPlugin() {
 
 var getPlugins = function getPlugins(sdk, onAction, restrictedMarks) {
   return [// AST must come after the HTML deserializer
-  plateCore.createDeserializeHtmlPlugin(), plateCore.createDeserializeAstPlugin(), plateSerializerDocx.createDeserializeDocxPlugin(), // Tracking - This should come first so all plugins below will have access to `editor.tracking`
+  p.createDeserializeHtmlPlugin(), p.createDeserializeAstPlugin(), plateSerializerDocx.createDeserializeDocxPlugin(), // Tracking - This should come first so all plugins below will have access to `editor.tracking`
   createTrackingPlugin(onAction), // Global / Global shortcuts
   createDragAndDropPlugin(), createCommandPalettePlugin(), // Block Elements
   createParagraphPlugin(), createListPlugin(), createHrPlugin(), createHeadingPlugin(), createQuotePlugin(), createTablePlugin(), createEmbeddedEntryBlockPlugin(sdk), createEmbeddedAssetBlockPlugin(sdk), // Inline elements
@@ -7254,7 +7570,7 @@ var hasContent = function hasContent(doc) {
 
 var setEditorContent = function setEditorContent(editor, nodes) {
   // Replaces editor content while keeping change history
-  slate.Editor.withoutNormalizing(editor, function () {
+  withoutNormalizing(editor, function () {
     var children = [].concat(editor.children);
     children.forEach(function (node) {
       return editor.apply({
@@ -7265,9 +7581,9 @@ var setEditorContent = function setEditorContent(editor, nodes) {
     });
 
     if (nodes) {
-      var nodesArray = slate.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
@@ -7275,10 +7591,10 @@ var setEditorContent = function setEditorContent(editor, nodes) {
       });
     }
 
-    var point = slate.Editor.end(editor, []);
+    var point = getEndPoint(editor, []);
 
     if (point) {
-      slate.Transforms.select(editor, point);
+      select(editor, point);
     }
   });
 };
@@ -7296,9 +7612,9 @@ var documentToEditorValue = function documentToEditorValue(doc) {
   return sanitizeIncomingSlateDoc(slateDoc);
 };
 var normalizeEditorValue = function normalizeEditorValue(value, options) {
-  var editor = plateCore.createPlateEditor(options);
+  var editor = createPlateEditor(options);
   editor.children = value;
-  slate.Editor.normalize(editor, {
+  normalize(editor, {
     force: true
   });
   return editor.children;
@@ -7406,7 +7722,7 @@ var EmbedEntityWidget = function EmbedEntityWidget(_ref) {
     nodeType: Contentful.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,
@@ -7464,7 +7780,7 @@ var Dropdown = function Dropdown(_ref) {
   var sdk = _ref.sdk,
       isDisabled = _ref.isDisabled;
   var editor = useContentfulEditor();
-  var isActive = plateCore.isMarkActive(editor, Contentful.MARKS.SUPERSCRIPT) || plateCore.isMarkActive(editor, Contentful.MARKS.SUBSCRIPT) || plateCore.isMarkActive(editor, Contentful.MARKS.CODE);
+  var isActive = editor && (isMarkActive(editor, Contentful.MARKS.SUPERSCRIPT) || isMarkActive(editor, Contentful.MARKS.SUBSCRIPT) || isMarkActive(editor, Contentful.MARKS.CODE));
   return /*#__PURE__*/React__default.createElement(f36Components.Menu, null, /*#__PURE__*/React__default.createElement(f36Components.Menu.Trigger, null, /*#__PURE__*/React__default.createElement("span", null, /*#__PURE__*/React__default.createElement(f36Components.IconButton, {
     size: "small",
     className: styles$l.toolbarBtn,
@@ -7618,7 +7934,7 @@ var useOnValueChanged = function useOnValueChanged(_ref) {
     }, 500);
   }, [handler]);
   return React.useCallback(function (value) {
-    var editor = plateCore.getPlateSelectors(editorId).editor();
+    var editor = p.getPlateSelectors(editorId).editor();
 
     if (!editor) {
       throw new Error('Editor change callback called but editor not defined. Editor id: ' + editorId);
@@ -7674,7 +7990,7 @@ var ConnectedRichTextEditor = function ConnectedRichTextEditor(props) {
        the change listener isn't invoked
     */
     setIsFirstRender(false);
-    var editor = plateCore.getPlateSelectors(id).editor();
+    var editor = getPlateSelectors(id).editor();
 
     if (!editor) {
       return;
@@ -7691,7 +8007,9 @@ var ConnectedRichTextEditor = function ConnectedRichTextEditor(props) {
       return;
     }
 
-    plateCore.getPlateActions(id).value(normalizeEditorValue(documentToEditorValue(props.value), {
+    p.getPlateActions(id).value( // FIXME: fix types here
+    // @ts-expect-error
+    normalizeEditorValue(documentToEditorValue(props.value), {
       plugins: plugins,
       disableCorePlugins: disableCorePlugins
     }));
@@ -7703,7 +8021,7 @@ var ConnectedRichTextEditor = function ConnectedRichTextEditor(props) {
   }, /*#__PURE__*/React__default.createElement("div", {
     className: styles$k.root,
     "data-test-id": "rich-text-editor"
-  }, /*#__PURE__*/React__default.createElement(plateCore.Plate, {
+  }, /*#__PURE__*/React__default.createElement(p.Plate, {
     id: id,
     plugins: plugins,
     disableCorePlugins: disableCorePlugins,
@@ -7711,12 +8029,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) {