slate-react 0.130.0-20261008002243 → 0.130.0

package/dist/index.es.js

@@ -1,7 +1,7 @@
 import getDirection from 'direction';
 import debounce from 'lodash/debounce';
 import throttle from 'lodash/throttle';
-import React, { createContext, useContext, useRef, useEffect, useLayoutEffect, useState, memo, forwardRef, useCallback, useReducer, useMemo, Fragment, Component } from 'react';
+import React, { useContext, createContext, useRef, useEffect, useLayoutEffect, useState, memo, forwardRef, useCallback, useReducer, useMemo, Fragment, Component } from 'react';
 import scrollIntoView from 'scroll-into-view-if-needed';
 import { Node, Range, Editor, Path, Transforms, Location, Text as Text$1, Scrubber } from 'slate';
 import { DOMEditor, isTrackedMutation, EDITOR_TO_FORCE_RENDER, IS_NODE_MAP_DIRTY, EDITOR_TO_PENDING_DIFFS, EDITOR_TO_PENDING_SELECTION, applyStringDiff, EDITOR_TO_PENDING_INSERTION_MARKS, isDOMSelection, IS_COMPOSING, EDITOR_TO_PENDING_ACTION, EDITOR_TO_USER_MARKS, targetRange, verifyDiffState, EDITOR_TO_PLACEHOLDER_ELEMENT, normalizeStringDiff, mergeStringDiffs, normalizeRange, normalizePoint, CAN_USE_DOM, IS_ANDROID, EDITOR_TO_SCHEDULE_FLUSH, MARK_PLACEHOLDER_SYMBOL, PLACEHOLDER_SYMBOL, IS_WEBKIT, isTextDecorationsEqual, isElementDecorationsEqual, EDITOR_TO_KEY_TO_ELEMENT, NODE_TO_ELEMENT, ELEMENT_TO_NODE, NODE_TO_INDEX, NODE_TO_PARENT, Key, splitDecorationsByChild, IS_READ_ONLY, getActiveElement, getSelection, IS_FOCUSED, getDefaultView, EDITOR_TO_WINDOW, EDITOR_TO_ELEMENT, IS_FIREFOX, containsShadowAware, EDITOR_TO_USER_SELECTION, HAS_BEFORE_INPUT_SUPPORT, isPlainTextOnlyPaste, Hotkeys, IS_CHROME, IS_FIREFOX_LEGACY, IS_IOS, IS_WECHATBROWSER, IS_UC_MOBILE, isDOMNode, TRIPLE_CLICK, isDOMElement, EDITOR_TO_ON_CHANGE, withDOM } from 'slate-dom';
@@ -9,33 +9,26 @@ export { NODE_TO_INDEX, NODE_TO_PARENT } from 'slate-dom';
 import ReactDOM from 'react-dom';
 import { ResizeObserver } from '@juggle/resize-observer';
 
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
   }
-  return target;
+  return t;
 }
 
-function _objectWithoutProperties(source, excluded) {
-  if (source == null) return {};
-  var target = _objectWithoutPropertiesLoose(source, excluded);
-  var key, i;
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
   if (Object.getOwnPropertySymbols) {
-    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-    for (i = 0; i < sourceSymbolKeys.length; i++) {
-      key = sourceSymbolKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-      target[key] = source[key];
-    }
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
   }
-  return target;
+  return i;
 }
 
 function _typeof(o) {
@@ -48,114 +41,107 @@ function _typeof(o) {
   }, _typeof(o);
 }
 
-function _toPrimitive(input, hint) {
-  if (_typeof(input) !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint);
-    if (_typeof(res) !== "object") return res;
+function toPrimitive(t, r) {
+  if ("object" != _typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof(i)) return i;
     throw new TypeError("@@toPrimitive must return a primitive value.");
   }
-  return (hint === "string" ? String : Number)(input);
+  return ("string" === r ? String : Number)(t);
 }
 
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return _typeof(key) === "symbol" ? key : String(key);
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : i + "";
 }
 
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
+function _defineProperty(e, r, t) {
+  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
 }
 
 /**
  * A React context for sharing the editor object.
  */
-var EditorContext = /*#__PURE__*/createContext(null);
+const EditorContext = /*#__PURE__*/createContext(null);
 /**
  * Get the current editor object from the React context.
  */
-var useSlateStatic = () => {
-  var editor = useContext(EditorContext);
+const useSlateStatic = () => {
+  const editor = useContext(EditorContext);
   if (!editor) {
-    throw new Error("The `useSlateStatic` hook must be used inside the <Slate> component's context.");
+    throw new Error(`The \`useSlateStatic\` hook must be used inside the <Slate> component's context.`);
   }
   return editor;
 };
 
 // eslint-disable-next-line no-redeclare
-var ReactEditor = DOMEditor;
+const ReactEditor = DOMEditor;
 
 function ownKeys$8(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread$8(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$8(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$8(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 // https://github.com/facebook/draft-js/blob/main/src/component/handlers/composition/DraftEditorCompositionHandler.js#L41
 // When using keyboard English association function, conpositionEnd triggered too fast, resulting in after `insertText` still maintain association state.
-var RESOLVE_DELAY = 25;
+const RESOLVE_DELAY = 25;
 // Time with no user interaction before the current user action is considered as done.
-var FLUSH_DELAY = 200;
+const FLUSH_DELAY = 200;
 // Time with no composition input after which a composition that never ended is
 // treated as stale. Long enough that pausing mid-word does not cut a live
 // composition short.
-var COMPOSITION_IDLE_TIMEOUT = 5000;
+const COMPOSITION_IDLE_TIMEOUT = 5000;
 // How often a deferred flush re-checks whether the composition is still live.
 // Only bounds how quickly the value catches up with a composition that ended
 // without firing `compositionend`; one that ends normally flushes immediately.
-var COMPOSITION_RECHECK_DELAY = 50;
+const COMPOSITION_RECHECK_DELAY = 50;
 // Replace with `const debug = console.log` to debug
-var debug = function debug() {};
+const debug = (..._) => {};
 // Type guard to check if a value is a DataTransfer
-var isDataTransfer = value => (value === null || value === void 0 ? void 0 : value.constructor.name) === 'DataTransfer';
-function createAndroidInputManager(_ref) {
-  var {
-    editor,
-    scheduleOnDOMSelectionChange,
-    onDOMSelectionChange
-  } = _ref;
-  var flushing = false;
-  var compositionEndTimeoutId = null;
-  var flushTimeoutId = null;
-  var actionTimeoutId = null;
-  var lastCompositionActivity = 0;
-  var compositionCleared = false;
-  var idCounter = 0;
-  var insertPositionHint = false;
-  var applyPendingSelection = () => {
-    var pendingSelection = EDITOR_TO_PENDING_SELECTION.get(editor);
+const isDataTransfer = value => (value === null || value === void 0 ? void 0 : value.constructor.name) === 'DataTransfer';
+function createAndroidInputManager({
+  editor,
+  scheduleOnDOMSelectionChange,
+  onDOMSelectionChange
+}) {
+  let flushing = false;
+  let compositionEndTimeoutId = null;
+  let flushTimeoutId = null;
+  let actionTimeoutId = null;
+  let lastCompositionActivity = 0;
+  let compositionCleared = false;
+  let idCounter = 0;
+  let insertPositionHint = false;
+  const applyPendingSelection = () => {
+    const pendingSelection = EDITOR_TO_PENDING_SELECTION.get(editor);
     EDITOR_TO_PENDING_SELECTION.delete(editor);
     if (pendingSelection) {
-      var {
+      const {
         selection
       } = editor;
-      var normalized = normalizeRange(editor, pendingSelection);
+      const normalized = normalizeRange(editor, pendingSelection);
       if (normalized && (!selection || !Range.equals(normalized, selection))) {
         Transforms.select(editor, normalized);
       }
     }
   };
-  var performAction = () => {
-    var action = EDITOR_TO_PENDING_ACTION.get(editor);
+  const performAction = () => {
+    const action = EDITOR_TO_PENDING_ACTION.get(editor);
     EDITOR_TO_PENDING_ACTION.delete(editor);
     if (!action) {
       return;
     }
     if (action.at) {
-      var target = Location.isPoint(action.at) ? normalizePoint(editor, action.at) : normalizeRange(editor, action.at);
+      const target = Location.isPoint(action.at) ? normalizePoint(editor, action.at) : normalizeRange(editor, action.at);
       if (!target) {
         return;
       }
-      var _targetRange = Editor.range(editor, target);
-      if (!editor.selection || !Range.equals(editor.selection, _targetRange)) {
+      const targetRange = Editor.range(editor, target);
+      if (!editor.selection || !Range.equals(editor.selection, targetRange)) {
         Transforms.select(editor, target);
       }
     }
@@ -165,13 +151,13 @@ function createAndroidInputManager(_ref) {
   // already works around on keydown. Deferring flushes on a composition that
   // never ends would strand the typed text outside the value, so a composition
   // that has gone quiet, or that has lost focus, no longer holds flushes back.
-  var isCompositionLive = () => {
+  const isCompositionLive = () => {
     if (!IS_COMPOSING.get(editor) || compositionCleared) {
       return false;
     }
     try {
-      var editable = ReactEditor.toDOMNode(editor, editor);
-      var {
+      const editable = ReactEditor.toDOMNode(editor, editor);
+      const {
         activeElement
       } = ReactEditor.getWindow(editor).document;
       if (activeElement !== editable && !editable.contains(activeElement)) {
@@ -188,12 +174,11 @@ function createAndroidInputManager(_ref) {
   // composition. Applying the pending diffs re-renders that leaf as a text
   // leaf, which unmounts the zero-width span and takes the text node the IME is
   // composing in with it, silently cancelling the composition.
-  var hasPendingDiffsInEmptyLeaf = () => {
+  const hasPendingDiffsInEmptyLeaf = () => {
     var _EDITOR_TO_PENDING_DI;
-    return !!((_EDITOR_TO_PENDING_DI = EDITOR_TO_PENDING_DIFFS.get(editor)) !== null && _EDITOR_TO_PENDING_DI !== void 0 && _EDITOR_TO_PENDING_DI.some(_ref2 => {
-      var {
-        path
-      } = _ref2;
+    return !!((_EDITOR_TO_PENDING_DI = EDITOR_TO_PENDING_DIFFS.get(editor)) !== null && _EDITOR_TO_PENDING_DI !== void 0 && _EDITOR_TO_PENDING_DI.some(({
+      path
+    }) => {
       try {
         return Node.leaf(editor, path).text.length === 0;
       } catch (_unused2) {
@@ -202,7 +187,7 @@ function createAndroidInputManager(_ref) {
       }
     }));
   };
-  var flush = () => {
+  const flush = () => {
     if (flushTimeoutId) {
       clearTimeout(flushTimeoutId);
       flushTimeoutId = null;
@@ -231,16 +216,16 @@ function createAndroidInputManager(_ref) {
     if (hasPendingAction()) {
       flushing = 'action';
     }
-    var selectionRef = editor.selection && Editor.rangeRef(editor, editor.selection, {
+    const selectionRef = editor.selection && Editor.rangeRef(editor, editor.selection, {
       affinity: 'forward'
     });
     EDITOR_TO_USER_MARKS.set(editor, editor.marks);
     debug('flush', EDITOR_TO_PENDING_ACTION.get(editor), EDITOR_TO_PENDING_DIFFS.get(editor));
-    var scheduleSelectionChange = hasPendingDiffs();
-    var diff;
+    let scheduleSelectionChange = hasPendingDiffs();
+    let diff;
     while (diff = (_EDITOR_TO_PENDING_DI2 = EDITOR_TO_PENDING_DIFFS.get(editor)) === null || _EDITOR_TO_PENDING_DI2 === void 0 ? void 0 : _EDITOR_TO_PENDING_DI2[0]) {
       var _EDITOR_TO_PENDING_DI2, _EDITOR_TO_PENDING_DI3;
-      var pendingMarks = EDITOR_TO_PENDING_INSERTION_MARKS.get(editor);
+      const pendingMarks = EDITOR_TO_PENDING_INSERTION_MARKS.get(editor);
       if (pendingMarks !== undefined) {
         EDITOR_TO_PENDING_INSERTION_MARKS.delete(editor);
         editor.marks = pendingMarks;
@@ -248,7 +233,7 @@ function createAndroidInputManager(_ref) {
       if (pendingMarks && insertPositionHint === false) {
         insertPositionHint = null;
       }
-      var range = targetRange(diff);
+      const range = targetRange(diff);
       if (!editor.selection || !Range.equals(editor.selection, range)) {
         Transforms.select(editor, range);
       }
@@ -259,12 +244,9 @@ function createAndroidInputManager(_ref) {
       }
       // Remove diff only after we have applied it to account for it when transforming
       // pending ranges.
-      EDITOR_TO_PENDING_DIFFS.set(editor, (_EDITOR_TO_PENDING_DI3 = EDITOR_TO_PENDING_DIFFS.get(editor)) === null || _EDITOR_TO_PENDING_DI3 === void 0 ? void 0 : _EDITOR_TO_PENDING_DI3.filter(_ref3 => {
-        var {
-          id
-        } = _ref3;
-        return id !== diff.id;
-      }));
+      EDITOR_TO_PENDING_DIFFS.set(editor, (_EDITOR_TO_PENDING_DI3 = EDITOR_TO_PENDING_DIFFS.get(editor)) === null || _EDITOR_TO_PENDING_DI3 === void 0 ? void 0 : _EDITOR_TO_PENDING_DI3.filter(({
+        id
+      }) => id !== diff.id));
       if (!verifyDiffState(editor, diff)) {
         scheduleSelectionChange = false;
         EDITOR_TO_PENDING_ACTION.delete(editor);
@@ -278,7 +260,7 @@ function createAndroidInputManager(_ref) {
         selectionRef === null || selectionRef === void 0 || selectionRef.unref();
       }
     }
-    var selection = selectionRef === null || selectionRef === void 0 ? void 0 : selectionRef.unref();
+    const selection = selectionRef === null || selectionRef === void 0 ? void 0 : selectionRef.unref();
     if (selection && !EDITOR_TO_PENDING_SELECTION.get(editor) && (!editor.selection || !Range.equals(selection, editor.selection))) {
       Transforms.select(editor, selection);
     }
@@ -295,14 +277,14 @@ function createAndroidInputManager(_ref) {
     scheduleOnDOMSelectionChange.flush();
     onDOMSelectionChange.flush();
     applyPendingSelection();
-    var userMarks = EDITOR_TO_USER_MARKS.get(editor);
+    const userMarks = EDITOR_TO_USER_MARKS.get(editor);
     EDITOR_TO_USER_MARKS.delete(editor);
     if (userMarks !== undefined) {
       editor.marks = userMarks;
       editor.onChange();
     }
   };
-  var handleCompositionEnd = _event => {
+  const handleCompositionEnd = _event => {
     if (compositionEndTimeoutId) {
       clearTimeout(compositionEndTimeoutId);
     }
@@ -331,7 +313,7 @@ function createAndroidInputManager(_ref) {
       updatePlaceholderVisibility();
     }, RESOLVE_DELAY);
   };
-  var handleCompositionStart = _event => {
+  const handleCompositionStart = _event => {
     IS_COMPOSING.set(editor, true);
     lastCompositionActivity = Date.now();
     compositionCleared = false;
@@ -340,9 +322,8 @@ function createAndroidInputManager(_ref) {
       compositionEndTimeoutId = null;
     }
   };
-  var updatePlaceholderVisibility = function updatePlaceholderVisibility() {
-    var forceHide = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-    var placeholderElement = EDITOR_TO_PLACEHOLDER_ELEMENT.get(editor);
+  const updatePlaceholderVisibility = (forceHide = false) => {
+    const placeholderElement = EDITOR_TO_PLACEHOLDER_ELEMENT.get(editor);
     if (!placeholderElement) {
       return;
     }
@@ -352,14 +333,14 @@ function createAndroidInputManager(_ref) {
     }
     placeholderElement.style.removeProperty('display');
   };
-  var storeDiff = (path, diff) => {
+  const storeDiff = (path, diff) => {
     var _EDITOR_TO_PENDING_DI4;
-    var pendingDiffs = (_EDITOR_TO_PENDING_DI4 = EDITOR_TO_PENDING_DIFFS.get(editor)) !== null && _EDITOR_TO_PENDING_DI4 !== void 0 ? _EDITOR_TO_PENDING_DI4 : [];
+    const pendingDiffs = (_EDITOR_TO_PENDING_DI4 = EDITOR_TO_PENDING_DIFFS.get(editor)) !== null && _EDITOR_TO_PENDING_DI4 !== void 0 ? _EDITOR_TO_PENDING_DI4 : [];
     EDITOR_TO_PENDING_DIFFS.set(editor, pendingDiffs);
-    var target = Node.leaf(editor, path);
-    var idx = pendingDiffs.findIndex(change => Path.equals(change.path, path));
+    const target = Node.leaf(editor, path);
+    const idx = pendingDiffs.findIndex(change => Path.equals(change.path, path));
     if (idx < 0) {
-      var normalized = normalizeStringDiff(target.text, diff);
+      const normalized = normalizeStringDiff(target.text, diff);
       if (normalized) {
         pendingDiffs.push({
           path,
@@ -370,7 +351,7 @@ function createAndroidInputManager(_ref) {
       updatePlaceholderVisibility();
       return;
     }
-    var merged = mergeStringDiffs(target.text, pendingDiffs[idx].diff, diff);
+    const merged = mergeStringDiffs(target.text, pendingDiffs[idx].diff, diff);
     if (!merged) {
       pendingDiffs.splice(idx, 1);
       updatePlaceholderVisibility();
@@ -380,10 +361,9 @@ function createAndroidInputManager(_ref) {
       diff: merged
     });
   };
-  var scheduleAction = function scheduleAction(run) {
-    var {
-      at
-    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const scheduleAction = (run, {
+    at
+  } = {}) => {
     insertPositionHint = false;
     EDITOR_TO_PENDING_SELECTION.delete(editor);
     scheduleOnDOMSelectionChange.cancel();
@@ -400,14 +380,13 @@ function createAndroidInputManager(_ref) {
     // in this case and thus never actually perform the action.
     actionTimeoutId = setTimeout(flush);
   };
-  var handleDOMBeforeInput = event => {
-    var _targetRange2;
+  const handleDOMBeforeInput = event => {
     if (flushTimeoutId) {
       clearTimeout(flushTimeoutId);
       flushTimeoutId = null;
     }
-    var isNodeMapDirty = IS_NODE_MAP_DIRTY.get(editor);
-    var {
+    const isNodeMapDirty = IS_NODE_MAP_DIRTY.get(editor);
+    const {
       inputType: type
     } = event;
     if (type === 'insertCompositionText' || type === 'deleteCompositionText') {
@@ -421,12 +400,11 @@ function createAndroidInputManager(_ref) {
         // would churn the DOM mid-composition and can make Android close the
         // keyboard.
         compositionCleared = true;
-        var deferredDiffs = EDITOR_TO_PENDING_DIFFS.get(editor);
+        const deferredDiffs = EDITOR_TO_PENDING_DIFFS.get(editor);
         if (deferredDiffs !== null && deferredDiffs !== void 0 && deferredDiffs.length) {
-          var allInEmptyLeaves = deferredDiffs.every(_ref4 => {
-            var {
-              path
-            } = _ref4;
+          const allInEmptyLeaves = deferredDiffs.every(({
+            path
+          }) => {
             try {
               return Node.leaf(editor, path).text.length === 0;
             } catch (_unused3) {
@@ -440,12 +418,12 @@ function createAndroidInputManager(_ref) {
         }
       }
     }
-    var targetRange = null;
-    var data = event.dataTransfer || event.data || undefined;
+    let targetRange = null;
+    const data = event.dataTransfer || event.data || undefined;
     if (insertPositionHint !== false && type !== 'insertText' && type !== 'insertCompositionText') {
       insertPositionHint = false;
     }
-    var [nativeTargetRange] = event.getTargetRanges();
+    let [nativeTargetRange] = event.getTargetRanges();
     if (nativeTargetRange && !isNodeMapDirty) {
       targetRange = ReactEditor.toSlateRange(editor, nativeTargetRange, {
         exactMatch: false,
@@ -454,8 +432,8 @@ function createAndroidInputManager(_ref) {
     }
     // COMPAT: SelectionChange event is fired after the action is performed, so we
     // have to manually get the selection here to ensure it's up-to-date.
-    var window = ReactEditor.getWindow(editor);
-    var domSelection = window.getSelection();
+    const window = ReactEditor.getWindow(editor);
+    const domSelection = window.getSelection();
     if (!targetRange && domSelection && !isNodeMapDirty) {
       nativeTargetRange = domSelection;
       targetRange = ReactEditor.toSlateRange(editor, domSelection, {
@@ -463,7 +441,7 @@ function createAndroidInputManager(_ref) {
         suppressThrow: true
       });
     }
-    targetRange = (_targetRange2 = targetRange) !== null && _targetRange2 !== void 0 ? _targetRange2 : editor.selection;
+    targetRange = targetRange !== null && targetRange !== void 0 ? targetRange : editor.selection;
     if (!targetRange) {
       return;
     }
@@ -472,14 +450,14 @@ function createAndroidInputManager(_ref) {
     // for every input event as this can be expensive. However, there are some
     // scenarios where we cannot safely store the text diff and must instead
     // schedule an action to let Slate normalize the editor state.
-    var canStoreDiff = true;
+    let canStoreDiff = true;
     if (type.startsWith('delete')) {
-      var direction = type.endsWith('Backward') ? 'backward' : 'forward';
-      var [start, end] = Range.edges(targetRange);
-      var [leaf, path] = Editor.leaf(editor, start.path);
+      const direction = type.endsWith('Backward') ? 'backward' : 'forward';
+      let [start, end] = Range.edges(targetRange);
+      let [leaf, path] = Editor.leaf(editor, start.path);
       if (Range.isExpanded(targetRange)) {
         if (leaf.text.length === start.offset && end.offset === 0) {
-          var next = Editor.next(editor, {
+          const next = Editor.next(editor, {
             at: start.path,
             match: Node.isText
           });
@@ -504,15 +482,15 @@ function createAndroidInputManager(_ref) {
           }
         }
       }
-      var diff = {
+      const diff = {
         text: '',
         start: start.offset,
         end: end.offset
       };
-      var pendingDiffs = EDITOR_TO_PENDING_DIFFS.get(editor);
-      var relevantPendingDiffs = pendingDiffs === null || pendingDiffs === void 0 ? void 0 : pendingDiffs.find(change => Path.equals(change.path, path));
-      var diffs = relevantPendingDiffs ? [relevantPendingDiffs.diff, diff] : [diff];
-      var text = applyStringDiff(leaf.text, ...diffs);
+      const pendingDiffs = EDITOR_TO_PENDING_DIFFS.get(editor);
+      const relevantPendingDiffs = pendingDiffs === null || pendingDiffs === void 0 ? void 0 : pendingDiffs.find(change => Path.equals(change.path, path));
+      const diffs = relevantPendingDiffs ? [relevantPendingDiffs.diff, diff] : [diff];
+      const text = applyStringDiff(leaf.text, ...diffs);
       if (text.length === 0) {
         // Text leaf will be removed, so we need to schedule an
         // action to remove it so that Slate can normalize instead
@@ -521,11 +499,11 @@ function createAndroidInputManager(_ref) {
       }
       if (Range.isExpanded(targetRange)) {
         if (canStoreDiff && Path.equals(targetRange.anchor.path, targetRange.focus.path)) {
-          var point = {
+          const point = {
             path: targetRange.anchor.path,
             offset: start.offset
           };
-          var range = Editor.range(editor, point, point);
+          const range = Editor.range(editor, point, point);
           handleUserSelect(range);
           return storeDiff(targetRange.anchor.path, {
             text: '',
@@ -552,11 +530,11 @@ function createAndroidInputManager(_ref) {
       case 'deleteContent':
       case 'deleteContentForward':
         {
-          var {
+          const {
             anchor
           } = targetRange;
           if (canStoreDiff && Range.isCollapsed(targetRange)) {
-            var targetNode = Node.leaf(editor, anchor.path);
+            const targetNode = Node.leaf(editor, anchor.path);
             if (anchor.offset < targetNode.text.length) {
               return storeDiff(anchor.path, {
                 text: '',
@@ -572,18 +550,18 @@ function createAndroidInputManager(_ref) {
       case 'deleteContentBackward':
         {
           var _nativeTargetRange;
-          var {
-            anchor: _anchor
+          const {
+            anchor
           } = targetRange;
           // If we have a mismatch between the native and slate selection being collapsed
           // we are most likely deleting a zero-width placeholder and thus should perform it
           // as an action to ensure correct behavior (mostly happens with mark placeholders)
-          var nativeCollapsed = isDOMSelection(nativeTargetRange) ? nativeTargetRange.isCollapsed : !!((_nativeTargetRange = nativeTargetRange) !== null && _nativeTargetRange !== void 0 && _nativeTargetRange.collapsed);
-          if (canStoreDiff && nativeCollapsed && Range.isCollapsed(targetRange) && _anchor.offset > 0) {
-            return storeDiff(_anchor.path, {
+          const nativeCollapsed = isDOMSelection(nativeTargetRange) ? nativeTargetRange.isCollapsed : !!((_nativeTargetRange = nativeTargetRange) !== null && _nativeTargetRange !== void 0 && _nativeTargetRange.collapsed);
+          if (canStoreDiff && nativeCollapsed && Range.isCollapsed(targetRange) && anchor.offset > 0) {
+            return storeDiff(anchor.path, {
               text: '',
-              start: _anchor.offset - 1,
-              end: _anchor.offset
+              start: anchor.offset - 1,
+              end: anchor.offset
             });
           }
           return scheduleAction(() => Editor.deleteBackward(editor), {
@@ -677,23 +655,23 @@ function createAndroidInputManager(_ref) {
               at: targetRange
             });
           }
-          var _text = data !== null && data !== void 0 ? data : '';
+          let text = data !== null && data !== void 0 ? data : '';
           // COMPAT: If we are writing inside a placeholder, the ime inserts the text inside
           // the placeholder itself and thus includes the zero-width space inside edit events.
           if (EDITOR_TO_PENDING_INSERTION_MARKS.get(editor)) {
-            _text = _text.replace('\uFEFF', '');
+            text = text.replace('\uFEFF', '');
           }
           // Pastes from the Android clipboard will generate `insertText` events.
           // If the copied text contains any newlines, Android will append an
           // extra newline to the end of the copied text.
-          if (type === 'insertText' && /.*\n.*\n$/.test(_text)) {
-            _text = _text.slice(0, -1);
+          if (type === 'insertText' && /.*\n.*\n$/.test(text)) {
+            text = text.slice(0, -1);
           }
           // If the text includes a newline, split it at newlines and paste each component
           // string, with soft breaks in between each.
-          if (_text.includes('\n')) {
+          if (text.includes('\n')) {
             return scheduleAction(() => {
-              var parts = _text.split('\n');
+              const parts = text.split('\n');
               parts.forEach((line, i) => {
                 if (line) {
                   Editor.insertText(editor, line);
@@ -707,11 +685,11 @@ function createAndroidInputManager(_ref) {
             });
           }
           if (Path.equals(targetRange.anchor.path, targetRange.focus.path)) {
-            var [_start, _end] = Range.edges(targetRange);
-            var _diff = {
-              start: _start.offset,
-              end: _end.offset,
-              text: _text
+            const [start, end] = Range.edges(targetRange);
+            const diff = {
+              start: start.offset,
+              end: end.offset,
+              text
             };
             // COMPAT: Swiftkey has a weird bug where the target range of the 2nd word
             // inserted after a mark placeholder is inserted with an anchor offset off by 1.
@@ -719,11 +697,11 @@ function createAndroidInputManager(_ref) {
             // text events are fired with the correct target ranges, only the final 'insertComposition'
             // isn't, so we can adjust the target range start offset if we are confident this is the
             // swiftkey insert causing the issue.
-            if (_text && insertPositionHint && type === 'insertCompositionText') {
-              var hintPosition = insertPositionHint.start + insertPositionHint.text.search(/\S|$/);
-              var diffPosition = _diff.start + _diff.text.search(/\S|$/);
-              if (diffPosition === hintPosition + 1 && _diff.end === insertPositionHint.start + insertPositionHint.text.length) {
-                _diff.start -= 1;
+            if (text && insertPositionHint && type === 'insertCompositionText') {
+              const hintPosition = insertPositionHint.start + insertPositionHint.text.search(/\S|$/);
+              const diffPosition = diff.start + diff.text.search(/\S|$/);
+              if (diffPosition === hintPosition + 1 && diff.end === insertPositionHint.start + insertPositionHint.text.length) {
+                diff.start -= 1;
                 insertPositionHint = null;
                 scheduleFlush();
               } else {
@@ -731,10 +709,10 @@ function createAndroidInputManager(_ref) {
               }
             } else if (type === 'insertText') {
               if (insertPositionHint === null) {
-                insertPositionHint = _diff;
-              } else if (insertPositionHint && Range.isCollapsed(targetRange) && insertPositionHint.end + insertPositionHint.text.length === _start.offset) {
+                insertPositionHint = diff;
+              } else if (insertPositionHint && Range.isCollapsed(targetRange) && insertPositionHint.end + insertPositionHint.text.length === start.offset) {
                 insertPositionHint = _objectSpread$8(_objectSpread$8({}, insertPositionHint), {}, {
-                  text: insertPositionHint.text + _text
+                  text: insertPositionHint.text + text
                 });
               } else {
                 insertPositionHint = false;
@@ -743,12 +721,12 @@ function createAndroidInputManager(_ref) {
               insertPositionHint = false;
             }
             if (canStoreDiff) {
-              var currentSelection = editor.selection;
-              storeDiff(_start.path, _diff);
+              const currentSelection = editor.selection;
+              storeDiff(start.path, diff);
               if (currentSelection) {
-                var newPoint = {
-                  path: _start.path,
-                  offset: _start.offset + _text.length
+                const newPoint = {
+                  path: start.path,
+                  offset: start.offset + text.length
                 };
                 scheduleAction(() => {
                   Transforms.select(editor, {
@@ -762,39 +740,39 @@ function createAndroidInputManager(_ref) {
               return;
             }
           }
-          return scheduleAction(() => Editor.insertText(editor, _text), {
+          return scheduleAction(() => Editor.insertText(editor, text), {
             at: targetRange
           });
         }
     }
   };
-  var hasPendingAction = () => {
+  const hasPendingAction = () => {
     return !!EDITOR_TO_PENDING_ACTION.get(editor);
   };
-  var hasPendingDiffs = () => {
+  const hasPendingDiffs = () => {
     var _EDITOR_TO_PENDING_DI5;
     return !!((_EDITOR_TO_PENDING_DI5 = EDITOR_TO_PENDING_DIFFS.get(editor)) !== null && _EDITOR_TO_PENDING_DI5 !== void 0 && _EDITOR_TO_PENDING_DI5.length);
   };
-  var hasPendingChanges = () => {
+  const hasPendingChanges = () => {
     return hasPendingAction() || hasPendingDiffs();
   };
-  var isFlushing = () => {
+  const isFlushing = () => {
     return flushing;
   };
-  var handleUserSelect = range => {
+  const handleUserSelect = range => {
     EDITOR_TO_PENDING_SELECTION.set(editor, range);
     if (flushTimeoutId) {
       clearTimeout(flushTimeoutId);
       flushTimeoutId = null;
     }
-    var {
+    const {
       selection
     } = editor;
     if (!range) {
       return;
     }
-    var pathChanged = !selection || !Path.equals(selection.anchor.path, range.anchor.path);
-    var parentPathChanged = !selection || !Path.equals(selection.anchor.path.slice(0, -1), range.anchor.path.slice(0, -1));
+    const pathChanged = !selection || !Path.equals(selection.anchor.path, range.anchor.path);
+    const parentPathChanged = !selection || !Path.equals(selection.anchor.path.slice(0, -1), range.anchor.path.slice(0, -1));
     if (pathChanged && insertPositionHint || parentPathChanged) {
       insertPositionHint = false;
     }
@@ -802,12 +780,12 @@ function createAndroidInputManager(_ref) {
       flushTimeoutId = setTimeout(flush, FLUSH_DELAY);
     }
   };
-  var handleInput = () => {
+  const handleInput = () => {
     if (hasPendingAction() || !hasPendingDiffs()) {
       flush();
     }
   };
-  var handleKeyDown = _ => {
+  const handleKeyDown = _ => {
     // COMPAT: Swiftkey closes the keyboard when typing inside a empty node
     // directly next to a non-contenteditable element (= the placeholder).
     // The only event fired soon enough for us to allow hiding the placeholder
@@ -818,12 +796,12 @@ function createAndroidInputManager(_ref) {
       setTimeout(updatePlaceholderVisibility);
     }
   };
-  var scheduleFlush = () => {
+  const scheduleFlush = () => {
     if (!hasPendingAction()) {
       actionTimeoutId = setTimeout(flush);
     }
   };
-  var handleDomMutations = mutations => {
+  const handleDomMutations = mutations => {
     if (hasPendingDiffs() || hasPendingAction()) {
       return;
     }
@@ -852,7 +830,7 @@ function createAndroidInputManager(_ref) {
 }
 
 function useIsMounted() {
-  var isMountedRef = useRef(false);
+  const isMountedRef = useRef(false);
   useEffect(() => {
     isMountedRef.current = true;
     return () => {
@@ -865,10 +843,10 @@ function useIsMounted() {
 /**
  * Prevent warning on SSR by falling back to useEffect when DOM isn't available
  */
-var useIsomorphicLayoutEffect = CAN_USE_DOM ? useLayoutEffect : useEffect;
+const useIsomorphicLayoutEffect = CAN_USE_DOM ? useLayoutEffect : useEffect;
 
 function useMutationObserver(node, callback, options) {
-  var [mutationObserver] = useState(() => new MutationObserver(callback));
+  const [mutationObserver] = useState(() => new MutationObserver(callback));
   useIsomorphicLayoutEffect(() => {
     // Discard mutations caused during render phase. This works due to react calling
     // useLayoutEffect synchronously after the render phase before the next tick.
@@ -883,25 +861,25 @@ function useMutationObserver(node, callback, options) {
   }, [mutationObserver, node, options]);
 }
 
-var _excluded$2 = ["node"];
+const _excluded$2 = ["node"];
 function ownKeys$7(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread$7(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$7(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$7(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var MUTATION_OBSERVER_CONFIG$1 = {
+const MUTATION_OBSERVER_CONFIG$1 = {
   subtree: true,
   childList: true,
   characterData: true
 };
-var useAndroidInputManager = !IS_ANDROID ? () => null : _ref => {
-  var {
+const useAndroidInputManager = !IS_ANDROID ? () => null : _ref => {
+  let {
       node
     } = _ref,
     options = _objectWithoutProperties(_ref, _excluded$2);
   if (!IS_ANDROID) {
     return null;
   }
-  var editor = useSlateStatic();
-  var isMounted = useIsMounted();
-  var [inputManager] = useState(() => createAndroidInputManager(_objectSpread$7({
+  const editor = useSlateStatic();
+  const isMounted = useIsMounted();
+  const [inputManager] = useState(() => createAndroidInputManager(_objectSpread$7({
     editor
   }, options)));
   useMutationObserver(node, inputManager.handleDomMutations, MUTATION_OBSERVER_CONFIG$1);
@@ -917,17 +895,17 @@ function _objectSpread$6(e) { for (var r = 1; r < arguments.length; r++) { var t
 /**
  * Leaf content strings.
  */
-var String$1 = props => {
-  var {
+const String$1 = props => {
+  const {
     isLast,
     leaf,
     parent,
     text
   } = props;
-  var editor = useSlateStatic();
-  var path = ReactEditor.findPath(editor, text);
-  var parentPath = Path.parent(path);
-  var isMarkPlaceholder = Boolean(leaf[MARK_PLACEHOLDER_SYMBOL]);
+  const editor = useSlateStatic();
+  const path = ReactEditor.findPath(editor, text);
+  const parentPath = Path.parent(path);
+  const isMarkPlaceholder = Boolean(leaf[MARK_PLACEHOLDER_SYMBOL]);
   // COMPAT: Render text inside void nodes with a zero-width space.
   // So the node can contain selection but the text is not visible.
   if (editor.isVoid(parent)) {
@@ -967,17 +945,17 @@ var String$1 = props => {
 /**
  * Leaf strings with text in them.
  */
-var TextString = props => {
-  var {
+const TextString = props => {
+  const {
     text,
     isTrailing = false
   } = props;
-  var editor = useSlateStatic();
-  var ref = useRef(null);
-  var getTextContent = () => {
-    return "".concat(text !== null && text !== void 0 ? text : '').concat(isTrailing ? '\n' : '');
+  const editor = useSlateStatic();
+  const ref = useRef(null);
+  const getTextContent = () => {
+    return `${text !== null && text !== void 0 ? text : ''}${isTrailing ? '\n' : ''}`;
   };
-  var [initialText] = useState(getTextContent);
+  const [initialText] = useState(getTextContent);
   // This is the actual text rendering boundary where we interface with the DOM
   // The text is not rendered as part of the virtual DOM, as since we handle basic character insertions natively,
   // updating the DOM is not a one way dataflow anymore. What we need here is not reconciliation and diffing
@@ -988,7 +966,7 @@ var TextString = props => {
   // useLayoutEffect: updating our span before browser paint
   useIsomorphicLayoutEffect(() => {
     // null coalescing text to make sure we're not outputing "null" as a string in the extreme case it is nullish at runtime
-    var textWithTrailing = getTextContent();
+    const textWithTrailing = getTextContent();
     if (ref.current && ref.current.textContent !== textWithTrailing) {
       // On Android the DOM intentionally runs ahead of the value while the IME
       // composes, since input is buffered as pending diffs. Writing
@@ -997,7 +975,7 @@ var TextString = props => {
       // composition ends.
       if (IS_ANDROID && IS_COMPOSING.get(editor)) {
         var _ReactEditor$getWindo;
-        var composingNode = (_ReactEditor$getWindo = ReactEditor.getWindow(editor).getSelection()) === null || _ReactEditor$getWindo === void 0 ? void 0 : _ReactEditor$getWindo.anchorNode;
+        const composingNode = (_ReactEditor$getWindo = ReactEditor.getWindow(editor).getSelection()) === null || _ReactEditor$getWindo === void 0 ? void 0 : _ReactEditor$getWindo.anchorNode;
         if (composingNode && ref.current.contains(composingNode)) {
           return;
         }
@@ -1013,7 +991,7 @@ var TextString = props => {
     ref: ref
   }, initialText);
 };
-var MemoizedText$1 = /*#__PURE__*/memo(/*#__PURE__*/forwardRef((props, ref) => {
+const MemoizedText$1 = /*#__PURE__*/memo(/*#__PURE__*/forwardRef((props, ref) => {
   return /*#__PURE__*/React.createElement("span", {
     "data-slate-string": true,
     ref: ref
@@ -1022,13 +1000,13 @@ var MemoizedText$1 = /*#__PURE__*/memo(/*#__PURE__*/forwardRef((props, ref) => {
 /**
  * Leaf strings without text, render as zero-width strings.
  */
-var ZeroWidthString = props => {
-  var {
+const ZeroWidthString = props => {
+  const {
     length = 0,
     isLineBreak = false,
     isMarkPlaceholder = false
   } = props;
-  var attributes = {
+  const attributes = {
     'data-slate-zero-width': isLineBreak ? 'n' : 'z',
     'data-slate-length': length
   };
@@ -1056,7 +1034,7 @@ function ownKeys$5(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymb
 function _objectSpread$5(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$5(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$5(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 // Delay the placeholder on Android to prevent the keyboard from closing.
 // (https://github.com/ianstormtaylor/slate/pull/5368)
-var PLACEHOLDER_DELAY = IS_ANDROID ? 300 : 0;
+const PLACEHOLDER_DELAY = IS_ANDROID ? 300 : 0;
 function disconnectPlaceholderResizeObserver(placeholderResizeObserver, releaseObserver) {
   if (placeholderResizeObserver.current) {
     placeholderResizeObserver.current.disconnect();
@@ -1071,12 +1049,12 @@ function clearTimeoutRef(timeoutRef) {
     timeoutRef.current = null;
   }
 }
-var defaultRenderLeaf = props => /*#__PURE__*/React.createElement(DefaultLeaf, _objectSpread$5({}, props));
+const defaultRenderLeaf = props => /*#__PURE__*/React.createElement(DefaultLeaf, _objectSpread$5({}, props));
 /**
  * Individual leaves in a text node with unique formatting.
  */
-var Leaf = props => {
-  var {
+const Leaf = props => {
+  const {
     leaf,
     isLast,
     text,
@@ -1085,12 +1063,12 @@ var Leaf = props => {
     renderLeaf = defaultRenderLeaf,
     leafPosition
   } = props;
-  var editor = useSlateStatic();
-  var placeholderResizeObserver = useRef(null);
-  var placeholderRef = useRef(null);
-  var [showPlaceholder, setShowPlaceholder] = useState(false);
-  var showPlaceholderTimeoutRef = useRef(null);
-  var callbackPlaceholderRef = useCallback(placeholderEl => {
+  const editor = useSlateStatic();
+  const placeholderResizeObserver = useRef(null);
+  const placeholderRef = useRef(null);
+  const [showPlaceholder, setShowPlaceholder] = useState(false);
+  const showPlaceholderTimeoutRef = useRef(null);
+  const callbackPlaceholderRef = useCallback(placeholderEl => {
     disconnectPlaceholderResizeObserver(placeholderResizeObserver, placeholderEl == null);
     if (placeholderEl == null) {
       var _leaf$onPlaceholderRe;
@@ -1100,7 +1078,7 @@ var Leaf = props => {
       EDITOR_TO_PLACEHOLDER_ELEMENT.set(editor, placeholderEl);
       if (!placeholderResizeObserver.current) {
         // Create a new observer and observe the placeholder element.
-        var ResizeObserver$1 = window.ResizeObserver || ResizeObserver;
+        const ResizeObserver$1 = window.ResizeObserver || ResizeObserver;
         placeholderResizeObserver.current = new ResizeObserver$1(() => {
           var _leaf$onPlaceholderRe2;
           (_leaf$onPlaceholderRe2 = leaf.onPlaceholderResize) === null || _leaf$onPlaceholderRe2 === void 0 || _leaf$onPlaceholderRe2.call(leaf, placeholderEl);
@@ -1110,13 +1088,13 @@ var Leaf = props => {
       placeholderRef.current = placeholderEl;
     }
   }, [placeholderRef, leaf, editor]);
-  var children = /*#__PURE__*/React.createElement(String$1, {
+  let children = /*#__PURE__*/React.createElement(String$1, {
     isLast: isLast,
     leaf: leaf,
     parent: parent,
     text: text
   });
-  var leafIsPlaceholder = Boolean(leaf[PLACEHOLDER_SYMBOL]);
+  const leafIsPlaceholder = Boolean(leaf[PLACEHOLDER_SYMBOL]);
   useEffect(() => {
     if (leafIsPlaceholder) {
       if (!showPlaceholderTimeoutRef.current) {
@@ -1133,7 +1111,7 @@ var Leaf = props => {
     return () => clearTimeoutRef(showPlaceholderTimeoutRef);
   }, [leafIsPlaceholder, setShowPlaceholder]);
   if (leafIsPlaceholder && showPlaceholder) {
-    var placeholderProps = {
+    const placeholderProps = {
       children: leaf.placeholder,
       attributes: {
         'data-slate-placeholder': true,
@@ -1159,7 +1137,7 @@ var Leaf = props => {
   // COMPAT: Having the `data-` attributes on these leaf elements ensures that
   // in certain misbehaving browsers they aren't weirdly cloned/destroyed by
   // contenteditable behaviors. (2019/05/08)
-  var attributes = {
+  const attributes = {
     'data-slate-leaf': true
   };
   return renderLeaf({
@@ -1170,11 +1148,11 @@ var Leaf = props => {
     leafPosition
   });
 };
-var MemoizedLeaf = /*#__PURE__*/React.memo(Leaf, (prev, next) => {
+const MemoizedLeaf = /*#__PURE__*/React.memo(Leaf, (prev, next) => {
   return next.parent === prev.parent && next.isLast === prev.isLast && next.renderLeaf === prev.renderLeaf && next.renderPlaceholder === prev.renderPlaceholder && next.text === prev.text && Text$1.equals(next.leaf, prev.leaf) && next.leaf[PLACEHOLDER_SYMBOL] === prev.leaf[PLACEHOLDER_SYMBOL];
 });
-var DefaultLeaf = props => {
-  var {
+const DefaultLeaf = props => {
+  const {
     attributes,
     children
   } = props;
@@ -1200,14 +1178,14 @@ var DefaultLeaf = props => {
  * return state
  */
 function useGenericSelector(selector, equalityFn) {
-  var [, forceRender] = useReducer(s => s + 1, 0);
-  var latestSubscriptionCallbackError = useRef();
-  var latestSelector = useRef(() => null);
-  var latestSelectedState = useRef(null);
-  var selectedState;
+  const [, forceRender] = useReducer(s => s + 1, 0);
+  const latestSubscriptionCallbackError = useRef();
+  const latestSelector = useRef(() => null);
+  const latestSelectedState = useRef(null);
+  let selectedState;
   try {
     if (selector !== latestSelector.current || latestSubscriptionCallbackError.current) {
-      var selectorResult = selector();
+      const selectorResult = selector();
       if (equalityFn(latestSelectedState.current, selectorResult)) {
         selectedState = latestSelectedState.current;
       } else {
@@ -1218,16 +1196,16 @@ function useGenericSelector(selector, equalityFn) {
     }
   } catch (err) {
     if (latestSubscriptionCallbackError.current && isError(err)) {
-      err.message += "\nThe error may be correlated with this previous error:\n".concat(latestSubscriptionCallbackError.current.stack, "\n\n");
+      err.message += `\nThe error may be correlated with this previous error:\n${latestSubscriptionCallbackError.current.stack}\n\n`;
     }
     throw err;
   }
   latestSelector.current = selector;
   latestSelectedState.current = selectedState;
   latestSubscriptionCallbackError.current = undefined;
-  var update = useCallback(() => {
+  const update = useCallback(() => {
     try {
-      var newSelectedState = latestSelector.current();
+      const newSelectedState = latestSelector.current();
       if (equalityFn(latestSelectedState.current, newSelectedState)) {
         return;
       }
@@ -1257,32 +1235,32 @@ function isError(error) {
  * A React context for sharing the `decorate` prop of the editable and
  * subscribing to changes on this prop.
  */
-var DecorateContext = /*#__PURE__*/createContext({});
-var useDecorations = (node, parentDecorations) => {
-  var editor = useSlateStatic();
-  var {
+const DecorateContext = /*#__PURE__*/createContext({});
+const useDecorations = (node, parentDecorations) => {
+  const editor = useSlateStatic();
+  const {
     decorate,
     addEventListener
   } = useContext(DecorateContext);
   // Not memoized since we want nodes to be decorated on each render
-  var selector = () => {
-    var path = ReactEditor.findPath(editor, node);
+  const selector = () => {
+    const path = ReactEditor.findPath(editor, node);
     return decorate([node, path]);
   };
-  var equalityFn = Node.isText(node) ? isTextDecorationsEqual : isElementDecorationsEqual;
-  var [decorations, update] = useGenericSelector(selector, equalityFn);
+  const equalityFn = Node.isText(node) ? isTextDecorationsEqual : isElementDecorationsEqual;
+  const [decorations, update] = useGenericSelector(selector, equalityFn);
   useIsomorphicLayoutEffect(() => {
-    var unsubscribe = addEventListener(update);
+    const unsubscribe = addEventListener(update);
     update();
     return unsubscribe;
   }, [addEventListener, update]);
   return useMemo(() => [...decorations, ...parentDecorations], [decorations, parentDecorations]);
 };
-var useDecorateContext = decorateProp => {
-  var [, forceUpdate] = useReducer(s => s + 1, 0);
-  var eventListeners = useRef(new Set());
-  var hasMounted = useRef(false);
-  var latestDecorate = useRef(decorateProp);
+const useDecorateContext = decorateProp => {
+  const [, forceUpdate] = useReducer(s => s + 1, 0);
+  const eventListeners = useRef(new Set());
+  const hasMounted = useRef(false);
+  const latestDecorate = useRef(decorateProp);
   useIsomorphicLayoutEffect(() => {
     latestDecorate.current = decorateProp;
     eventListeners.current.forEach(listener => listener());
@@ -1301,8 +1279,8 @@ var useDecorateContext = decorateProp => {
     }
     forceUpdate();
   }, [decorateProp]);
-  var decorate = useCallback(entry => latestDecorate.current(entry), []);
-  var addEventListener = useCallback(callback => {
+  const decorate = useCallback(entry => latestDecorate.current(entry), []);
+  const addEventListener = useCallback(callback => {
     eventListeners.current.add(callback);
     return () => {
       eventListeners.current.delete(callback);
@@ -1316,12 +1294,12 @@ var useDecorateContext = decorateProp => {
 
 function ownKeys$4(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread$4(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$4(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$4(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var defaultRenderText = props => /*#__PURE__*/React.createElement(DefaultText, _objectSpread$4({}, props));
+const defaultRenderText = props => /*#__PURE__*/React.createElement(DefaultText, _objectSpread$4({}, props));
 /**
  * Text.
  */
-var Text = props => {
-  var {
+const Text = props => {
+  const {
     decorations: parentDecorations,
     isLast,
     parent,
@@ -1330,20 +1308,20 @@ var Text = props => {
     renderText = defaultRenderText,
     text
   } = props;
-  var editor = useSlateStatic();
-  var ref = useRef(null);
-  var decorations = useDecorations(text, parentDecorations);
-  var decoratedLeaves = Text$1.decorations(text, decorations);
-  var key = ReactEditor.findKey(editor, text);
-  var children = [];
-  for (var i = 0; i < decoratedLeaves.length; i++) {
-    var {
+  const editor = useSlateStatic();
+  const ref = useRef(null);
+  const decorations = useDecorations(text, parentDecorations);
+  const decoratedLeaves = Text$1.decorations(text, decorations);
+  const key = ReactEditor.findKey(editor, text);
+  const children = [];
+  for (let i = 0; i < decoratedLeaves.length; i++) {
+    const {
       leaf,
       position
     } = decoratedLeaves[i];
     children.push(/*#__PURE__*/React.createElement(MemoizedLeaf, {
       isLast: isLast && i === decoratedLeaves.length - 1,
-      key: "".concat(key.id, "-").concat(i),
+      key: `${key.id}-${i}`,
       renderPlaceholder: renderPlaceholder,
       leaf: leaf,
       leafPosition: position,
@@ -1353,8 +1331,8 @@ var Text = props => {
     }));
   }
   // Update element-related weak maps with the DOM element ref.
-  var callbackRef = useCallback(span => {
-    var KEY_TO_ELEMENT = EDITOR_TO_KEY_TO_ELEMENT.get(editor);
+  const callbackRef = useCallback(span => {
+    const KEY_TO_ELEMENT = EDITOR_TO_KEY_TO_ELEMENT.get(editor);
     if (span) {
       KEY_TO_ELEMENT === null || KEY_TO_ELEMENT === void 0 || KEY_TO_ELEMENT.set(key, span);
       NODE_TO_ELEMENT.set(text, span);
@@ -1368,7 +1346,7 @@ var Text = props => {
     }
     ref.current = span;
   }, [ref, editor, key, text]);
-  var attributes = {
+  const attributes = {
     'data-slate-node': 'text',
     ref: callbackRef
   };
@@ -1378,11 +1356,11 @@ var Text = props => {
     attributes
   });
 };
-var MemoizedText = /*#__PURE__*/React.memo(Text, (prev, next) => {
+const MemoizedText = /*#__PURE__*/React.memo(Text, (prev, next) => {
   return next.parent === prev.parent && next.isLast === prev.isLast && next.renderText === prev.renderText && next.renderLeaf === prev.renderLeaf && next.renderPlaceholder === prev.renderPlaceholder && next.text === prev.text && isTextDecorationsEqual(next.decorations, prev.decorations);
 });
-var DefaultText = props => {
-  var {
+const DefaultText = props => {
+  const {
     attributes,
     children
   } = props;
@@ -1391,12 +1369,12 @@ var DefaultText = props => {
 
 function ownKeys$3(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread$3(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$3(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$3(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var defaultRenderElement = props => (/*#__PURE__*/React.createElement(DefaultElement, _objectSpread$3({}, props)));
+const defaultRenderElement = props => (/*#__PURE__*/React.createElement(DefaultElement, _objectSpread$3({}, props)));
 /**
  * Element.
  */
-var Element = props => {
-  var {
+const Element = props => {
+  const {
     decorations: parentDecorations,
     element,
     renderElement = defaultRenderElement,
@@ -1405,14 +1383,14 @@ var Element = props => {
     renderLeaf,
     renderText
   } = props;
-  var editor = useSlateStatic();
-  var readOnly = useReadOnly();
-  var isInline = editor.isInline(element);
-  var decorations = useDecorations(element, parentDecorations);
-  var key = ReactEditor.findKey(editor, element);
-  var ref = useCallback(ref => {
+  const editor = useSlateStatic();
+  const readOnly = useReadOnly();
+  const isInline = editor.isInline(element);
+  const decorations = useDecorations(element, parentDecorations);
+  const key = ReactEditor.findKey(editor, element);
+  const ref = useCallback(ref => {
     // Update element-related weak maps with the DOM element ref.
-    var KEY_TO_ELEMENT = EDITOR_TO_KEY_TO_ELEMENT.get(editor);
+    const KEY_TO_ELEMENT = EDITOR_TO_KEY_TO_ELEMENT.get(editor);
     if (ref) {
       KEY_TO_ELEMENT === null || KEY_TO_ELEMENT === void 0 || KEY_TO_ELEMENT.set(key, ref);
       NODE_TO_ELEMENT.set(element, ref);
@@ -1422,7 +1400,7 @@ var Element = props => {
       NODE_TO_ELEMENT.delete(element);
     }
   }, [editor, key, element]);
-  var children = useChildren({
+  let children = useChildren({
     decorations,
     node: element,
     renderElement,
@@ -1433,7 +1411,7 @@ var Element = props => {
   });
   // Attributes that the developer must mix into the element in their
   // custom node renderer component.
-  var attributes = {
+  const attributes = {
     'data-slate-node': 'element',
     ref
   };
@@ -1443,8 +1421,8 @@ var Element = props => {
   // If it's a block node with inline children, add the proper `dir` attribute
   // for text direction.
   if (!isInline && Editor.hasInlines(editor, element)) {
-    var text = Node.string(element);
-    var dir = getDirection(text);
+    const text = Node.string(element);
+    const dir = getDirection(text);
     if (dir === 'rtl') {
       attributes.dir = dir;
     }
@@ -1455,8 +1433,8 @@ var Element = props => {
     if (!readOnly && isInline) {
       attributes.contentEditable = false;
     }
-    var Tag = isInline ? 'span' : 'div';
-    var [[_text]] = Node.texts(element);
+    const Tag = isInline ? 'span' : 'div';
+    const [[text]] = Node.texts(element);
     children = /*#__PURE__*/React.createElement(Tag, {
       "data-slate-spacer": true,
       style: {
@@ -1470,10 +1448,10 @@ var Element = props => {
       decorations: [],
       isLast: false,
       parent: element,
-      text: _text
+      text: text
     }));
-    NODE_TO_INDEX.set(_text, 0);
-    NODE_TO_PARENT.set(_text, element);
+    NODE_TO_INDEX.set(text, 0);
+    NODE_TO_PARENT.set(text, element);
   }
   return renderElement({
     attributes,
@@ -1481,20 +1459,20 @@ var Element = props => {
     element
   });
 };
-var MemoizedElement = /*#__PURE__*/React.memo(Element, (prev, next) => {
+const MemoizedElement = /*#__PURE__*/React.memo(Element, (prev, next) => {
   return prev.element === next.element && prev.renderElement === next.renderElement && prev.renderChunk === next.renderChunk && prev.renderText === next.renderText && prev.renderLeaf === next.renderLeaf && prev.renderPlaceholder === next.renderPlaceholder && isElementDecorationsEqual(prev.decorations, next.decorations);
 });
 /**
  * The default element renderer.
  */
-var DefaultElement = props => {
-  var {
+const DefaultElement = props => {
+  const {
     attributes,
     children,
     element
   } = props;
-  var editor = useSlateStatic();
-  var Tag = editor.isInline(element) ? 'span' : 'div';
+  const editor = useSlateStatic();
+  const Tag = editor.isInline(element) ? 'span' : 'div';
   return /*#__PURE__*/React.createElement(Tag, _objectSpread$3(_objectSpread$3({}, attributes), {}, {
     style: {
       position: 'relative'
@@ -1506,11 +1484,10 @@ var DefaultElement = props => {
  * Traverse and modify a chunk tree
  */
 class ChunkTreeHelper {
-  constructor(chunkTree, _ref) {
-    var {
-      chunkSize,
-      debug
-    } = _ref;
+  constructor(chunkTree, {
+    chunkSize,
+    debug
+  }) {
     /**
      * The root of the chunk tree
      */
@@ -1644,15 +1621,15 @@ class ChunkTreeHelper {
   insertAfter(leaves) {
     // istanbul ignore next
     if (leaves.length === 0) return;
-    var beforeDepth = 0;
-    var afterDepth = 0;
+    let beforeDepth = 0;
+    let afterDepth = 0;
     // While at the end of a chunk, insert any leaves that will fit, and then
     // exit the chunk
     while (this.pointerChunk.type === 'chunk' && this.pointerIndex === this.pointerSiblings.length - 1) {
-      var remainingCapacity = this.chunkSize - this.pointerSiblings.length;
-      var toInsertCount = Math.min(remainingCapacity, leaves.length);
+      const remainingCapacity = this.chunkSize - this.pointerSiblings.length;
+      const toInsertCount = Math.min(remainingCapacity, leaves.length);
       if (toInsertCount > 0) {
-        var leavesToInsert = leaves.splice(0, toInsertCount);
+        const leavesToInsert = leaves.splice(0, toInsertCount);
         this.rawInsertAfter(leavesToInsert, beforeDepth);
       }
       this.exitChunk();
@@ -1661,23 +1638,23 @@ class ChunkTreeHelper {
     if (leaves.length === 0) return;
     // Save the pointer so that we can come back here after inserting leaves
     // into the starts of subsequent blocks
-    var rawInsertPointer = this.savePointer();
+    const rawInsertPointer = this.savePointer();
     // If leaves are inserted into the start of a subsequent block, then we
     // eventually need to restore the pointer to the last such inserted leaf
-    var finalPointer = null;
+    let finalPointer = null;
     // Move the pointer into the chunk containing the next leaf, if it exists
     if (this.readLeaf()) {
       // While at the start of a chunk, insert any leaves that will fit, and
       // then exit the chunk
       while (this.pointerChunk.type === 'chunk' && this.pointerIndex === 0) {
-        var _remainingCapacity = this.chunkSize - this.pointerSiblings.length;
-        var _toInsertCount = Math.min(_remainingCapacity, leaves.length);
-        if (_toInsertCount > 0) {
-          var _leavesToInsert = leaves.splice(-_toInsertCount, _toInsertCount);
+        const remainingCapacity = this.chunkSize - this.pointerSiblings.length;
+        const toInsertCount = Math.min(remainingCapacity, leaves.length);
+        if (toInsertCount > 0) {
+          const leavesToInsert = leaves.splice(-toInsertCount, toInsertCount);
           // Insert the leaves at the start of the chunk
           this.pointerIndex = -1;
           this.cachedPointerNode = undefined;
-          this.rawInsertAfter(_leavesToInsert, afterDepth);
+          this.rawInsertAfter(leavesToInsert, afterDepth);
           // If this is the first batch of insertions at the start of a
           // subsequent chunk, set the final pointer to the last inserted leaf
           if (!finalPointer) {
@@ -1692,7 +1669,7 @@ class ChunkTreeHelper {
     // If there are leaves left to insert, insert them between the end of the
     // previous chunk and the start of the first subsequent chunk, or wherever
     // the pointer ended up after the first batch of insertions
-    var minDepth = Math.max(beforeDepth, afterDepth);
+    const minDepth = Math.max(beforeDepth, afterDepth);
     this.rawInsertAfter(leaves, minDepth);
     if (finalPointer) {
       this.restorePointer(finalPointer);
@@ -1719,7 +1696,7 @@ class ChunkTreeHelper {
    * chunks
    */
   invalidateChunk() {
-    for (var c = this.pointerChunk; c.type === 'chunk'; c = c.parent) {
+    for (let c = this.pointerChunk; c.type === 'chunk'; c = c.parent) {
       this.root.modifiedChunks.add(c);
     }
   }
@@ -1754,7 +1731,7 @@ class ChunkTreeHelper {
    */
   get pointerNode() {
     if (this.cachedPointerNode !== undefined) return this.cachedPointerNode;
-    var pointerNode = this.getPointerNode();
+    const pointerNode = this.getPointerNode();
     this.cachedPointerNode = pointerNode;
     return pointerNode;
   }
@@ -1763,9 +1740,9 @@ class ChunkTreeHelper {
    * is not connected to the root
    */
   getChunkPath(chunk) {
-    var path = [];
-    for (var c = chunk; c.type === 'chunk'; c = c.parent) {
-      var index = c.parent.children.indexOf(c);
+    const path = [];
+    for (let c = chunk; c.type === 'chunk'; c = c.parent) {
+      const index = c.parent.children.indexOf(c);
       // istanbul ignore next
       if (index === -1) {
         return null;
@@ -1804,16 +1781,16 @@ class ChunkTreeHelper {
     // pointer since it was saved, the index and index stack must be
     // recomputed. This is slow, but this is fine since restoring a pointer is
     // not a frequent operation.
-    var {
+    const {
       chunk,
       node
     } = savedPointer;
-    var index = chunk.children.indexOf(node);
+    const index = chunk.children.indexOf(node);
     // istanbul ignore next
     if (index === -1) {
       throw new Error('Cannot restore point because saved node is no longer in saved chunk');
     }
-    var indexStack = this.getChunkPath(chunk);
+    const indexStack = this.getChunkPath(chunk);
     // istanbul ignore next
     if (!indexStack) {
       throw new Error('Cannot restore point because saved chunk is no longer connected to root');
@@ -1868,7 +1845,7 @@ class ChunkTreeHelper {
     if (this.pointerChunk.type === 'root') {
       throw new Error('Cannot exit root');
     }
-    var previousPointerChunk = this.pointerChunk;
+    const previousPointerChunk = this.pointerChunk;
     this.pointerChunk = previousPointerChunk.parent;
     this.pointerIndex = this.pointerIndexStack.pop();
     this.cachedPointerNode = undefined;
@@ -1883,13 +1860,13 @@ class ChunkTreeHelper {
    */
   rawInsertAfter(leaves, minDepth) {
     if (leaves.length === 0) return;
-    var groupIntoChunks = (leaves, parent, perChunk) => {
+    const groupIntoChunks = (leaves, parent, perChunk) => {
       if (perChunk === 1) return leaves;
-      var chunks = [];
-      for (var i = 0; i < this.chunkSize; i++) {
-        var chunkNodes = leaves.slice(i * perChunk, (i + 1) * perChunk);
+      const chunks = [];
+      for (let i = 0; i < this.chunkSize; i++) {
+        const chunkNodes = leaves.slice(i * perChunk, (i + 1) * perChunk);
         if (chunkNodes.length === 0) break;
-        var chunk = {
+        const chunk = {
           type: 'chunk',
           key: new Key(),
           parent,
@@ -1902,15 +1879,15 @@ class ChunkTreeHelper {
     };
     // Determine the chunking depth based on the number of existing nodes in
     // the chunk and the number of nodes being inserted
-    var newTotal = this.pointerSiblings.length + leaves.length;
-    var depthForTotal = 0;
-    for (var i = this.chunkSize; i < newTotal; i *= this.chunkSize) {
+    const newTotal = this.pointerSiblings.length + leaves.length;
+    let depthForTotal = 0;
+    for (let i = this.chunkSize; i < newTotal; i *= this.chunkSize) {
       depthForTotal++;
     }
     // A depth of 0 means no chunking
-    var depth = Math.max(depthForTotal, minDepth);
-    var perTopLevelChunk = Math.pow(this.chunkSize, depth);
-    var chunks = groupIntoChunks(leaves, this.pointerChunk, perTopLevelChunk);
+    const depth = Math.max(depthForTotal, minDepth);
+    const perTopLevelChunk = Math.pow(this.chunkSize, depth);
+    const chunks = groupIntoChunks(leaves, this.pointerChunk, perTopLevelChunk);
     this.pointerSiblings.splice(this.pointerIndex + 1, 0, ...chunks);
     this.pointerIndex += chunks.length;
     this.cachedPointerNode = undefined;
@@ -1923,14 +1900,14 @@ class ChunkTreeHelper {
   // istanbul ignore next
   validateState() {
     if (!this.debug) return;
-    var validateDescendant = node => {
+    const validateDescendant = node => {
       if (node.type === 'chunk') {
-        var {
+        const {
           parent,
           children
         } = node;
         if (!parent.children.includes(node)) {
-          throw new Error("Debug: Chunk ".concat(node.key.id, " has an incorrect parent property"));
+          throw new Error(`Debug: Chunk ${node.key.id} has an incorrect parent property`);
         }
         children.forEach(validateDescendant);
       }
@@ -1939,12 +1916,12 @@ class ChunkTreeHelper {
     if (this.cachedPointerNode !== undefined && this.cachedPointerNode !== this.getPointerNode()) {
       throw new Error('Debug: The cached pointer is incorrect and has not been invalidated');
     }
-    var actualIndexStack = this.getChunkPath(this.pointerChunk);
+    const actualIndexStack = this.getChunkPath(this.pointerChunk);
     if (!actualIndexStack) {
       throw new Error('Debug: The pointer chunk is not connected to the root');
     }
     if (!Path.equals(this.pointerIndexStack, actualIndexStack)) {
-      throw new Error("Debug: The cached index stack [".concat(this.pointerIndexStack.join(', '), "] does not match the path of the pointer chunk [").concat(actualIndexStack.join(', '), "]"));
+      throw new Error(`Debug: The cached index stack [${this.pointerIndexStack.join(', ')}] does not match the path of the pointer chunk [${actualIndexStack.join(', ')}]`);
     }
   }
 }
@@ -1982,7 +1959,7 @@ class ChildrenHelper {
     if (n === 1) {
       return [this.children[this.pointerIndex++]];
     }
-    var slicedChildren = this.remaining(n);
+    const slicedChildren = this.remaining(n);
     this.pointerIndex += n;
     return slicedChildren;
   }
@@ -2017,11 +1994,11 @@ class ChildrenHelper {
    * by one and compare it to the known key.
    */
   lookAhead(node, key) {
-    var elementResult = this.children.indexOf(node, this.pointerIndex);
+    const elementResult = this.children.indexOf(node, this.pointerIndex);
     if (elementResult > -1) return elementResult - this.pointerIndex;
-    for (var i = this.pointerIndex; i < this.children.length; i++) {
-      var candidateNode = this.children[i];
-      var candidateKey = this.findKey(candidateNode, i);
+    for (let i = this.pointerIndex; i < this.children.length; i++) {
+      const candidateNode = this.children[i];
+      const candidateKey = this.findKey(candidateNode, i);
       if (candidateKey === key) return i - this.pointerIndex;
     }
     return -1;
@@ -2042,9 +2019,9 @@ class ChildrenHelper {
    * Get the key for a Slate node, cached using the node's index
    */
   findKey(node, index) {
-    var cachedKey = this.cachedKeys[index];
+    const cachedKey = this.cachedKeys[index];
     if (cachedKey) return cachedKey;
-    var key = ReactEditor.findKey(this.editor, node);
+    const key = ReactEditor.findKey(this.editor, node);
     this.cachedKeys[index] = key;
     return key;
   }
@@ -2054,55 +2031,54 @@ class ChildrenHelper {
  * Update the chunk tree to match the children array, inserting, removing and
  * updating differing nodes
  */
-var reconcileChildren = (editor, _ref) => {
-  var {
-    chunkTree,
-    children,
-    chunkSize,
-    rerenderChildren = [],
-    onInsert,
-    onUpdate,
-    onIndexChange,
-    debug
-  } = _ref;
-  var chunkTreeHelper = new ChunkTreeHelper(chunkTree, {
+const reconcileChildren = (editor, {
+  chunkTree,
+  children,
+  chunkSize,
+  rerenderChildren: _rerenderChildren = [],
+  onInsert,
+  onUpdate,
+  onIndexChange,
+  debug
+}) => {
+  const chunkTreeHelper = new ChunkTreeHelper(chunkTree, {
     chunkSize,
     debug
   });
-  var childrenHelper = new ChildrenHelper(editor, children);
-  var treeLeaf;
+  const childrenHelper = new ChildrenHelper(editor, children);
+  let treeLeaf;
   // Read leaves from the tree one by one, each one representing a single Slate
   // node. Each leaf from the tree is compared to the current node in the
   // children array to determine whether nodes have been inserted, removed or
   // updated.
-  var _loop = function _loop() {
+  while (treeLeaf = chunkTreeHelper.readLeaf()) {
     // Check where the tree node appears in the children array. In the most
     // common case (where no insertions or removals have occurred), this will be
     // 0. If the node has been removed, this will be -1. If new nodes have been
     // inserted before the node, or if the node has been moved to a later
     // position in the same children array, this will be a positive number.
-    var lookAhead = childrenHelper.lookAhead(treeLeaf.node, treeLeaf.key);
+    const lookAhead = childrenHelper.lookAhead(treeLeaf.node, treeLeaf.key);
     // If the node was moved, we want to remove it and insert it later, rather
     // then re-inserting all intermediate nodes before it.
-    var wasMoved = lookAhead > 0 && chunkTree.movedNodeKeys.has(treeLeaf.key);
+    const wasMoved = lookAhead > 0 && chunkTree.movedNodeKeys.has(treeLeaf.key);
     // If the tree leaf was moved or removed, remove it
     if (lookAhead === -1 || wasMoved) {
       chunkTreeHelper.remove();
-      return 1; // continue
+      continue;
     }
     // Get the matching Slate node and any nodes that may have been inserted
     // prior to it. Insert these into the chunk tree.
-    var insertedChildrenStartIndex = childrenHelper.pointerIndex;
-    var insertedChildren = childrenHelper.read(lookAhead + 1);
-    var matchingChild = insertedChildren.pop();
+    const insertedChildrenStartIndex = childrenHelper.pointerIndex;
+    const insertedChildren = childrenHelper.read(lookAhead + 1);
+    const matchingChild = insertedChildren.pop();
     if (insertedChildren.length) {
-      var _leavesToInsert = childrenHelper.toChunkLeaves(insertedChildren, insertedChildrenStartIndex);
-      chunkTreeHelper.insertBefore(_leavesToInsert);
+      const leavesToInsert = childrenHelper.toChunkLeaves(insertedChildren, insertedChildrenStartIndex);
+      chunkTreeHelper.insertBefore(leavesToInsert);
       insertedChildren.forEach((node, relativeIndex) => {
         onInsert === null || onInsert === void 0 || onInsert(node, insertedChildrenStartIndex + relativeIndex);
       });
     }
-    var matchingChildIndex = childrenHelper.pointerIndex - 1;
+    const matchingChildIndex = childrenHelper.pointerIndex - 1;
     // Make sure the chunk tree contains the most recent version of the Slate
     // node
     if (treeLeaf.node !== matchingChild) {
@@ -2117,18 +2093,15 @@ var reconcileChildren = (editor, _ref) => {
     }
     // Manually invalidate chunks containing specific children that we want to
     // re-render
-    if (rerenderChildren.includes(matchingChildIndex)) {
+    if (_rerenderChildren.includes(matchingChildIndex)) {
       chunkTreeHelper.invalidateChunk();
     }
-  };
-  while (treeLeaf = chunkTreeHelper.readLeaf()) {
-    if (_loop()) continue;
   }
   // If there are still Slate nodes remaining from the children array that were
   // not matched to nodes in the tree, insert them at the end of the tree
   if (!childrenHelper.reachedEnd) {
-    var remainingChildren = childrenHelper.remaining();
-    var leavesToInsert = childrenHelper.toChunkLeaves(remainingChildren, childrenHelper.pointerIndex);
+    const remainingChildren = childrenHelper.remaining();
+    const leavesToInsert = childrenHelper.toChunkLeaves(remainingChildren, childrenHelper.pointerIndex);
     // Move the pointer back to the final leaf in the tree, or the start of the
     // tree if the tree is currently empty
     chunkTreeHelper.returnToPreviousLeaf();
@@ -2142,7 +2115,7 @@ var reconcileChildren = (editor, _ref) => {
 
 function ownKeys$2(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread$2(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$2(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$2(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var KEY_TO_CHUNK_TREE = new WeakMap();
+const KEY_TO_CHUNK_TREE = new WeakMap();
 /**
  * Get or create the chunk tree for a Slate node
  *
@@ -2150,10 +2123,11 @@ var KEY_TO_CHUNK_TREE = new WeakMap();
  * match the current children of the node. The children are chunked
  * automatically using the given chunk size.
  */
-var getChunkTreeForNode = function getChunkTreeForNode(editor, node) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var key = ReactEditor.findKey(editor, node);
-  var chunkTree = KEY_TO_CHUNK_TREE.get(key);
+const getChunkTreeForNode = (editor, node,
+// istanbul ignore next
+options = {}) => {
+  const key = ReactEditor.findKey(editor, node);
+  let chunkTree = KEY_TO_CHUNK_TREE.get(key);
   if (!chunkTree) {
     chunkTree = {
       type: 'root',
@@ -2174,14 +2148,11 @@ var getChunkTreeForNode = function getChunkTreeForNode(editor, node) {
 
 function ownKeys$1(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread$1(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$1(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var defaultRenderChunk = _ref => {
-  var {
-    children
-  } = _ref;
-  return children;
-};
-var ChunkAncestor = props => {
-  var {
+const defaultRenderChunk = ({
+  children
+}) => children;
+const ChunkAncestor = props => {
+  const {
     root,
     ancestor,
     renderElement,
@@ -2189,8 +2160,8 @@ var ChunkAncestor = props => {
   } = props;
   return ancestor.children.map(chunkNode => {
     if (chunkNode.type === 'chunk') {
-      var key = chunkNode.key.id;
-      var renderedChunk = renderChunk({
+      const key = chunkNode.key.id;
+      const renderedChunk = renderChunk({
         highest: ancestor === root,
         lowest: chunkNode.children.some(c => c.type === 'leaf'),
         attributes: {
@@ -2208,11 +2179,11 @@ var ChunkAncestor = props => {
       }, renderedChunk);
     }
     // Only blocks containing no inlines are chunked
-    var element = chunkNode.node;
+    const element = chunkNode.node;
     return renderElement(element, chunkNode.index, chunkNode.key);
   });
 };
-var ChunkTree = props => {
+const ChunkTree = props => {
   // Clear the set of modified chunks only when React finishes rendering. The
   // timing of this is important in strict mode because if the chunks are
   // cleared during rendering (such as in reconcileChildren), strict mode's
@@ -2222,14 +2193,14 @@ var ChunkTree = props => {
   });
   return /*#__PURE__*/React.createElement(ChunkAncestor, _objectSpread$1({}, props));
 };
-var MemoizedChunk = /*#__PURE__*/React.memo(ChunkAncestor, (prev, next) => prev.root === next.root && prev.renderElement === next.renderElement && prev.renderChunk === next.renderChunk && !next.root.modifiedChunks.has(next.ancestor));
+const MemoizedChunk = /*#__PURE__*/React.memo(ChunkAncestor, (prev, next) => prev.root === next.root && prev.renderElement === next.renderElement && prev.renderChunk === next.renderChunk && !next.root.modifiedChunks.has(next.ancestor));
 
-var ElementContext = /*#__PURE__*/createContext(null);
+const ElementContext = /*#__PURE__*/createContext(null);
 /**
  * Get the current element.
  */
-var useElement = () => {
-  var context = useContext(ElementContext);
+const useElement = () => {
+  const context = useContext(ElementContext);
   if (!context) {
     throw new Error('The `useElement` hook must be used inside `renderElement`.');
   }
@@ -2238,13 +2209,13 @@ var useElement = () => {
 /**
  * Get the current element, or return null if not inside `renderElement`.
  */
-var useElementIf = () => useContext(ElementContext);
+const useElementIf = () => useContext(ElementContext);
 
 /**
  * Children.
  */
-var useChildren = props => {
-  var {
+const useChildren = props => {
+  const {
     decorations,
     node,
     renderElement,
@@ -2253,13 +2224,13 @@ var useChildren = props => {
     renderText,
     renderLeaf
   } = props;
-  var editor = useSlateStatic();
+  const editor = useSlateStatic();
   IS_NODE_MAP_DIRTY.set(editor, false);
-  var isBlock = Node.isElement(node) && !editor.isInline(node);
-  var isLeafBlock = isBlock && Editor.hasInlines(editor, node);
-  var chunkSize = isLeafBlock ? null : editor.getChunkSize(node);
-  var chunking = !!chunkSize;
-  var {
+  const isBlock = Node.isElement(node) && !editor.isInline(node);
+  const isLeafBlock = isBlock && Editor.hasInlines(editor, node);
+  const chunkSize = isLeafBlock ? null : editor.getChunkSize(node);
+  const chunking = !!chunkSize;
+  const {
     decorationsByChild,
     childrenToRedecorate
   } = useDecorationsByChild(editor, node, decorations);
@@ -2272,10 +2243,10 @@ var useChildren = props => {
       NODE_TO_PARENT.set(n, node);
     });
   }
-  var renderElementComponent = useCallback((n, i, cachedKey) => {
-    var key = cachedKey !== null && cachedKey !== void 0 ? cachedKey : ReactEditor.findKey(editor, n);
+  const renderElementComponent = useCallback((n, i, cachedKey) => {
+    const key = cachedKey !== null && cachedKey !== void 0 ? cachedKey : ReactEditor.findKey(editor, n);
     return /*#__PURE__*/React.createElement(ElementContext.Provider, {
-      key: "provider-".concat(key.id),
+      key: `provider-${key.id}`,
       value: n
     }, /*#__PURE__*/React.createElement(MemoizedElement, {
       decorations: decorationsByChild[i],
@@ -2288,8 +2259,8 @@ var useChildren = props => {
       renderText: renderText
     }));
   }, [editor, decorationsByChild, renderElement, renderChunk, renderPlaceholder, renderLeaf, renderText]);
-  var renderTextComponent = (n, i) => {
-    var key = ReactEditor.findKey(editor, n);
+  const renderTextComponent = (n, i) => {
+    const key = ReactEditor.findKey(editor, n);
     return /*#__PURE__*/React.createElement(MemoizedText, {
       decorations: decorationsByChild[i],
       key: key.id,
@@ -2304,7 +2275,7 @@ var useChildren = props => {
   if (!chunking) {
     return node.children.map((n, i) => Node.isText(n) ? renderTextComponent(n, i) : renderElementComponent(n, i));
   }
-  var chunkTree = getChunkTreeForNode(editor, node, {
+  const chunkTree = getChunkTreeForNode(editor, node, {
     reconcile: {
       chunkSize,
       rerenderChildren: childrenToRedecorate,
@@ -2328,23 +2299,23 @@ var useChildren = props => {
     renderChunk: renderChunk
   });
 };
-var useDecorationsByChild = (editor, node, decorations) => {
-  var decorationsByChild = splitDecorationsByChild(editor, node, decorations);
+const useDecorationsByChild = (editor, node, decorations) => {
+  const decorationsByChild = splitDecorationsByChild(editor, node, decorations);
   // The value we return is a mutable array of `DecoratedRange[]` arrays. This
   // lets us avoid passing an immutable array of decorations for each child into
   // `ChunkTree` using props. Each `DecoratedRange[]` is only updated if the
   // decorations at that index have changed, which speeds up the equality check
   // for the `decorations` prop in the memoized `Element` and `Text` components.
-  var mutableDecorationsByChild = useRef(decorationsByChild).current;
+  const mutableDecorationsByChild = useRef(decorationsByChild).current;
   // Track the list of child indices whose decorations have changed, so that we
   // can tell the chunk tree to re-render these children.
-  var childrenToRedecorate = [];
+  const childrenToRedecorate = [];
   // Resize the mutable array to match the latest result
   mutableDecorationsByChild.length = decorationsByChild.length;
-  for (var i = 0; i < decorationsByChild.length; i++) {
+  for (let i = 0; i < decorationsByChild.length; i++) {
     var _mutableDecorationsBy;
-    var _decorations = decorationsByChild[i];
-    var previousDecorations = (_mutableDecorationsBy = mutableDecorationsByChild[i]) !== null && _mutableDecorationsBy !== void 0 ? _mutableDecorationsBy : null;
+    const _decorations = decorationsByChild[i];
+    const previousDecorations = (_mutableDecorationsBy = mutableDecorationsByChild[i]) !== null && _mutableDecorationsBy !== void 0 ? _mutableDecorationsBy : null;
     if (!isElementDecorationsEqual(previousDecorations, _decorations)) {
       mutableDecorationsByChild[i] = _decorations;
       childrenToRedecorate.push(i);
@@ -2359,11 +2330,11 @@ var useDecorationsByChild = (editor, node, decorations) => {
 /**
  * A React context for sharing the `readOnly` state of the editor.
  */
-var ReadOnlyContext = /*#__PURE__*/createContext(false);
+const ReadOnlyContext = /*#__PURE__*/createContext(false);
 /**
  * Get the current `readOnly` state of the editor.
  */
-var useReadOnly = () => {
+const useReadOnly = () => {
   return useContext(ReadOnlyContext);
 };
 
@@ -2371,8 +2342,8 @@ var useReadOnly = () => {
  * A React context for sharing the editor selector context in a way to control
  * re-renders.
  */
-var SlateSelectorContext = /*#__PURE__*/createContext({});
-var refEquality = (a, b) => a === b;
+const SlateSelectorContext = /*#__PURE__*/createContext({});
+const refEquality = (a, b) => a === b;
 /**
  * Use redux style selectors to prevent re-rendering on every keystroke.
  *
@@ -2387,23 +2358,21 @@ var refEquality = (a, b) => a === b;
  * @example
  * const isSelectionActive = useSlateSelector(editor => Boolean(editor.selection))
  */
-function useSlateSelector(selector) {
-  var equalityFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : refEquality;
-  var {
-    deferred
-  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var context = useContext(SlateSelectorContext);
+function useSlateSelector(selector, equalityFn = refEquality, {
+  deferred
+} = {}) {
+  const context = useContext(SlateSelectorContext);
   if (!context) {
-    throw new Error("The `useSlateSelector` hook must be used inside the <Slate> component's context.");
+    throw new Error(`The \`useSlateSelector\` hook must be used inside the <Slate> component's context.`);
   }
-  var {
+  const {
     addEventListener
   } = context;
-  var editor = useSlateStatic();
-  var genericSelector = useCallback(() => selector(editor), [editor, selector]);
-  var [selectedState, update] = useGenericSelector(genericSelector, equalityFn);
+  const editor = useSlateStatic();
+  const genericSelector = useCallback(() => selector(editor), [editor, selector]);
+  const [selectedState, update] = useGenericSelector(genericSelector, equalityFn);
   useIsomorphicLayoutEffect(() => {
-    var unsubscribe = addEventListener(update, {
+    const unsubscribe = addEventListener(update, {
       deferred
     });
     update();
@@ -2415,26 +2384,25 @@ function useSlateSelector(selector) {
  * Create selector context with editor updating on every editor change
  */
 function useSelectorContext() {
-  var eventListeners = useRef(new Set());
-  var deferredEventListeners = useRef(new Set());
-  var onChange = useCallback(() => {
+  const eventListeners = useRef(new Set());
+  const deferredEventListeners = useRef(new Set());
+  const onChange = useCallback(() => {
     eventListeners.current.forEach(listener => listener());
   }, []);
-  var flushDeferred = useCallback(() => {
+  const flushDeferred = useCallback(() => {
     deferredEventListeners.current.forEach(listener => listener());
     deferredEventListeners.current.clear();
   }, []);
-  var addEventListener = useCallback(function (callbackProp) {
-    var {
-      deferred = false
-    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var callback = deferred ? () => deferredEventListeners.current.add(callbackProp) : callbackProp;
+  const addEventListener = useCallback((callbackProp, {
+    deferred: _deferred = false
+  } = {}) => {
+    const callback = _deferred ? () => deferredEventListeners.current.add(callbackProp) : callbackProp;
     eventListeners.current.add(callback);
     return () => {
       eventListeners.current.delete(callback);
     };
   }, []);
-  var selectorContext = useMemo(() => ({
+  const selectorContext = useMemo(() => ({
     addEventListener,
     flushDeferred
   }), [addEventListener, flushDeferred]);
@@ -2444,7 +2412,7 @@ function useSelectorContext() {
   };
 }
 function useFlushDeferredSelectorsOnRender() {
-  var {
+  const {
     flushDeferred
   } = useContext(SlateSelectorContext);
   useIsomorphicLayoutEffect(flushDeferred);
@@ -2453,20 +2421,20 @@ function useFlushDeferredSelectorsOnRender() {
 /**
  * Get the current editor object and re-render whenever it changes.
  */
-var useSlate = () => {
-  var {
+const useSlate = () => {
+  const {
     addEventListener
   } = useContext(SlateSelectorContext);
-  var [, forceRender] = useReducer(s => s + 1, 0);
+  const [, forceRender] = useReducer(s => s + 1, 0);
   if (!addEventListener) {
-    throw new Error("The `useSlate` hook must be used inside the <Slate> component's context.");
+    throw new Error(`The \`useSlate\` hook must be used inside the <Slate> component's context.`);
   }
   useIsomorphicLayoutEffect(() => addEventListener(forceRender), [addEventListener]);
   return useSlateStatic();
 };
-var EDITOR_TO_V = new WeakMap();
-var getEditorVersionRef = editor => {
-  var v = EDITOR_TO_V.get(editor);
+const EDITOR_TO_V = new WeakMap();
+const getEditorVersionRef = editor => {
+  let v = EDITOR_TO_V.get(editor);
   if (v) {
     return v;
   }
@@ -2475,7 +2443,7 @@ var getEditorVersionRef = editor => {
   };
   EDITOR_TO_V.set(editor, v);
   // Register the `onChange` handler exactly once per editor
-  var {
+  const {
     onChange
   } = editor;
   editor.onChange = options => {
@@ -2491,9 +2459,9 @@ var getEditorVersionRef = editor => {
  * @deprecated The `v` counter is no longer used except for this hook, and may
  * be removed in a future version.
  */
-var useSlateWithV = () => {
-  var editor = useSlate();
-  var vRef = useMemo(() => getEditorVersionRef(editor), [editor]);
+const useSlateWithV = () => {
+  const editor = useSlate();
+  const vRef = useMemo(() => getEditorVersionRef(editor), [editor]);
   return {
     editor,
     v: vRef.current
@@ -2501,15 +2469,15 @@ var useSlateWithV = () => {
 };
 
 function useTrackUserInput() {
-  var editor = useSlateStatic();
-  var receivedUserInput = useRef(false);
-  var animationFrameIdRef = useRef(0);
-  var onUserInput = useCallback(() => {
+  const editor = useSlateStatic();
+  const receivedUserInput = useRef(false);
+  const animationFrameIdRef = useRef(0);
+  const onUserInput = useCallback(() => {
     if (receivedUserInput.current) {
       return;
     }
     receivedUserInput.current = true;
-    var window = ReactEditor.getWindow(editor);
+    const window = ReactEditor.getWindow(editor);
     window.cancelAnimationFrame(animationFrameIdRef.current);
     animationFrameIdRef.current = window.requestAnimationFrame(() => {
       receivedUserInput.current = false;
@@ -2522,16 +2490,16 @@ function useTrackUserInput() {
   };
 }
 
-var createRestoreDomManager = (editor, receivedUserInput) => {
-  var bufferedMutations = [];
-  var clear = () => {
+const createRestoreDomManager = (editor, receivedUserInput) => {
+  let bufferedMutations = [];
+  const clear = () => {
     bufferedMutations = [];
   };
-  var registerMutations = mutations => {
+  const registerMutations = mutations => {
     if (!receivedUserInput.current) {
       return;
     }
-    var trackedMutations = mutations.filter(mutation => isTrackedMutation(editor, mutation, mutations));
+    const trackedMutations = mutations.filter(mutation => isTrackedMutation(editor, mutation, mutations));
     bufferedMutations.push(...trackedMutations);
   };
   function restoreDOM() {
@@ -2560,7 +2528,7 @@ var createRestoreDomManager = (editor, receivedUserInput) => {
   };
 };
 
-var MUTATION_OBSERVER_CONFIG = {
+const MUTATION_OBSERVER_CONFIG = {
   subtree: true,
   childList: true,
   characterData: true,
@@ -2569,15 +2537,15 @@ var MUTATION_OBSERVER_CONFIG = {
 // We have to use a class component here since we rely on `getSnapshotBeforeUpdate` which has no FC equivalent
 // to run code synchronously immediately before react commits the component update to the DOM.
 class RestoreDOMComponent extends Component {
-  constructor() {
-    super(...arguments);
+  constructor(...args) {
+    super(...args);
     _defineProperty(this, "context", null);
     _defineProperty(this, "manager", null);
     _defineProperty(this, "mutationObserver", null);
   }
   observe() {
     var _this$mutationObserve;
-    var {
+    const {
       node
     } = this.props;
     if (!node.current) {
@@ -2586,17 +2554,17 @@ class RestoreDOMComponent extends Component {
     (_this$mutationObserve = this.mutationObserver) === null || _this$mutationObserve === void 0 || _this$mutationObserve.observe(node.current, MUTATION_OBSERVER_CONFIG);
   }
   componentDidMount() {
-    var {
+    const {
       receivedUserInput
     } = this.props;
-    var editor = this.context;
+    const editor = this.context;
     this.manager = createRestoreDomManager(editor, receivedUserInput);
     this.mutationObserver = new MutationObserver(this.manager.registerMutations);
     this.observe();
   }
   getSnapshotBeforeUpdate() {
     var _this$mutationObserve2, _this$mutationObserve3, _this$manager2;
-    var pendingMutations = (_this$mutationObserve2 = this.mutationObserver) === null || _this$mutationObserve2 === void 0 ? void 0 : _this$mutationObserve2.takeRecords();
+    const pendingMutations = (_this$mutationObserve2 = this.mutationObserver) === null || _this$mutationObserve2 === void 0 ? void 0 : _this$mutationObserve2.takeRecords();
     if (pendingMutations !== null && pendingMutations !== void 0 && pendingMutations.length) {
       var _this$manager;
       (_this$manager = this.manager) === null || _this$manager === void 0 || _this$manager.registerMutations(pendingMutations);
@@ -2619,46 +2587,43 @@ class RestoreDOMComponent extends Component {
   }
 }
 _defineProperty(RestoreDOMComponent, "contextType", EditorContext);
-var RestoreDOM = IS_ANDROID ? RestoreDOMComponent : _ref => {
-  var {
-    children
-  } = _ref;
-  return /*#__PURE__*/React.createElement(React.Fragment, null, children);
-};
+const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
+  children
+}) => /*#__PURE__*/React.createElement(React.Fragment, null, children);
 
 /**
  * A React context for sharing the `composing` state of the editor.
  */
-var ComposingContext = /*#__PURE__*/createContext(false);
+const ComposingContext = /*#__PURE__*/createContext(false);
 /**
  * Get the current `composing` state of the editor.
  */
-var useComposing = () => {
+const useComposing = () => {
   return useContext(ComposingContext);
 };
 
-var _excluded$1 = ["autoFocus", "decorate", "onDOMBeforeInput", "placeholder", "readOnly", "renderElement", "renderChunk", "renderLeaf", "renderText", "renderPlaceholder", "scrollSelectionIntoView", "style", "as", "disableDefaultStyles"],
+const _excluded$1 = ["autoFocus", "decorate", "onDOMBeforeInput", "placeholder", "readOnly", "renderElement", "renderChunk", "renderLeaf", "renderText", "renderPlaceholder", "scrollSelectionIntoView", "style", "as", "disableDefaultStyles"],
   _excluded2 = ["text"];
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var isSameCaretPosition = (editor, a, b) => {
+const isSameCaretPosition = (editor, a, b) => {
   if (!Range.isCollapsed(a) || !Range.isCollapsed(b)) {
     return false;
   }
-  var [first, second] = Path.isBefore(a.anchor.path, b.anchor.path) ? [a.anchor, b.anchor] : [b.anchor, a.anchor];
+  const [first, second] = Path.isBefore(a.anchor.path, b.anchor.path) ? [a.anchor, b.anchor] : [b.anchor, a.anchor];
   if (second.offset !== 0 || !Path.equals(Path.next(first.path), second.path)) {
     return false;
   }
-  var node = Node.get(editor, first.path);
+  const node = Node.get(editor, first.path);
   return Node.isText(node) && first.offset === node.text.length;
 };
-var Children = props => (/*#__PURE__*/React.createElement(React.Fragment, null, useChildren(props)));
+const Children = props => (/*#__PURE__*/React.createElement(React.Fragment, null, useChildren(props)));
 /**
  * Editable.
  */
-var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
-  var defaultRenderPlaceholder = useCallback(props => /*#__PURE__*/React.createElement(DefaultPlaceholder, _objectSpread({}, props)), []);
-  var {
+const Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
+  const defaultRenderPlaceholder = useCallback(props => /*#__PURE__*/React.createElement(DefaultPlaceholder, _objectSpread({}, props)), []);
+  const {
       autoFocus,
       decorate = defaultDecorate,
       onDOMBeforeInput: propsOnDOMBeforeInput,
@@ -2675,23 +2640,23 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       disableDefaultStyles = false
     } = props,
     attributes = _objectWithoutProperties(props, _excluded$1);
-  var editor = useSlate();
+  const editor = useSlate();
   // Rerender editor when composition status changed
-  var [isComposing, setIsComposing] = useState(false);
-  var ref = useRef(null);
-  var deferredOperations = useRef([]);
-  var [placeholderHeight, setPlaceholderHeight] = useState();
-  var processing = useRef(false);
-  var {
+  const [isComposing, setIsComposing] = useState(false);
+  const ref = useRef(null);
+  const deferredOperations = useRef([]);
+  const [placeholderHeight, setPlaceholderHeight] = useState();
+  const processing = useRef(false);
+  const {
     onUserInput,
     receivedUserInput
   } = useTrackUserInput();
-  var [, forceRender] = useReducer(s => s + 1, 0);
+  const [, forceRender] = useReducer(s => s + 1, 0);
   EDITOR_TO_FORCE_RENDER.set(editor, forceRender);
   // Update internal state on each render.
   IS_READ_ONLY.set(editor, readOnly);
   // Keep track of some state for the event handler logic.
-  var state = useMemo(() => ({
+  const state = useMemo(() => ({
     isDraggingInternally: false,
     isUpdatingSelection: false,
     latestElement: null,
@@ -2715,22 +2680,22 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
    * It is defined as a reference to simplify hook dependencies and clarify that
    * it needs to be initialized.
    */
-  var androidInputManagerRef = useRef();
+  const androidInputManagerRef = useRef();
   // Listen on the native `selectionchange` event to be able to update any time
   // the selection changes. This is required because React's `onSelect` is leaky
   // and non-standard so it doesn't fire until after a selection has been
   // released. This causes issues in situations where another change happens
   // while a selection is being dragged.
-  var onDOMSelectionChange = useMemo(() => throttle(() => {
+  const onDOMSelectionChange = useMemo(() => throttle(() => {
     if (IS_NODE_MAP_DIRTY.get(editor)) {
       onDOMSelectionChange();
       return;
     }
-    var el = ReactEditor.toDOMNode(editor, editor);
-    var root = el.getRootNode();
+    const el = ReactEditor.toDOMNode(editor, editor);
+    const root = el.getRootNode();
     if (!processing.current && IS_WEBKIT && root instanceof ShadowRoot) {
       processing.current = true;
-      var active = getActiveElement();
+      const active = getActiveElement();
       if (active) {
         document.execCommand('indent');
       } else {
@@ -2739,14 +2704,14 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       processing.current = false;
       return;
     }
-    var androidInputManager = androidInputManagerRef.current;
+    const androidInputManager = androidInputManagerRef.current;
     if ((IS_ANDROID || !ReactEditor.isComposing(editor)) && (!state.isUpdatingSelection || androidInputManager !== null && androidInputManager !== void 0 && androidInputManager.isFlushing()) && !state.isDraggingInternally) {
-      var _root = ReactEditor.findDocumentOrShadowRoot(editor);
-      var {
+      const _root = ReactEditor.findDocumentOrShadowRoot(editor);
+      const {
         activeElement
       } = _root;
-      var _el = ReactEditor.toDOMNode(editor, editor);
-      var domSelection = getSelection(_root);
+      const _el = ReactEditor.toDOMNode(editor, editor);
+      const domSelection = getSelection(_root);
       if (activeElement === _el) {
         state.latestElement = activeElement;
         IS_FOCUSED.set(editor, true);
@@ -2756,14 +2721,14 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       if (!domSelection) {
         return Transforms.deselect(editor);
       }
-      var {
+      const {
         anchorNode,
         focusNode
       } = domSelection;
-      var anchorNodeSelectable = ReactEditor.hasEditableTarget(editor, anchorNode) || ReactEditor.isTargetInsideNonReadonlyVoid(editor, anchorNode);
-      var focusNodeInEditor = ReactEditor.hasTarget(editor, focusNode);
+      const anchorNodeSelectable = ReactEditor.hasEditableTarget(editor, anchorNode) || ReactEditor.isTargetInsideNonReadonlyVoid(editor, anchorNode);
+      const focusNodeInEditor = ReactEditor.hasTarget(editor, focusNode);
       if (anchorNodeSelectable && focusNodeInEditor) {
-        var range = ReactEditor.toSlateRange(editor, domSelection, {
+        const range = ReactEditor.toSlateRange(editor, domSelection, {
           exactMatch: false,
           suppressThrow: true
         });
@@ -2781,7 +2746,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       }
     }
   }, 100), [editor, readOnly, state]);
-  var scheduleOnDOMSelectionChange = useMemo(() => debounce(onDOMSelectionChange, 0), [onDOMSelectionChange]);
+  const scheduleOnDOMSelectionChange = useMemo(() => debounce(onDOMSelectionChange, 0), [onDOMSelectionChange]);
   androidInputManagerRef.current = useAndroidInputManager({
     node: ref,
     onDOMSelectionChange,
@@ -2790,7 +2755,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
   useIsomorphicLayoutEffect(() => {
     var _androidInputManagerR, _androidInputManagerR2;
     // Update element-related weak maps with the DOM element ref.
-    var window;
+    let window;
     if (ref.current && (window = getDefaultView(ref.current))) {
       EDITOR_TO_WINDOW.set(editor, window);
       EDITOR_TO_ELEMENT.set(editor, ref.current);
@@ -2800,28 +2765,28 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       NODE_TO_ELEMENT.delete(editor);
     }
     // Make sure the DOM selection state is in sync.
-    var {
+    const {
       selection
     } = editor;
-    var root = ReactEditor.findDocumentOrShadowRoot(editor);
-    var domSelection = getSelection(root);
+    const root = ReactEditor.findDocumentOrShadowRoot(editor);
+    const domSelection = getSelection(root);
     if (!domSelection || !ReactEditor.isFocused(editor) || (_androidInputManagerR = androidInputManagerRef.current) !== null && _androidInputManagerR !== void 0 && _androidInputManagerR.hasPendingAction()) {
       return;
     }
-    var setDomSelection = forceChange => {
-      var hasDomSelection = domSelection.type !== 'None';
+    const setDomSelection = forceChange => {
+      const hasDomSelection = domSelection.type !== 'None';
       // If the DOM selection is properly unset, we're done.
       if (!selection && !hasDomSelection) {
         return;
       }
       // Get anchorNode and focusNode
-      var focusNode = domSelection.focusNode;
-      var anchorNode;
+      const focusNode = domSelection.focusNode;
+      let anchorNode;
       // COMPAT: In firefox the normal selection way does not work
       // (https://github.com/ianstormtaylor/slate/pull/5486#issue-1820720223)
       if (IS_FIREFOX && domSelection.rangeCount > 1) {
-        var firstRange = domSelection.getRangeAt(0);
-        var lastRange = domSelection.getRangeAt(domSelection.rangeCount - 1);
+        const firstRange = domSelection.getRangeAt(0);
+        const lastRange = domSelection.getRangeAt(domSelection.rangeCount - 1);
         // Right to left
         if (firstRange.startContainer === focusNode) {
           anchorNode = lastRange.endContainer;
@@ -2833,14 +2798,14 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
         anchorNode = domSelection.anchorNode;
       }
       // verify that the dom selection is in the editor
-      var editorElement = EDITOR_TO_ELEMENT.get(editor);
-      var hasDomSelectionInEditor = false;
+      const editorElement = EDITOR_TO_ELEMENT.get(editor);
+      let hasDomSelectionInEditor = false;
       if (containsShadowAware(editorElement, anchorNode) && containsShadowAware(editorElement, focusNode)) {
         hasDomSelectionInEditor = true;
       }
       // If the DOM selection is in the editor and the editor selection is already correct, we're done.
       if (hasDomSelection && hasDomSelectionInEditor && selection && !forceChange) {
-        var slateRange = ReactEditor.toSlateRange(editor, domSelection, {
+        const slateRange = ReactEditor.toSlateRange(editor, domSelection, {
           exactMatch: true,
           // domSelection is not necessarily a valid Slate range
           // (e.g. when clicking on contentEditable:false element)
@@ -2870,7 +2835,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       }
       // Otherwise the DOM selection is out of sync, so update it.
       state.isUpdatingSelection = true;
-      var newDomRange = null;
+      let newDomRange = null;
       try {
         newDomRange = selection && ReactEditor.toDOMRange(editor, selection);
       } catch (e) {
@@ -2896,19 +2861,19 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
     if (domSelection.rangeCount <= 1) {
       setDomSelection();
     }
-    var ensureSelection = ((_androidInputManagerR2 = androidInputManagerRef.current) === null || _androidInputManagerR2 === void 0 ? void 0 : _androidInputManagerR2.isFlushing()) === 'action';
+    const ensureSelection = ((_androidInputManagerR2 = androidInputManagerRef.current) === null || _androidInputManagerR2 === void 0 ? void 0 : _androidInputManagerR2.isFlushing()) === 'action';
     if (!IS_ANDROID || !ensureSelection) {
       setTimeout(() => {
         state.isUpdatingSelection = false;
       });
       return;
     }
-    var timeoutId = null;
-    var animationFrameId = requestAnimationFrame(() => {
+    let timeoutId = null;
+    const animationFrameId = requestAnimationFrame(() => {
       if (ensureSelection) {
-        var ensureDomSelection = forceChange => {
+        const ensureDomSelection = forceChange => {
           try {
-            var el = ReactEditor.toDOMNode(editor, editor);
+            const el = ReactEditor.toDOMNode(editor, editor);
             el.focus();
             setDomSelection(forceChange);
           } catch (e) {
@@ -2940,21 +2905,21 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
   // is required because React's `beforeinput` is fake and never really attaches
   // to the real event sadly. (2019/11/01)
   // https://github.com/facebook/react/issues/11211
-  var onDOMBeforeInput = useCallback(event => {
+  const onDOMBeforeInput = useCallback(event => {
     if (!event.isTrusted) {
       return;
     }
     handleNativeHistoryEvents(editor, event);
-    var el = ReactEditor.toDOMNode(editor, editor);
-    var root = el.getRootNode();
+    const el = ReactEditor.toDOMNode(editor, editor);
+    const root = el.getRootNode();
     if (processing !== null && processing !== void 0 && processing.current && IS_WEBKIT && root instanceof ShadowRoot) {
-      var ranges = event.getTargetRanges();
-      var range = ranges[0];
-      var newRange = new window.Range();
+      const ranges = event.getTargetRanges();
+      const range = ranges[0];
+      const newRange = new window.Range();
       newRange.setStart(range.startContainer, range.startOffset);
       newRange.setEnd(range.endContainer, range.endOffset);
       // Unresolvable ranges would throw out of the handler (#3556); suppress and skip the move.
-      var slateRange = ReactEditor.toSlateRange(editor, newRange, {
+      const slateRange = ReactEditor.toSlateRange(editor, newRange, {
         exactMatch: false,
         suppressThrow: true
       });
@@ -2977,20 +2942,20 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       // set selection.
       scheduleOnDOMSelectionChange.flush();
       onDOMSelectionChange.flush();
-      var {
+      const {
         selection
       } = editor;
-      var {
+      const {
         inputType: type
       } = event;
-      var data = event.dataTransfer || event.data || undefined;
-      var isCompositionChange = type === 'insertCompositionText' || type === 'deleteCompositionText';
+      const data = event.dataTransfer || event.data || undefined;
+      const isCompositionChange = type === 'insertCompositionText' || type === 'deleteCompositionText';
       // COMPAT: use composition change events as a hint to where we should insert
       // composition text if we aren't composing to work around https://github.com/ianstormtaylor/slate/issues/5038
       if (isCompositionChange && ReactEditor.isComposing(editor)) {
         return;
       }
-      var native = false;
+      let native = false;
       if (type === 'insertText' && selection && Range.isCollapsed(selection) &&
       // Only use native character insertion for single characters a-z or space for now.
       // Long-press events (hold a + press 4 = ä) to choose a special character otherwise
@@ -3011,24 +2976,24 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
           var _node$parentElement, _window$getComputedSt;
           // Chrome also has issues correctly editing the end of anchor elements: https://bugs.chromium.org/p/chromium/issues/detail?id=1259100
           // Therefore we don't allow native events to insert text at the end of anchor nodes.
-          var {
+          const {
             anchor
           } = selection;
-          var [node, offset] = ReactEditor.toDOMPoint(editor, anchor);
-          var anchorNode = (_node$parentElement = node.parentElement) === null || _node$parentElement === void 0 ? void 0 : _node$parentElement.closest('a');
-          var _window = ReactEditor.getWindow(editor);
+          const [node, offset] = ReactEditor.toDOMPoint(editor, anchor);
+          const anchorNode = (_node$parentElement = node.parentElement) === null || _node$parentElement === void 0 ? void 0 : _node$parentElement.closest('a');
+          const window = ReactEditor.getWindow(editor);
           if (native && anchorNode && ReactEditor.hasDOMNode(editor, anchorNode)) {
             var _lastText$textContent;
             // Find the last text node inside the anchor.
-            var lastText = _window === null || _window === void 0 ? void 0 : _window.document.createTreeWalker(anchorNode, NodeFilter.SHOW_TEXT).lastChild();
+            const lastText = window === null || window === void 0 ? void 0 : window.document.createTreeWalker(anchorNode, NodeFilter.SHOW_TEXT).lastChild();
             if (lastText === node && ((_lastText$textContent = lastText.textContent) === null || _lastText$textContent === void 0 ? void 0 : _lastText$textContent.length) === offset) {
               native = false;
             }
           }
           // Chrome has issues with the presence of tab characters inside elements with whiteSpace = 'pre'
           // causing abnormal insert behavior: https://bugs.chromium.org/p/chromium/issues/detail?id=1219139
-          if (native && node.parentElement && (_window === null || _window === void 0 || (_window$getComputedSt = _window.getComputedStyle(node.parentElement)) === null || _window$getComputedSt === void 0 ? void 0 : _window$getComputedSt.whiteSpace) === 'pre') {
-            var block = Editor.above(editor, {
+          if (native && node.parentElement && (window === null || window === void 0 || (_window$getComputedSt = window.getComputedStyle(node.parentElement)) === null || _window$getComputedSt === void 0 ? void 0 : _window$getComputedSt.whiteSpace) === 'pre') {
+            const block = Editor.above(editor, {
               at: anchor.path,
               match: n => Node.isElement(n) && Editor.isBlock(editor, n)
             });
@@ -3043,19 +3008,19 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       // and those commands determine that for themselves.
       // If the NODE_MAP is dirty, we can't trust the selection anchor (eg ReactEditor.toDOMPoint via ReactEditor.toSlateRange)
       if ((!type.startsWith('delete') || type.startsWith('deleteBy')) && !IS_NODE_MAP_DIRTY.get(editor)) {
-        var [targetRange] = event.getTargetRanges();
+        const [targetRange] = event.getTargetRanges();
         if (targetRange) {
           // Unresolvable ranges would throw out of the handler (#3556); suppress and fall back to synthetic handling.
-          var _range = ReactEditor.toSlateRange(editor, targetRange, {
+          const range = ReactEditor.toSlateRange(editor, targetRange, {
             exactMatch: false,
             suppressThrow: true
           });
-          if (!_range) {
+          if (!range) {
             native = false;
-          } else if (!selection || !Range.equals(selection, _range)) {
+          } else if (!selection || !Range.equals(selection, range)) {
             native = false;
-            var selectionRef = !isCompositionChange && editor.selection && !isSameCaretPosition(editor, editor.selection, _range) && Editor.rangeRef(editor, editor.selection);
-            Transforms.select(editor, _range);
+            const selectionRef = !isCompositionChange && editor.selection && !isSameCaretPosition(editor, editor.selection, range) && Editor.rangeRef(editor, editor.selection);
+            Transforms.select(editor, range);
             if (selectionRef) {
               EDITOR_TO_USER_SELECTION.set(editor, selectionRef);
             }
@@ -3073,7 +3038,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       // COMPAT: If the selection is expanded, even if the command seems like
       // a delete forward/backward command it should delete the selection.
       if (selection && Range.isExpanded(selection) && type.startsWith('delete')) {
-        var direction = type.endsWith('Backward') ? 'backward' : 'forward';
+        const direction = type.endsWith('Backward') ? 'backward' : 'forward';
         Editor.deleteFragment(editor, {
           direction
         });
@@ -3194,14 +3159,14 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
           }
       }
       // Restore the actual user section if nothing manually set it.
-      var toRestore = (_EDITOR_TO_USER_SELEC = EDITOR_TO_USER_SELECTION.get(editor)) === null || _EDITOR_TO_USER_SELEC === void 0 ? void 0 : _EDITOR_TO_USER_SELEC.unref();
+      const toRestore = (_EDITOR_TO_USER_SELEC = EDITOR_TO_USER_SELECTION.get(editor)) === null || _EDITOR_TO_USER_SELEC === void 0 ? void 0 : _EDITOR_TO_USER_SELEC.unref();
       EDITOR_TO_USER_SELECTION.delete(editor);
       if (toRestore && (!editor.selection || !Range.equals(editor.selection, toRestore))) {
         Transforms.select(editor, toRestore);
       }
     }
   }, [editor, onDOMSelectionChange, onUserInput, propsOnDOMBeforeInput, readOnly, scheduleOnDOMSelectionChange]);
-  var callbackRef = useCallback(node => {
+  const callbackRef = useCallback(node => {
     if (node == null) {
       onDOMSelectionChange.cancel();
       scheduleOnDOMSelectionChange.cancel();
@@ -3229,17 +3194,16 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
     }
   }, [onDOMSelectionChange, scheduleOnDOMSelectionChange, editor, onDOMBeforeInput, forwardedRef]);
   useIsomorphicLayoutEffect(() => {
-    var window = ReactEditor.getWindow(editor);
+    const window = ReactEditor.getWindow(editor);
     // COMPAT: In Chrome, `selectionchange` events can fire when <input> and
     // <textarea> elements are appended to the DOM, causing
     // `editor.selection` to be overwritten in some circumstances.
     // (2025/01/16) https://issues.chromium.org/issues/389368412
-    var onSelectionChange = _ref => {
-      var {
-        target
-      } = _ref;
-      var targetElement = target instanceof HTMLElement ? target : null;
-      var targetTagName = targetElement === null || targetElement === void 0 ? void 0 : targetElement.tagName;
+    const onSelectionChange = ({
+      target
+    }) => {
+      const targetElement = target instanceof HTMLElement ? target : null;
+      const targetTagName = targetElement === null || targetElement === void 0 ? void 0 : targetElement.tagName;
       if (targetTagName === 'INPUT' || targetTagName === 'TEXTAREA') {
         return;
       }
@@ -3254,7 +3218,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
     // Listen for dragend and drop globally. In Firefox, if a drop handler
     // initiates an operation that causes the originally dragged element to
     // unmount, that element will not emit a dragend event. (2024/06/21)
-    var stoppedDragging = () => {
+    const stoppedDragging = () => {
       state.isDraggingInternally = false;
     };
     window.document.addEventListener('dragend', stoppedDragging);
@@ -3265,10 +3229,10 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       window.document.removeEventListener('drop', stoppedDragging);
     };
   }, [scheduleOnDOMSelectionChange, state]);
-  var decorations = decorate([editor, []]);
-  var decorateContext = useDecorateContext(decorate);
-  var showPlaceholder = placeholder && editor.children.length === 1 && Array.from(Node.texts(editor)).length === 1 && Node.string(editor) === '' && !isComposing;
-  var placeHolderResizeHandler = useCallback(placeholderEl => {
+  const decorations = decorate([editor, []]);
+  const decorateContext = useDecorateContext(decorate);
+  const showPlaceholder = placeholder && editor.children.length === 1 && Array.from(Node.texts(editor)).length === 1 && Node.string(editor) === '' && !isComposing;
+  const placeHolderResizeHandler = useCallback(placeholderEl => {
     if (placeholderEl && showPlaceholder) {
       var _placeholderEl$getBou;
       setPlaceholderHeight((_placeholderEl$getBou = placeholderEl.getBoundingClientRect()) === null || _placeholderEl$getBou === void 0 ? void 0 : _placeholderEl$getBou.height);
@@ -3277,7 +3241,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
     }
   }, [showPlaceholder]);
   if (showPlaceholder) {
-    var start = Editor.start(editor, []);
+    const start = Editor.start(editor, []);
     decorations.push({
       [PLACEHOLDER_SYMBOL]: true,
       placeholder,
@@ -3286,16 +3250,16 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       focus: start
     });
   }
-  var {
+  const {
     marks
   } = editor;
   state.hasMarkPlaceholder = false;
   if (editor.selection && Range.isCollapsed(editor.selection) && marks) {
-    var {
+    const {
       anchor
     } = editor.selection;
-    var leaf = Node.leaf(editor, anchor.path);
-    var {
+    const leaf = Node.leaf(editor, anchor.path);
+    const {
         text
       } = leaf,
       rest = _objectWithoutProperties(leaf, _excluded2);
@@ -3305,7 +3269,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       loose: true
     })) {
       state.hasMarkPlaceholder = true;
-      var unset = Object.fromEntries(Object.keys(rest).map(mark => [mark, null]));
+      const unset = Object.fromEntries(Object.keys(rest).map(mark => [mark, null]));
       decorations.push(_objectSpread(_objectSpread(_objectSpread({
         [MARK_PLACEHOLDER_SYMBOL]: true
       }, unset), marks), {}, {
@@ -3318,17 +3282,17 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
   // before we receive the composition end event.
   useEffect(() => {
     setTimeout(() => {
-      var {
+      const {
         selection
       } = editor;
       if (selection) {
-        var {
-          anchor: _anchor
+        const {
+          anchor
         } = selection;
-        var _text = Node.leaf(editor, _anchor.path);
+        const text = Node.leaf(editor, anchor.path);
         // While marks isn't a 'complete' text, we can still use loose Text.equals
         // here which only compares marks anyway.
-        if (marks && !Text$1.equals(_text, marks, {
+        if (marks && !Text$1.equals(text, marks, {
           loose: true
         })) {
           EDITOR_TO_PENDING_INSERTION_MARKS.set(editor, marks);
@@ -3388,8 +3352,8 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       if (!HAS_BEFORE_INPUT_SUPPORT && !readOnly && !isEventHandled(event, attributes.onBeforeInput) && ReactEditor.hasSelectableTarget(editor, event.target)) {
         event.preventDefault();
         if (!ReactEditor.isComposing(editor)) {
-          var _text2 = event.data;
-          Editor.insertText(editor, _text2);
+          const text = event.data;
+          Editor.insertText(editor, text);
         }
       }
     }, [attributes.onBeforeInput, editor, readOnly]),
@@ -3405,7 +3369,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       // and we can correctly compare DOM text values in components
       // to stop rendering, so that browser functions like autocorrect
       // and spellcheck work as expected.
-      for (var op of deferredOperations.current) {
+      for (const op of deferredOperations.current) {
         op();
       }
       deferredOperations.current = [];
@@ -3425,14 +3389,14 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       // one, this is due to the window being blurred when the tab
       // itself becomes unfocused, so we want to abort early to allow to
       // editor to stay focused when the tab becomes focused again.
-      var root = ReactEditor.findDocumentOrShadowRoot(editor);
+      const root = ReactEditor.findDocumentOrShadowRoot(editor);
       if (state.latestElement === root.activeElement) {
         return;
       }
-      var {
+      const {
         relatedTarget
       } = event;
-      var el = ReactEditor.toDOMNode(editor, editor);
+      const el = ReactEditor.toDOMNode(editor, editor);
       // COMPAT: The event should be ignored if the focus is returning
       // to the editor from an embedded editable element (eg. an <input>
       // element inside a void node).
@@ -3448,7 +3412,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       // non- editable section of an element that isn't a void node (eg.
       // a list item of the check list example).
       if (relatedTarget != null && isDOMNode(relatedTarget) && ReactEditor.hasDOMNode(editor, relatedTarget)) {
-        var node = ReactEditor.toSlateNode(editor, relatedTarget);
+        const node = ReactEditor.toSlateNode(editor, relatedTarget);
         if (Node.isElement(node) && !editor.isVoid(node)) {
           return;
         }
@@ -3457,15 +3421,15 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       // editable element no longer has focus. Refer to:
       // https://stackoverflow.com/questions/12353247/force-contenteditable-div-to-stop-accepting-input-after-it-loses-focus-under-web
       if (IS_WEBKIT) {
-        var domSelection = getSelection(root);
+        const domSelection = getSelection(root);
         domSelection === null || domSelection === void 0 || domSelection.removeAllRanges();
       }
       IS_FOCUSED.delete(editor);
     }, [readOnly, state.isUpdatingSelection, state.latestElement, editor, attributes.onBlur]),
     onClick: useCallback(event => {
       if (ReactEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onClick) && isDOMNode(event.target)) {
-        var node = ReactEditor.toSlateNode(editor, event.target);
-        var path = ReactEditor.findPath(editor, node);
+        const node = ReactEditor.toSlateNode(editor, event.target);
+        const path = ReactEditor.findPath(editor, node);
         // At this time, the Slate document may be arbitrarily different,
         // because onClick handlers can change the document before we get here.
         // Therefore we must check that this path actually exists,
@@ -3474,33 +3438,33 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
           return;
         }
         if (event.detail === TRIPLE_CLICK && path.length >= 1) {
-          var blockPath = path;
+          let blockPath = path;
           if (!(Node.isElement(node) && Editor.isBlock(editor, node))) {
             var _block$;
-            var block = Editor.above(editor, {
+            const block = Editor.above(editor, {
               match: n => Node.isElement(n) && Editor.isBlock(editor, n),
               at: path
             });
             blockPath = (_block$ = block === null || block === void 0 ? void 0 : block[1]) !== null && _block$ !== void 0 ? _block$ : path.slice(0, 1);
           }
-          var range = Editor.range(editor, blockPath);
+          const range = Editor.range(editor, blockPath);
           Transforms.select(editor, range);
           return;
         }
         if (readOnly) {
           return;
         }
-        var _start = Editor.start(editor, path);
-        var end = Editor.end(editor, path);
-        var startVoid = Editor.void(editor, {
-          at: _start
+        const start = Editor.start(editor, path);
+        const end = Editor.end(editor, path);
+        const startVoid = Editor.void(editor, {
+          at: start
         });
-        var endVoid = Editor.void(editor, {
+        const endVoid = Editor.void(editor, {
           at: end
         });
         if (startVoid && endVoid && Path.equals(startVoid[1], endVoid[1])) {
-          var _range2 = Editor.range(editor, _start);
-          Transforms.select(editor, _range2);
+          const range = Editor.range(editor, start);
+          Transforms.select(editor, range);
         }
       }
     }, [editor, attributes.onClick, readOnly]),
@@ -3525,7 +3489,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
         // type that we need. So instead, insert whenever a composition
         // ends since it will already have been committed to the DOM.
         if (!IS_WEBKIT && !IS_FIREFOX_LEGACY && !IS_IOS && !IS_WECHATBROWSER && !IS_UC_MOBILE && event.data) {
-          var placeholderMarks = EDITOR_TO_PENDING_INSERTION_MARKS.get(editor);
+          const placeholderMarks = EDITOR_TO_PENDING_INSERTION_MARKS.get(editor);
           EDITOR_TO_PENDING_INSERTION_MARKS.delete(editor);
           // Ensure we insert text with the marks the user was actually seeing
           if (placeholderMarks !== undefined) {
@@ -3533,7 +3497,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
             editor.marks = placeholderMarks;
           }
           Editor.insertText(editor, event.data);
-          var userMarks = EDITOR_TO_USER_MARKS.get(editor);
+          const userMarks = EDITOR_TO_USER_MARKS.get(editor);
           EDITOR_TO_USER_MARKS.delete(editor);
           if (userMarks !== undefined) {
             editor.marks = userMarks;
@@ -3560,7 +3524,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
           return;
         }
         setIsComposing(true);
-        var {
+        const {
           selection
         } = editor;
         if (selection && Range.isExpanded(selection)) {
@@ -3579,14 +3543,14 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       if (!readOnly && ReactEditor.hasSelectableTarget(editor, event.target) && !isEventHandled(event, attributes.onCut) && !isDOMEventTargetInput(event)) {
         event.preventDefault();
         ReactEditor.setFragmentData(editor, event.clipboardData, 'cut');
-        var {
+        const {
           selection
         } = editor;
         if (selection) {
           if (Range.isExpanded(selection)) {
             Editor.deleteFragment(editor);
           } else {
-            var node = Node.parent(editor, selection.anchor.path);
+            const node = Node.parent(editor, selection.anchor.path);
             if (Editor.isVoid(editor, node)) {
               Transforms.delete(editor);
             }
@@ -3599,7 +3563,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
         // Only when the target is void, call `preventDefault` to signal
         // that drops are allowed. Editable content is droppable by
         // default, and calling `preventDefault` hides the cursor.
-        var node = ReactEditor.toSlateNode(editor, event.target);
+        const node = ReactEditor.toSlateNode(editor, event.target);
         if (Node.isElement(node) && Editor.isVoid(editor, node)) {
           event.preventDefault();
         }
@@ -3607,16 +3571,16 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
     }, [attributes.onDragOver, editor]),
     onDragStart: useCallback(event => {
       if (!readOnly && ReactEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onDragStart)) {
-        var node = ReactEditor.toSlateNode(editor, event.target);
-        var path = ReactEditor.findPath(editor, node);
-        var voidMatch = Node.isElement(node) && Editor.isVoid(editor, node) || Editor.void(editor, {
+        const node = ReactEditor.toSlateNode(editor, event.target);
+        const path = ReactEditor.findPath(editor, node);
+        const voidMatch = Node.isElement(node) && Editor.isVoid(editor, node) || Editor.void(editor, {
           at: path,
           voids: true
         });
         // If starting a drag on a void node, make sure it is selected
         // so that it shows up in the selection's fragment.
         if (voidMatch) {
-          var range = Editor.range(editor, path);
+          const range = Editor.range(editor, path);
           Transforms.select(editor, range);
         }
         state.isDraggingInternally = true;
@@ -3627,10 +3591,10 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       if (!readOnly && event.isTrusted && ReactEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onDrop)) {
         event.preventDefault();
         // Keep a reference to the dragged range before updating selection
-        var draggedRange = editor.selection;
+        const draggedRange = editor.selection;
         // Find the range where the drop happened
-        var range = ReactEditor.findEventRange(editor, event);
-        var data = event.dataTransfer;
+        const range = ReactEditor.findEventRange(editor, event);
+        const data = event.dataTransfer;
         Transforms.select(editor, range);
         if (state.isDraggingInternally) {
           if (draggedRange && !Range.equals(draggedRange, range) && !Editor.void(editor, {
@@ -3657,8 +3621,8 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
     }, [readOnly, state, attributes, editor]),
     onFocus: useCallback(event => {
       if (!readOnly && !state.isUpdatingSelection && ReactEditor.hasEditableTarget(editor, event.target) && !isEventHandled(event, attributes.onFocus)) {
-        var el = ReactEditor.toDOMNode(editor, editor);
-        var root = ReactEditor.findDocumentOrShadowRoot(editor);
+        const el = ReactEditor.toDOMNode(editor, editor);
+        const root = ReactEditor.findDocumentOrShadowRoot(editor);
         state.latestElement = root.activeElement;
         // COMPAT: If the editor has nested editable elements, the focus
         // can go to them. In Firefox, this must be prevented because it
@@ -3674,7 +3638,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
       if (!readOnly && ReactEditor.hasEditableTarget(editor, event.target)) {
         var _androidInputManagerR5;
         (_androidInputManagerR5 = androidInputManagerRef.current) === null || _androidInputManagerR5 === void 0 || _androidInputManagerR5.handleKeyDown(event);
-        var {
+        const {
           nativeEvent
         } = event;
         // COMPAT: The composition end event isn't fired reliably in all browsers,
@@ -3687,18 +3651,18 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
         if (isEventHandled(event, attributes.onKeyDown) || ReactEditor.isComposing(editor)) {
           return;
         }
-        var {
+        const {
           selection
         } = editor;
-        var element = editor.children[selection !== null ? selection.focus.path[0] : 0];
-        var isRTL = getDirection(Node.string(element)) === 'rtl';
+        const element = editor.children[selection !== null ? selection.focus.path[0] : 0];
+        const isRTL = getDirection(Node.string(element)) === 'rtl';
         // COMPAT: Since we prevent the default behavior on
         // `beforeinput` events, the browser doesn't think there's ever
         // any history stack to undo or redo, so we have to manage these
         // hotkeys ourselves. (2019/11/06)
         if (Hotkeys.isRedo(nativeEvent)) {
           event.preventDefault();
-          var maybeHistoryEditor = editor;
+          const maybeHistoryEditor = editor;
           if (typeof maybeHistoryEditor.redo === 'function') {
             maybeHistoryEditor.redo();
           }
@@ -3706,9 +3670,9 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
         }
         if (Hotkeys.isUndo(nativeEvent)) {
           event.preventDefault();
-          var _maybeHistoryEditor = editor;
-          if (typeof _maybeHistoryEditor.undo === 'function') {
-            _maybeHistoryEditor.undo();
+          const maybeHistoryEditor = editor;
+          if (typeof maybeHistoryEditor.undo === 'function') {
+            maybeHistoryEditor.undo();
           }
           return;
         }
@@ -3904,7 +3868,7 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
             // COMPAT: Chrome and Safari support `beforeinput` event but do not fire
             // an event when deleting backwards in a selected void inline node
             if (selection && (Hotkeys.isDeleteBackward(nativeEvent) || Hotkeys.isDeleteForward(nativeEvent)) && Range.isCollapsed(selection)) {
-              var currentNode = Node.parent(editor, selection.anchor.path);
+              const currentNode = Node.parent(editor, selection.anchor.path);
               if (Node.isElement(currentNode) && Editor.isVoid(editor, currentNode) && (Editor.isInline(editor, currentNode) || Editor.isBlock(editor, currentNode))) {
                 event.preventDefault();
                 if (Hotkeys.isDeleteForward(nativeEvent)) {
@@ -3951,39 +3915,35 @@ var Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
 /**
  * The default placeholder element
  */
-var DefaultPlaceholder = _ref2 => {
-  var {
-    attributes,
-    children
-  } = _ref2;
-  return (
-    /*#__PURE__*/
-    // COMPAT: Artificially add a line-break to the end on the placeholder element
-    // to prevent Android IMEs to pick up its content in autocorrect and to auto-capitalize the first letter
-    React.createElement("span", _objectSpread({}, attributes), children, IS_ANDROID && /*#__PURE__*/React.createElement("br", null))
-  );
-};
+const DefaultPlaceholder = ({
+  attributes,
+  children
+}) => (
+/*#__PURE__*/
+// COMPAT: Artificially add a line-break to the end on the placeholder element
+// to prevent Android IMEs to pick up its content in autocorrect and to auto-capitalize the first letter
+React.createElement("span", _objectSpread({}, attributes), children, IS_ANDROID && /*#__PURE__*/React.createElement("br", null)));
 /**
  * A default memoized decorate function.
  */
-var defaultDecorate = () => [];
+const defaultDecorate = () => [];
 /**
  * A default implement to scroll dom range into view.
  */
-var defaultScrollSelectionIntoView = (editor, domRange) => {
+const defaultScrollSelectionIntoView = (editor, domRange) => {
   // Scroll to the focus point of the selection, in case the selection is expanded
-  var isBackward = !!editor.selection && Range.isBackward(editor.selection);
-  var domFocusPoint = domRange.cloneRange();
+  const isBackward = !!editor.selection && Range.isBackward(editor.selection);
+  const domFocusPoint = domRange.cloneRange();
   domFocusPoint.collapse(isBackward);
   if (domFocusPoint.getBoundingClientRect) {
-    var leafEl = domFocusPoint.startContainer.parentElement;
+    const leafEl = domFocusPoint.startContainer.parentElement;
     // COMPAT: In Chrome, domFocusPoint.getBoundingClientRect() can return zero dimensions for valid ranges (e.g. line breaks).
     // When this happens, do not scroll like most editors do.
-    var domRect = domFocusPoint.getBoundingClientRect();
-    var isZeroDimensionRect = domRect.width === 0 && domRect.height === 0 && domRect.x === 0 && domRect.y === 0;
+    const domRect = domFocusPoint.getBoundingClientRect();
+    const isZeroDimensionRect = domRect.width === 0 && domRect.height === 0 && domRect.x === 0 && domRect.y === 0;
     if (isZeroDimensionRect) {
-      var leafRect = leafEl.getBoundingClientRect();
-      var leafHasDimensions = leafRect.width > 0 || leafRect.height > 0;
+      const leafRect = leafEl.getBoundingClientRect();
+      const leafHasDimensions = leafRect.width > 0 || leafRect.height > 0;
       if (leafHasDimensions) {
         return;
       }
@@ -4000,13 +3960,13 @@ var defaultScrollSelectionIntoView = (editor, domRange) => {
 /**
  * Check if an event is overrided by a handler.
  */
-var isEventHandled = (event, handler) => {
+const isEventHandled = (event, handler) => {
   if (!handler) {
     return false;
   }
   // The custom event handler may return a boolean to specify whether the event
   // shall be treated as being handled or not.
-  var shouldTreatEventAsHandled = handler(event);
+  const shouldTreatEventAsHandled = handler(event);
   if (shouldTreatEventAsHandled != null) {
     return shouldTreatEventAsHandled;
   }
@@ -4015,26 +3975,26 @@ var isEventHandled = (event, handler) => {
 /**
  * Check if the event's target is an input element
  */
-var isDOMEventTargetInput = event => {
+const isDOMEventTargetInput = event => {
   return isDOMNode(event.target) && (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement);
 };
 /**
  * Check if a DOM event is overrided by a handler.
  */
-var isDOMEventHandled = (event, handler) => {
+const isDOMEventHandled = (event, handler) => {
   if (!handler) {
     return false;
   }
   // The custom event handler may return a boolean to specify whether the event
   // shall be treated as being handled or not.
-  var shouldTreatEventAsHandled = handler(event);
+  const shouldTreatEventAsHandled = handler(event);
   if (shouldTreatEventAsHandled != null) {
     return shouldTreatEventAsHandled;
   }
   return event.defaultPrevented;
 };
-var handleNativeHistoryEvents = (editor, event) => {
-  var maybeHistoryEditor = editor;
+const handleNativeHistoryEvents = (editor, event) => {
+  const maybeHistoryEditor = editor;
   if (event.inputType === 'historyUndo' && typeof maybeHistoryEditor.undo === 'function') {
     maybeHistoryEditor.undo();
     return;
@@ -4048,23 +4008,23 @@ var handleNativeHistoryEvents = (editor, event) => {
 /**
  * A React context for sharing the `focused` state of the editor.
  */
-var FocusedContext = /*#__PURE__*/createContext(false);
+const FocusedContext = /*#__PURE__*/createContext(false);
 /**
  * Get the current `focused` state of the editor.
  */
-var useFocused = () => {
+const useFocused = () => {
   return useContext(FocusedContext);
 };
 
-var REACT_MAJOR_VERSION = parseInt(React.version.split('.')[0], 10);
+const REACT_MAJOR_VERSION = parseInt(React.version.split('.')[0], 10);
 
-var _excluded = ["editor", "children", "onChange", "onSelectionChange", "onValueChange", "initialValue"];
+const _excluded = ["editor", "children", "onChange", "onSelectionChange", "onValueChange", "initialValue"];
 /**
  * A wrapper around the provider to handle `onChange` events, because the editor
  * is a mutable singleton so it won't ever register as "changed" otherwise.
  */
-var Slate = props => {
-  var {
+const Slate = props => {
+  const {
       editor,
       children,
       onChange,
@@ -4073,23 +4033,23 @@ var Slate = props => {
       initialValue
     } = props,
     rest = _objectWithoutProperties(props, _excluded);
-  var initializedEditor = useRef(null);
+  const initializedEditor = useRef(null);
   if (initializedEditor.current !== editor) {
     if (!Node.isNodeList(initialValue)) {
-      throw new Error("[Slate] initialValue is invalid! Expected a list of elements but got: ".concat(Scrubber.stringify(initialValue)));
+      throw new Error(`[Slate] initialValue is invalid! Expected a list of elements but got: ${Scrubber.stringify(initialValue)}`);
     }
     if (!Editor.isEditor(editor)) {
-      throw new Error("[Slate] editor is invalid! You passed: ".concat(Scrubber.stringify(editor)));
+      throw new Error(`[Slate] editor is invalid! You passed: ${Scrubber.stringify(editor)}`);
     }
     editor.children = initialValue;
     Object.assign(editor, rest);
     initializedEditor.current = editor;
   }
-  var {
+  const {
     selectorContext,
     onChange: handleSelectorChange
   } = useSelectorContext();
-  var onContextChange = useCallback(() => {
+  const onContextChange = useCallback(() => {
     if (onChange) {
       onChange(editor.children);
     }
@@ -4107,12 +4067,12 @@ var Slate = props => {
       EDITOR_TO_ON_CHANGE.set(editor, () => {});
     };
   }, [editor, onContextChange]);
-  var [isFocused, setIsFocused] = useState(ReactEditor.isFocused(editor));
+  const [isFocused, setIsFocused] = useState(ReactEditor.isFocused(editor));
   useEffect(() => {
     setIsFocused(ReactEditor.isFocused(editor));
   }, [editor]);
   useIsomorphicLayoutEffect(() => {
-    var fn = () => setIsFocused(ReactEditor.isFocused(editor));
+    const fn = () => setIsFocused(ReactEditor.isFocused(editor));
     if (REACT_MAJOR_VERSION >= 17) {
       // In React >= 17 onFocus and onBlur listen to the focusin and focusout events during the bubbling phase.
       // Therefore in order for <Editable />'s handlers to run first, which is necessary for ReactEditor.isFocused(editor)
@@ -4145,10 +4105,10 @@ var Slate = props => {
  * Get the current editor object from the React context.
  * @deprecated Use useSlateStatic instead.
  */
-var useEditor = () => {
-  var editor = useContext(EditorContext);
+const useEditor = () => {
+  const editor = useContext(EditorContext);
   if (!editor) {
-    throw new Error("The `useEditor` hook must be used inside the <Slate> component's context.");
+    throw new Error(`The \`useEditor\` hook must be used inside the <Slate> component's context.`);
   }
   return editor;
 };
@@ -4159,30 +4119,29 @@ var useEditor = () => {
  * Set `suppressThrow` to return `false` instead of throwing when the element
  * can no longer be found in the editor.
  */
-var useSelected = function useSelected() {
-  var {
-    suppressThrow = false
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var element = useElementIf();
+const useSelected = ({
+  suppressThrow: _suppressThrow = false
+} = {}) => {
+  const element = useElementIf();
   // Breaking the rules of hooks is fine here since `!element` will remain true
   // or false for the entire lifetime of the component this hook is called from.
   // TODO: Decide if we want to throw an error instead when calling
   // `useSelected` outside of an element (potentially a breaking change).
   if (!element) return false;
   // eslint-disable-next-line react-hooks/rules-of-hooks
-  var selector = useCallback(editor => {
+  const selector = useCallback(editor => {
     if (!editor.selection) return false;
     try {
-      var path = ReactEditor.findPath(editor, element);
-      var range = Editor.range(editor, path);
+      const path = ReactEditor.findPath(editor, element);
+      const range = Editor.range(editor, path);
       return !!Range.intersection(range, editor.selection);
     } catch (e) {
-      if (suppressThrow) {
+      if (_suppressThrow) {
         return false;
       }
       throw e;
     }
-  }, [element, suppressThrow]);
+  }, [element, _suppressThrow]);
   // eslint-disable-next-line react-hooks/rules-of-hooks
   return useSlateSelector(selector, undefined, {
     // Defer the selector until after `Editable` has rendered so that the path
@@ -4195,10 +4154,10 @@ var useSelected = function useSelected() {
  * Get the current slate selection.
  * Only triggers a rerender when the selection actually changes
  */
-var useSlateSelection = () => {
+const useSlateSelection = () => {
   return useSlateSelector(editor => editor.selection, isSelectionEqual);
 };
-var isSelectionEqual = (a, b) => {
+const isSelectionEqual = (a, b) => {
   if (!a && !b) return true;
   if (!a || !b) return false;
   return Range.equals(a, b);
@@ -4212,11 +4171,10 @@ var isSelectionEqual = (a, b) => {
  *
  * See https://docs.slatejs.org/concepts/11-typescript to learn how.
  */
-var withReact = function withReact(editor) {
-  var clipboardFormatKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'x-slate-fragment';
-  var e = editor;
+const withReact = (editor, clipboardFormatKey = 'x-slate-fragment') => {
+  let e = editor;
   e = withDOM(e, clipboardFormatKey);
-  var {
+  const {
     onChange,
     apply,
     insertText
@@ -4240,7 +4198,7 @@ var withReact = function withReact(editor) {
     // pass. So we have to use this unstable API to ensure it batches them.
     // (2019/12/03)
     // https://github.com/facebook/react/issues/14259#issuecomment-439702367
-    var maybeBatchUpdates = REACT_MAJOR_VERSION < 18 ? ReactDOM.unstable_batchedUpdates : callback => callback();
+    const maybeBatchUpdates = REACT_MAJOR_VERSION < 18 ? ReactDOM.unstable_batchedUpdates : callback => callback();
     maybeBatchUpdates(() => {
       onChange(options);
     });
@@ -4250,12 +4208,12 @@ var withReact = function withReact(editor) {
   // parent's chunk tree.
   e.apply = operation => {
     if (operation.type === 'move_node') {
-      var parent = Node.parent(e, operation.path);
-      var chunking = !!e.getChunkSize(parent);
+      const parent = Node.parent(e, operation.path);
+      const chunking = !!e.getChunkSize(parent);
       if (chunking) {
-        var node = Node.get(e, operation.path);
-        var chunkTree = getChunkTreeForNode(e, parent);
-        var key = ReactEditor.findKey(e, node);
+        const node = Node.get(e, operation.path);
+        const chunkTree = getChunkTreeForNode(e, parent);
+        const key = ReactEditor.findKey(e, node);
         chunkTree.movedNodeKeys.add(key);
       }
     }