{"version":3,"file":"static/js/7238_15583969d9a0cad4ca1d.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/slate-history@0.93.0_slate@0.94.1/node_modules/slate-history/dist/index.es.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/scroll-into-view-if-needed@2.2.31/node_modules/scroll-into-view-if-needed/es/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/slate-react@0.98.4_rehni4dfsz7b477gynmqnob23i/node_modules/slate-react/dist/index.es.js"],"sourcesContent":["import { isPlainObject } from 'is-plain-object';\nimport { Operation, Editor, Transforms, Path } from 'slate';\n\nvar History = {\n  /**\r\n   * Check if a value is a `History` object.\r\n   */\n  isHistory(value) {\n    return isPlainObject(value) && Array.isArray(value.redos) && Array.isArray(value.undos) && (value.redos.length === 0 || Operation.isOperationList(value.redos[0].operations)) && (value.undos.length === 0 || Operation.isOperationList(value.undos[0].operations));\n  }\n\n};\n\n/**\r\n * Weakmaps for attaching state to the editor.\r\n */\n\nvar HISTORY = new WeakMap();\nvar SAVING = new WeakMap();\nvar MERGING = new WeakMap(); // eslint-disable-next-line no-redeclare\n\nvar HistoryEditor = {\n  /**\r\n   * Check if a value is a `HistoryEditor` object.\r\n   */\n  isHistoryEditor(value) {\n    return History.isHistory(value.history) && Editor.isEditor(value);\n  },\n\n  /**\r\n   * Get the merge flag's current value.\r\n   */\n  isMerging(editor) {\n    return MERGING.get(editor);\n  },\n\n  /**\r\n   * Get the saving flag's current value.\r\n   */\n  isSaving(editor) {\n    return SAVING.get(editor);\n  },\n\n  /**\r\n   * Redo to the previous saved state.\r\n   */\n  redo(editor) {\n    editor.redo();\n  },\n\n  /**\r\n   * Undo to the previous saved state.\r\n   */\n  undo(editor) {\n    editor.undo();\n  },\n\n  /**\r\n   * Apply a series of changes inside a synchronous `fn`, without merging any of\r\n   * the new operations into previous save point in the history.\r\n   */\n  withoutMerging(editor, fn) {\n    var prev = HistoryEditor.isMerging(editor);\n    MERGING.set(editor, false);\n    fn();\n    MERGING.set(editor, prev);\n  },\n\n  /**\r\n   * Apply a series of changes inside a synchronous `fn`, without saving any of\r\n   * their operations into the history.\r\n   */\n  withoutSaving(editor, fn) {\n    var prev = HistoryEditor.isSaving(editor);\n    SAVING.set(editor, false);\n    fn();\n    SAVING.set(editor, prev);\n  }\n\n};\n\n/**\r\n * The `withHistory` plugin keeps track of the operation history of a Slate\r\n * editor as operations are applied to it, using undo and redo stacks.\r\n *\r\n * If you are using TypeScript, you must extend Slate's CustomTypes to use\r\n * this plugin.\r\n *\r\n * See https://docs.slatejs.org/concepts/11-typescript to learn how.\r\n */\n\nvar withHistory = editor => {\n  var e = editor;\n  var {\n    apply\n  } = e;\n  e.history = {\n    undos: [],\n    redos: []\n  };\n\n  e.redo = () => {\n    var {\n      history\n    } = e;\n    var {\n      redos\n    } = history;\n\n    if (redos.length > 0) {\n      var batch = redos[redos.length - 1];\n\n      if (batch.selectionBefore) {\n        Transforms.setSelection(e, batch.selectionBefore);\n      }\n\n      HistoryEditor.withoutSaving(e, () => {\n        Editor.withoutNormalizing(e, () => {\n          for (var op of batch.operations) {\n            e.apply(op);\n          }\n        });\n      });\n      history.redos.pop();\n      e.writeHistory('undos', batch);\n    }\n  };\n\n  e.undo = () => {\n    var {\n      history\n    } = e;\n    var {\n      undos\n    } = history;\n\n    if (undos.length > 0) {\n      var batch = undos[undos.length - 1];\n      HistoryEditor.withoutSaving(e, () => {\n        Editor.withoutNormalizing(e, () => {\n          var inverseOps = batch.operations.map(Operation.inverse).reverse();\n\n          for (var op of inverseOps) {\n            e.apply(op);\n          }\n\n          if (batch.selectionBefore) {\n            Transforms.setSelection(e, batch.selectionBefore);\n          }\n        });\n      });\n      e.writeHistory('redos', batch);\n      history.undos.pop();\n    }\n  };\n\n  e.apply = op => {\n    var {\n      operations,\n      history\n    } = e;\n    var {\n      undos\n    } = history;\n    var lastBatch = undos[undos.length - 1];\n    var lastOp = lastBatch && lastBatch.operations[lastBatch.operations.length - 1];\n    var save = HistoryEditor.isSaving(e);\n    var merge = HistoryEditor.isMerging(e);\n\n    if (save == null) {\n      save = shouldSave(op);\n    }\n\n    if (save) {\n      if (merge == null) {\n        if (lastBatch == null) {\n          merge = false;\n        } else if (operations.length !== 0) {\n          merge = true;\n        } else {\n          merge = shouldMerge(op, lastOp);\n        }\n      }\n\n      if (lastBatch && merge) {\n        lastBatch.operations.push(op);\n      } else {\n        var batch = {\n          operations: [op],\n          selectionBefore: e.selection\n        };\n        e.writeHistory('undos', batch);\n      }\n\n      while (undos.length > 100) {\n        undos.shift();\n      }\n\n      history.redos = [];\n    }\n\n    apply(op);\n  };\n\n  e.writeHistory = (stack, batch) => {\n    e.history[stack].push(batch);\n  };\n\n  return e;\n};\n/**\r\n * Check whether to merge an operation into the previous operation.\r\n */\n\nvar shouldMerge = (op, prev) => {\n  if (prev && op.type === 'insert_text' && prev.type === 'insert_text' && op.offset === prev.offset + prev.text.length && Path.equals(op.path, prev.path)) {\n    return true;\n  }\n\n  if (prev && op.type === 'remove_text' && prev.type === 'remove_text' && op.offset + op.text.length === prev.offset && Path.equals(op.path, prev.path)) {\n    return true;\n  }\n\n  return false;\n};\n/**\r\n * Check whether an operation needs to be saved to the history.\r\n */\n\n\nvar shouldSave = (op, prev) => {\n  if (op.type === 'set_selection') {\n    return false;\n  }\n\n  return true;\n};\n\nexport { HISTORY, History, HistoryEditor, MERGING, SAVING, withHistory };\n//# sourceMappingURL=index.es.js.map\n","import compute from 'compute-scroll-into-view';\nfunction isOptionsObject(options) {\n  return options === Object(options) && Object.keys(options).length !== 0;\n}\nfunction defaultBehavior(actions, behavior) {\n  if (behavior === void 0) {\n    behavior = 'auto';\n  }\n  var canSmoothScroll = ('scrollBehavior' in document.body.style);\n  actions.forEach(function (_ref) {\n    var el = _ref.el,\n      top = _ref.top,\n      left = _ref.left;\n    if (el.scroll && canSmoothScroll) {\n      el.scroll({\n        top: top,\n        left: left,\n        behavior: behavior\n      });\n    } else {\n      el.scrollTop = top;\n      el.scrollLeft = left;\n    }\n  });\n}\nfunction getOptions(options) {\n  if (options === false) {\n    return {\n      block: 'end',\n      inline: 'nearest'\n    };\n  }\n  if (isOptionsObject(options)) {\n    return options;\n  }\n  return {\n    block: 'start',\n    inline: 'nearest'\n  };\n}\nfunction scrollIntoView(target, options) {\n  var isTargetAttached = target.isConnected || target.ownerDocument.documentElement.contains(target);\n  if (isOptionsObject(options) && typeof options.behavior === 'function') {\n    return options.behavior(isTargetAttached ? compute(target, options) : []);\n  }\n  if (!isTargetAttached) {\n    return;\n  }\n  var computeOptions = getOptions(options);\n  return defaultBehavior(compute(target, computeOptions), computeOptions.behavior);\n}\nexport default scrollIntoView;","import getDirection from 'direction';\nimport debounce from 'lodash/debounce';\nimport throttle from 'lodash/throttle';\nimport React, { createContext, useContext, useRef, useEffect, useLayoutEffect, useState, memo, forwardRef, useCallback, Component, useReducer, useMemo } from 'react';\nimport scrollIntoView from 'scroll-into-view-if-needed';\nimport { Transforms, Element as Element$1, Editor, Scrubber, Range, Path, Point, Node, Text as Text$1 } from 'slate';\nimport { ResizeObserver } from '@juggle/resize-observer';\nimport { isHotkey } from 'is-hotkey';\nimport ReactDOM from 'react-dom';\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = _objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n\n/**\r\n * A React context for sharing the editor object.\r\n */\n\nvar EditorContext = /*#__PURE__*/createContext(null);\n/**\r\n * Get the current editor object from the React context.\r\n */\n\nvar useSlateStatic = () => {\n  var editor = useContext(EditorContext);\n\n  if (!editor) {\n    throw new Error(\"The `useSlateStatic` hook must be used inside the <Slate> component's context.\");\n  }\n\n  return editor;\n};\n\nvar REACT_MAJOR_VERSION = parseInt(React.version.split('.')[0], 10);\nvar IS_IOS = typeof navigator !== 'undefined' && typeof window !== 'undefined' && /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;\nvar IS_APPLE = typeof navigator !== 'undefined' && /Mac OS X/.test(navigator.userAgent);\nvar IS_ANDROID = typeof navigator !== 'undefined' && /Android/.test(navigator.userAgent);\nvar IS_FIREFOX = typeof navigator !== 'undefined' && /^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);\nvar IS_WEBKIT = typeof navigator !== 'undefined' && /AppleWebKit(?!.*Chrome)/i.test(navigator.userAgent); // \"modern\" Edge was released at 79.x\n\nvar IS_EDGE_LEGACY = typeof navigator !== 'undefined' && /Edge?\\/(?:[0-6][0-9]|[0-7][0-8])(?:\\.)/i.test(navigator.userAgent);\nvar IS_CHROME = typeof navigator !== 'undefined' && /Chrome/i.test(navigator.userAgent); // Native `beforeInput` events don't work well with react on Chrome 75\n// and older, Chrome 76+ can use `beforeInput` though.\n\nvar IS_CHROME_LEGACY = typeof navigator !== 'undefined' && /Chrome?\\/(?:[0-7][0-5]|[0-6][0-9])(?:\\.)/i.test(navigator.userAgent);\nvar IS_ANDROID_CHROME_LEGACY = IS_ANDROID && typeof navigator !== 'undefined' && /Chrome?\\/(?:[0-5]?\\d)(?:\\.)/i.test(navigator.userAgent); // Firefox did not support `beforeInput` until `v87`.\n\nvar IS_FIREFOX_LEGACY = typeof navigator !== 'undefined' && /^(?!.*Seamonkey)(?=.*Firefox\\/(?:[0-7][0-9]|[0-8][0-6])(?:\\.)).*/i.test(navigator.userAgent); // UC mobile browser\n\nvar IS_UC_MOBILE = typeof navigator !== 'undefined' && /.*UCBrowser/.test(navigator.userAgent); // Wechat browser (not including mac wechat)\n\nvar IS_WECHATBROWSER = typeof navigator !== 'undefined' && /.*Wechat/.test(navigator.userAgent) && !/.*MacWechat/.test(navigator.userAgent); // avoid lookbehind (buggy in safari < 16.4)\n// Check if DOM is available as React does internally.\n// https://github.com/facebook/react/blob/master/packages/shared/ExecutionEnvironment.js\n\nvar CAN_USE_DOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined'); // COMPAT: Firefox/Edge Legacy don't support the `beforeinput` event\n// Chrome Legacy doesn't support `beforeinput` correctly\n\nvar HAS_BEFORE_INPUT_SUPPORT = (!IS_CHROME_LEGACY || !IS_ANDROID_CHROME_LEGACY) && !IS_EDGE_LEGACY && // globalThis is undefined in older browsers\ntypeof globalThis !== 'undefined' && globalThis.InputEvent && // @ts-ignore The `getTargetRanges` property isn't recognized.\ntypeof globalThis.InputEvent.prototype.getTargetRanges === 'function';\n\n/**\r\n * Two weak maps that allow us rebuild a path given a node. They are populated\r\n * at render time such that after a render occurs we can always backtrack.\r\n */\nvar NODE_TO_INDEX = new WeakMap();\nvar NODE_TO_PARENT = new WeakMap();\n/**\r\n * Weak maps that allow us to go between Slate nodes and DOM nodes. These\r\n * are used to resolve DOM event-related logic into Slate actions.\r\n */\n\nvar EDITOR_TO_WINDOW = new WeakMap();\nvar EDITOR_TO_ELEMENT = new WeakMap();\nvar EDITOR_TO_PLACEHOLDER_ELEMENT = new WeakMap();\nvar ELEMENT_TO_NODE = new WeakMap();\nvar NODE_TO_ELEMENT = new WeakMap();\nvar NODE_TO_KEY = new WeakMap();\nvar EDITOR_TO_KEY_TO_ELEMENT = new WeakMap();\n/**\r\n * Weak maps for storing editor-related state.\r\n */\n\nvar IS_READ_ONLY = new WeakMap();\nvar IS_FOCUSED = new WeakMap();\nvar IS_COMPOSING = new WeakMap();\nvar EDITOR_TO_USER_SELECTION = new WeakMap();\n/**\r\n * Weak map for associating the context `onChange` context with the plugin.\r\n */\n\nvar EDITOR_TO_ON_CHANGE = new WeakMap();\n/**\r\n * Weak maps for saving pending state on composition stage.\r\n */\n\nvar EDITOR_TO_SCHEDULE_FLUSH = new WeakMap();\nvar EDITOR_TO_PENDING_INSERTION_MARKS = new WeakMap();\nvar EDITOR_TO_USER_MARKS = new WeakMap();\n/**\r\n * Android input handling specific weak-maps\r\n */\n\nvar EDITOR_TO_PENDING_DIFFS = new WeakMap();\nvar EDITOR_TO_PENDING_ACTION = new WeakMap();\nvar EDITOR_TO_PENDING_SELECTION = new WeakMap();\nvar EDITOR_TO_FORCE_RENDER = new WeakMap();\n/**\r\n * Symbols.\r\n */\n\nvar PLACEHOLDER_SYMBOL = Symbol('placeholder');\nvar MARK_PLACEHOLDER_SYMBOL = Symbol('mark-placeholder');\n\n/**\r\n * Types.\r\n */\nvar DOMText = globalThis.Text;\n/**\r\n * Returns the host window of a DOM node\r\n */\n\nvar getDefaultView = value => {\n  return value && value.ownerDocument && value.ownerDocument.defaultView || null;\n};\n/**\r\n * Check if a DOM node is a comment node.\r\n */\n\nvar isDOMComment = value => {\n  return isDOMNode(value) && value.nodeType === 8;\n};\n/**\r\n * Check if a DOM node is an element node.\r\n */\n\nvar isDOMElement = value => {\n  return isDOMNode(value) && value.nodeType === 1;\n};\n/**\r\n * Check if a value is a DOM node.\r\n */\n\nvar isDOMNode = value => {\n  var window = getDefaultView(value);\n  return !!window && value instanceof window.Node;\n};\n/**\r\n * Check if a value is a DOM selection.\r\n */\n\nvar isDOMSelection = value => {\n  var window = value && value.anchorNode && getDefaultView(value.anchorNode);\n  return !!window && value instanceof window.Selection;\n};\n/**\r\n * Check if a DOM node is an element node.\r\n */\n\nvar isDOMText = value => {\n  return isDOMNode(value) && value.nodeType === 3;\n};\n/**\r\n * Checks whether a paste event is a plaintext-only event.\r\n */\n\nvar isPlainTextOnlyPaste = event => {\n  return event.clipboardData && event.clipboardData.getData('text/plain') !== '' && event.clipboardData.types.length === 1;\n};\n/**\r\n * Normalize a DOM point so that it always refers to a text node.\r\n */\n\nvar normalizeDOMPoint = domPoint => {\n  var [node, offset] = domPoint; // If it's an element node, its offset refers to the index of its children\n  // including comment nodes, so try to find the right text child node.\n\n  if (isDOMElement(node) && node.childNodes.length) {\n    var isLast = offset === node.childNodes.length;\n    var index = isLast ? offset - 1 : offset;\n    [node, index] = getEditableChildAndIndex(node, index, isLast ? 'backward' : 'forward'); // If the editable child found is in front of input offset, we instead seek to its end\n\n    isLast = index < offset; // If the node has children, traverse until we have a leaf node. Leaf nodes\n    // can be either text nodes, or other void DOM nodes.\n\n    while (isDOMElement(node) && node.childNodes.length) {\n      var i = isLast ? node.childNodes.length - 1 : 0;\n      node = getEditableChild(node, i, isLast ? 'backward' : 'forward');\n    } // Determine the new offset inside the text node.\n\n\n    offset = isLast && node.textContent != null ? node.textContent.length : 0;\n  } // Return the node and offset.\n\n\n  return [node, offset];\n};\n/**\r\n * Determines whether the active element is nested within a shadowRoot\r\n */\n\nvar hasShadowRoot = node => {\n  var parent = node && node.parentNode;\n\n  while (parent) {\n    if (parent.toString() === '[object ShadowRoot]') {\n      return true;\n    }\n\n    parent = parent.parentNode;\n  }\n\n  return false;\n};\n/**\r\n * Get the nearest editable child and index at `index` in a `parent`, preferring\r\n * `direction`.\r\n */\n\nvar getEditableChildAndIndex = (parent, index, direction) => {\n  var {\n    childNodes\n  } = parent;\n  var child = childNodes[index];\n  var i = index;\n  var triedForward = false;\n  var triedBackward = false; // While the child is a comment node, or an element node with no children,\n  // keep iterating to find a sibling non-void, non-comment node.\n\n  while (isDOMComment(child) || isDOMElement(child) && child.childNodes.length === 0 || isDOMElement(child) && child.getAttribute('contenteditable') === 'false') {\n    if (triedForward && triedBackward) {\n      break;\n    }\n\n    if (i >= childNodes.length) {\n      triedForward = true;\n      i = index - 1;\n      direction = 'backward';\n      continue;\n    }\n\n    if (i < 0) {\n      triedBackward = true;\n      i = index + 1;\n      direction = 'forward';\n      continue;\n    }\n\n    child = childNodes[i];\n    index = i;\n    i += direction === 'forward' ? 1 : -1;\n  }\n\n  return [child, index];\n};\n/**\r\n * Get the nearest editable child at `index` in a `parent`, preferring\r\n * `direction`.\r\n */\n\nvar getEditableChild = (parent, index, direction) => {\n  var [child] = getEditableChildAndIndex(parent, index, direction);\n  return child;\n};\n/**\r\n * Get a plaintext representation of the content of a node, accounting for block\r\n * elements which get a newline appended.\r\n *\r\n * The domNode must be attached to the DOM.\r\n */\n\nvar getPlainText = domNode => {\n  var text = '';\n\n  if (isDOMText(domNode) && domNode.nodeValue) {\n    return domNode.nodeValue;\n  }\n\n  if (isDOMElement(domNode)) {\n    for (var childNode of Array.from(domNode.childNodes)) {\n      text += getPlainText(childNode);\n    }\n\n    var display = getComputedStyle(domNode).getPropertyValue('display');\n\n    if (display === 'block' || display === 'list' || domNode.tagName === 'BR') {\n      text += '\\n';\n    }\n  }\n\n  return text;\n};\n/**\r\n * Get x-slate-fragment attribute from data-slate-fragment\r\n */\n\nvar catchSlateFragment = /data-slate-fragment=\"(.+?)\"/m;\nvar getSlateFragmentAttribute = dataTransfer => {\n  var htmlData = dataTransfer.getData('text/html');\n  var [, fragment] = htmlData.match(catchSlateFragment) || [];\n  return fragment;\n};\n/**\r\n * Check whether a mutation originates from a editable element inside the editor.\r\n */\n\nvar isTrackedMutation = (editor, mutation, batch) => {\n  var {\n    target\n  } = mutation;\n\n  if (isDOMElement(target) && target.matches('[contentEditable=\"false\"]')) {\n    return false;\n  }\n\n  var {\n    document\n  } = ReactEditor.getWindow(editor);\n\n  if (document.contains(target)) {\n    return ReactEditor.hasDOMNode(editor, target, {\n      editable: true\n    });\n  }\n\n  var parentMutation = batch.find(_ref => {\n    var {\n      addedNodes,\n      removedNodes\n    } = _ref;\n\n    for (var node of addedNodes) {\n      if (node === target || node.contains(target)) {\n        return true;\n      }\n    }\n\n    for (var _node of removedNodes) {\n      if (_node === target || _node.contains(target)) {\n        return true;\n      }\n    }\n  });\n\n  if (!parentMutation || parentMutation === mutation) {\n    return false;\n  } // Target add/remove is tracked. Track the mutation if we track the parent mutation.\n\n\n  return isTrackedMutation(editor, parentMutation, batch);\n};\n\n/**\r\n * An auto-incrementing identifier for keys.\r\n */\nvar n = 0;\n/**\r\n * A class that keeps track of a key string. We use a full class here because we\r\n * want to be able to use them as keys in `WeakMap` objects.\r\n */\n\nclass Key {\n  constructor() {\n    this.id = \"\".concat(n++);\n  }\n\n}\n\nvar ReactEditor = {\n  androidPendingDiffs: editor => EDITOR_TO_PENDING_DIFFS.get(editor),\n  androidScheduleFlush: editor => {\n    var _EDITOR_TO_SCHEDULE_F;\n\n    (_EDITOR_TO_SCHEDULE_F = EDITOR_TO_SCHEDULE_FLUSH.get(editor)) === null || _EDITOR_TO_SCHEDULE_F === void 0 ? void 0 : _EDITOR_TO_SCHEDULE_F();\n  },\n  blur: editor => {\n    var el = ReactEditor.toDOMNode(editor, editor);\n    var root = ReactEditor.findDocumentOrShadowRoot(editor);\n    IS_FOCUSED.set(editor, false);\n\n    if (root.activeElement === el) {\n      el.blur();\n    }\n  },\n  deselect: editor => {\n    var {\n      selection\n    } = editor;\n    var root = ReactEditor.findDocumentOrShadowRoot(editor);\n    var domSelection = root.getSelection();\n\n    if (domSelection && domSelection.rangeCount > 0) {\n      domSelection.removeAllRanges();\n    }\n\n    if (selection) {\n      Transforms.deselect(editor);\n    }\n  },\n  findDocumentOrShadowRoot: editor => {\n    var el = ReactEditor.toDOMNode(editor, editor);\n    var root = el.getRootNode();\n\n    if ((root instanceof Document || root instanceof ShadowRoot) && root.getSelection != null) {\n      return root;\n    }\n\n    return el.ownerDocument;\n  },\n  findEventRange: (editor, event) => {\n    if ('nativeEvent' in event) {\n      event = event.nativeEvent;\n    }\n\n    var {\n      clientX: x,\n      clientY: y,\n      target\n    } = event;\n\n    if (x == null || y == null) {\n      throw new Error(\"Cannot resolve a Slate range from a DOM event: \".concat(event));\n    }\n\n    var node = ReactEditor.toSlateNode(editor, event.target);\n    var path = ReactEditor.findPath(editor, node); // If the drop target is inside a void node, move it into either the\n    // next or previous node, depending on which side the `x` and `y`\n    // coordinates are closest to.\n\n    if (Element$1.isElement(node) && Editor.isVoid(editor, node)) {\n      var rect = target.getBoundingClientRect();\n      var isPrev = editor.isInline(node) ? x - rect.left < rect.left + rect.width - x : y - rect.top < rect.top + rect.height - y;\n      var edge = Editor.point(editor, path, {\n        edge: isPrev ? 'start' : 'end'\n      });\n      var point = isPrev ? Editor.before(editor, edge) : Editor.after(editor, edge);\n\n      if (point) {\n        var _range = Editor.range(editor, point);\n\n        return _range;\n      }\n    } // Else resolve a range from the caret position where the drop occured.\n\n\n    var domRange;\n    var {\n      document\n    } = ReactEditor.getWindow(editor); // COMPAT: In Firefox, `caretRangeFromPoint` doesn't exist. (2016/07/25)\n\n    if (document.caretRangeFromPoint) {\n      domRange = document.caretRangeFromPoint(x, y);\n    } else {\n      var position = document.caretPositionFromPoint(x, y);\n\n      if (position) {\n        domRange = document.createRange();\n        domRange.setStart(position.offsetNode, position.offset);\n        domRange.setEnd(position.offsetNode, position.offset);\n      }\n    }\n\n    if (!domRange) {\n      throw new Error(\"Cannot resolve a Slate range from a DOM event: \".concat(event));\n    } // Resolve a Slate range from the DOM range.\n\n\n    var range = ReactEditor.toSlateRange(editor, domRange, {\n      exactMatch: false,\n      suppressThrow: false\n    });\n    return range;\n  },\n  findKey: (editor, node) => {\n    var key = NODE_TO_KEY.get(node);\n\n    if (!key) {\n      key = new Key();\n      NODE_TO_KEY.set(node, key);\n    }\n\n    return key;\n  },\n  findPath: (editor, node) => {\n    var path = [];\n    var child = node;\n\n    while (true) {\n      var parent = NODE_TO_PARENT.get(child);\n\n      if (parent == null) {\n        if (Editor.isEditor(child)) {\n          return path;\n        } else {\n          break;\n        }\n      }\n\n      var i = NODE_TO_INDEX.get(child);\n\n      if (i == null) {\n        break;\n      }\n\n      path.unshift(i);\n      child = parent;\n    }\n\n    throw new Error(\"Unable to find the path for Slate node: \".concat(Scrubber.stringify(node)));\n  },\n  focus: editor => {\n    var el = ReactEditor.toDOMNode(editor, editor);\n    var root = ReactEditor.findDocumentOrShadowRoot(editor);\n    IS_FOCUSED.set(editor, true);\n\n    if (root.activeElement !== el) {\n      el.focus({\n        preventScroll: true\n      });\n    }\n  },\n  getWindow: editor => {\n    var window = EDITOR_TO_WINDOW.get(editor);\n\n    if (!window) {\n      throw new Error('Unable to find a host window element for this editor');\n    }\n\n    return window;\n  },\n  hasDOMNode: function hasDOMNode(editor, target) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var {\n      editable = false\n    } = options;\n    var editorEl = ReactEditor.toDOMNode(editor, editor);\n    var targetEl; // COMPAT: In Firefox, reading `target.nodeType` will throw an error if\n    // target is originating from an internal \"restricted\" element (e.g. a\n    // stepper arrow on a number input). (2018/05/04)\n    // https://github.com/ianstormtaylor/slate/issues/1819\n\n    try {\n      targetEl = isDOMElement(target) ? target : target.parentElement;\n    } catch (err) {\n      if (!err.message.includes('Permission denied to access property \"nodeType\"')) {\n        throw err;\n      }\n    }\n\n    if (!targetEl) {\n      return false;\n    }\n\n    return targetEl.closest(\"[data-slate-editor]\") === editorEl && (!editable || targetEl.isContentEditable ? true : typeof targetEl.isContentEditable === 'boolean' && // isContentEditable exists only on HTMLElement, and on other nodes it will be undefined\n    // this is the core logic that lets you know you got the right editor.selection instead of null when editor is contenteditable=\"false\"(readOnly)\n    targetEl.closest('[contenteditable=\"false\"]') === editorEl || !!targetEl.getAttribute('data-slate-zero-width'));\n  },\n  hasEditableTarget: (editor, target) => isDOMNode(target) && ReactEditor.hasDOMNode(editor, target, {\n    editable: true\n  }),\n  hasRange: (editor, range) => {\n    var {\n      anchor,\n      focus\n    } = range;\n    return Editor.hasPath(editor, anchor.path) && Editor.hasPath(editor, focus.path);\n  },\n  hasSelectableTarget: (editor, target) => ReactEditor.hasEditableTarget(editor, target) || ReactEditor.isTargetInsideNonReadonlyVoid(editor, target),\n  hasTarget: (editor, target) => isDOMNode(target) && ReactEditor.hasDOMNode(editor, target),\n  insertData: (editor, data) => {\n    editor.insertData(data);\n  },\n  insertFragmentData: (editor, data) => editor.insertFragmentData(data),\n  insertTextData: (editor, data) => editor.insertTextData(data),\n  isComposing: editor => {\n    return !!IS_COMPOSING.get(editor);\n  },\n  isFocused: editor => !!IS_FOCUSED.get(editor),\n  isReadOnly: editor => !!IS_READ_ONLY.get(editor),\n  isTargetInsideNonReadonlyVoid: (editor, target) => {\n    if (IS_READ_ONLY.get(editor)) return false;\n    var slateNode = ReactEditor.hasTarget(editor, target) && ReactEditor.toSlateNode(editor, target);\n    return Element$1.isElement(slateNode) && Editor.isVoid(editor, slateNode);\n  },\n  setFragmentData: (editor, data, originEvent) => editor.setFragmentData(data, originEvent),\n  toDOMNode: (editor, node) => {\n    var KEY_TO_ELEMENT = EDITOR_TO_KEY_TO_ELEMENT.get(editor);\n    var domNode = Editor.isEditor(node) ? EDITOR_TO_ELEMENT.get(editor) : KEY_TO_ELEMENT === null || KEY_TO_ELEMENT === void 0 ? void 0 : KEY_TO_ELEMENT.get(ReactEditor.findKey(editor, node));\n\n    if (!domNode) {\n      throw new Error(\"Cannot resolve a DOM node from Slate node: \".concat(Scrubber.stringify(node)));\n    }\n\n    return domNode;\n  },\n  toDOMPoint: (editor, point) => {\n    var [node] = Editor.node(editor, point.path);\n    var el = ReactEditor.toDOMNode(editor, node);\n    var domPoint; // If we're inside a void node, force the offset to 0, otherwise the zero\n    // width spacing character will result in an incorrect offset of 1\n\n    if (Editor.void(editor, {\n      at: point\n    })) {\n      point = {\n        path: point.path,\n        offset: 0\n      };\n    } // For each leaf, we need to isolate its content, which means filtering\n    // to its direct text and zero-width spans. (We have to filter out any\n    // other siblings that may have been rendered alongside them.)\n\n\n    var selector = \"[data-slate-string], [data-slate-zero-width]\";\n    var texts = Array.from(el.querySelectorAll(selector));\n    var start = 0;\n\n    for (var i = 0; i < texts.length; i++) {\n      var text = texts[i];\n      var domNode = text.childNodes[0];\n\n      if (domNode == null || domNode.textContent == null) {\n        continue;\n      }\n\n      var {\n        length\n      } = domNode.textContent;\n      var attr = text.getAttribute('data-slate-length');\n      var trueLength = attr == null ? length : parseInt(attr, 10);\n      var end = start + trueLength; // Prefer putting the selection inside the mark placeholder to ensure\n      // composed text is displayed with the correct marks.\n\n      var nextText = texts[i + 1];\n\n      if (point.offset === end && nextText !== null && nextText !== void 0 && nextText.hasAttribute('data-slate-mark-placeholder')) {\n        var _nextText$textContent;\n\n        var domText = nextText.childNodes[0];\n        domPoint = [// COMPAT: If we don't explicity set the dom point to be on the actual\n        // dom text element, chrome will put the selection behind the actual dom\n        // text element, causing domRange.getBoundingClientRect() calls on a collapsed\n        // selection to return incorrect zero values (https://bugs.chromium.org/p/chromium/issues/detail?id=435438)\n        // which will cause issues when scrolling to it.\n        domText instanceof DOMText ? domText : nextText, (_nextText$textContent = nextText.textContent) !== null && _nextText$textContent !== void 0 && _nextText$textContent.startsWith('\\uFEFF') ? 1 : 0];\n        break;\n      }\n\n      if (point.offset <= end) {\n        var offset = Math.min(length, Math.max(0, point.offset - start));\n        domPoint = [domNode, offset];\n        break;\n      }\n\n      start = end;\n    }\n\n    if (!domPoint) {\n      throw new Error(\"Cannot resolve a DOM point from Slate point: \".concat(Scrubber.stringify(point)));\n    }\n\n    return domPoint;\n  },\n  toDOMRange: (editor, range) => {\n    var {\n      anchor,\n      focus\n    } = range;\n    var isBackward = Range.isBackward(range);\n    var domAnchor = ReactEditor.toDOMPoint(editor, anchor);\n    var domFocus = Range.isCollapsed(range) ? domAnchor : ReactEditor.toDOMPoint(editor, focus);\n    var window = ReactEditor.getWindow(editor);\n    var domRange = window.document.createRange();\n    var [startNode, startOffset] = isBackward ? domFocus : domAnchor;\n    var [endNode, endOffset] = isBackward ? domAnchor : domFocus; // A slate Point at zero-width Leaf always has an offset of 0 but a native DOM selection at\n    // zero-width node has an offset of 1 so we have to check if we are in a zero-width node and\n    // adjust the offset accordingly.\n\n    var startEl = isDOMElement(startNode) ? startNode : startNode.parentElement;\n    var isStartAtZeroWidth = !!startEl.getAttribute('data-slate-zero-width');\n    var endEl = isDOMElement(endNode) ? endNode : endNode.parentElement;\n    var isEndAtZeroWidth = !!endEl.getAttribute('data-slate-zero-width');\n    domRange.setStart(startNode, isStartAtZeroWidth ? 1 : startOffset);\n    domRange.setEnd(endNode, isEndAtZeroWidth ? 1 : endOffset);\n    return domRange;\n  },\n  toSlateNode: (editor, domNode) => {\n    var domEl = isDOMElement(domNode) ? domNode : domNode.parentElement;\n\n    if (domEl && !domEl.hasAttribute('data-slate-node')) {\n      domEl = domEl.closest(\"[data-slate-node]\");\n    }\n\n    var node = domEl ? ELEMENT_TO_NODE.get(domEl) : null;\n\n    if (!node) {\n      throw new Error(\"Cannot resolve a Slate node from DOM node: \".concat(domEl));\n    }\n\n    return node;\n  },\n  toSlatePoint: (editor, domPoint, options) => {\n    var {\n      exactMatch,\n      suppressThrow\n    } = options;\n    var [nearestNode, nearestOffset] = exactMatch ? domPoint : normalizeDOMPoint(domPoint);\n    var parentNode = nearestNode.parentNode;\n    var textNode = null;\n    var offset = 0;\n\n    if (parentNode) {\n      var _domNode$textContent, _domNode$textContent2;\n\n      var editorEl = ReactEditor.toDOMNode(editor, editor);\n      var potentialVoidNode = parentNode.closest('[data-slate-void=\"true\"]'); // Need to ensure that the closest void node is actually a void node\n      // within this editor, and not a void node within some parent editor. This can happen\n      // if this editor is within a void node of another editor (\"nested editors\", like in\n      // the \"Editable Voids\" example on the docs site).\n\n      var voidNode = potentialVoidNode && editorEl.contains(potentialVoidNode) ? potentialVoidNode : null;\n      var leafNode = parentNode.closest('[data-slate-leaf]');\n      var domNode = null; // Calculate how far into the text node the `nearestNode` is, so that we\n      // can determine what the offset relative to the text node is.\n\n      if (leafNode) {\n        textNode = leafNode.closest('[data-slate-node=\"text\"]');\n\n        if (textNode) {\n          var window = ReactEditor.getWindow(editor);\n          var range = window.document.createRange();\n          range.setStart(textNode, 0);\n          range.setEnd(nearestNode, nearestOffset);\n          var contents = range.cloneContents();\n          var removals = [...Array.prototype.slice.call(contents.querySelectorAll('[data-slate-zero-width]')), ...Array.prototype.slice.call(contents.querySelectorAll('[contenteditable=false]'))];\n          removals.forEach(el => {\n            // COMPAT: While composing at the start of a text node, some keyboards put\n            // the text content inside the zero width space.\n            if (IS_ANDROID && !exactMatch && el.hasAttribute('data-slate-zero-width') && el.textContent.length > 0 && el.textContext !== '\\uFEFF') {\n              if (el.textContent.startsWith('\\uFEFF')) {\n                el.textContent = el.textContent.slice(1);\n              }\n\n              return;\n            }\n\n            el.parentNode.removeChild(el);\n          }); // COMPAT: Edge has a bug where Range.prototype.toString() will\n          // convert \\n into \\r\\n. The bug causes a loop when slate-react\n          // attempts to reposition its cursor to match the native position. Use\n          // textContent.length instead.\n          // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/10291116/\n\n          offset = contents.textContent.length;\n          domNode = textNode;\n        }\n      } else if (voidNode) {\n        // For void nodes, the element with the offset key will be a cousin, not an\n        // ancestor, so find it by going down from the nearest void parent and taking the\n        // first one that isn't inside a nested editor.\n        var leafNodes = voidNode.querySelectorAll('[data-slate-leaf]');\n\n        for (var index = 0; index < leafNodes.length; index++) {\n          var current = leafNodes[index];\n\n          if (ReactEditor.hasDOMNode(editor, current)) {\n            leafNode = current;\n            break;\n          }\n        } // COMPAT: In read-only editors the leaf is not rendered.\n\n\n        if (!leafNode) {\n          offset = 1;\n        } else {\n          textNode = leafNode.closest('[data-slate-node=\"text\"]');\n          domNode = leafNode;\n          offset = domNode.textContent.length;\n          domNode.querySelectorAll('[data-slate-zero-width]').forEach(el => {\n            offset -= el.textContent.length;\n          });\n        }\n      }\n\n      if (domNode && offset === domNode.textContent.length && // COMPAT: Android IMEs might remove the zero width space while composing,\n      // and we don't add it for line-breaks.\n      IS_ANDROID && domNode.getAttribute('data-slate-zero-width') === 'z' && (_domNode$textContent = domNode.textContent) !== null && _domNode$textContent !== void 0 && _domNode$textContent.startsWith('\\uFEFF') && (parentNode.hasAttribute('data-slate-zero-width') || IS_FIREFOX && (_domNode$textContent2 = domNode.textContent) !== null && _domNode$textContent2 !== void 0 && _domNode$textContent2.endsWith('\\n\\n'))) {\n        offset--;\n      }\n    }\n\n    if (IS_ANDROID && !textNode && !exactMatch) {\n      var node = parentNode.hasAttribute('data-slate-node') ? parentNode : parentNode.closest('[data-slate-node]');\n\n      if (node && ReactEditor.hasDOMNode(editor, node, {\n        editable: true\n      })) {\n        var _slateNode = ReactEditor.toSlateNode(editor, node);\n\n        var {\n          path: _path,\n          offset: _offset\n        } = Editor.start(editor, ReactEditor.findPath(editor, _slateNode));\n\n        if (!node.querySelector('[data-slate-leaf]')) {\n          _offset = nearestOffset;\n        }\n\n        return {\n          path: _path,\n          offset: _offset\n        };\n      }\n    }\n\n    if (!textNode) {\n      if (suppressThrow) {\n        return null;\n      }\n\n      throw new Error(\"Cannot resolve a Slate point from DOM point: \".concat(domPoint));\n    } // COMPAT: If someone is clicking from one Slate editor into another,\n    // the select event fires twice, once for the old editor's `element`\n    // first, and then afterwards for the correct `element`. (2017/03/03)\n\n\n    var slateNode = ReactEditor.toSlateNode(editor, textNode);\n    var path = ReactEditor.findPath(editor, slateNode);\n    return {\n      path,\n      offset\n    };\n  },\n  toSlateRange: (editor, domRange, options) => {\n    var {\n      exactMatch,\n      suppressThrow\n    } = options;\n    var el = isDOMSelection(domRange) ? domRange.anchorNode : domRange.startContainer;\n    var anchorNode;\n    var anchorOffset;\n    var focusNode;\n    var focusOffset;\n    var isCollapsed;\n\n    if (el) {\n      if (isDOMSelection(domRange)) {\n        // COMPAT: In firefox the normal seletion way does not work\n        // (https://github.com/ianstormtaylor/slate/pull/5486#issue-1820720223)\n        if (IS_FIREFOX && domRange.rangeCount > 1) {\n          focusNode = domRange.focusNode; // Focus node works fine\n\n          var firstRange = domRange.getRangeAt(0);\n          var lastRange = domRange.getRangeAt(domRange.rangeCount - 1); // Here we are in the contenteditable mode of a table in firefox\n\n          if (focusNode instanceof HTMLTableRowElement && firstRange.startContainer instanceof HTMLTableRowElement && lastRange.startContainer instanceof HTMLTableRowElement) {\n            // HTMLElement, becouse Element is a slate element\n            function getLastChildren(element) {\n              if (element.childElementCount > 0) {\n                return getLastChildren(element.children[0]);\n              } else {\n                return element;\n              }\n            }\n\n            var firstNodeRow = firstRange.startContainer;\n            var lastNodeRow = lastRange.startContainer; // This should never fail as \"The HTMLElement interface represents any HTML element.\"\n\n            var firstNode = getLastChildren(firstNodeRow.children[firstRange.startOffset]);\n            var lastNode = getLastChildren(lastNodeRow.children[lastRange.startOffset]); // Zero, as we allways take the right one as the anchor point\n\n            focusOffset = 0;\n\n            if (lastNode.childNodes.length > 0) {\n              anchorNode = lastNode.childNodes[0];\n            } else {\n              anchorNode = lastNode;\n            }\n\n            if (firstNode.childNodes.length > 0) {\n              focusNode = firstNode.childNodes[0];\n            } else {\n              focusNode = firstNode;\n            }\n\n            if (lastNode instanceof HTMLElement) {\n              anchorOffset = lastNode.innerHTML.length;\n            } else {\n              // Fallback option\n              anchorOffset = 0;\n            }\n          } else {\n            // This is the read only mode of a firefox table\n            // Right to left\n            if (firstRange.startContainer === focusNode) {\n              anchorNode = lastRange.endContainer;\n              anchorOffset = lastRange.endOffset;\n              focusOffset = firstRange.startOffset;\n            } else {\n              // Left to right\n              anchorNode = firstRange.startContainer;\n              anchorOffset = firstRange.endOffset;\n              focusOffset = lastRange.startOffset;\n            }\n          }\n        } else {\n          anchorNode = domRange.anchorNode;\n          anchorOffset = domRange.anchorOffset;\n          focusNode = domRange.focusNode;\n          focusOffset = domRange.focusOffset;\n        } // COMPAT: There's a bug in chrome that always returns `true` for\n        // `isCollapsed` for a Selection that comes from a ShadowRoot.\n        // (2020/08/08)\n        // https://bugs.chromium.org/p/chromium/issues/detail?id=447523\n        // IsCollapsed might not work in firefox, but this will\n\n\n        if (IS_CHROME && hasShadowRoot(anchorNode) || IS_FIREFOX) {\n          isCollapsed = domRange.anchorNode === domRange.focusNode && domRange.anchorOffset === domRange.focusOffset;\n        } else {\n          isCollapsed = domRange.isCollapsed;\n        }\n      } else {\n        anchorNode = domRange.startContainer;\n        anchorOffset = domRange.startOffset;\n        focusNode = domRange.endContainer;\n        focusOffset = domRange.endOffset;\n        isCollapsed = domRange.collapsed;\n      }\n    }\n\n    if (anchorNode == null || focusNode == null || anchorOffset == null || focusOffset == null) {\n      throw new Error(\"Cannot resolve a Slate range from DOM range: \".concat(domRange));\n    } // COMPAT: Triple-clicking a word in chrome will sometimes place the focus\n    // inside a `contenteditable=\"false\"` DOM node following the word, which\n    // will cause `toSlatePoint` to throw an error. (2023/03/07)\n\n\n    if ('getAttribute' in focusNode && focusNode.getAttribute('contenteditable') === 'false' && focusNode.getAttribute('data-slate-void') !== 'true') {\n      var _anchorNode$textConte;\n\n      focusNode = anchorNode;\n      focusOffset = ((_anchorNode$textConte = anchorNode.textContent) === null || _anchorNode$textConte === void 0 ? void 0 : _anchorNode$textConte.length) || 0;\n    }\n\n    var anchor = ReactEditor.toSlatePoint(editor, [anchorNode, anchorOffset], {\n      exactMatch,\n      suppressThrow\n    });\n\n    if (!anchor) {\n      return null;\n    }\n\n    var focus = isCollapsed ? anchor : ReactEditor.toSlatePoint(editor, [focusNode, focusOffset], {\n      exactMatch,\n      suppressThrow\n    });\n\n    if (!focus) {\n      return null;\n    }\n\n    var range = {\n      anchor: anchor,\n      focus: focus\n    }; // if the selection is a hanging range that ends in a void\n    // and the DOM focus is an Element\n    // (meaning that the selection ends before the element)\n    // unhang the range to avoid mistakenly including the void\n\n    if (Range.isExpanded(range) && Range.isForward(range) && isDOMElement(focusNode) && Editor.void(editor, {\n      at: range.focus,\n      mode: 'highest'\n    })) {\n      range = Editor.unhangRange(editor, range, {\n        voids: true\n      });\n    }\n\n    return range;\n  }\n};\n\n/**\r\n * Check whether a text diff was applied in a way we can perform the pending action on /\r\n * recover the pending selection.\r\n */\n\nfunction verifyDiffState(editor, textDiff) {\n  var {\n    path,\n    diff\n  } = textDiff;\n\n  if (!Editor.hasPath(editor, path)) {\n    return false;\n  }\n\n  var node = Node.get(editor, path);\n\n  if (!Text$1.isText(node)) {\n    return false;\n  }\n\n  if (diff.start !== node.text.length || diff.text.length === 0) {\n    return node.text.slice(diff.start, diff.start + diff.text.length) === diff.text;\n  }\n\n  var nextPath = Path.next(path);\n\n  if (!Editor.hasPath(editor, nextPath)) {\n    return false;\n  }\n\n  var nextNode = Node.get(editor, nextPath);\n  return Text$1.isText(nextNode) && nextNode.text.startsWith(diff.text);\n}\nfunction applyStringDiff(text) {\n  for (var _len = arguments.length, diffs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    diffs[_key - 1] = arguments[_key];\n  }\n\n  return diffs.reduce((text, diff) => text.slice(0, diff.start) + diff.text + text.slice(diff.end), text);\n}\n\nfunction longestCommonPrefixLength(str, another) {\n  var length = Math.min(str.length, another.length);\n\n  for (var i = 0; i < length; i++) {\n    if (str.charAt(i) !== another.charAt(i)) {\n      return i;\n    }\n  }\n\n  return length;\n}\n\nfunction longestCommonSuffixLength(str, another, max) {\n  var length = Math.min(str.length, another.length, max);\n\n  for (var i = 0; i < length; i++) {\n    if (str.charAt(str.length - i - 1) !== another.charAt(another.length - i - 1)) {\n      return i;\n    }\n  }\n\n  return length;\n}\n/**\r\n * Remove redundant changes from the diff so that it spans the minimal possible range\r\n */\n\n\nfunction normalizeStringDiff(targetText, diff) {\n  var {\n    start,\n    end,\n    text\n  } = diff;\n  var removedText = targetText.slice(start, end);\n  var prefixLength = longestCommonPrefixLength(removedText, text);\n  var max = Math.min(removedText.length - prefixLength, text.length - prefixLength);\n  var suffixLength = longestCommonSuffixLength(removedText, text, max);\n  var normalized = {\n    start: start + prefixLength,\n    end: end - suffixLength,\n    text: text.slice(prefixLength, text.length - suffixLength)\n  };\n\n  if (normalized.start === normalized.end && normalized.text.length === 0) {\n    return null;\n  }\n\n  return normalized;\n}\n/**\r\n * Return a string diff that is equivalent to applying b after a spanning the range of\r\n * both changes\r\n */\n\nfunction mergeStringDiffs(targetText, a, b) {\n  var start = Math.min(a.start, b.start);\n  var overlap = Math.max(0, Math.min(a.start + a.text.length, b.end) - b.start);\n  var applied = applyStringDiff(targetText, a, b);\n  var sliceEnd = Math.max(b.start + b.text.length, a.start + a.text.length + (a.start + a.text.length > b.start ? b.text.length : 0) - overlap);\n  var text = applied.slice(start, sliceEnd);\n  var end = Math.max(a.end, b.end - a.text.length + (a.end - a.start));\n  return normalizeStringDiff(targetText, {\n    start,\n    end,\n    text\n  });\n}\n/**\r\n * Get the slate range the text diff spans.\r\n */\n\nfunction targetRange(textDiff) {\n  var {\n    path,\n    diff\n  } = textDiff;\n  return {\n    anchor: {\n      path,\n      offset: diff.start\n    },\n    focus: {\n      path,\n      offset: diff.end\n    }\n  };\n}\n/**\r\n * Normalize a 'pending point' a.k.a a point based on the dom state before applying\r\n * the pending diffs. Since the pending diffs might have been inserted with different\r\n * marks we have to 'walk' the offset from the starting position to ensure we still\r\n * have a valid point inside the document\r\n */\n\nfunction normalizePoint(editor, point) {\n  var {\n    path,\n    offset\n  } = point;\n\n  if (!Editor.hasPath(editor, path)) {\n    return null;\n  }\n\n  var leaf = Node.get(editor, path);\n\n  if (!Text$1.isText(leaf)) {\n    return null;\n  }\n\n  var parentBlock = Editor.above(editor, {\n    match: n => Element$1.isElement(n) && Editor.isBlock(editor, n),\n    at: path\n  });\n\n  if (!parentBlock) {\n    return null;\n  }\n\n  while (offset > leaf.text.length) {\n    var entry = Editor.next(editor, {\n      at: path,\n      match: Text$1.isText\n    });\n\n    if (!entry || !Path.isDescendant(entry[1], parentBlock[1])) {\n      return null;\n    }\n\n    offset -= leaf.text.length;\n    leaf = entry[0];\n    path = entry[1];\n  }\n\n  return {\n    path,\n    offset\n  };\n}\n/**\r\n * Normalize a 'pending selection' to ensure it's valid in the current document state.\r\n */\n\nfunction normalizeRange(editor, range) {\n  var anchor = normalizePoint(editor, range.anchor);\n\n  if (!anchor) {\n    return null;\n  }\n\n  if (Range.isCollapsed(range)) {\n    return {\n      anchor,\n      focus: anchor\n    };\n  }\n\n  var focus = normalizePoint(editor, range.focus);\n\n  if (!focus) {\n    return null;\n  }\n\n  return {\n    anchor,\n    focus\n  };\n}\nfunction transformPendingPoint(editor, point, op) {\n  var pendingDiffs = EDITOR_TO_PENDING_DIFFS.get(editor);\n  var textDiff = pendingDiffs === null || pendingDiffs === void 0 ? void 0 : pendingDiffs.find(_ref => {\n    var {\n      path\n    } = _ref;\n    return Path.equals(path, point.path);\n  });\n\n  if (!textDiff || point.offset <= textDiff.diff.start) {\n    return Point.transform(point, op, {\n      affinity: 'backward'\n    });\n  }\n\n  var {\n    diff\n  } = textDiff; // Point references location inside the diff => transform the point based on the location\n  // the diff will be applied to and add the offset inside the diff.\n\n  if (point.offset <= diff.start + diff.text.length) {\n    var _anchor = {\n      path: point.path,\n      offset: diff.start\n    };\n\n    var _transformed = Point.transform(_anchor, op, {\n      affinity: 'backward'\n    });\n\n    if (!_transformed) {\n      return null;\n    }\n\n    return {\n      path: _transformed.path,\n      offset: _transformed.offset + point.offset - diff.start\n    };\n  } // Point references location after the diff\n\n\n  var anchor = {\n    path: point.path,\n    offset: point.offset - diff.text.length + diff.end - diff.start\n  };\n  var transformed = Point.transform(anchor, op, {\n    affinity: 'backward'\n  });\n\n  if (!transformed) {\n    return null;\n  }\n\n  if (op.type === 'split_node' && Path.equals(op.path, point.path) && anchor.offset < op.position && diff.start < op.position) {\n    return transformed;\n  }\n\n  return {\n    path: transformed.path,\n    offset: transformed.offset + diff.text.length - diff.end + diff.start\n  };\n}\nfunction transformPendingRange(editor, range, op) {\n  var anchor = transformPendingPoint(editor, range.anchor, op);\n\n  if (!anchor) {\n    return null;\n  }\n\n  if (Range.isCollapsed(range)) {\n    return {\n      anchor,\n      focus: anchor\n    };\n  }\n\n  var focus = transformPendingPoint(editor, range.focus, op);\n\n  if (!focus) {\n    return null;\n  }\n\n  return {\n    anchor,\n    focus\n  };\n}\nfunction transformTextDiff(textDiff, op) {\n  var {\n    path,\n    diff,\n    id\n  } = textDiff;\n\n  switch (op.type) {\n    case 'insert_text':\n      {\n        if (!Path.equals(op.path, path) || op.offset >= diff.end) {\n          return textDiff;\n        }\n\n        if (op.offset <= diff.start) {\n          return {\n            diff: {\n              start: op.text.length + diff.start,\n              end: op.text.length + diff.end,\n              text: diff.text\n            },\n            id,\n            path\n          };\n        }\n\n        return {\n          diff: {\n            start: diff.start,\n            end: diff.end + op.text.length,\n            text: diff.text\n          },\n          id,\n          path\n        };\n      }\n\n    case 'remove_text':\n      {\n        if (!Path.equals(op.path, path) || op.offset >= diff.end) {\n          return textDiff;\n        }\n\n        if (op.offset + op.text.length <= diff.start) {\n          return {\n            diff: {\n              start: diff.start - op.text.length,\n              end: diff.end - op.text.length,\n              text: diff.text\n            },\n            id,\n            path\n          };\n        }\n\n        return {\n          diff: {\n            start: diff.start,\n            end: diff.end - op.text.length,\n            text: diff.text\n          },\n          id,\n          path\n        };\n      }\n\n    case 'split_node':\n      {\n        if (!Path.equals(op.path, path) || op.position >= diff.end) {\n          return {\n            diff,\n            id,\n            path: Path.transform(path, op, {\n              affinity: 'backward'\n            })\n          };\n        }\n\n        if (op.position > diff.start) {\n          return {\n            diff: {\n              start: diff.start,\n              end: Math.min(op.position, diff.end),\n              text: diff.text\n            },\n            id,\n            path\n          };\n        }\n\n        return {\n          diff: {\n            start: diff.start - op.position,\n            end: diff.end - op.position,\n            text: diff.text\n          },\n          id,\n          path: Path.transform(path, op, {\n            affinity: 'forward'\n          })\n        };\n      }\n\n    case 'merge_node':\n      {\n        if (!Path.equals(op.path, path)) {\n          return {\n            diff,\n            id,\n            path: Path.transform(path, op)\n          };\n        }\n\n        return {\n          diff: {\n            start: diff.start + op.position,\n            end: diff.end + op.position,\n            text: diff.text\n          },\n          id,\n          path: Path.transform(path, op)\n        };\n      }\n  }\n\n  var newPath = Path.transform(path, op);\n\n  if (!newPath) {\n    return null;\n  }\n\n  return {\n    diff,\n    path: newPath,\n    id\n  };\n}\n\nfunction ownKeys$3(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$3(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$3(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n// When using keyboard English association function, conpositionEnd triggered too fast, resulting in after `insertText` still maintain association state.\n\nvar RESOLVE_DELAY = 25; // Time with no user interaction before the current user action is considered as done.\n\nvar FLUSH_DELAY = 200; // Replace with `const debug = console.log` to debug\n\nvar debug = function debug() {}; // Type guard to check if a value is a DataTransfer\n\n\nvar isDataTransfer = value => (value === null || value === void 0 ? void 0 : value.constructor.name) === 'DataTransfer';\n\nfunction createAndroidInputManager(_ref) {\n  var {\n    editor,\n    scheduleOnDOMSelectionChange,\n    onDOMSelectionChange\n  } = _ref;\n  var flushing = false;\n  var compositionEndTimeoutId = null;\n  var flushTimeoutId = null;\n  var actionTimeoutId = null;\n  var idCounter = 0;\n  var insertPositionHint = false;\n\n  var applyPendingSelection = () => {\n    var pendingSelection = EDITOR_TO_PENDING_SELECTION.get(editor);\n    EDITOR_TO_PENDING_SELECTION.delete(editor);\n\n    if (pendingSelection) {\n      var {\n        selection\n      } = editor;\n      var normalized = normalizeRange(editor, pendingSelection);\n\n      if (normalized && (!selection || !Range.equals(normalized, selection))) {\n        Transforms.select(editor, normalized);\n      }\n    }\n  };\n\n  var performAction = () => {\n    var action = EDITOR_TO_PENDING_ACTION.get(editor);\n    EDITOR_TO_PENDING_ACTION.delete(editor);\n\n    if (!action) {\n      return;\n    }\n\n    if (action.at) {\n      var target = Point.isPoint(action.at) ? normalizePoint(editor, action.at) : normalizeRange(editor, action.at);\n\n      if (!target) {\n        return;\n      }\n\n      var _targetRange = Editor.range(editor, target);\n\n      if (!editor.selection || !Range.equals(editor.selection, _targetRange)) {\n        Transforms.select(editor, target);\n      }\n    }\n\n    action.run();\n  };\n\n  var flush = () => {\n    if (flushTimeoutId) {\n      clearTimeout(flushTimeoutId);\n      flushTimeoutId = null;\n    }\n\n    if (actionTimeoutId) {\n      clearTimeout(actionTimeoutId);\n      actionTimeoutId = null;\n    }\n\n    if (!hasPendingDiffs() && !hasPendingAction()) {\n      applyPendingSelection();\n      return;\n    }\n\n    if (!flushing) {\n      flushing = true;\n      setTimeout(() => flushing = false);\n    }\n\n    if (hasPendingAction()) {\n      flushing = 'action';\n    }\n\n    var selectionRef = editor.selection && Editor.rangeRef(editor, editor.selection, {\n      affinity: 'forward'\n    });\n    EDITOR_TO_USER_MARKS.set(editor, editor.marks);\n    debug('flush', EDITOR_TO_PENDING_ACTION.get(editor), EDITOR_TO_PENDING_DIFFS.get(editor));\n    var scheduleSelectionChange = hasPendingDiffs();\n    var diff;\n\n    while (diff = (_EDITOR_TO_PENDING_DI = EDITOR_TO_PENDING_DIFFS.get(editor)) === null || _EDITOR_TO_PENDING_DI === void 0 ? void 0 : _EDITOR_TO_PENDING_DI[0]) {\n      var _EDITOR_TO_PENDING_DI, _EDITOR_TO_PENDING_DI2;\n\n      var pendingMarks = EDITOR_TO_PENDING_INSERTION_MARKS.get(editor);\n\n      if (pendingMarks !== undefined) {\n        EDITOR_TO_PENDING_INSERTION_MARKS.delete(editor);\n        editor.marks = pendingMarks;\n      }\n\n      if (pendingMarks && insertPositionHint === false) {\n        insertPositionHint = null;\n      }\n\n      var range = targetRange(diff);\n\n      if (!editor.selection || !Range.equals(editor.selection, range)) {\n        Transforms.select(editor, range);\n      }\n\n      if (diff.diff.text) {\n        Editor.insertText(editor, diff.diff.text);\n      } else {\n        Editor.deleteFragment(editor);\n      } // Remove diff only after we have applied it to account for it when transforming\n      // pending ranges.\n\n\n      EDITOR_TO_PENDING_DIFFS.set(editor, (_EDITOR_TO_PENDING_DI2 = EDITOR_TO_PENDING_DIFFS.get(editor)) === null || _EDITOR_TO_PENDING_DI2 === void 0 ? void 0 : _EDITOR_TO_PENDING_DI2.filter(_ref2 => {\n        var {\n          id\n        } = _ref2;\n        return id !== diff.id;\n      }));\n\n      if (!verifyDiffState(editor, diff)) {\n        scheduleSelectionChange = false;\n        EDITOR_TO_PENDING_ACTION.delete(editor);\n        EDITOR_TO_USER_MARKS.delete(editor);\n        flushing = 'action'; // Ensure we don't restore the pending user (dom) selection\n        // since the document and dom state do not match.\n\n        EDITOR_TO_PENDING_SELECTION.delete(editor);\n        scheduleOnDOMSelectionChange.cancel();\n        onDOMSelectionChange.cancel();\n        selectionRef === null || selectionRef === void 0 ? void 0 : selectionRef.unref();\n      }\n    }\n\n    var selection = selectionRef === null || selectionRef === void 0 ? void 0 : selectionRef.unref();\n\n    if (selection && !EDITOR_TO_PENDING_SELECTION.get(editor) && (!editor.selection || !Range.equals(selection, editor.selection))) {\n      Transforms.select(editor, selection);\n    }\n\n    if (hasPendingAction()) {\n      performAction();\n      return;\n    } // COMPAT: The selectionChange event is fired after the action is performed,\n    // so we have to manually schedule it to ensure we don't 'throw away' the selection\n    // while rendering if we have pending changes.\n\n\n    if (scheduleSelectionChange) {\n      scheduleOnDOMSelectionChange();\n    }\n\n    scheduleOnDOMSelectionChange.flush();\n    onDOMSelectionChange.flush();\n    applyPendingSelection();\n    var userMarks = EDITOR_TO_USER_MARKS.get(editor);\n    EDITOR_TO_USER_MARKS.delete(editor);\n\n    if (userMarks !== undefined) {\n      editor.marks = userMarks;\n      editor.onChange();\n    }\n  };\n\n  var handleCompositionEnd = _event => {\n    if (compositionEndTimeoutId) {\n      clearTimeout(compositionEndTimeoutId);\n    }\n\n    compositionEndTimeoutId = setTimeout(() => {\n      IS_COMPOSING.set(editor, false);\n      flush();\n    }, RESOLVE_DELAY);\n  };\n\n  var handleCompositionStart = _event => {\n    IS_COMPOSING.set(editor, true);\n\n    if (compositionEndTimeoutId) {\n      clearTimeout(compositionEndTimeoutId);\n      compositionEndTimeoutId = null;\n    }\n  };\n\n  var updatePlaceholderVisibility = function updatePlaceholderVisibility() {\n    var forceHide = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n    var placeholderElement = EDITOR_TO_PLACEHOLDER_ELEMENT.get(editor);\n\n    if (!placeholderElement) {\n      return;\n    }\n\n    if (hasPendingDiffs() || forceHide) {\n      placeholderElement.style.display = 'none';\n      return;\n    }\n\n    placeholderElement.style.removeProperty('display');\n  };\n\n  var storeDiff = (path, diff) => {\n    var _EDITOR_TO_PENDING_DI3;\n    var pendingDiffs = (_EDITOR_TO_PENDING_DI3 = EDITOR_TO_PENDING_DIFFS.get(editor)) !== null && _EDITOR_TO_PENDING_DI3 !== void 0 ? _EDITOR_TO_PENDING_DI3 : [];\n    EDITOR_TO_PENDING_DIFFS.set(editor, pendingDiffs);\n    var target = Node.leaf(editor, path);\n    var idx = pendingDiffs.findIndex(change => Path.equals(change.path, path));\n\n    if (idx < 0) {\n      var normalized = normalizeStringDiff(target.text, diff);\n\n      if (normalized) {\n        pendingDiffs.push({\n          path,\n          diff,\n          id: idCounter++\n        });\n      }\n\n      updatePlaceholderVisibility();\n      return;\n    }\n\n    var merged = mergeStringDiffs(target.text, pendingDiffs[idx].diff, diff);\n\n    if (!merged) {\n      pendingDiffs.splice(idx, 1);\n      updatePlaceholderVisibility();\n      return;\n    }\n\n    pendingDiffs[idx] = _objectSpread$3(_objectSpread$3({}, pendingDiffs[idx]), {}, {\n      diff: merged\n    });\n  };\n\n  var scheduleAction = function scheduleAction(run) {\n    var {\n      at\n    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    insertPositionHint = false;\n    EDITOR_TO_PENDING_SELECTION.delete(editor);\n    scheduleOnDOMSelectionChange.cancel();\n    onDOMSelectionChange.cancel();\n\n    if (hasPendingAction()) {\n      flush();\n    }\n\n    EDITOR_TO_PENDING_ACTION.set(editor, {\n      at,\n      run\n    }); // COMPAT: When deleting before a non-contenteditable element chrome only fires a beforeinput,\n    // (no input) and doesn't perform any dom mutations. Without a flush timeout we would never flush\n    // in this case and thus never actually perform the action.\n\n    actionTimeoutId = setTimeout(flush);\n  };\n\n  var handleDOMBeforeInput = event => {\n    var _targetRange2;\n\n    if (flushTimeoutId) {\n      clearTimeout(flushTimeoutId);\n      flushTimeoutId = null;\n    }\n\n    var {\n      inputType: type\n    } = event;\n    var targetRange = null;\n    var data = event.dataTransfer || event.data || undefined;\n\n    if (insertPositionHint !== false && type !== 'insertText' && type !== 'insertCompositionText') {\n      insertPositionHint = false;\n    }\n\n    var [nativeTargetRange] = event.getTargetRanges();\n\n    if (nativeTargetRange) {\n      targetRange = ReactEditor.toSlateRange(editor, nativeTargetRange, {\n        exactMatch: false,\n        suppressThrow: true\n      });\n    } // COMPAT: SelectionChange event is fired after the action is performed, so we\n    // have to manually get the selection here to ensure it's up-to-date.\n\n\n    var window = ReactEditor.getWindow(editor);\n    var domSelection = window.getSelection();\n\n    if (!targetRange && domSelection) {\n      nativeTargetRange = domSelection;\n      targetRange = ReactEditor.toSlateRange(editor, domSelection, {\n        exactMatch: false,\n        suppressThrow: true\n      });\n    }\n\n    targetRange = (_targetRange2 = targetRange) !== null && _targetRange2 !== void 0 ? _targetRange2 : editor.selection;\n\n    if (!targetRange) {\n      return;\n    } // By default, the input manager tries to store text diffs so that we can\n    // defer flushing them at a later point in time. We don't want to flush\n    // for every input event as this can be expensive. However, there are some\n    // scenarios where we cannot safely store the text diff and must instead\n    // schedule an action to let Slate normalize the editor state.\n\n\n    var canStoreDiff = true;\n\n    if (type.startsWith('delete')) {\n      if (Range.isExpanded(targetRange)) {\n        var [_start, _end] = Range.edges(targetRange);\n\n        var _leaf = Node.leaf(editor, _start.path);\n\n        if (_leaf.text.length === _start.offset && _end.offset === 0) {\n          var next = Editor.next(editor, {\n            at: _start.path,\n            match: Text$1.isText\n          });\n\n          if (next && Path.equals(next[1], _end.path)) {\n            targetRange = {\n              anchor: _end,\n              focus: _end\n            };\n          }\n        }\n      }\n\n      var direction = type.endsWith('Backward') ? 'backward' : 'forward';\n      var [start, end] = Range.edges(targetRange);\n      var [leaf, path] = Editor.leaf(editor, start.path);\n      var diff = {\n        text: '',\n        start: start.offset,\n        end: end.offset\n      };\n      var pendingDiffs = EDITOR_TO_PENDING_DIFFS.get(editor);\n      var relevantPendingDiffs = pendingDiffs === null || pendingDiffs === void 0 ? void 0 : pendingDiffs.find(change => Path.equals(change.path, path));\n      var diffs = relevantPendingDiffs ? [relevantPendingDiffs.diff, diff] : [diff];\n      var text = applyStringDiff(leaf.text, ...diffs);\n\n      if (text.length === 0) {\n        // Text leaf will be removed, so we need to schedule an\n        // action to remove it so that Slate can normalize instead\n        // of storing as a diff\n        canStoreDiff = false;\n      }\n\n      if (Range.isExpanded(targetRange)) {\n        if (canStoreDiff && Path.equals(targetRange.anchor.path, targetRange.focus.path)) {\n          var point = {\n            path: targetRange.anchor.path,\n            offset: start.offset\n          };\n          var range = Editor.range(editor, point, point);\n          handleUserSelect(range);\n          return storeDiff(targetRange.anchor.path, {\n            text: '',\n            end: end.offset,\n            start: start.offset\n          });\n        }\n\n        return scheduleAction(() => Editor.deleteFragment(editor, {\n          direction\n        }), {\n          at: targetRange\n        });\n      }\n    }\n\n    switch (type) {\n      case 'deleteByComposition':\n      case 'deleteByCut':\n      case 'deleteByDrag':\n        {\n          return scheduleAction(() => Editor.deleteFragment(editor), {\n            at: targetRange\n          });\n        }\n\n      case 'deleteContent':\n      case 'deleteContentForward':\n        {\n          var {\n            anchor\n          } = targetRange;\n\n          if (canStoreDiff && Range.isCollapsed(targetRange)) {\n            var targetNode = Node.leaf(editor, anchor.path);\n\n            if (anchor.offset < targetNode.text.length) {\n              return storeDiff(anchor.path, {\n                text: '',\n                start: anchor.offset,\n                end: anchor.offset + 1\n              });\n            }\n          }\n\n          return scheduleAction(() => Editor.deleteForward(editor), {\n            at: targetRange\n          });\n        }\n\n      case 'deleteContentBackward':\n        {\n          var _nativeTargetRange;\n\n          var {\n            anchor: _anchor\n          } = targetRange; // If we have a mismatch between the native and slate selection being collapsed\n          // we are most likely deleting a zero-width placeholder and thus should perform it\n          // as an action to ensure correct behavior (mostly happens with mark placeholders)\n\n          var nativeCollapsed = isDOMSelection(nativeTargetRange) ? nativeTargetRange.isCollapsed : !!((_nativeTargetRange = nativeTargetRange) !== null && _nativeTargetRange !== void 0 && _nativeTargetRange.collapsed);\n\n          if (canStoreDiff && nativeCollapsed && Range.isCollapsed(targetRange) && _anchor.offset > 0) {\n            return storeDiff(_anchor.path, {\n              text: '',\n              start: _anchor.offset - 1,\n              end: _anchor.offset\n            });\n          }\n\n          return scheduleAction(() => Editor.deleteBackward(editor), {\n            at: targetRange\n          });\n        }\n\n      case 'deleteEntireSoftLine':\n        {\n          return scheduleAction(() => {\n            Editor.deleteBackward(editor, {\n              unit: 'line'\n            });\n            Editor.deleteForward(editor, {\n              unit: 'line'\n            });\n          }, {\n            at: targetRange\n          });\n        }\n\n      case 'deleteHardLineBackward':\n        {\n          return scheduleAction(() => Editor.deleteBackward(editor, {\n            unit: 'block'\n          }), {\n            at: targetRange\n          });\n        }\n\n      case 'deleteSoftLineBackward':\n        {\n          return scheduleAction(() => Editor.deleteBackward(editor, {\n            unit: 'line'\n          }), {\n            at: targetRange\n          });\n        }\n\n      case 'deleteHardLineForward':\n        {\n          return scheduleAction(() => Editor.deleteForward(editor, {\n            unit: 'block'\n          }), {\n            at: targetRange\n          });\n        }\n\n      case 'deleteSoftLineForward':\n        {\n          return scheduleAction(() => Editor.deleteForward(editor, {\n            unit: 'line'\n          }), {\n            at: targetRange\n          });\n        }\n\n      case 'deleteWordBackward':\n        {\n          return scheduleAction(() => Editor.deleteBackward(editor, {\n            unit: 'word'\n          }), {\n            at: targetRange\n          });\n        }\n\n      case 'deleteWordForward':\n        {\n          return scheduleAction(() => Editor.deleteForward(editor, {\n            unit: 'word'\n          }), {\n            at: targetRange\n          });\n        }\n\n      case 'insertLineBreak':\n        {\n          return scheduleAction(() => Editor.insertSoftBreak(editor), {\n            at: targetRange\n          });\n        }\n\n      case 'insertParagraph':\n        {\n          return scheduleAction(() => Editor.insertBreak(editor), {\n            at: targetRange\n          });\n        }\n\n      case 'insertCompositionText':\n      case 'deleteCompositionText':\n      case 'insertFromComposition':\n      case 'insertFromDrop':\n      case 'insertFromPaste':\n      case 'insertFromYank':\n      case 'insertReplacementText':\n      case 'insertText':\n        {\n          if (isDataTransfer(data)) {\n            return scheduleAction(() => ReactEditor.insertData(editor, data), {\n              at: targetRange\n            });\n          }\n\n          var _text = data !== null && data !== void 0 ? data : ''; // COMPAT: If we are writing inside a placeholder, the ime inserts the text inside\n          // the placeholder itself and thus includes the zero-width space inside edit events.\n\n\n          if (EDITOR_TO_PENDING_INSERTION_MARKS.get(editor)) {\n            _text = _text.replace('\\uFEFF', '');\n          } // Pastes from the Android clipboard will generate `insertText` events.\n          // If the copied text contains any newlines, Android will append an\n          // extra newline to the end of the copied text.\n\n\n          if (type === 'insertText' && /.*\\n.*\\n$/.test(_text)) {\n            _text = _text.slice(0, -1);\n          } // If the text includes a newline, split it at newlines and paste each component\n          // string, with soft breaks in between each.\n\n\n          if (_text.includes('\\n')) {\n            return scheduleAction(() => {\n              var parts = _text.split('\\n');\n\n              parts.forEach((line, i) => {\n                if (line) {\n                  Editor.insertText(editor, line);\n                }\n\n                if (i !== parts.length - 1) {\n                  Editor.insertSoftBreak(editor);\n                }\n              });\n            }, {\n              at: targetRange\n            });\n          }\n\n          if (Path.equals(targetRange.anchor.path, targetRange.focus.path)) {\n            var [_start2, _end2] = Range.edges(targetRange);\n            var _diff = {\n              start: _start2.offset,\n              end: _end2.offset,\n              text: _text\n            }; // COMPAT: Swiftkey has a weird bug where the target range of the 2nd word\n            // inserted after a mark placeholder is inserted with an anchor offset off by 1.\n            // So writing 'some text' will result in 'some ttext'. Luckily all 'normal' insert\n            // text events are fired with the correct target ranges, only the final 'insertComposition'\n            // isn't, so we can adjust the target range start offset if we are confident this is the\n            // swiftkey insert causing the issue.\n\n            if (_text && insertPositionHint && type === 'insertCompositionText') {\n              var hintPosition = insertPositionHint.start + insertPositionHint.text.search(/\\S|$/);\n\n              var diffPosition = _diff.start + _diff.text.search(/\\S|$/);\n\n              if (diffPosition === hintPosition + 1 && _diff.end === insertPositionHint.start + insertPositionHint.text.length) {\n                _diff.start -= 1;\n                insertPositionHint = null;\n                scheduleFlush();\n              } else {\n                insertPositionHint = false;\n              }\n            } else if (type === 'insertText') {\n              if (insertPositionHint === null) {\n                insertPositionHint = _diff;\n              } else if (insertPositionHint && Range.isCollapsed(targetRange) && insertPositionHint.end + insertPositionHint.text.length === _start2.offset) {\n                insertPositionHint = _objectSpread$3(_objectSpread$3({}, insertPositionHint), {}, {\n                  text: insertPositionHint.text + _text\n                });\n              } else {\n                insertPositionHint = false;\n              }\n            } else {\n              insertPositionHint = false;\n            }\n\n            if (canStoreDiff) {\n              storeDiff(_start2.path, _diff);\n              return;\n            }\n          }\n\n          return scheduleAction(() => Editor.insertText(editor, _text), {\n            at: targetRange\n          });\n        }\n    }\n  };\n\n  var hasPendingAction = () => {\n    return !!EDITOR_TO_PENDING_ACTION.get(editor);\n  };\n\n  var hasPendingDiffs = () => {\n    var _EDITOR_TO_PENDING_DI4;\n\n    return !!((_EDITOR_TO_PENDING_DI4 = EDITOR_TO_PENDING_DIFFS.get(editor)) !== null && _EDITOR_TO_PENDING_DI4 !== void 0 && _EDITOR_TO_PENDING_DI4.length);\n  };\n\n  var hasPendingChanges = () => {\n    return hasPendingAction() || hasPendingDiffs();\n  };\n\n  var isFlushing = () => {\n    return flushing;\n  };\n\n  var handleUserSelect = range => {\n    EDITOR_TO_PENDING_SELECTION.set(editor, range);\n\n    if (flushTimeoutId) {\n      clearTimeout(flushTimeoutId);\n      flushTimeoutId = null;\n    }\n\n    var {\n      selection\n    } = editor;\n\n    if (!range) {\n      return;\n    }\n\n    var pathChanged = !selection || !Path.equals(selection.anchor.path, range.anchor.path);\n    var parentPathChanged = !selection || !Path.equals(selection.anchor.path.slice(0, -1), range.anchor.path.slice(0, -1));\n\n    if (pathChanged && insertPositionHint || parentPathChanged) {\n      insertPositionHint = false;\n    }\n\n    if (pathChanged || hasPendingDiffs()) {\n      flushTimeoutId = setTimeout(flush, FLUSH_DELAY);\n    }\n  };\n\n  var handleInput = () => {\n    if (hasPendingAction() || !hasPendingDiffs()) {\n      flush();\n    }\n  };\n\n  var handleKeyDown = _ => {\n    // COMPAT: Swiftkey closes the keyboard when typing inside a empty node\n    // directly next to a non-contenteditable element (= the placeholder).\n    // The only event fired soon enough for us to allow hiding the placeholder\n    // without swiftkey picking it up is the keydown event, so we have to hide it\n    // here. See https://github.com/ianstormtaylor/slate/pull/4988#issuecomment-1201050535\n    if (!hasPendingDiffs()) {\n      updatePlaceholderVisibility(true);\n      setTimeout(updatePlaceholderVisibility);\n    }\n  };\n\n  var scheduleFlush = () => {\n    if (!hasPendingAction()) {\n      actionTimeoutId = setTimeout(flush);\n    }\n  };\n\n  var handleDomMutations = mutations => {\n    if (hasPendingDiffs() || hasPendingAction()) {\n      return;\n    }\n\n    if (mutations.some(mutation => isTrackedMutation(editor, mutation, mutations))) {\n      var _EDITOR_TO_FORCE_REND;\n\n      // Cause a re-render to restore the dom state if we encounter tracked mutations without\n      // a corresponding pending action.\n      (_EDITOR_TO_FORCE_REND = EDITOR_TO_FORCE_RENDER.get(editor)) === null || _EDITOR_TO_FORCE_REND === void 0 ? void 0 : _EDITOR_TO_FORCE_REND();\n    }\n  };\n\n  return {\n    flush,\n    scheduleFlush,\n    hasPendingDiffs,\n    hasPendingAction,\n    hasPendingChanges,\n    isFlushing,\n    handleUserSelect,\n    handleCompositionEnd,\n    handleCompositionStart,\n    handleDOMBeforeInput,\n    handleKeyDown,\n    handleDomMutations,\n    handleInput\n  };\n}\n\nfunction useIsMounted() {\n  var isMountedRef = useRef(false);\n  useEffect(() => {\n    isMountedRef.current = true;\n    return () => {\n      isMountedRef.current = false;\n    };\n  }, []);\n  return isMountedRef.current;\n}\n\n/**\r\n * Prevent warning on SSR by falling back to useEffect when DOM isn't available\r\n */\n\nvar useIsomorphicLayoutEffect = CAN_USE_DOM ? useLayoutEffect : useEffect;\n\nfunction useMutationObserver(node, callback, options) {\n  var [mutationObserver] = useState(() => new MutationObserver(callback));\n  useIsomorphicLayoutEffect(() => {\n    // Discard mutations caused during render phase. This works due to react calling\n    // useLayoutEffect synchronously after the render phase before the next tick.\n    mutationObserver.takeRecords();\n  });\n  useEffect(() => {\n    if (!node.current) {\n      throw new Error('Failed to attach MutationObserver, `node` is undefined');\n    }\n\n    mutationObserver.observe(node.current, options);\n    return () => mutationObserver.disconnect();\n  }, [mutationObserver, node, options]);\n}\n\nvar _excluded$3 = [\"node\"];\n\nfunction ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$2(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\nvar MUTATION_OBSERVER_CONFIG$1 = {\n  subtree: true,\n  childList: true,\n  characterData: true\n};\nvar useAndroidInputManager = !IS_ANDROID ? () => null : _ref => {\n  var {\n    node\n  } = _ref,\n      options = _objectWithoutProperties(_ref, _excluded$3);\n\n  if (!IS_ANDROID) {\n    return null;\n  }\n\n  var editor = useSlateStatic();\n  var isMounted = useIsMounted();\n  var [inputManager] = useState(() => createAndroidInputManager(_objectSpread$2({\n    editor\n  }, options)));\n  useMutationObserver(node, inputManager.handleDomMutations, MUTATION_OBSERVER_CONFIG$1);\n  EDITOR_TO_SCHEDULE_FLUSH.set(editor, inputManager.scheduleFlush);\n\n  if (isMounted) {\n    inputManager.flush();\n  }\n\n  return inputManager;\n};\n\nvar _excluded$2 = [\"anchor\", \"focus\"],\n    _excluded2$1 = [\"anchor\", \"focus\"];\nvar shallowCompare = (obj1, obj2) => Object.keys(obj1).length === Object.keys(obj2).length && Object.keys(obj1).every(key => obj2.hasOwnProperty(key) && obj1[key] === obj2[key]);\n\nvar isDecorationFlagsEqual = (range, other) => {\n  var rangeOwnProps = _objectWithoutProperties(range, _excluded$2);\n\n  var otherOwnProps = _objectWithoutProperties(other, _excluded2$1);\n\n  return range[PLACEHOLDER_SYMBOL] === other[PLACEHOLDER_SYMBOL] && shallowCompare(rangeOwnProps, otherOwnProps);\n};\n/**\r\n * Check if a list of decorator ranges are equal to another.\r\n *\r\n * PERF: this requires the two lists to also have the ranges inside them in the\r\n * same order, but this is an okay constraint for us since decorations are\r\n * kept in order, and the odd case where they aren't is okay to re-render for.\r\n */\n\n\nvar isElementDecorationsEqual = (list, another) => {\n  if (list.length !== another.length) {\n    return false;\n  }\n\n  for (var i = 0; i < list.length; i++) {\n    var range = list[i];\n    var other = another[i];\n\n    if (!Range.equals(range, other) || !isDecorationFlagsEqual(range, other)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n/**\r\n * Check if a list of decorator ranges are equal to another.\r\n *\r\n * PERF: this requires the two lists to also have the ranges inside them in the\r\n * same order, but this is an okay constraint for us since decorations are\r\n * kept in order, and the odd case where they aren't is okay to re-render for.\r\n */\n\nvar isTextDecorationsEqual = (list, another) => {\n  if (list.length !== another.length) {\n    return false;\n  }\n\n  for (var i = 0; i < list.length; i++) {\n    var range = list[i];\n    var other = another[i]; // compare only offsets because paths doesn't matter for text\n\n    if (range.anchor.offset !== other.anchor.offset || range.focus.offset !== other.focus.offset || !isDecorationFlagsEqual(range, other)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\r\n * Leaf content strings.\r\n */\n\nvar String = props => {\n  var {\n    isLast,\n    leaf,\n    parent,\n    text\n  } = props;\n  var editor = useSlateStatic();\n  var path = ReactEditor.findPath(editor, text);\n  var parentPath = Path.parent(path);\n  var isMarkPlaceholder = leaf[MARK_PLACEHOLDER_SYMBOL] === true; // COMPAT: Render text inside void nodes with a zero-width space.\n  // So the node can contain selection but the text is not visible.\n\n  if (editor.isVoid(parent)) {\n    return /*#__PURE__*/React.createElement(ZeroWidthString, {\n      length: Node.string(parent).length\n    });\n  } // COMPAT: If this is the last text node in an empty block, render a zero-\n  // width space that will convert into a line break when copying and pasting\n  // to support expected plain text.\n\n\n  if (leaf.text === '' && parent.children[parent.children.length - 1] === text && !editor.isInline(parent) && Editor.string(editor, parentPath) === '') {\n    return /*#__PURE__*/React.createElement(ZeroWidthString, {\n      isLineBreak: true,\n      isMarkPlaceholder: isMarkPlaceholder\n    });\n  } // COMPAT: If the text is empty, it's because it's on the edge of an inline\n  // node, so we render a zero-width space so that the selection can be\n  // inserted next to it still.\n\n\n  if (leaf.text === '') {\n    return /*#__PURE__*/React.createElement(ZeroWidthString, {\n      isMarkPlaceholder: isMarkPlaceholder\n    });\n  } // COMPAT: Browsers will collapse trailing new lines at the end of blocks,\n  // so we need to add an extra trailing new lines to prevent that.\n\n\n  if (isLast && leaf.text.slice(-1) === '\\n') {\n    return /*#__PURE__*/React.createElement(TextString, {\n      isTrailing: true,\n      text: leaf.text\n    });\n  }\n\n  return /*#__PURE__*/React.createElement(TextString, {\n    text: leaf.text\n  });\n};\n/**\r\n * Leaf strings with text in them.\r\n */\n\n\nvar TextString = props => {\n  var {\n    text,\n    isTrailing = false\n  } = props;\n  var ref = useRef(null);\n\n  var getTextContent = () => {\n    return \"\".concat(text !== null && text !== void 0 ? text : '').concat(isTrailing ? '\\n' : '');\n  };\n\n  var [initialText] = useState(getTextContent); // This is the actual text rendering boundary where we interface with the DOM\n  // The text is not rendered as part of the virtual DOM, as since we handle basic character insertions natively,\n  // updating the DOM is not a one way dataflow anymore. What we need here is not reconciliation and diffing\n  // with previous version of the virtual DOM, but rather diffing with the actual DOM element, and replace the DOM <span> content\n  // exactly if and only if its current content does not match our current virtual DOM.\n  // Otherwise the DOM TextNode would always be replaced by React as the user types, which interferes with native text features,\n  // eg makes native spellcheck opt out from checking the text node.\n  // useLayoutEffect: updating our span before browser paint\n\n  useIsomorphicLayoutEffect(() => {\n    // null coalescing text to make sure we're not outputing \"null\" as a string in the extreme case it is nullish at runtime\n    var textWithTrailing = getTextContent();\n\n    if (ref.current && ref.current.textContent !== textWithTrailing) {\n      ref.current.textContent = textWithTrailing;\n    } // intentionally not specifying dependencies, so that this effect runs on every render\n    // as this effectively replaces \"specifying the text in the virtual DOM under the <span> below\" on each render\n\n  }); // We intentionally render a memoized <span> that only receives the initial text content when the component is mounted.\n  // We defer to the layout effect above to update the `textContent` of the span element when needed.\n\n  return /*#__PURE__*/React.createElement(MemoizedText$1, {\n    ref: ref\n  }, initialText);\n};\n\nvar MemoizedText$1 = /*#__PURE__*/memo( /*#__PURE__*/forwardRef((props, ref) => {\n  return /*#__PURE__*/React.createElement(\"span\", {\n    \"data-slate-string\": true,\n    ref: ref\n  }, props.children);\n}));\n/**\r\n * Leaf strings without text, render as zero-width strings.\r\n */\n\nvar ZeroWidthString = props => {\n  var {\n    length = 0,\n    isLineBreak = false,\n    isMarkPlaceholder = false\n  } = props;\n  var attributes = {\n    'data-slate-zero-width': isLineBreak ? 'n' : 'z',\n    'data-slate-length': length\n  };\n\n  if (isMarkPlaceholder) {\n    attributes['data-slate-mark-placeholder'] = true;\n  }\n\n  return /*#__PURE__*/React.createElement(\"span\", Object.assign({}, attributes), !IS_ANDROID || !isLineBreak ? '\\uFEFF' : null, isLineBreak ? /*#__PURE__*/React.createElement(\"br\", null) : null);\n};\n\nfunction disconnectPlaceholderResizeObserver(placeholderResizeObserver, releaseObserver) {\n  if (placeholderResizeObserver.current) {\n    placeholderResizeObserver.current.disconnect();\n\n    if (releaseObserver) {\n      placeholderResizeObserver.current = null;\n    }\n  }\n}\n\nfunction clearTimeoutRef(timeoutRef) {\n  if (timeoutRef.current) {\n    clearTimeout(timeoutRef.current);\n    timeoutRef.current = null;\n  }\n}\n/**\r\n * Individual leaves in a text node with unique formatting.\r\n */\n\n\nvar Leaf = props => {\n  var {\n    leaf,\n    isLast,\n    text,\n    parent,\n    renderPlaceholder,\n    renderLeaf = props => /*#__PURE__*/React.createElement(DefaultLeaf, Object.assign({}, props))\n  } = props;\n  var editor = useSlateStatic();\n  var placeholderResizeObserver = useRef(null);\n  var placeholderRef = useRef(null);\n  var [showPlaceholder, setShowPlaceholder] = useState(false);\n  var showPlaceholderTimeoutRef = useRef(null);\n  var callbackPlaceholderRef = useCallback(placeholderEl => {\n    disconnectPlaceholderResizeObserver(placeholderResizeObserver, placeholderEl == null);\n\n    if (placeholderEl == null) {\n      var _leaf$onPlaceholderRe;\n\n      EDITOR_TO_PLACEHOLDER_ELEMENT.delete(editor);\n      (_leaf$onPlaceholderRe = leaf.onPlaceholderResize) === null || _leaf$onPlaceholderRe === void 0 ? void 0 : _leaf$onPlaceholderRe.call(leaf, null);\n    } else {\n      EDITOR_TO_PLACEHOLDER_ELEMENT.set(editor, placeholderEl);\n\n      if (!placeholderResizeObserver.current) {\n        // Create a new observer and observe the placeholder element.\n        var ResizeObserver$1 = window.ResizeObserver || ResizeObserver;\n        placeholderResizeObserver.current = new ResizeObserver$1(() => {\n          var _leaf$onPlaceholderRe2;\n\n          (_leaf$onPlaceholderRe2 = leaf.onPlaceholderResize) === null || _leaf$onPlaceholderRe2 === void 0 ? void 0 : _leaf$onPlaceholderRe2.call(leaf, placeholderEl);\n        });\n      }\n\n      placeholderResizeObserver.current.observe(placeholderEl);\n      placeholderRef.current = placeholderEl;\n    }\n  }, [placeholderRef, leaf, editor]);\n  var children = /*#__PURE__*/React.createElement(String, {\n    isLast: isLast,\n    leaf: leaf,\n    parent: parent,\n    text: text\n  });\n  var leafIsPlaceholder = leaf[PLACEHOLDER_SYMBOL];\n  useEffect(() => {\n    if (leafIsPlaceholder) {\n      if (!showPlaceholderTimeoutRef.current) {\n        // Delay the placeholder so it will not render in a selection\n        showPlaceholderTimeoutRef.current = setTimeout(() => {\n          setShowPlaceholder(true);\n          showPlaceholderTimeoutRef.current = null;\n        }, 300);\n      }\n    } else {\n      clearTimeoutRef(showPlaceholderTimeoutRef);\n      setShowPlaceholder(false);\n    }\n\n    return () => clearTimeoutRef(showPlaceholderTimeoutRef);\n  }, [leafIsPlaceholder, setShowPlaceholder]);\n\n  if (leafIsPlaceholder && showPlaceholder) {\n    var placeholderProps = {\n      children: leaf.placeholder,\n      attributes: {\n        'data-slate-placeholder': true,\n        style: {\n          position: 'absolute',\n          top: 0,\n          pointerEvents: 'none',\n          width: '100%',\n          maxWidth: '100%',\n          display: 'block',\n          opacity: '0.333',\n          userSelect: 'none',\n          textDecoration: 'none',\n          // Fixes https://github.com/udecode/plate/issues/2315\n          WebkitUserModify: IS_WEBKIT ? 'inherit' : undefined\n        },\n        contentEditable: false,\n        ref: callbackPlaceholderRef\n      }\n    };\n    children = /*#__PURE__*/React.createElement(React.Fragment, null, renderPlaceholder(placeholderProps), children);\n  } // COMPAT: Having the `data-` attributes on these leaf elements ensures that\n  // in certain misbehaving browsers they aren't weirdly cloned/destroyed by\n  // contenteditable behaviors. (2019/05/08)\n\n\n  var attributes = {\n    'data-slate-leaf': true\n  };\n  return renderLeaf({\n    attributes,\n    children,\n    leaf,\n    text\n  });\n};\n\nvar MemoizedLeaf = /*#__PURE__*/React.memo(Leaf, (prev, next) => {\n  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];\n});\nvar DefaultLeaf = props => {\n  var {\n    attributes,\n    children\n  } = props;\n  return /*#__PURE__*/React.createElement(\"span\", Object.assign({}, attributes), children);\n};\n\n/**\r\n * Text.\r\n */\n\nvar Text = props => {\n  var {\n    decorations,\n    isLast,\n    parent,\n    renderPlaceholder,\n    renderLeaf,\n    text\n  } = props;\n  var editor = useSlateStatic();\n  var ref = useRef(null);\n  var leaves = Text$1.decorations(text, decorations);\n  var key = ReactEditor.findKey(editor, text);\n  var children = [];\n\n  for (var i = 0; i < leaves.length; i++) {\n    var leaf = leaves[i];\n    children.push( /*#__PURE__*/React.createElement(MemoizedLeaf, {\n      isLast: isLast && i === leaves.length - 1,\n      key: \"\".concat(key.id, \"-\").concat(i),\n      renderPlaceholder: renderPlaceholder,\n      leaf: leaf,\n      text: text,\n      parent: parent,\n      renderLeaf: renderLeaf\n    }));\n  } // Update element-related weak maps with the DOM element ref.\n\n\n  var callbackRef = useCallback(span => {\n    var KEY_TO_ELEMENT = EDITOR_TO_KEY_TO_ELEMENT.get(editor);\n\n    if (span) {\n      KEY_TO_ELEMENT === null || KEY_TO_ELEMENT === void 0 ? void 0 : KEY_TO_ELEMENT.set(key, span);\n      NODE_TO_ELEMENT.set(text, span);\n      ELEMENT_TO_NODE.set(span, text);\n    } else {\n      KEY_TO_ELEMENT === null || KEY_TO_ELEMENT === void 0 ? void 0 : KEY_TO_ELEMENT.delete(key);\n      NODE_TO_ELEMENT.delete(text);\n\n      if (ref.current) {\n        ELEMENT_TO_NODE.delete(ref.current);\n      }\n    }\n\n    ref.current = span;\n  }, [ref, editor, key, text]);\n  return /*#__PURE__*/React.createElement(\"span\", {\n    \"data-slate-node\": \"text\",\n    ref: callbackRef\n  }, children);\n};\n\nvar MemoizedText = /*#__PURE__*/React.memo(Text, (prev, next) => {\n  return next.parent === prev.parent && next.isLast === prev.isLast && next.renderLeaf === prev.renderLeaf && next.renderPlaceholder === prev.renderPlaceholder && next.text === prev.text && isTextDecorationsEqual(next.decorations, prev.decorations);\n});\n\n/**\r\n * Element.\r\n */\n\nvar Element = props => {\n  var {\n    decorations,\n    element,\n    renderElement = p => /*#__PURE__*/React.createElement(DefaultElement, Object.assign({}, p)),\n    renderPlaceholder,\n    renderLeaf,\n    selection\n  } = props;\n  var editor = useSlateStatic();\n  var readOnly = useReadOnly();\n  var isInline = editor.isInline(element);\n  var key = ReactEditor.findKey(editor, element);\n  var ref = useCallback(ref => {\n    // Update element-related weak maps with the DOM element ref.\n    var KEY_TO_ELEMENT = EDITOR_TO_KEY_TO_ELEMENT.get(editor);\n\n    if (ref) {\n      KEY_TO_ELEMENT === null || KEY_TO_ELEMENT === void 0 ? void 0 : KEY_TO_ELEMENT.set(key, ref);\n      NODE_TO_ELEMENT.set(element, ref);\n      ELEMENT_TO_NODE.set(ref, element);\n    } else {\n      KEY_TO_ELEMENT === null || KEY_TO_ELEMENT === void 0 ? void 0 : KEY_TO_ELEMENT.delete(key);\n      NODE_TO_ELEMENT.delete(element);\n    }\n  }, [editor, key, element]);\n  var children = useChildren({\n    decorations,\n    node: element,\n    renderElement,\n    renderPlaceholder,\n    renderLeaf,\n    selection\n  }); // Attributes that the developer must mix into the element in their\n  // custom node renderer component.\n\n  var attributes = {\n    'data-slate-node': 'element',\n    ref\n  };\n\n  if (isInline) {\n    attributes['data-slate-inline'] = true;\n  } // If it's a block node with inline children, add the proper `dir` attribute\n  // for text direction.\n\n\n  if (!isInline && Editor.hasInlines(editor, element)) {\n    var text = Node.string(element);\n    var dir = getDirection(text);\n\n    if (dir === 'rtl') {\n      attributes.dir = dir;\n    }\n  } // If it's a void node, wrap the children in extra void-specific elements.\n\n\n  if (Editor.isVoid(editor, element)) {\n    attributes['data-slate-void'] = true;\n\n    if (!readOnly && isInline) {\n      attributes.contentEditable = false;\n    }\n\n    var Tag = isInline ? 'span' : 'div';\n    var [[_text]] = Node.texts(element);\n    children = /*#__PURE__*/React.createElement(Tag, {\n      \"data-slate-spacer\": true,\n      style: {\n        height: '0',\n        color: 'transparent',\n        outline: 'none',\n        position: 'absolute'\n      }\n    }, /*#__PURE__*/React.createElement(MemoizedText, {\n      renderPlaceholder: renderPlaceholder,\n      decorations: [],\n      isLast: false,\n      parent: element,\n      text: _text\n    }));\n    NODE_TO_INDEX.set(_text, 0);\n    NODE_TO_PARENT.set(_text, element);\n  }\n\n  return renderElement({\n    attributes,\n    children,\n    element\n  });\n};\n\nvar MemoizedElement = /*#__PURE__*/React.memo(Element, (prev, next) => {\n  return prev.element === next.element && prev.renderElement === next.renderElement && prev.renderLeaf === next.renderLeaf && prev.renderPlaceholder === next.renderPlaceholder && isElementDecorationsEqual(prev.decorations, next.decorations) && (prev.selection === next.selection || !!prev.selection && !!next.selection && Range.equals(prev.selection, next.selection));\n});\n/**\r\n * The default element renderer.\r\n */\n\nvar DefaultElement = props => {\n  var {\n    attributes,\n    children,\n    element\n  } = props;\n  var editor = useSlateStatic();\n  var Tag = editor.isInline(element) ? 'span' : 'div';\n  return /*#__PURE__*/React.createElement(Tag, Object.assign({}, attributes, {\n    style: {\n      position: 'relative'\n    }\n  }), children);\n};\n\n/**\r\n * A React context for sharing the `decorate` prop of the editable.\r\n */\n\nvar DecorateContext = /*#__PURE__*/createContext(() => []);\n/**\r\n * Get the current `decorate` prop of the editable.\r\n */\n\nvar useDecorate = () => {\n  return useContext(DecorateContext);\n};\n\n/**\r\n * A React context for sharing the `selected` state of an element.\r\n */\n\nvar SelectedContext = /*#__PURE__*/createContext(false);\n/**\r\n * Get the current `selected` state of an element.\r\n */\n\nvar useSelected = () => {\n  return useContext(SelectedContext);\n};\n\n/**\r\n * Children.\r\n */\n\nvar useChildren = props => {\n  var {\n    decorations,\n    node,\n    renderElement,\n    renderPlaceholder,\n    renderLeaf,\n    selection\n  } = props;\n  var decorate = useDecorate();\n  var editor = useSlateStatic();\n  var path = ReactEditor.findPath(editor, node);\n  var children = [];\n  var isLeafBlock = Element$1.isElement(node) && !editor.isInline(node) && Editor.hasInlines(editor, node);\n\n  for (var i = 0; i < node.children.length; i++) {\n    var p = path.concat(i);\n    var n = node.children[i];\n    var key = ReactEditor.findKey(editor, n);\n    var range = Editor.range(editor, p);\n    var sel = selection && Range.intersection(range, selection);\n    var ds = decorate([n, p]);\n\n    for (var dec of decorations) {\n      var d = Range.intersection(dec, range);\n\n      if (d) {\n        ds.push(d);\n      }\n    }\n\n    if (Element$1.isElement(n)) {\n      children.push( /*#__PURE__*/React.createElement(SelectedContext.Provider, {\n        key: \"provider-\".concat(key.id),\n        value: !!sel\n      }, /*#__PURE__*/React.createElement(MemoizedElement, {\n        decorations: ds,\n        element: n,\n        key: key.id,\n        renderElement: renderElement,\n        renderPlaceholder: renderPlaceholder,\n        renderLeaf: renderLeaf,\n        selection: sel\n      })));\n    } else {\n      children.push( /*#__PURE__*/React.createElement(MemoizedText, {\n        decorations: ds,\n        key: key.id,\n        isLast: isLeafBlock && i === node.children.length - 1,\n        parent: node,\n        renderPlaceholder: renderPlaceholder,\n        renderLeaf: renderLeaf,\n        text: n\n      }));\n    }\n\n    NODE_TO_INDEX.set(n, i);\n    NODE_TO_PARENT.set(n, node);\n  }\n\n  return children;\n};\n\n/**\r\n * A React context for sharing the `readOnly` state of the editor.\r\n */\n\nvar ReadOnlyContext = /*#__PURE__*/createContext(false);\n/**\r\n * Get the current `readOnly` state of the editor.\r\n */\n\nvar useReadOnly = () => {\n  return useContext(ReadOnlyContext);\n};\n\nvar SlateContext = /*#__PURE__*/createContext(null);\n/**\r\n * Get the current editor object from the React context.\r\n */\n\nvar useSlate = () => {\n  var context = useContext(SlateContext);\n\n  if (!context) {\n    throw new Error(\"The `useSlate` hook must be used inside the <Slate> component's context.\");\n  }\n\n  var {\n    editor\n  } = context;\n  return editor;\n};\nvar useSlateWithV = () => {\n  var context = useContext(SlateContext);\n\n  if (!context) {\n    throw new Error(\"The `useSlate` hook must be used inside the <Slate> component's context.\");\n  }\n\n  return context;\n};\n\nfunction useTrackUserInput() {\n  var editor = useSlateStatic();\n  var receivedUserInput = useRef(false);\n  var animationFrameIdRef = useRef(0);\n  var onUserInput = useCallback(() => {\n    if (receivedUserInput.current) {\n      return;\n    }\n\n    receivedUserInput.current = true;\n    var window = ReactEditor.getWindow(editor);\n    window.cancelAnimationFrame(animationFrameIdRef.current);\n    animationFrameIdRef.current = window.requestAnimationFrame(() => {\n      receivedUserInput.current = false;\n    });\n  }, [editor]);\n  useEffect(() => () => cancelAnimationFrame(animationFrameIdRef.current), []);\n  return {\n    receivedUserInput,\n    onUserInput\n  };\n}\n\nvar TRIPLE_CLICK = 3;\n\n/**\r\n * Hotkey mappings for each platform.\r\n */\n\nvar HOTKEYS = {\n  bold: 'mod+b',\n  compose: ['down', 'left', 'right', 'up', 'backspace', 'enter'],\n  moveBackward: 'left',\n  moveForward: 'right',\n  moveWordBackward: 'ctrl+left',\n  moveWordForward: 'ctrl+right',\n  deleteBackward: 'shift?+backspace',\n  deleteForward: 'shift?+delete',\n  extendBackward: 'shift+left',\n  extendForward: 'shift+right',\n  italic: 'mod+i',\n  insertSoftBreak: 'shift+enter',\n  splitBlock: 'enter',\n  undo: 'mod+z'\n};\nvar APPLE_HOTKEYS = {\n  moveLineBackward: 'opt+up',\n  moveLineForward: 'opt+down',\n  moveWordBackward: 'opt+left',\n  moveWordForward: 'opt+right',\n  deleteBackward: ['ctrl+backspace', 'ctrl+h'],\n  deleteForward: ['ctrl+delete', 'ctrl+d'],\n  deleteLineBackward: 'cmd+shift?+backspace',\n  deleteLineForward: ['cmd+shift?+delete', 'ctrl+k'],\n  deleteWordBackward: 'opt+shift?+backspace',\n  deleteWordForward: 'opt+shift?+delete',\n  extendLineBackward: 'opt+shift+up',\n  extendLineForward: 'opt+shift+down',\n  redo: 'cmd+shift+z',\n  transposeCharacter: 'ctrl+t'\n};\nvar WINDOWS_HOTKEYS = {\n  deleteWordBackward: 'ctrl+shift?+backspace',\n  deleteWordForward: 'ctrl+shift?+delete',\n  redo: ['ctrl+y', 'ctrl+shift+z']\n};\n/**\r\n * Create a platform-aware hotkey checker.\r\n */\n\nvar create = key => {\n  var generic = HOTKEYS[key];\n  var apple = APPLE_HOTKEYS[key];\n  var windows = WINDOWS_HOTKEYS[key];\n  var isGeneric = generic && isHotkey(generic);\n  var isApple = apple && isHotkey(apple);\n  var isWindows = windows && isHotkey(windows);\n  return event => {\n    if (isGeneric && isGeneric(event)) return true;\n    if (IS_APPLE && isApple && isApple(event)) return true;\n    if (!IS_APPLE && isWindows && isWindows(event)) return true;\n    return false;\n  };\n};\n/**\r\n * Hotkeys.\r\n */\n\n\nvar Hotkeys = {\n  isBold: create('bold'),\n  isCompose: create('compose'),\n  isMoveBackward: create('moveBackward'),\n  isMoveForward: create('moveForward'),\n  isDeleteBackward: create('deleteBackward'),\n  isDeleteForward: create('deleteForward'),\n  isDeleteLineBackward: create('deleteLineBackward'),\n  isDeleteLineForward: create('deleteLineForward'),\n  isDeleteWordBackward: create('deleteWordBackward'),\n  isDeleteWordForward: create('deleteWordForward'),\n  isExtendBackward: create('extendBackward'),\n  isExtendForward: create('extendForward'),\n  isExtendLineBackward: create('extendLineBackward'),\n  isExtendLineForward: create('extendLineForward'),\n  isItalic: create('italic'),\n  isMoveLineBackward: create('moveLineBackward'),\n  isMoveLineForward: create('moveLineForward'),\n  isMoveWordBackward: create('moveWordBackward'),\n  isMoveWordForward: create('moveWordForward'),\n  isRedo: create('redo'),\n  isSoftBreak: create('insertSoftBreak'),\n  isSplitBlock: create('splitBlock'),\n  isTransposeCharacter: create('transposeCharacter'),\n  isUndo: create('undo')\n};\n\nvar createRestoreDomManager = (editor, receivedUserInput) => {\n  var bufferedMutations = [];\n\n  var clear = () => {\n    bufferedMutations = [];\n  };\n\n  var registerMutations = mutations => {\n    if (!receivedUserInput.current) {\n      return;\n    }\n\n    var trackedMutations = mutations.filter(mutation => isTrackedMutation(editor, mutation, mutations));\n    bufferedMutations.push(...trackedMutations);\n  };\n\n  function restoreDOM() {\n    if (bufferedMutations.length > 0) {\n      bufferedMutations.reverse().forEach(mutation => {\n        if (mutation.type === 'characterData') {\n          // We don't want to restore the DOM for characterData mutations\n          // because this interrupts the composition.\n          return;\n        }\n\n        mutation.removedNodes.forEach(node => {\n          mutation.target.insertBefore(node, mutation.nextSibling);\n        });\n        mutation.addedNodes.forEach(node => {\n          mutation.target.removeChild(node);\n        });\n      }); // Clear buffered mutations to ensure we don't undo them twice\n\n      clear();\n    }\n  }\n\n  return {\n    registerMutations,\n    restoreDOM,\n    clear\n  };\n};\n\nvar MUTATION_OBSERVER_CONFIG = {\n  subtree: true,\n  childList: true,\n  characterData: true,\n  characterDataOldValue: true\n}; // We have to use a class component here since we rely on `getSnapshotBeforeUpdate` which has no FC equivalent\n// to run code synchronously immediately before react commits the component update to the DOM.\n\nclass RestoreDOMComponent extends Component {\n  constructor() {\n    super(...arguments);\n    this.context = null;\n    this.manager = null;\n    this.mutationObserver = null;\n  }\n\n  observe() {\n    var _this$mutationObserve;\n\n    var {\n      node\n    } = this.props;\n\n    if (!node.current) {\n      throw new Error('Failed to attach MutationObserver, `node` is undefined');\n    }\n\n    (_this$mutationObserve = this.mutationObserver) === null || _this$mutationObserve === void 0 ? void 0 : _this$mutationObserve.observe(node.current, MUTATION_OBSERVER_CONFIG);\n  }\n\n  componentDidMount() {\n    var {\n      receivedUserInput\n    } = this.props;\n    var editor = this.context;\n    this.manager = createRestoreDomManager(editor, receivedUserInput);\n    this.mutationObserver = new MutationObserver(this.manager.registerMutations);\n    this.observe();\n  }\n\n  getSnapshotBeforeUpdate() {\n    var _this$mutationObserve2, _this$mutationObserve3, _this$manager2;\n\n    var pendingMutations = (_this$mutationObserve2 = this.mutationObserver) === null || _this$mutationObserve2 === void 0 ? void 0 : _this$mutationObserve2.takeRecords();\n\n    if (pendingMutations !== null && pendingMutations !== void 0 && pendingMutations.length) {\n      var _this$manager;\n\n      (_this$manager = this.manager) === null || _this$manager === void 0 ? void 0 : _this$manager.registerMutations(pendingMutations);\n    }\n\n    (_this$mutationObserve3 = this.mutationObserver) === null || _this$mutationObserve3 === void 0 ? void 0 : _this$mutationObserve3.disconnect();\n    (_this$manager2 = this.manager) === null || _this$manager2 === void 0 ? void 0 : _this$manager2.restoreDOM();\n    return null;\n  }\n\n  componentDidUpdate() {\n    var _this$manager3;\n\n    (_this$manager3 = this.manager) === null || _this$manager3 === void 0 ? void 0 : _this$manager3.clear();\n    this.observe();\n  }\n\n  componentWillUnmount() {\n    var _this$mutationObserve4;\n\n    (_this$mutationObserve4 = this.mutationObserver) === null || _this$mutationObserve4 === void 0 ? void 0 : _this$mutationObserve4.disconnect();\n  }\n\n  render() {\n    return this.props.children;\n  }\n\n}\n\nRestoreDOMComponent.contextType = EditorContext;\nvar RestoreDOM = IS_ANDROID ? RestoreDOMComponent : _ref => {\n  var {\n    children\n  } = _ref;\n  return /*#__PURE__*/React.createElement(React.Fragment, null, children);\n};\n\nvar _excluded$1 = [\"autoFocus\", \"decorate\", \"onDOMBeforeInput\", \"placeholder\", \"readOnly\", \"renderElement\", \"renderLeaf\", \"renderPlaceholder\", \"scrollSelectionIntoView\", \"style\", \"as\", \"disableDefaultStyles\"],\n    _excluded2 = [\"text\"];\n\nfunction ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nvar Children = props => /*#__PURE__*/React.createElement(React.Fragment, null, useChildren(props));\n/**\r\n * Editable.\r\n */\n\n\nvar Editable = props => {\n  var defaultRenderPlaceholder = useCallback(props => /*#__PURE__*/React.createElement(DefaultPlaceholder, Object.assign({}, props)), []);\n\n  var {\n    autoFocus,\n    decorate = defaultDecorate,\n    onDOMBeforeInput: propsOnDOMBeforeInput,\n    placeholder,\n    readOnly = false,\n    renderElement,\n    renderLeaf,\n    renderPlaceholder = defaultRenderPlaceholder,\n    scrollSelectionIntoView = defaultScrollSelectionIntoView,\n    style: userStyle = {},\n    as: Component = 'div',\n    disableDefaultStyles = false\n  } = props,\n      attributes = _objectWithoutProperties(props, _excluded$1);\n\n  var editor = useSlate(); // Rerender editor when composition status changed\n\n  var [isComposing, setIsComposing] = useState(false);\n  var ref = useRef(null);\n  var deferredOperations = useRef([]);\n  var [placeholderHeight, setPlaceholderHeight] = useState();\n  var {\n    onUserInput,\n    receivedUserInput\n  } = useTrackUserInput();\n  var [, forceRender] = useReducer(s => s + 1, 0);\n  EDITOR_TO_FORCE_RENDER.set(editor, forceRender); // Update internal state on each render.\n\n  IS_READ_ONLY.set(editor, readOnly); // Keep track of some state for the event handler logic.\n\n  var state = useMemo(() => ({\n    isDraggingInternally: false,\n    isUpdatingSelection: false,\n    latestElement: null,\n    hasMarkPlaceholder: false\n  }), []); // The autoFocus TextareaHTMLAttribute doesn't do anything on a div, so it\n  // needs to be manually focused.\n\n  useEffect(() => {\n    if (ref.current && autoFocus) {\n      ref.current.focus();\n    }\n  }, [autoFocus]);\n  /**\r\n   * The AndroidInputManager object has a cyclical dependency on onDOMSelectionChange\r\n   *\r\n   * It is defined as a reference to simplify hook dependencies and clarify that\r\n   * it needs to be initialized.\r\n   */\n\n  var androidInputManagerRef = useRef(); // Listen on the native `selectionchange` event to be able to update any time\n  // the selection changes. This is required because React's `onSelect` is leaky\n  // and non-standard so it doesn't fire until after a selection has been\n  // released. This causes issues in situations where another change happens\n  // while a selection is being dragged.\n\n  var onDOMSelectionChange = useMemo(() => throttle(() => {\n    var androidInputManager = androidInputManagerRef.current;\n\n    if ((IS_ANDROID || !ReactEditor.isComposing(editor)) && (!state.isUpdatingSelection || androidInputManager !== null && androidInputManager !== void 0 && androidInputManager.isFlushing()) && !state.isDraggingInternally) {\n      var root = ReactEditor.findDocumentOrShadowRoot(editor);\n      var {\n        activeElement\n      } = root;\n      var el = ReactEditor.toDOMNode(editor, editor);\n      var domSelection = root.getSelection();\n\n      if (activeElement === el) {\n        state.latestElement = activeElement;\n        IS_FOCUSED.set(editor, true);\n      } else {\n        IS_FOCUSED.delete(editor);\n      }\n\n      if (!domSelection) {\n        return Transforms.deselect(editor);\n      }\n\n      var {\n        anchorNode,\n        focusNode\n      } = domSelection;\n      var anchorNodeSelectable = ReactEditor.hasEditableTarget(editor, anchorNode) || ReactEditor.isTargetInsideNonReadonlyVoid(editor, anchorNode);\n      var focusNodeSelectable = ReactEditor.hasEditableTarget(editor, focusNode) || ReactEditor.isTargetInsideNonReadonlyVoid(editor, focusNode);\n\n      if (anchorNodeSelectable && focusNodeSelectable) {\n        var range = ReactEditor.toSlateRange(editor, domSelection, {\n          exactMatch: false,\n          suppressThrow: true\n        });\n\n        if (range) {\n          if (!ReactEditor.isComposing(editor) && !(androidInputManager !== null && androidInputManager !== void 0 && androidInputManager.hasPendingChanges()) && !(androidInputManager !== null && androidInputManager !== void 0 && androidInputManager.isFlushing())) {\n            Transforms.select(editor, range);\n          } else {\n            androidInputManager === null || androidInputManager === void 0 ? void 0 : androidInputManager.handleUserSelect(range);\n          }\n        }\n      } // Deselect the editor if the dom selection is not selectable in readonly mode\n\n\n      if (readOnly && (!anchorNodeSelectable || !focusNodeSelectable)) {\n        Transforms.deselect(editor);\n      }\n    }\n  }, 100), [editor, readOnly, state]);\n  var scheduleOnDOMSelectionChange = useMemo(() => debounce(onDOMSelectionChange, 0), [onDOMSelectionChange]);\n  androidInputManagerRef.current = useAndroidInputManager({\n    node: ref,\n    onDOMSelectionChange,\n    scheduleOnDOMSelectionChange\n  });\n  useIsomorphicLayoutEffect(() => {\n    var _androidInputManagerR, _androidInputManagerR2;\n\n    // Update element-related weak maps with the DOM element ref.\n    var window;\n\n    if (ref.current && (window = getDefaultView(ref.current))) {\n      EDITOR_TO_WINDOW.set(editor, window);\n      EDITOR_TO_ELEMENT.set(editor, ref.current);\n      NODE_TO_ELEMENT.set(editor, ref.current);\n      ELEMENT_TO_NODE.set(ref.current, editor);\n    } else {\n      NODE_TO_ELEMENT.delete(editor);\n    } // Make sure the DOM selection state is in sync.\n\n\n    var {\n      selection\n    } = editor;\n    var root = ReactEditor.findDocumentOrShadowRoot(editor);\n    var domSelection = root.getSelection();\n\n    if (!domSelection || !ReactEditor.isFocused(editor) || (_androidInputManagerR = androidInputManagerRef.current) !== null && _androidInputManagerR !== void 0 && _androidInputManagerR.hasPendingAction()) {\n      return;\n    }\n\n    var setDomSelection = forceChange => {\n      var hasDomSelection = domSelection.type !== 'None'; // If the DOM selection is properly unset, we're done.\n\n      if (!selection && !hasDomSelection) {\n        return;\n      } // Get anchorNode and focusNode\n\n\n      var focusNode = domSelection.focusNode;\n      var anchorNode; // COMPAT: In firefox the normal seletion way does not work\n      // (https://github.com/ianstormtaylor/slate/pull/5486#issue-1820720223)\n\n      if (IS_FIREFOX && domSelection.rangeCount > 1) {\n        var firstRange = domSelection.getRangeAt(0);\n        var lastRange = domSelection.getRangeAt(domSelection.rangeCount - 1); // Right to left\n\n        if (firstRange.startContainer === focusNode) {\n          anchorNode = lastRange.endContainer;\n        } else {\n          // Left to right\n          anchorNode = firstRange.startContainer;\n        }\n      } else {\n        anchorNode = domSelection.anchorNode;\n      } // verify that the dom selection is in the editor\n\n\n      var editorElement = EDITOR_TO_ELEMENT.get(editor);\n      var hasDomSelectionInEditor = false;\n\n      if (editorElement.contains(anchorNode) && editorElement.contains(focusNode)) {\n        hasDomSelectionInEditor = true;\n      } // If the DOM selection is in the editor and the editor selection is already correct, we're done.\n\n\n      if (hasDomSelection && hasDomSelectionInEditor && selection && !forceChange) {\n        var slateRange = ReactEditor.toSlateRange(editor, domSelection, {\n          exactMatch: true,\n          // domSelection is not necessarily a valid Slate range\n          // (e.g. when clicking on contentEditable:false element)\n          suppressThrow: true\n        });\n\n        if (slateRange && Range.equals(slateRange, selection)) {\n          var _anchorNode, _anchorNode$parentEle;\n\n          if (!state.hasMarkPlaceholder) {\n            return;\n          } // Ensure selection is inside the mark placeholder\n\n\n          if ((_anchorNode = anchorNode) !== null && _anchorNode !== void 0 && (_anchorNode$parentEle = _anchorNode.parentElement) !== null && _anchorNode$parentEle !== void 0 && _anchorNode$parentEle.hasAttribute('data-slate-mark-placeholder')) {\n            return;\n          }\n        }\n      } // when <Editable/> is being controlled through external value\n      // then its children might just change - DOM responds to it on its own\n      // but Slate's value is not being updated through any operation\n      // and thus it doesn't transform selection on its own\n\n\n      if (selection && !ReactEditor.hasRange(editor, selection)) {\n        editor.selection = ReactEditor.toSlateRange(editor, domSelection, {\n          exactMatch: false,\n          suppressThrow: true\n        });\n        return;\n      } // Otherwise the DOM selection is out of sync, so update it.\n\n\n      state.isUpdatingSelection = true;\n      var newDomRange = selection && ReactEditor.toDOMRange(editor, selection);\n\n      if (newDomRange) {\n        if (ReactEditor.isComposing(editor) && !IS_ANDROID) {\n          domSelection.collapseToEnd();\n        } else if (Range.isBackward(selection)) {\n          domSelection.setBaseAndExtent(newDomRange.endContainer, newDomRange.endOffset, newDomRange.startContainer, newDomRange.startOffset);\n        } else {\n          domSelection.setBaseAndExtent(newDomRange.startContainer, newDomRange.startOffset, newDomRange.endContainer, newDomRange.endOffset);\n        }\n\n        scrollSelectionIntoView(editor, newDomRange);\n      } else {\n        domSelection.removeAllRanges();\n      }\n\n      return newDomRange;\n    }; // In firefox if there is more then 1 range and we call setDomSelection we remove the ability to select more cells in a table\n\n\n    if (domSelection.rangeCount <= 1) {\n      setDomSelection();\n    }\n\n    var ensureSelection = ((_androidInputManagerR2 = androidInputManagerRef.current) === null || _androidInputManagerR2 === void 0 ? void 0 : _androidInputManagerR2.isFlushing()) === 'action';\n\n    if (!IS_ANDROID || !ensureSelection) {\n      setTimeout(() => {\n        state.isUpdatingSelection = false;\n      });\n      return;\n    }\n\n    var timeoutId = null;\n    var animationFrameId = requestAnimationFrame(() => {\n      if (ensureSelection) {\n        var ensureDomSelection = forceChange => {\n          try {\n            var el = ReactEditor.toDOMNode(editor, editor);\n            el.focus();\n            setDomSelection(forceChange);\n          } catch (e) {// Ignore, dom and state might be out of sync\n          }\n        }; // Compat: Android IMEs try to force their selection by manually re-applying it even after we set it.\n        // This essentially would make setting the slate selection during an update meaningless, so we force it\n        // again here. We can't only do it in the setTimeout after the animation frame since that would cause a\n        // visible flicker.\n\n\n        ensureDomSelection();\n        timeoutId = setTimeout(() => {\n          // COMPAT: While setting the selection in an animation frame visually correctly sets the selection,\n          // it doesn't update GBoards spellchecker state. We have to manually trigger a selection change after\n          // the animation frame to ensure it displays the correct state.\n          ensureDomSelection(true);\n          state.isUpdatingSelection = false;\n        });\n      }\n    });\n    return () => {\n      cancelAnimationFrame(animationFrameId);\n\n      if (timeoutId) {\n        clearTimeout(timeoutId);\n      }\n    };\n  }); // Listen on the native `beforeinput` event to get real \"Level 2\" events. This\n  // is required because React's `beforeinput` is fake and never really attaches\n  // to the real event sadly. (2019/11/01)\n  // https://github.com/facebook/react/issues/11211\n\n  var onDOMBeforeInput = useCallback(event => {\n    onUserInput();\n\n    if (!readOnly && ReactEditor.hasEditableTarget(editor, event.target) && !isDOMEventHandled(event, propsOnDOMBeforeInput)) {\n      var _EDITOR_TO_USER_SELEC;\n\n      // COMPAT: BeforeInput events aren't cancelable on android, so we have to handle them differently using the android input manager.\n      if (androidInputManagerRef.current) {\n        return androidInputManagerRef.current.handleDOMBeforeInput(event);\n      } // Some IMEs/Chrome extensions like e.g. Grammarly set the selection immediately before\n      // triggering a `beforeinput` expecting the change to be applied to the immediately before\n      // set selection.\n\n\n      scheduleOnDOMSelectionChange.flush();\n      onDOMSelectionChange.flush();\n      var {\n        selection\n      } = editor;\n      var {\n        inputType: type\n      } = event;\n      var data = event.dataTransfer || event.data || undefined;\n      var isCompositionChange = type === 'insertCompositionText' || type === 'deleteCompositionText'; // COMPAT: use composition change events as a hint to where we should insert\n      // composition text if we aren't composing to work around https://github.com/ianstormtaylor/slate/issues/5038\n\n      if (isCompositionChange && ReactEditor.isComposing(editor)) {\n        return;\n      }\n\n      var native = false;\n\n      if (type === 'insertText' && selection && Range.isCollapsed(selection) && // Only use native character insertion for single characters a-z or space for now.\n      // Long-press events (hold a + press 4 = ä) to choose a special character otherwise\n      // causes duplicate inserts.\n      event.data && event.data.length === 1 && /[a-z ]/i.test(event.data) && // Chrome has issues correctly editing the start of nodes: https://bugs.chromium.org/p/chromium/issues/detail?id=1249405\n      // When there is an inline element, e.g. a link, and you select\n      // right after it (the start of the next node).\n      selection.anchor.offset !== 0) {\n        var _node$parentElement, _window$getComputedSt;\n\n        native = true; // Skip native if there are marks, as\n        // `insertText` will insert a node, not just text.\n\n        if (editor.marks) {\n          native = false;\n        } // Chrome also has issues correctly editing the end of anchor elements: https://bugs.chromium.org/p/chromium/issues/detail?id=1259100\n        // Therefore we don't allow native events to insert text at the end of anchor nodes.\n\n\n        var {\n          anchor\n        } = selection;\n        var [node, offset] = ReactEditor.toDOMPoint(editor, anchor);\n        var anchorNode = (_node$parentElement = node.parentElement) === null || _node$parentElement === void 0 ? void 0 : _node$parentElement.closest('a');\n        var window = ReactEditor.getWindow(editor);\n\n        if (native && anchorNode && ReactEditor.hasDOMNode(editor, anchorNode)) {\n          var _lastText$textContent;\n\n          // Find the last text node inside the anchor.\n          var lastText = window === null || window === void 0 ? void 0 : window.document.createTreeWalker(anchorNode, NodeFilter.SHOW_TEXT).lastChild();\n\n          if (lastText === node && ((_lastText$textContent = lastText.textContent) === null || _lastText$textContent === void 0 ? void 0 : _lastText$textContent.length) === offset) {\n            native = false;\n          }\n        } // Chrome has issues with the presence of tab characters inside elements with whiteSpace = 'pre'\n        // causing abnormal insert behavior: https://bugs.chromium.org/p/chromium/issues/detail?id=1219139\n\n\n        if (native && node.parentElement && (window === null || window === void 0 ? void 0 : (_window$getComputedSt = window.getComputedStyle(node.parentElement)) === null || _window$getComputedSt === void 0 ? void 0 : _window$getComputedSt.whiteSpace) === 'pre') {\n          var block = Editor.above(editor, {\n            at: anchor.path,\n            match: n => Element$1.isElement(n) && Editor.isBlock(editor, n)\n          });\n\n          if (block && Node.string(block[0]).includes('\\t')) {\n            native = false;\n          }\n        }\n      } // COMPAT: For the deleting forward/backward input types we don't want\n      // to change the selection because it is the range that will be deleted,\n      // and those commands determine that for themselves.\n\n\n      if (!type.startsWith('delete') || type.startsWith('deleteBy')) {\n        var [targetRange] = event.getTargetRanges();\n\n        if (targetRange) {\n          var range = ReactEditor.toSlateRange(editor, targetRange, {\n            exactMatch: false,\n            suppressThrow: false\n          });\n\n          if (!selection || !Range.equals(selection, range)) {\n            native = false;\n            var selectionRef = !isCompositionChange && editor.selection && Editor.rangeRef(editor, editor.selection);\n            Transforms.select(editor, range);\n\n            if (selectionRef) {\n              EDITOR_TO_USER_SELECTION.set(editor, selectionRef);\n            }\n          }\n        }\n      } // Composition change types occur while a user is composing text and can't be\n      // cancelled. Let them through and wait for the composition to end.\n\n\n      if (isCompositionChange) {\n        return;\n      }\n\n      if (!native) {\n        event.preventDefault();\n      } // COMPAT: If the selection is expanded, even if the command seems like\n      // a delete forward/backward command it should delete the selection.\n\n\n      if (selection && Range.isExpanded(selection) && type.startsWith('delete')) {\n        var direction = type.endsWith('Backward') ? 'backward' : 'forward';\n        Editor.deleteFragment(editor, {\n          direction\n        });\n        return;\n      }\n\n      switch (type) {\n        case 'deleteByComposition':\n        case 'deleteByCut':\n        case 'deleteByDrag':\n          {\n            Editor.deleteFragment(editor);\n            break;\n          }\n\n        case 'deleteContent':\n        case 'deleteContentForward':\n          {\n            Editor.deleteForward(editor);\n            break;\n          }\n\n        case 'deleteContentBackward':\n          {\n            Editor.deleteBackward(editor);\n            break;\n          }\n\n        case 'deleteEntireSoftLine':\n          {\n            Editor.deleteBackward(editor, {\n              unit: 'line'\n            });\n            Editor.deleteForward(editor, {\n              unit: 'line'\n            });\n            break;\n          }\n\n        case 'deleteHardLineBackward':\n          {\n            Editor.deleteBackward(editor, {\n              unit: 'block'\n            });\n            break;\n          }\n\n        case 'deleteSoftLineBackward':\n          {\n            Editor.deleteBackward(editor, {\n              unit: 'line'\n            });\n            break;\n          }\n\n        case 'deleteHardLineForward':\n          {\n            Editor.deleteForward(editor, {\n              unit: 'block'\n            });\n            break;\n          }\n\n        case 'deleteSoftLineForward':\n          {\n            Editor.deleteForward(editor, {\n              unit: 'line'\n            });\n            break;\n          }\n\n        case 'deleteWordBackward':\n          {\n            Editor.deleteBackward(editor, {\n              unit: 'word'\n            });\n            break;\n          }\n\n        case 'deleteWordForward':\n          {\n            Editor.deleteForward(editor, {\n              unit: 'word'\n            });\n            break;\n          }\n\n        case 'insertLineBreak':\n          Editor.insertSoftBreak(editor);\n          break;\n\n        case 'insertParagraph':\n          {\n            Editor.insertBreak(editor);\n            break;\n          }\n\n        case 'insertFromComposition':\n        case 'insertFromDrop':\n        case 'insertFromPaste':\n        case 'insertFromYank':\n        case 'insertReplacementText':\n        case 'insertText':\n          {\n            if (type === 'insertFromComposition') {\n              // COMPAT: in Safari, `compositionend` is dispatched after the\n              // `beforeinput` for \"insertFromComposition\". But if we wait for it\n              // then we will abort because we're still composing and the selection\n              // won't be updated properly.\n              // https://www.w3.org/TR/input-events-2/\n              if (ReactEditor.isComposing(editor)) {\n                setIsComposing(false);\n                IS_COMPOSING.set(editor, false);\n              }\n            } // use a weak comparison instead of 'instanceof' to allow\n            // programmatic access of paste events coming from external windows\n            // like cypress where cy.window does not work realibly\n\n\n            if ((data === null || data === void 0 ? void 0 : data.constructor.name) === 'DataTransfer') {\n              ReactEditor.insertData(editor, data);\n            } else if (typeof data === 'string') {\n              // Only insertText operations use the native functionality, for now.\n              // Potentially expand to single character deletes, as well.\n              if (native) {\n                deferredOperations.current.push(() => Editor.insertText(editor, data));\n              } else {\n                Editor.insertText(editor, data);\n              }\n            }\n\n            break;\n          }\n      } // Restore the actual user section if nothing manually set it.\n\n\n      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();\n      EDITOR_TO_USER_SELECTION.delete(editor);\n\n      if (toRestore && (!editor.selection || !Range.equals(editor.selection, toRestore))) {\n        Transforms.select(editor, toRestore);\n      }\n    }\n  }, [editor, onDOMSelectionChange, onUserInput, propsOnDOMBeforeInput, readOnly, scheduleOnDOMSelectionChange]);\n  var callbackRef = useCallback(node => {\n    if (node == null) {\n      onDOMSelectionChange.cancel();\n      scheduleOnDOMSelectionChange.cancel();\n      EDITOR_TO_ELEMENT.delete(editor);\n      NODE_TO_ELEMENT.delete(editor);\n\n      if (ref.current && HAS_BEFORE_INPUT_SUPPORT) {\n        // @ts-ignore The `beforeinput` event isn't recognized.\n        ref.current.removeEventListener('beforeinput', onDOMBeforeInput);\n      }\n    } else {\n      // Attach a native DOM event handler for `beforeinput` events, because React's\n      // built-in `onBeforeInput` is actually a leaky polyfill that doesn't expose\n      // real `beforeinput` events sadly... (2019/11/04)\n      // https://github.com/facebook/react/issues/11211\n      if (HAS_BEFORE_INPUT_SUPPORT) {\n        // @ts-ignore The `beforeinput` event isn't recognized.\n        node.addEventListener('beforeinput', onDOMBeforeInput);\n      }\n    }\n\n    ref.current = node;\n  }, [onDOMSelectionChange, scheduleOnDOMSelectionChange, editor, onDOMBeforeInput]); // Attach a native DOM event handler for `selectionchange`, because React's\n  // built-in `onSelect` handler doesn't fire for all selection changes. It's a\n  // leaky polyfill that only fires on keypresses or clicks. Instead, we want to\n  // fire for any change to the selection inside the editor. (2019/11/04)\n  // https://github.com/facebook/react/issues/5785\n\n  useIsomorphicLayoutEffect(() => {\n    var window = ReactEditor.getWindow(editor);\n    window.document.addEventListener('selectionchange', scheduleOnDOMSelectionChange);\n    return () => {\n      window.document.removeEventListener('selectionchange', scheduleOnDOMSelectionChange);\n    };\n  }, [scheduleOnDOMSelectionChange]);\n  var decorations = decorate([editor, []]);\n  var showPlaceholder = placeholder && editor.children.length === 1 && Array.from(Node.texts(editor)).length === 1 && Node.string(editor) === '' && !isComposing;\n  var placeHolderResizeHandler = useCallback(placeholderEl => {\n    if (placeholderEl && showPlaceholder) {\n      var _placeholderEl$getBou;\n\n      setPlaceholderHeight((_placeholderEl$getBou = placeholderEl.getBoundingClientRect()) === null || _placeholderEl$getBou === void 0 ? void 0 : _placeholderEl$getBou.height);\n    } else {\n      setPlaceholderHeight(undefined);\n    }\n  }, [showPlaceholder]);\n\n  if (showPlaceholder) {\n    var start = Editor.start(editor, []);\n    decorations.push({\n      [PLACEHOLDER_SYMBOL]: true,\n      placeholder,\n      onPlaceholderResize: placeHolderResizeHandler,\n      anchor: start,\n      focus: start\n    });\n  }\n\n  var {\n    marks\n  } = editor;\n  state.hasMarkPlaceholder = false;\n\n  if (editor.selection && Range.isCollapsed(editor.selection) && marks) {\n    var {\n      anchor\n    } = editor.selection;\n    var leaf = Node.leaf(editor, anchor.path);\n\n    var rest = _objectWithoutProperties(leaf, _excluded2); // While marks isn't a 'complete' text, we can still use loose Text.equals\n    // here which only compares marks anyway.\n\n\n    if (!Text$1.equals(leaf, marks, {\n      loose: true\n    })) {\n      state.hasMarkPlaceholder = true;\n      var unset = Object.fromEntries(Object.keys(rest).map(mark => [mark, null]));\n      decorations.push(_objectSpread$1(_objectSpread$1(_objectSpread$1({\n        [MARK_PLACEHOLDER_SYMBOL]: true\n      }, unset), marks), {}, {\n        anchor,\n        focus: anchor\n      }));\n    }\n  } // Update EDITOR_TO_MARK_PLACEHOLDER_MARKS in setTimeout useEffect to ensure we don't set it\n  // before we receive the composition end event.\n\n\n  useEffect(() => {\n    setTimeout(() => {\n      var {\n        selection\n      } = editor;\n\n      if (selection) {\n        var {\n          anchor: _anchor\n        } = selection;\n\n        var _text = Node.leaf(editor, _anchor.path); // While marks isn't a 'complete' text, we can still use loose Text.equals\n        // here which only compares marks anyway.\n\n\n        if (marks && !Text$1.equals(_text, marks, {\n          loose: true\n        })) {\n          EDITOR_TO_PENDING_INSERTION_MARKS.set(editor, marks);\n          return;\n        }\n      }\n\n      EDITOR_TO_PENDING_INSERTION_MARKS.delete(editor);\n    });\n  });\n  return /*#__PURE__*/React.createElement(ReadOnlyContext.Provider, {\n    value: readOnly\n  }, /*#__PURE__*/React.createElement(DecorateContext.Provider, {\n    value: decorate\n  }, /*#__PURE__*/React.createElement(RestoreDOM, {\n    node: ref,\n    receivedUserInput: receivedUserInput\n  }, /*#__PURE__*/React.createElement(Component, Object.assign({\n    role: readOnly ? undefined : 'textbox',\n    \"aria-multiline\": readOnly ? undefined : true\n  }, attributes, {\n    // COMPAT: Certain browsers don't support the `beforeinput` event, so we'd\n    // have to use hacks to make these replacement-based features work.\n    // For SSR situations HAS_BEFORE_INPUT_SUPPORT is false and results in prop\n    // mismatch warning app moves to browser. Pass-through consumer props when\n    // not CAN_USE_DOM (SSR) and default to falsy value\n    spellCheck: HAS_BEFORE_INPUT_SUPPORT || !CAN_USE_DOM ? attributes.spellCheck : false,\n    autoCorrect: HAS_BEFORE_INPUT_SUPPORT || !CAN_USE_DOM ? attributes.autoCorrect : 'false',\n    autoCapitalize: HAS_BEFORE_INPUT_SUPPORT || !CAN_USE_DOM ? attributes.autoCapitalize : 'false',\n    \"data-slate-editor\": true,\n    \"data-slate-node\": \"value\",\n    // explicitly set this\n    contentEditable: !readOnly,\n    // in some cases, a decoration needs access to the range / selection to decorate a text node,\n    // then you will select the whole text node when you select part the of text\n    // this magic zIndex=\"-1\" will fix it\n    zindex: -1,\n    suppressContentEditableWarning: true,\n    ref: callbackRef,\n    style: _objectSpread$1(_objectSpread$1({}, disableDefaultStyles ? {} : _objectSpread$1({\n      // Allow positioning relative to the editable element.\n      position: 'relative',\n      // Preserve adjacent whitespace and new lines.\n      whiteSpace: 'pre-wrap',\n      // Allow words to break if they are too long.\n      wordWrap: 'break-word'\n    }, placeholderHeight ? {\n      minHeight: placeholderHeight\n    } : {})), userStyle),\n    onBeforeInput: useCallback(event => {\n      // COMPAT: Certain browsers don't support the `beforeinput` event, so we\n      // fall back to React's leaky polyfill instead just for it. It\n      // only works for the `insertText` input type.\n      if (!HAS_BEFORE_INPUT_SUPPORT && !readOnly && !isEventHandled(event, attributes.onBeforeInput) && ReactEditor.hasSelectableTarget(editor, event.target)) {\n        event.preventDefault();\n\n        if (!ReactEditor.isComposing(editor)) {\n          var _text2 = event.data;\n          Editor.insertText(editor, _text2);\n        }\n      }\n    }, [attributes.onBeforeInput, editor, readOnly]),\n    onInput: useCallback(event => {\n      if (isEventHandled(event, attributes.onInput)) {\n        return;\n      }\n\n      if (androidInputManagerRef.current) {\n        androidInputManagerRef.current.handleInput();\n        return;\n      } // Flush native operations, as native events will have propogated\n      // and we can correctly compare DOM text values in components\n      // to stop rendering, so that browser functions like autocorrect\n      // and spellcheck work as expected.\n\n\n      for (var op of deferredOperations.current) {\n        op();\n      }\n\n      deferredOperations.current = [];\n    }, [attributes.onInput]),\n    onBlur: useCallback(event => {\n      if (readOnly || state.isUpdatingSelection || !ReactEditor.hasSelectableTarget(editor, event.target) || isEventHandled(event, attributes.onBlur)) {\n        return;\n      } // COMPAT: If the current `activeElement` is still the previous\n      // one, this is due to the window being blurred when the tab\n      // itself becomes unfocused, so we want to abort early to allow to\n      // editor to stay focused when the tab becomes focused again.\n\n\n      var root = ReactEditor.findDocumentOrShadowRoot(editor);\n\n      if (state.latestElement === root.activeElement) {\n        return;\n      }\n\n      var {\n        relatedTarget\n      } = event;\n      var el = ReactEditor.toDOMNode(editor, editor); // COMPAT: The event should be ignored if the focus is returning\n      // to the editor from an embedded editable element (eg. an <input>\n      // element inside a void node).\n\n      if (relatedTarget === el) {\n        return;\n      } // COMPAT: The event should be ignored if the focus is moving from\n      // the editor to inside a void node's spacer element.\n\n\n      if (isDOMElement(relatedTarget) && relatedTarget.hasAttribute('data-slate-spacer')) {\n        return;\n      } // COMPAT: The event should be ignored if the focus is moving to a\n      // non- editable section of an element that isn't a void node (eg.\n      // a list item of the check list example).\n\n\n      if (relatedTarget != null && isDOMNode(relatedTarget) && ReactEditor.hasDOMNode(editor, relatedTarget)) {\n        var node = ReactEditor.toSlateNode(editor, relatedTarget);\n\n        if (Element$1.isElement(node) && !editor.isVoid(node)) {\n          return;\n        }\n      } // COMPAT: Safari doesn't always remove the selection even if the content-\n      // editable element no longer has focus. Refer to:\n      // https://stackoverflow.com/questions/12353247/force-contenteditable-div-to-stop-accepting-input-after-it-loses-focus-under-web\n\n\n      if (IS_WEBKIT) {\n        var domSelection = root.getSelection();\n        domSelection === null || domSelection === void 0 ? void 0 : domSelection.removeAllRanges();\n      }\n\n      IS_FOCUSED.delete(editor);\n    }, [readOnly, state.isUpdatingSelection, state.latestElement, editor, attributes.onBlur]),\n    onClick: useCallback(event => {\n      if (ReactEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onClick) && isDOMNode(event.target)) {\n        var node = ReactEditor.toSlateNode(editor, event.target);\n        var path = ReactEditor.findPath(editor, node); // At this time, the Slate document may be arbitrarily different,\n        // because onClick handlers can change the document before we get here.\n        // Therefore we must check that this path actually exists,\n        // and that it still refers to the same node.\n\n        if (!Editor.hasPath(editor, path) || Node.get(editor, path) !== node) {\n          return;\n        }\n\n        if (event.detail === TRIPLE_CLICK && path.length >= 1) {\n          var blockPath = path;\n\n          if (!(Element$1.isElement(node) && Editor.isBlock(editor, node))) {\n            var _block$;\n\n            var block = Editor.above(editor, {\n              match: n => Element$1.isElement(n) && Editor.isBlock(editor, n),\n              at: path\n            });\n            blockPath = (_block$ = block === null || block === void 0 ? void 0 : block[1]) !== null && _block$ !== void 0 ? _block$ : path.slice(0, 1);\n          }\n\n          var range = Editor.range(editor, blockPath);\n          Transforms.select(editor, range);\n          return;\n        }\n\n        if (readOnly) {\n          return;\n        }\n\n        var _start = Editor.start(editor, path);\n\n        var end = Editor.end(editor, path);\n        var startVoid = Editor.void(editor, {\n          at: _start\n        });\n        var endVoid = Editor.void(editor, {\n          at: end\n        });\n\n        if (startVoid && endVoid && Path.equals(startVoid[1], endVoid[1])) {\n          var _range = Editor.range(editor, _start);\n\n          Transforms.select(editor, _range);\n        }\n      }\n    }, [editor, attributes.onClick, readOnly]),\n    onCompositionEnd: useCallback(event => {\n      if (ReactEditor.hasSelectableTarget(editor, event.target)) {\n        var _androidInputManagerR3;\n\n        if (ReactEditor.isComposing(editor)) {\n          setIsComposing(false);\n          IS_COMPOSING.set(editor, false);\n        }\n\n        (_androidInputManagerR3 = androidInputManagerRef.current) === null || _androidInputManagerR3 === void 0 ? void 0 : _androidInputManagerR3.handleCompositionEnd(event);\n\n        if (isEventHandled(event, attributes.onCompositionEnd) || IS_ANDROID) {\n          return;\n        } // COMPAT: In Chrome, `beforeinput` events for compositions\n        // aren't correct and never fire the \"insertFromComposition\"\n        // type that we need. So instead, insert whenever a composition\n        // ends since it will already have been committed to the DOM.\n\n\n        if (!IS_WEBKIT && !IS_FIREFOX_LEGACY && !IS_IOS && !IS_WECHATBROWSER && !IS_UC_MOBILE && event.data) {\n          var placeholderMarks = EDITOR_TO_PENDING_INSERTION_MARKS.get(editor);\n          EDITOR_TO_PENDING_INSERTION_MARKS.delete(editor); // Ensure we insert text with the marks the user was actually seeing\n\n          if (placeholderMarks !== undefined) {\n            EDITOR_TO_USER_MARKS.set(editor, editor.marks);\n            editor.marks = placeholderMarks;\n          }\n\n          Editor.insertText(editor, event.data);\n          var userMarks = EDITOR_TO_USER_MARKS.get(editor);\n          EDITOR_TO_USER_MARKS.delete(editor);\n\n          if (userMarks !== undefined) {\n            editor.marks = userMarks;\n          }\n        }\n      }\n    }, [attributes.onCompositionEnd, editor]),\n    onCompositionUpdate: useCallback(event => {\n      if (ReactEditor.hasSelectableTarget(editor, event.target) && !isEventHandled(event, attributes.onCompositionUpdate)) {\n        if (!ReactEditor.isComposing(editor)) {\n          setIsComposing(true);\n          IS_COMPOSING.set(editor, true);\n        }\n      }\n    }, [attributes.onCompositionUpdate, editor]),\n    onCompositionStart: useCallback(event => {\n      if (ReactEditor.hasSelectableTarget(editor, event.target)) {\n        var _androidInputManagerR4;\n\n        (_androidInputManagerR4 = androidInputManagerRef.current) === null || _androidInputManagerR4 === void 0 ? void 0 : _androidInputManagerR4.handleCompositionStart(event);\n\n        if (isEventHandled(event, attributes.onCompositionStart) || IS_ANDROID) {\n          return;\n        }\n\n        setIsComposing(true);\n        var {\n          selection\n        } = editor;\n\n        if (selection) {\n          if (Range.isExpanded(selection)) {\n            Editor.deleteFragment(editor);\n            return;\n          }\n\n          var inline = Editor.above(editor, {\n            match: n => Element$1.isElement(n) && Editor.isInline(editor, n),\n            mode: 'highest'\n          });\n\n          if (inline) {\n            var [, inlinePath] = inline;\n\n            if (Editor.isEnd(editor, selection.anchor, inlinePath)) {\n              var point = Editor.after(editor, inlinePath);\n              Transforms.setSelection(editor, {\n                anchor: point,\n                focus: point\n              });\n            }\n          }\n        }\n      }\n    }, [attributes.onCompositionStart, editor]),\n    onCopy: useCallback(event => {\n      if (ReactEditor.hasSelectableTarget(editor, event.target) && !isEventHandled(event, attributes.onCopy) && !isDOMEventTargetInput(event)) {\n        event.preventDefault();\n        ReactEditor.setFragmentData(editor, event.clipboardData, 'copy');\n      }\n    }, [attributes.onCopy, editor]),\n    onCut: useCallback(event => {\n      if (!readOnly && ReactEditor.hasSelectableTarget(editor, event.target) && !isEventHandled(event, attributes.onCut) && !isDOMEventTargetInput(event)) {\n        event.preventDefault();\n        ReactEditor.setFragmentData(editor, event.clipboardData, 'cut');\n        var {\n          selection\n        } = editor;\n\n        if (selection) {\n          if (Range.isExpanded(selection)) {\n            Editor.deleteFragment(editor);\n          } else {\n            var node = Node.parent(editor, selection.anchor.path);\n\n            if (Editor.isVoid(editor, node)) {\n              Transforms.delete(editor);\n            }\n          }\n        }\n      }\n    }, [readOnly, editor, attributes.onCut]),\n    onDragOver: useCallback(event => {\n      if (ReactEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onDragOver)) {\n        // Only when the target is void, call `preventDefault` to signal\n        // that drops are allowed. Editable content is droppable by\n        // default, and calling `preventDefault` hides the cursor.\n        var node = ReactEditor.toSlateNode(editor, event.target);\n\n        if (Element$1.isElement(node) && Editor.isVoid(editor, node)) {\n          event.preventDefault();\n        }\n      }\n    }, [attributes.onDragOver, editor]),\n    onDragStart: useCallback(event => {\n      if (!readOnly && ReactEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onDragStart)) {\n        var node = ReactEditor.toSlateNode(editor, event.target);\n        var path = ReactEditor.findPath(editor, node);\n        var voidMatch = Element$1.isElement(node) && Editor.isVoid(editor, node) || Editor.void(editor, {\n          at: path,\n          voids: true\n        }); // If starting a drag on a void node, make sure it is selected\n        // so that it shows up in the selection's fragment.\n\n        if (voidMatch) {\n          var range = Editor.range(editor, path);\n          Transforms.select(editor, range);\n        }\n\n        state.isDraggingInternally = true;\n        ReactEditor.setFragmentData(editor, event.dataTransfer, 'drag');\n      }\n    }, [readOnly, editor, attributes.onDragStart, state]),\n    onDrop: useCallback(event => {\n      if (!readOnly && ReactEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onDrop)) {\n        event.preventDefault(); // Keep a reference to the dragged range before updating selection\n\n        var draggedRange = editor.selection; // Find the range where the drop happened\n\n        var range = ReactEditor.findEventRange(editor, event);\n        var data = event.dataTransfer;\n        Transforms.select(editor, range);\n\n        if (state.isDraggingInternally) {\n          if (draggedRange && !Range.equals(draggedRange, range) && !Editor.void(editor, {\n            at: range,\n            voids: true\n          })) {\n            Transforms.delete(editor, {\n              at: draggedRange\n            });\n          }\n        }\n\n        ReactEditor.insertData(editor, data); // When dragging from another source into the editor, it's possible\n        // that the current editor does not have focus.\n\n        if (!ReactEditor.isFocused(editor)) {\n          ReactEditor.focus(editor);\n        }\n      }\n\n      state.isDraggingInternally = false;\n    }, [readOnly, editor, attributes.onDrop, state]),\n    onDragEnd: useCallback(event => {\n      if (!readOnly && state.isDraggingInternally && attributes.onDragEnd && ReactEditor.hasTarget(editor, event.target)) {\n        attributes.onDragEnd(event);\n      } // When dropping on a different droppable element than the current editor,\n      // `onDrop` is not called. So we need to clean up in `onDragEnd` instead.\n      // Note: `onDragEnd` is only called when `onDrop` is not called\n\n\n      state.isDraggingInternally = false;\n    }, [readOnly, state, attributes, editor]),\n    onFocus: useCallback(event => {\n      if (!readOnly && !state.isUpdatingSelection && ReactEditor.hasEditableTarget(editor, event.target) && !isEventHandled(event, attributes.onFocus)) {\n        var el = ReactEditor.toDOMNode(editor, editor);\n        var root = ReactEditor.findDocumentOrShadowRoot(editor);\n        state.latestElement = root.activeElement; // COMPAT: If the editor has nested editable elements, the focus\n        // can go to them. In Firefox, this must be prevented because it\n        // results in issues with keyboard navigation. (2017/03/30)\n\n        if (IS_FIREFOX && event.target !== el) {\n          el.focus();\n          return;\n        }\n\n        IS_FOCUSED.set(editor, true);\n      }\n    }, [readOnly, state, editor, attributes.onFocus]),\n    onKeyDown: useCallback(event => {\n      if (!readOnly && ReactEditor.hasEditableTarget(editor, event.target)) {\n        var _androidInputManagerR5;\n\n        (_androidInputManagerR5 = androidInputManagerRef.current) === null || _androidInputManagerR5 === void 0 ? void 0 : _androidInputManagerR5.handleKeyDown(event);\n        var {\n          nativeEvent\n        } = event; // COMPAT: The composition end event isn't fired reliably in all browsers,\n        // so we sometimes might end up stuck in a composition state even though we\n        // aren't composing any more.\n\n        if (ReactEditor.isComposing(editor) && nativeEvent.isComposing === false) {\n          IS_COMPOSING.set(editor, false);\n          setIsComposing(false);\n        }\n\n        if (isEventHandled(event, attributes.onKeyDown) || ReactEditor.isComposing(editor)) {\n          return;\n        }\n\n        var {\n          selection\n        } = editor;\n        var element = editor.children[selection !== null ? selection.focus.path[0] : 0];\n        var isRTL = getDirection(Node.string(element)) === 'rtl'; // COMPAT: Since we prevent the default behavior on\n        // `beforeinput` events, the browser doesn't think there's ever\n        // any history stack to undo or redo, so we have to manage these\n        // hotkeys ourselves. (2019/11/06)\n\n        if (Hotkeys.isRedo(nativeEvent)) {\n          event.preventDefault();\n          var maybeHistoryEditor = editor;\n\n          if (typeof maybeHistoryEditor.redo === 'function') {\n            maybeHistoryEditor.redo();\n          }\n\n          return;\n        }\n\n        if (Hotkeys.isUndo(nativeEvent)) {\n          event.preventDefault();\n          var _maybeHistoryEditor = editor;\n\n          if (typeof _maybeHistoryEditor.undo === 'function') {\n            _maybeHistoryEditor.undo();\n          }\n\n          return;\n        } // COMPAT: Certain browsers don't handle the selection updates\n        // properly. In Chrome, the selection isn't properly extended.\n        // And in Firefox, the selection isn't properly collapsed.\n        // (2017/10/17)\n\n\n        if (Hotkeys.isMoveLineBackward(nativeEvent)) {\n          event.preventDefault();\n          Transforms.move(editor, {\n            unit: 'line',\n            reverse: true\n          });\n          return;\n        }\n\n        if (Hotkeys.isMoveLineForward(nativeEvent)) {\n          event.preventDefault();\n          Transforms.move(editor, {\n            unit: 'line'\n          });\n          return;\n        }\n\n        if (Hotkeys.isExtendLineBackward(nativeEvent)) {\n          event.preventDefault();\n          Transforms.move(editor, {\n            unit: 'line',\n            edge: 'focus',\n            reverse: true\n          });\n          return;\n        }\n\n        if (Hotkeys.isExtendLineForward(nativeEvent)) {\n          event.preventDefault();\n          Transforms.move(editor, {\n            unit: 'line',\n            edge: 'focus'\n          });\n          return;\n        } // COMPAT: If a void node is selected, or a zero-width text node\n        // adjacent to an inline is selected, we need to handle these\n        // hotkeys manually because browsers won't be able to skip over\n        // the void node with the zero-width space not being an empty\n        // string.\n\n\n        if (Hotkeys.isMoveBackward(nativeEvent)) {\n          event.preventDefault();\n\n          if (selection && Range.isCollapsed(selection)) {\n            Transforms.move(editor, {\n              reverse: !isRTL\n            });\n          } else {\n            Transforms.collapse(editor, {\n              edge: 'start'\n            });\n          }\n\n          return;\n        }\n\n        if (Hotkeys.isMoveForward(nativeEvent)) {\n          event.preventDefault();\n\n          if (selection && Range.isCollapsed(selection)) {\n            Transforms.move(editor, {\n              reverse: isRTL\n            });\n          } else {\n            Transforms.collapse(editor, {\n              edge: 'end'\n            });\n          }\n\n          return;\n        }\n\n        if (Hotkeys.isMoveWordBackward(nativeEvent)) {\n          event.preventDefault();\n\n          if (selection && Range.isExpanded(selection)) {\n            Transforms.collapse(editor, {\n              edge: 'focus'\n            });\n          }\n\n          Transforms.move(editor, {\n            unit: 'word',\n            reverse: !isRTL\n          });\n          return;\n        }\n\n        if (Hotkeys.isMoveWordForward(nativeEvent)) {\n          event.preventDefault();\n\n          if (selection && Range.isExpanded(selection)) {\n            Transforms.collapse(editor, {\n              edge: 'focus'\n            });\n          }\n\n          Transforms.move(editor, {\n            unit: 'word',\n            reverse: isRTL\n          });\n          return;\n        } // COMPAT: Certain browsers don't support the `beforeinput` event, so we\n        // fall back to guessing at the input intention for hotkeys.\n        // COMPAT: In iOS, some of these hotkeys are handled in the\n\n\n        if (!HAS_BEFORE_INPUT_SUPPORT) {\n          // We don't have a core behavior for these, but they change the\n          // DOM if we don't prevent them, so we have to.\n          if (Hotkeys.isBold(nativeEvent) || Hotkeys.isItalic(nativeEvent) || Hotkeys.isTransposeCharacter(nativeEvent)) {\n            event.preventDefault();\n            return;\n          }\n\n          if (Hotkeys.isSoftBreak(nativeEvent)) {\n            event.preventDefault();\n            Editor.insertSoftBreak(editor);\n            return;\n          }\n\n          if (Hotkeys.isSplitBlock(nativeEvent)) {\n            event.preventDefault();\n            Editor.insertBreak(editor);\n            return;\n          }\n\n          if (Hotkeys.isDeleteBackward(nativeEvent)) {\n            event.preventDefault();\n\n            if (selection && Range.isExpanded(selection)) {\n              Editor.deleteFragment(editor, {\n                direction: 'backward'\n              });\n            } else {\n              Editor.deleteBackward(editor);\n            }\n\n            return;\n          }\n\n          if (Hotkeys.isDeleteForward(nativeEvent)) {\n            event.preventDefault();\n\n            if (selection && Range.isExpanded(selection)) {\n              Editor.deleteFragment(editor, {\n                direction: 'forward'\n              });\n            } else {\n              Editor.deleteForward(editor);\n            }\n\n            return;\n          }\n\n          if (Hotkeys.isDeleteLineBackward(nativeEvent)) {\n            event.preventDefault();\n\n            if (selection && Range.isExpanded(selection)) {\n              Editor.deleteFragment(editor, {\n                direction: 'backward'\n              });\n            } else {\n              Editor.deleteBackward(editor, {\n                unit: 'line'\n              });\n            }\n\n            return;\n          }\n\n          if (Hotkeys.isDeleteLineForward(nativeEvent)) {\n            event.preventDefault();\n\n            if (selection && Range.isExpanded(selection)) {\n              Editor.deleteFragment(editor, {\n                direction: 'forward'\n              });\n            } else {\n              Editor.deleteForward(editor, {\n                unit: 'line'\n              });\n            }\n\n            return;\n          }\n\n          if (Hotkeys.isDeleteWordBackward(nativeEvent)) {\n            event.preventDefault();\n\n            if (selection && Range.isExpanded(selection)) {\n              Editor.deleteFragment(editor, {\n                direction: 'backward'\n              });\n            } else {\n              Editor.deleteBackward(editor, {\n                unit: 'word'\n              });\n            }\n\n            return;\n          }\n\n          if (Hotkeys.isDeleteWordForward(nativeEvent)) {\n            event.preventDefault();\n\n            if (selection && Range.isExpanded(selection)) {\n              Editor.deleteFragment(editor, {\n                direction: 'forward'\n              });\n            } else {\n              Editor.deleteForward(editor, {\n                unit: 'word'\n              });\n            }\n\n            return;\n          }\n        } else {\n          if (IS_CHROME || IS_WEBKIT) {\n            // COMPAT: Chrome and Safari support `beforeinput` event but do not fire\n            // an event when deleting backwards in a selected void inline node\n            if (selection && (Hotkeys.isDeleteBackward(nativeEvent) || Hotkeys.isDeleteForward(nativeEvent)) && Range.isCollapsed(selection)) {\n              var currentNode = Node.parent(editor, selection.anchor.path);\n\n              if (Element$1.isElement(currentNode) && Editor.isVoid(editor, currentNode) && (Editor.isInline(editor, currentNode) || Editor.isBlock(editor, currentNode))) {\n                event.preventDefault();\n                Editor.deleteBackward(editor, {\n                  unit: 'block'\n                });\n                return;\n              }\n            }\n          }\n        }\n      }\n    }, [readOnly, editor, attributes.onKeyDown]),\n    onPaste: useCallback(event => {\n      if (!readOnly && ReactEditor.hasEditableTarget(editor, event.target) && !isEventHandled(event, attributes.onPaste)) {\n        // COMPAT: Certain browsers don't support the `beforeinput` event, so we\n        // fall back to React's `onPaste` here instead.\n        // COMPAT: Firefox, Chrome and Safari don't emit `beforeinput` events\n        // when \"paste without formatting\" is used, so fallback. (2020/02/20)\n        // COMPAT: Safari InputEvents generated by pasting won't include\n        // application/x-slate-fragment items, so use the\n        // ClipboardEvent here. (2023/03/15)\n        if (!HAS_BEFORE_INPUT_SUPPORT || isPlainTextOnlyPaste(event.nativeEvent) || IS_WEBKIT) {\n          event.preventDefault();\n          ReactEditor.insertData(editor, event.clipboardData);\n        }\n      }\n    }, [readOnly, editor, attributes.onPaste])\n  }), /*#__PURE__*/React.createElement(Children, {\n    decorations: decorations,\n    node: editor,\n    renderElement: renderElement,\n    renderPlaceholder: renderPlaceholder,\n    renderLeaf: renderLeaf,\n    selection: editor.selection\n  })))));\n};\n/**\r\n * The default placeholder element\r\n */\n\nvar DefaultPlaceholder = _ref => {\n  var {\n    attributes,\n    children\n  } = _ref;\n  return (\n    /*#__PURE__*/\n    // COMPAT: Artificially add a line-break to the end on the placeholder element\n    // to prevent Android IMEs to pick up its content in autocorrect and to auto-capitalize the first letter\n    React.createElement(\"span\", Object.assign({}, attributes), children, IS_ANDROID && /*#__PURE__*/React.createElement(\"br\", null))\n  );\n};\n/**\r\n * A default memoized decorate function.\r\n */\n\nvar defaultDecorate = () => [];\n/**\r\n * A default implement to scroll dom range into view.\r\n */\n\nvar defaultScrollSelectionIntoView = (editor, domRange) => {\n  // This was affecting the selection of multiple blocks and dragging behavior,\n  // so enabled only if the selection has been collapsed.\n  if (domRange.getBoundingClientRect && (!editor.selection || editor.selection && Range.isCollapsed(editor.selection))) {\n    var leafEl = domRange.startContainer.parentElement;\n    leafEl.getBoundingClientRect = domRange.getBoundingClientRect.bind(domRange);\n    scrollIntoView(leafEl, {\n      scrollMode: 'if-needed'\n    }); // @ts-expect-error an unorthodox delete D:\n\n    delete leafEl.getBoundingClientRect;\n  }\n};\n/**\r\n * Check if an event is overrided by a handler.\r\n */\n\n\nvar isEventHandled = (event, handler) => {\n  if (!handler) {\n    return false;\n  } // The custom event handler may return a boolean to specify whether the event\n  // shall be treated as being handled or not.\n\n\n  var shouldTreatEventAsHandled = handler(event);\n\n  if (shouldTreatEventAsHandled != null) {\n    return shouldTreatEventAsHandled;\n  }\n\n  return event.isDefaultPrevented() || event.isPropagationStopped();\n};\n/**\r\n * Check if the event's target is an input element\r\n */\n\nvar isDOMEventTargetInput = event => {\n  return isDOMNode(event.target) && (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement);\n};\n/**\r\n * Check if a DOM event is overrided by a handler.\r\n */\n\nvar isDOMEventHandled = (event, handler) => {\n  if (!handler) {\n    return false;\n  } // The custom event handler may return a boolean to specify whether the event\n  // shall be treated as being handled or not.\n\n\n  var shouldTreatEventAsHandled = handler(event);\n\n  if (shouldTreatEventAsHandled != null) {\n    return shouldTreatEventAsHandled;\n  }\n\n  return event.defaultPrevented;\n};\n\n/**\r\n * A React context for sharing the `focused` state of the editor.\r\n */\n\nvar FocusedContext = /*#__PURE__*/createContext(false);\n/**\r\n * Get the current `focused` state of the editor.\r\n */\n\nvar useFocused = () => {\n  return useContext(FocusedContext);\n};\n\nfunction isError(error) {\n  return error instanceof Error;\n}\n/**\r\n * A React context for sharing the editor selector context in a way to control rerenders\r\n */\n\n\nvar SlateSelectorContext = /*#__PURE__*/createContext({});\n\nvar refEquality = (a, b) => a === b;\n/**\r\n * use redux style selectors to prevent rerendering on every keystroke.\r\n * Bear in mind rerendering can only prevented if the returned value is a value type or for reference types (e.g. objects and arrays) add a custom equality function.\r\n *\r\n * Example:\r\n * ```\r\n *  const isSelectionActive = useSlateSelector(editor => Boolean(editor.selection));\r\n * ```\r\n */\n\n\nfunction useSlateSelector(selector) {\n  var equalityFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : refEquality;\n  var [, forceRender] = useReducer(s => s + 1, 0);\n  var context = useContext(SlateSelectorContext);\n\n  if (!context) {\n    throw new Error(\"The `useSlateSelector` hook must be used inside the <Slate> component's context.\");\n  }\n\n  var {\n    getSlate,\n    addEventListener\n  } = context;\n  var latestSubscriptionCallbackError = useRef();\n  var latestSelector = useRef(() => null);\n  var latestSelectedState = useRef(null);\n  var selectedState;\n\n  try {\n    if (selector !== latestSelector.current || latestSubscriptionCallbackError.current) {\n      selectedState = selector(getSlate());\n    } else {\n      selectedState = latestSelectedState.current;\n    }\n  } catch (err) {\n    if (latestSubscriptionCallbackError.current && isError(err)) {\n      err.message += \"\\nThe error may be correlated with this previous error:\\n\".concat(latestSubscriptionCallbackError.current.stack, \"\\n\\n\");\n    }\n\n    throw err;\n  }\n\n  useIsomorphicLayoutEffect(() => {\n    latestSelector.current = selector;\n    latestSelectedState.current = selectedState;\n    latestSubscriptionCallbackError.current = undefined;\n  });\n  useIsomorphicLayoutEffect(() => {\n    function checkForUpdates() {\n      try {\n        var newSelectedState = latestSelector.current(getSlate());\n\n        if (equalityFn(newSelectedState, latestSelectedState.current)) {\n          return;\n        }\n\n        latestSelectedState.current = newSelectedState;\n      } catch (err) {\n        // we ignore all errors here, since when the component\n        // is re-rendered, the selectors are called again, and\n        // will throw again, if neither props nor store state\n        // changed\n        latestSubscriptionCallbackError.current = err;\n      }\n\n      forceRender();\n    }\n\n    var unsubscribe = addEventListener(checkForUpdates);\n    checkForUpdates();\n    return () => unsubscribe();\n  }, // don't rerender on equalityFn change since we want to be able to define it inline\n  [addEventListener, getSlate]);\n  return selectedState;\n}\n/**\r\n * Create selector context with editor updating on every editor change\r\n */\n\nfunction useSelectorContext(editor) {\n  var eventListeners = useRef([]).current;\n  var slateRef = useRef({\n    editor\n  }).current;\n  var onChange = useCallback(editor => {\n    slateRef.editor = editor;\n    eventListeners.forEach(listener => listener(editor));\n  }, [eventListeners, slateRef]);\n  var selectorContext = useMemo(() => {\n    return {\n      getSlate: () => slateRef.editor,\n      addEventListener: callback => {\n        eventListeners.push(callback);\n        return () => {\n          eventListeners.splice(eventListeners.indexOf(callback), 1);\n        };\n      }\n    };\n  }, [eventListeners, slateRef]);\n  return {\n    selectorContext,\n    onChange\n  };\n}\n\nvar _excluded = [\"editor\", \"children\", \"onChange\", \"initialValue\"];\n/**\r\n * A wrapper around the provider to handle `onChange` events, because the editor\r\n * is a mutable singleton so it won't ever register as \"changed\" otherwise.\r\n */\n\nvar Slate = props => {\n  var {\n    editor,\n    children,\n    onChange,\n    initialValue\n  } = props,\n      rest = _objectWithoutProperties(props, _excluded);\n\n  var [context, setContext] = React.useState(() => {\n    if (!Node.isNodeList(initialValue)) {\n      throw new Error(\"[Slate] initialValue is invalid! Expected a list of elements but got: \".concat(Scrubber.stringify(initialValue)));\n    }\n\n    if (!Editor.isEditor(editor)) {\n      throw new Error(\"[Slate] editor is invalid! You passed: \".concat(Scrubber.stringify(editor)));\n    }\n\n    editor.children = initialValue;\n    Object.assign(editor, rest);\n    return {\n      v: 0,\n      editor\n    };\n  });\n  var {\n    selectorContext,\n    onChange: handleSelectorChange\n  } = useSelectorContext(editor);\n  var onContextChange = useCallback(() => {\n    if (onChange) {\n      onChange(editor.children);\n    }\n\n    setContext(prevContext => ({\n      v: prevContext.v + 1,\n      editor\n    }));\n    handleSelectorChange(editor);\n  }, [editor, handleSelectorChange, onChange]);\n  useEffect(() => {\n    EDITOR_TO_ON_CHANGE.set(editor, onContextChange);\n    return () => {\n      EDITOR_TO_ON_CHANGE.set(editor, () => {});\n    };\n  }, [editor, onContextChange]);\n  var [isFocused, setIsFocused] = useState(ReactEditor.isFocused(editor));\n  useEffect(() => {\n    setIsFocused(ReactEditor.isFocused(editor));\n  }, [editor]);\n  useIsomorphicLayoutEffect(() => {\n    var fn = () => setIsFocused(ReactEditor.isFocused(editor));\n\n    if (REACT_MAJOR_VERSION >= 17) {\n      // In React >= 17 onFocus and onBlur listen to the focusin and focusout events during the bubbling phase.\n      // Therefore in order for <Editable />'s handlers to run first, which is necessary for ReactEditor.isFocused(editor)\n      // to return the correct value, we have to listen to the focusin and focusout events without useCapture here.\n      document.addEventListener('focusin', fn);\n      document.addEventListener('focusout', fn);\n      return () => {\n        document.removeEventListener('focusin', fn);\n        document.removeEventListener('focusout', fn);\n      };\n    } else {\n      document.addEventListener('focus', fn, true);\n      document.addEventListener('blur', fn, true);\n      return () => {\n        document.removeEventListener('focus', fn, true);\n        document.removeEventListener('blur', fn, true);\n      };\n    }\n  }, []);\n  return /*#__PURE__*/React.createElement(SlateSelectorContext.Provider, {\n    value: selectorContext\n  }, /*#__PURE__*/React.createElement(SlateContext.Provider, {\n    value: context\n  }, /*#__PURE__*/React.createElement(EditorContext.Provider, {\n    value: context.editor\n  }, /*#__PURE__*/React.createElement(FocusedContext.Provider, {\n    value: isFocused\n  }, children))));\n};\n\n/**\r\n * Get the current editor object from the React context.\r\n * @deprecated Use useSlateStatic instead.\r\n */\n\nvar useEditor = () => {\n  var editor = useContext(EditorContext);\n\n  if (!editor) {\n    throw new Error(\"The `useEditor` hook must be used inside the <Slate> component's context.\");\n  }\n\n  return editor;\n};\n\n/**\r\n * Get the current slate selection.\r\n * Only triggers a rerender when the selection actually changes\r\n */\n\nvar useSlateSelection = () => {\n  return useSlateSelector(editor => editor.selection, isSelectionEqual);\n};\n\nvar isSelectionEqual = (a, b) => {\n  if (!a && !b) return true;\n  if (!a || !b) return false;\n  return Range.equals(a, b);\n};\n\n/**\r\n * Utilities for single-line deletion\r\n */\n\nvar doRectsIntersect = (rect, compareRect) => {\n  var middle = (compareRect.top + compareRect.bottom) / 2;\n  return rect.top <= middle && rect.bottom >= middle;\n};\n\nvar areRangesSameLine = (editor, range1, range2) => {\n  var rect1 = ReactEditor.toDOMRange(editor, range1).getBoundingClientRect();\n  var rect2 = ReactEditor.toDOMRange(editor, range2).getBoundingClientRect();\n  return doRectsIntersect(rect1, rect2) && doRectsIntersect(rect2, rect1);\n};\n/**\r\n * A helper utility that returns the end portion of a `Range`\r\n * which is located on a single line.\r\n *\r\n * @param {Editor} editor The editor object to compare against\r\n * @param {Range} parentRange The parent range to compare against\r\n * @returns {Range} A valid portion of the parentRange which is one a single line\r\n */\n\n\nvar findCurrentLineRange = (editor, parentRange) => {\n  var parentRangeBoundary = Editor.range(editor, Range.end(parentRange));\n  var positions = Array.from(Editor.positions(editor, {\n    at: parentRange\n  }));\n  var left = 0;\n  var right = positions.length;\n  var middle = Math.floor(right / 2);\n\n  if (areRangesSameLine(editor, Editor.range(editor, positions[left]), parentRangeBoundary)) {\n    return Editor.range(editor, positions[left], parentRangeBoundary);\n  }\n\n  if (positions.length < 2) {\n    return Editor.range(editor, positions[positions.length - 1], parentRangeBoundary);\n  }\n\n  while (middle !== positions.length && middle !== left) {\n    if (areRangesSameLine(editor, Editor.range(editor, positions[middle]), parentRangeBoundary)) {\n      right = middle;\n    } else {\n      left = middle;\n    }\n\n    middle = Math.floor((left + right) / 2);\n  }\n\n  return Editor.range(editor, positions[right], parentRangeBoundary);\n};\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n/**\r\n * `withReact` adds React and DOM specific behaviors to the editor.\r\n *\r\n * If you are using TypeScript, you must extend Slate's CustomTypes to use\r\n * this plugin.\r\n *\r\n * See https://docs.slatejs.org/concepts/11-typescript to learn how.\r\n */\n\nvar withReact = function withReact(editor) {\n  var clipboardFormatKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'x-slate-fragment';\n  var e = editor;\n  var {\n    apply,\n    onChange,\n    deleteBackward,\n    addMark,\n    removeMark\n  } = e; // The WeakMap which maps a key to a specific HTMLElement must be scoped to the editor instance to\n  // avoid collisions between editors in the DOM that share the same value.\n\n  EDITOR_TO_KEY_TO_ELEMENT.set(e, new WeakMap());\n\n  e.addMark = (key, value) => {\n    var _EDITOR_TO_SCHEDULE_F, _EDITOR_TO_PENDING_DI;\n\n    (_EDITOR_TO_SCHEDULE_F = EDITOR_TO_SCHEDULE_FLUSH.get(e)) === null || _EDITOR_TO_SCHEDULE_F === void 0 ? void 0 : _EDITOR_TO_SCHEDULE_F();\n\n    if (!EDITOR_TO_PENDING_INSERTION_MARKS.get(e) && (_EDITOR_TO_PENDING_DI = EDITOR_TO_PENDING_DIFFS.get(e)) !== null && _EDITOR_TO_PENDING_DI !== void 0 && _EDITOR_TO_PENDING_DI.length) {\n      // Ensure the current pending diffs originating from changes before the addMark\n      // are applied with the current formatting\n      EDITOR_TO_PENDING_INSERTION_MARKS.set(e, null);\n    }\n\n    EDITOR_TO_USER_MARKS.delete(e);\n    addMark(key, value);\n  };\n\n  e.removeMark = key => {\n    var _EDITOR_TO_PENDING_DI2;\n\n    if (!EDITOR_TO_PENDING_INSERTION_MARKS.get(e) && (_EDITOR_TO_PENDING_DI2 = EDITOR_TO_PENDING_DIFFS.get(e)) !== null && _EDITOR_TO_PENDING_DI2 !== void 0 && _EDITOR_TO_PENDING_DI2.length) {\n      // Ensure the current pending diffs originating from changes before the addMark\n      // are applied with the current formatting\n      EDITOR_TO_PENDING_INSERTION_MARKS.set(e, null);\n    }\n\n    EDITOR_TO_USER_MARKS.delete(e);\n    removeMark(key);\n  };\n\n  e.deleteBackward = unit => {\n    if (unit !== 'line') {\n      return deleteBackward(unit);\n    }\n\n    if (e.selection && Range.isCollapsed(e.selection)) {\n      var parentBlockEntry = Editor.above(e, {\n        match: n => Element$1.isElement(n) && Editor.isBlock(e, n),\n        at: e.selection\n      });\n\n      if (parentBlockEntry) {\n        var [, parentBlockPath] = parentBlockEntry;\n        var parentElementRange = Editor.range(e, parentBlockPath, e.selection.anchor);\n        var currentLineRange = findCurrentLineRange(e, parentElementRange);\n\n        if (!Range.isCollapsed(currentLineRange)) {\n          Transforms.delete(e, {\n            at: currentLineRange\n          });\n        }\n      }\n    }\n  }; // This attempts to reset the NODE_TO_KEY entry to the correct value\n  // as apply() changes the object reference and hence invalidates the NODE_TO_KEY entry\n\n\n  e.apply = op => {\n    var matches = [];\n    var pendingDiffs = EDITOR_TO_PENDING_DIFFS.get(e);\n\n    if (pendingDiffs !== null && pendingDiffs !== void 0 && pendingDiffs.length) {\n      var transformed = pendingDiffs.map(textDiff => transformTextDiff(textDiff, op)).filter(Boolean);\n      EDITOR_TO_PENDING_DIFFS.set(e, transformed);\n    }\n\n    var pendingSelection = EDITOR_TO_PENDING_SELECTION.get(e);\n\n    if (pendingSelection) {\n      EDITOR_TO_PENDING_SELECTION.set(e, transformPendingRange(e, pendingSelection, op));\n    }\n\n    var pendingAction = EDITOR_TO_PENDING_ACTION.get(e);\n\n    if (pendingAction !== null && pendingAction !== void 0 && pendingAction.at) {\n      var at = Point.isPoint(pendingAction === null || pendingAction === void 0 ? void 0 : pendingAction.at) ? transformPendingPoint(e, pendingAction.at, op) : transformPendingRange(e, pendingAction.at, op);\n      EDITOR_TO_PENDING_ACTION.set(e, at ? _objectSpread(_objectSpread({}, pendingAction), {}, {\n        at\n      }) : null);\n    }\n\n    switch (op.type) {\n      case 'insert_text':\n      case 'remove_text':\n      case 'set_node':\n      case 'split_node':\n        {\n          matches.push(...getMatches(e, op.path));\n          break;\n        }\n\n      case 'set_selection':\n        {\n          var _EDITOR_TO_USER_SELEC;\n\n          // Selection was manually set, don't restore the user selection after the change.\n          (_EDITOR_TO_USER_SELEC = EDITOR_TO_USER_SELECTION.get(e)) === null || _EDITOR_TO_USER_SELEC === void 0 ? void 0 : _EDITOR_TO_USER_SELEC.unref();\n          EDITOR_TO_USER_SELECTION.delete(e);\n          break;\n        }\n\n      case 'insert_node':\n      case 'remove_node':\n        {\n          matches.push(...getMatches(e, Path.parent(op.path)));\n          break;\n        }\n\n      case 'merge_node':\n        {\n          var prevPath = Path.previous(op.path);\n          matches.push(...getMatches(e, prevPath));\n          break;\n        }\n\n      case 'move_node':\n        {\n          var commonPath = Path.common(Path.parent(op.path), Path.parent(op.newPath));\n          matches.push(...getMatches(e, commonPath));\n          break;\n        }\n    }\n\n    apply(op);\n\n    for (var [path, key] of matches) {\n      var [node] = Editor.node(e, path);\n      NODE_TO_KEY.set(node, key);\n    }\n  };\n\n  e.setFragmentData = data => {\n    var {\n      selection\n    } = e;\n\n    if (!selection) {\n      return;\n    }\n\n    var [start, end] = Range.edges(selection);\n    var startVoid = Editor.void(e, {\n      at: start.path\n    });\n    var endVoid = Editor.void(e, {\n      at: end.path\n    });\n\n    if (Range.isCollapsed(selection) && !startVoid) {\n      return;\n    } // Create a fake selection so that we can add a Base64-encoded copy of the\n    // fragment to the HTML, to decode on future pastes.\n\n\n    var domRange = ReactEditor.toDOMRange(e, selection);\n    var contents = domRange.cloneContents();\n    var attach = contents.childNodes[0]; // Make sure attach is non-empty, since empty nodes will not get copied.\n\n    contents.childNodes.forEach(node => {\n      if (node.textContent && node.textContent.trim() !== '') {\n        attach = node;\n      }\n    }); // COMPAT: If the end node is a void node, we need to move the end of the\n    // range from the void node's spacer span, to the end of the void node's\n    // content, since the spacer is before void's content in the DOM.\n\n    if (endVoid) {\n      var [voidNode] = endVoid;\n      var r = domRange.cloneRange();\n      var domNode = ReactEditor.toDOMNode(e, voidNode);\n      r.setEndAfter(domNode);\n      contents = r.cloneContents();\n    } // COMPAT: If the start node is a void node, we need to attach the encoded\n    // fragment to the void node's content node instead of the spacer, because\n    // attaching it to empty `<div>/<span>` nodes will end up having it erased by\n    // most browsers. (2018/04/27)\n\n\n    if (startVoid) {\n      attach = contents.querySelector('[data-slate-spacer]');\n    } // Remove any zero-width space spans from the cloned DOM so that they don't\n    // show up elsewhere when pasted.\n\n\n    Array.from(contents.querySelectorAll('[data-slate-zero-width]')).forEach(zw => {\n      var isNewline = zw.getAttribute('data-slate-zero-width') === 'n';\n      zw.textContent = isNewline ? '\\n' : '';\n    }); // Set a `data-slate-fragment` attribute on a non-empty node, so it shows up\n    // in the HTML, and can be used for intra-Slate pasting. If it's a text\n    // node, wrap it in a `<span>` so we have something to set an attribute on.\n\n    if (isDOMText(attach)) {\n      var span = attach.ownerDocument.createElement('span'); // COMPAT: In Chrome and Safari, if we don't add the `white-space` style\n      // then leading and trailing spaces will be ignored. (2017/09/21)\n\n      span.style.whiteSpace = 'pre';\n      span.appendChild(attach);\n      contents.appendChild(span);\n      attach = span;\n    }\n\n    var fragment = e.getFragment();\n    var string = JSON.stringify(fragment);\n    var encoded = window.btoa(encodeURIComponent(string));\n    attach.setAttribute('data-slate-fragment', encoded);\n    data.setData(\"application/\".concat(clipboardFormatKey), encoded); // Add the content to a <div> so that we can get its inner HTML.\n\n    var div = contents.ownerDocument.createElement('div');\n    div.appendChild(contents);\n    div.setAttribute('hidden', 'true');\n    contents.ownerDocument.body.appendChild(div);\n    data.setData('text/html', div.innerHTML);\n    data.setData('text/plain', getPlainText(div));\n    contents.ownerDocument.body.removeChild(div);\n    return data;\n  };\n\n  e.insertData = data => {\n    if (!e.insertFragmentData(data)) {\n      e.insertTextData(data);\n    }\n  };\n\n  e.insertFragmentData = data => {\n    /**\r\n     * Checking copied fragment from application/x-slate-fragment or data-slate-fragment\r\n     */\n    var fragment = data.getData(\"application/\".concat(clipboardFormatKey)) || getSlateFragmentAttribute(data);\n\n    if (fragment) {\n      var decoded = decodeURIComponent(window.atob(fragment));\n      var parsed = JSON.parse(decoded);\n      e.insertFragment(parsed);\n      return true;\n    }\n\n    return false;\n  };\n\n  e.insertTextData = data => {\n    var text = data.getData('text/plain');\n\n    if (text) {\n      var lines = text.split(/\\r\\n|\\r|\\n/);\n      var split = false;\n\n      for (var line of lines) {\n        if (split) {\n          Transforms.splitNodes(e, {\n            always: true\n          });\n        }\n\n        e.insertText(line);\n        split = true;\n      }\n\n      return true;\n    }\n\n    return false;\n  };\n\n  e.onChange = options => {\n    // COMPAT: React < 18 doesn't batch `setState` hook calls, which means\n    // that the children and selection can get out of sync for one render\n    // pass. So we have to use this unstable API to ensure it batches them.\n    // (2019/12/03)\n    // https://github.com/facebook/react/issues/14259#issuecomment-439702367\n    var maybeBatchUpdates = REACT_MAJOR_VERSION < 18 ? ReactDOM.unstable_batchedUpdates : callback => callback();\n    maybeBatchUpdates(() => {\n      var onContextChange = EDITOR_TO_ON_CHANGE.get(e);\n\n      if (onContextChange) {\n        onContextChange();\n      }\n\n      onChange(options);\n    });\n  };\n\n  return e;\n};\n\nvar getMatches = (e, path) => {\n  var matches = [];\n\n  for (var [n, p] of Editor.levels(e, {\n    at: path\n  })) {\n    var key = ReactEditor.findKey(e, n);\n    matches.push([p, key]);\n  }\n\n  return matches;\n};\n\nexport { DefaultElement, DefaultLeaf, DefaultPlaceholder, Editable, ReactEditor, Slate, useEditor, useFocused, useReadOnly, useSelected, useSlate, useSlateSelection, useSlateSelector, useSlateStatic, useSlateWithV, withReact };\n//# sourceMappingURL=index.es.js.map\n"],"names":["History","isHistory","value","Array","isArray","redos","undos","length","operations","SAVING","WeakMap","MERGING","HistoryEditor","isHistoryEditor","history","isMerging","editor","get","isSaving","redo","undo","withoutMerging","fn","prev","set","withoutSaving","withHistory","e","apply","batch","selectionBefore","op","pop","writeHistory","inverseOps","map","reverse","lastBatch","lastOp","save","merge","shouldSave","shouldMerge","push","selection","shift","stack","type","offset","text","path","isOptionsObject","options","Object","keys","target","isTargetAttached","isConnected","ownerDocument","documentElement","contains","behavior","computeOptions","block","inline","getOptions","actions","canSmoothScroll","document","body","style","forEach","_ref","el","top","left","scroll","scrollTop","scrollLeft","defaultBehavior","_defineProperty","obj","key","defineProperty","enumerable","configurable","writable","_objectWithoutProperties","source","excluded","i","sourceKeys","indexOf","_objectWithoutPropertiesLoose","getOwnPropertySymbols","sourceSymbolKeys","prototype","propertyIsEnumerable","call","EditorContext","createContext","useSlateStatic","useContext","Error","REACT_MAJOR_VERSION","parseInt","IS_IOS","navigator","window","test","userAgent","MSStream","IS_APPLE","IS_ANDROID","IS_FIREFOX","IS_WEBKIT","IS_EDGE_LEGACY","IS_CHROME","IS_CHROME_LEGACY","IS_ANDROID_CHROME_LEGACY","IS_FIREFOX_LEGACY","IS_UC_MOBILE","IS_WECHATBROWSER","CAN_USE_DOM","createElement","HAS_BEFORE_INPUT_SUPPORT","globalThis","InputEvent","getTargetRanges","NODE_TO_INDEX","NODE_TO_PARENT","EDITOR_TO_WINDOW","EDITOR_TO_ELEMENT","EDITOR_TO_PLACEHOLDER_ELEMENT","ELEMENT_TO_NODE","NODE_TO_ELEMENT","NODE_TO_KEY","EDITOR_TO_KEY_TO_ELEMENT","IS_READ_ONLY","IS_FOCUSED","IS_COMPOSING","EDITOR_TO_USER_SELECTION","EDITOR_TO_ON_CHANGE","EDITOR_TO_SCHEDULE_FLUSH","EDITOR_TO_PENDING_INSERTION_MARKS","EDITOR_TO_USER_MARKS","EDITOR_TO_PENDING_DIFFS","EDITOR_TO_PENDING_ACTION","EDITOR_TO_PENDING_SELECTION","EDITOR_TO_FORCE_RENDER","PLACEHOLDER_SYMBOL","Symbol","MARK_PLACEHOLDER_SYMBOL","DOMText","Text","getDefaultView","defaultView","isDOMElement","isDOMNode","nodeType","Node","isDOMSelection","anchorNode","Selection","isDOMText","getEditableChildAndIndex","parent","index","direction","childNodes","child","triedForward","triedBackward","getAttribute","getEditableChild","getPlainText","domNode","nodeValue","childNode","from","display","getComputedStyle","getPropertyValue","tagName","catchSlateFragment","isTrackedMutation","mutation","matches","ReactEditor","getWindow","hasDOMNode","editable","parentMutation","find","addedNodes","removedNodes","node","_node","n","Key","constructor","this","id","concat","androidPendingDiffs","androidScheduleFlush","_EDITOR_TO_SCHEDULE_F","blur","toDOMNode","root","findDocumentOrShadowRoot","activeElement","deselect","domSelection","getSelection","rangeCount","removeAllRanges","getRootNode","Document","ShadowRoot","findEventRange","event","nativeEvent","clientX","x","clientY","y","domRange","toSlateNode","findPath","rect","getBoundingClientRect","isPrev","isInline","width","height","edge","point","caretRangeFromPoint","position","caretPositionFromPoint","createRange","setStart","offsetNode","setEnd","toSlateRange","exactMatch","suppressThrow","findKey","unshift","focus","preventScroll","targetEl","arguments","undefined","editorEl","parentElement","err","message","includes","closest","isContentEditable","hasEditableTarget","hasRange","range","anchor","hasSelectableTarget","isTargetInsideNonReadonlyVoid","hasTarget","insertData","data","insertFragmentData","insertTextData","isComposing","isFocused","isReadOnly","slateNode","setFragmentData","originEvent","KEY_TO_ELEMENT","toDOMPoint","domPoint","at","texts","querySelectorAll","start","textContent","attr","end","nextText","hasAttribute","_nextText$textContent","domText","startsWith","Math","min","max","toDOMRange","isBackward","domAnchor","domFocus","startNode","startOffset","endNode","endOffset","isStartAtZeroWidth","isEndAtZeroWidth","domEl","toSlatePoint","nearestNode","nearestOffset","isLast","normalizeDOMPoint","parentNode","textNode","_domNode$textContent","_domNode$textContent2","potentialVoidNode","voidNode","leafNode","contents","cloneContents","slice","textContext","removeChild","leafNodes","current","endsWith","_slateNode","_path","_offset","querySelector","anchorOffset","focusNode","focusOffset","isCollapsed","_anchorNode$textConte","startContainer","firstRange","getRangeAt","lastRange","HTMLTableRowElement","getLastChildren","element","childElementCount","children","firstNodeRow","lastNodeRow","firstNode","lastNode","HTMLElement","innerHTML","endContainer","toString","hasShadowRoot","collapsed","mode","voids","verifyDiffState","textDiff","diff","nextPath","nextNode","applyStringDiff","_len","diffs","_key","reduce","normalizeStringDiff","targetText","removedText","prefixLength","str","another","charAt","longestCommonPrefixLength","suffixLength","longestCommonSuffixLength","normalized","targetRange","normalizePoint","leaf","parentBlock","match","entry","normalizeRange","transformPendingPoint","pendingDiffs","affinity","_anchor","_transformed","transformed","transformPendingRange","ownKeys$3","object","enumerableOnly","symbols","filter","sym","getOwnPropertyDescriptor","_objectSpread$3","getOwnPropertyDescriptors","defineProperties","createAndroidInputManager","scheduleOnDOMSelectionChange","onDOMSelectionChange","flushing","compositionEndTimeoutId","flushTimeoutId","actionTimeoutId","idCounter","insertPositionHint","applyPendingSelection","pendingSelection","delete","flush","clearTimeout","hasPendingDiffs","hasPendingAction","setTimeout","selectionRef","marks","scheduleSelectionChange","_EDITOR_TO_PENDING_DI","_EDITOR_TO_PENDING_DI2","pendingMarks","_ref2","cancel","unref","action","_targetRange","run","performAction","userMarks","onChange","updatePlaceholderVisibility","forceHide","placeholderElement","removeProperty","storeDiff","_EDITOR_TO_PENDING_DI3","idx","findIndex","change","a","b","overlap","applied","sliceEnd","merged","splice","scheduleAction","_EDITOR_TO_PENDING_DI4","handleUserSelect","pathChanged","parentPathChanged","scheduleFlush","hasPendingChanges","isFlushing","handleCompositionEnd","_event","handleCompositionStart","handleDOMBeforeInput","_targetRange2","inputType","dataTransfer","nativeTargetRange","canStoreDiff","_start","_end","next","relevantPendingDiffs","targetNode","_nativeTargetRange","nativeCollapsed","unit","name","_text","replace","parts","split","line","_start2","_end2","_diff","hintPosition","search","handleKeyDown","_","handleDomMutations","mutations","_EDITOR_TO_FORCE_REND","some","handleInput","useIsomorphicLayoutEffect","useLayoutEffect","useEffect","_excluded$3","ownKeys$2","MUTATION_OBSERVER_CONFIG$1","subtree","childList","characterData","useAndroidInputManager","isMountedRef","isMounted","useRef","inputManager","useState","_objectSpread$2","callback","mutationObserver","MutationObserver","takeRecords","observe","disconnect","useMutationObserver","_excluded$2","_excluded2$1","isDecorationFlagsEqual","other","obj1","obj2","rangeOwnProps","otherOwnProps","every","hasOwnProperty","props","parentPath","isMarkPlaceholder","isVoid","ZeroWidthString","TextString","isTrailing","isLineBreak","ref","getTextContent","initialText","textWithTrailing","MemoizedText$1","memo","forwardRef","attributes","assign","clearTimeoutRef","timeoutRef","Leaf","renderPlaceholder","renderLeaf","DefaultLeaf","placeholderResizeObserver","placeholderRef","showPlaceholder","setShowPlaceholder","showPlaceholderTimeoutRef","callbackPlaceholderRef","useCallback","placeholderEl","releaseObserver","disconnectPlaceholderResizeObserver","_leaf$onPlaceholderRe","onPlaceholderResize","ResizeObserver$1","ResizeObserver","_leaf$onPlaceholderRe2","leafIsPlaceholder","placeholderProps","placeholder","pointerEvents","maxWidth","opacity","userSelect","textDecoration","WebkitUserModify","contentEditable","MemoizedLeaf","decorations","leaves","callbackRef","span","MemoizedText","list","isTextDecorationsEqual","Element","renderElement","p","DefaultElement","readOnly","useReadOnly","useChildren","dir","Tag","color","outline","MemoizedElement","isElementDecorationsEqual","DecorateContext","SelectedContext","decorate","isLeafBlock","sel","ds","dec","d","Provider","ReadOnlyContext","SlateContext","useSlate","context","HOTKEYS","bold","compose","moveBackward","moveForward","moveWordBackward","moveWordForward","deleteBackward","deleteForward","extendBackward","extendForward","italic","insertSoftBreak","splitBlock","APPLE_HOTKEYS","moveLineBackward","moveLineForward","deleteLineBackward","deleteLineForward","deleteWordBackward","deleteWordForward","extendLineBackward","extendLineForward","transposeCharacter","WINDOWS_HOTKEYS","create","generic","apple","windows","isGeneric","isApple","isWindows","Hotkeys","isBold","isCompose","isMoveBackward","isMoveForward","isDeleteBackward","isDeleteForward","isDeleteLineBackward","isDeleteLineForward","isDeleteWordBackward","isDeleteWordForward","isExtendBackward","isExtendForward","isExtendLineBackward","isExtendLineForward","isItalic","isMoveLineBackward","isMoveLineForward","isMoveWordBackward","isMoveWordForward","isRedo","isSoftBreak","isSplitBlock","isTransposeCharacter","isUndo","MUTATION_OBSERVER_CONFIG","characterDataOldValue","RestoreDOMComponent","Component","super","manager","_this$mutationObserve","componentDidMount","receivedUserInput","bufferedMutations","clear","registerMutations","trackedMutations","restoreDOM","insertBefore","nextSibling","createRestoreDomManager","getSnapshotBeforeUpdate","_this$mutationObserve2","_this$mutationObserve3","_this$manager2","_this$manager","pendingMutations","componentDidUpdate","_this$manager3","componentWillUnmount","_this$mutationObserve4","render","contextType","RestoreDOM","_excluded$1","_excluded2","ownKeys$1","_objectSpread$1","Children","Editable","defaultRenderPlaceholder","DefaultPlaceholder","autoFocus","defaultDecorate","onDOMBeforeInput","propsOnDOMBeforeInput","scrollSelectionIntoView","defaultScrollSelectionIntoView","userStyle","as","disableDefaultStyles","setIsComposing","deferredOperations","placeholderHeight","setPlaceholderHeight","onUserInput","animationFrameIdRef","cancelAnimationFrame","requestAnimationFrame","useTrackUserInput","forceRender","useReducer","s","state","useMemo","isDraggingInternally","isUpdatingSelection","latestElement","hasMarkPlaceholder","androidInputManagerRef","androidInputManager","anchorNodeSelectable","focusNodeSelectable","_androidInputManagerR","_androidInputManagerR2","setDomSelection","forceChange","hasDomSelection","editorElement","hasDomSelectionInEditor","slateRange","_anchorNode","_anchorNode$parentEle","newDomRange","collapseToEnd","setBaseAndExtent","ensureSelection","timeoutId","animationFrameId","ensureDomSelection","isDOMEventHandled","_EDITOR_TO_USER_SELEC","isCompositionChange","native","_node$parentElement","_window$getComputedSt","_lastText$textContent","lastText","createTreeWalker","NodeFilter","SHOW_TEXT","lastChild","whiteSpace","preventDefault","toRestore","removeEventListener","addEventListener","placeHolderResizeHandler","_placeholderEl$getBou","rest","loose","unset","fromEntries","mark","role","spellCheck","autoCorrect","autoCapitalize","zindex","suppressContentEditableWarning","wordWrap","minHeight","onBeforeInput","isEventHandled","_text2","onInput","onBlur","relatedTarget","onClick","detail","blockPath","_block$","startVoid","endVoid","_range","onCompositionEnd","_androidInputManagerR3","placeholderMarks","onCompositionUpdate","onCompositionStart","_androidInputManagerR4","inlinePath","onCopy","isDOMEventTargetInput","clipboardData","onCut","onDragOver","onDragStart","onDrop","draggedRange","onDragEnd","onFocus","onKeyDown","_androidInputManagerR5","isRTL","maybeHistoryEditor","_maybeHistoryEditor","currentNode","onPaste","getData","types","isPlainTextOnlyPaste","leafEl","bind","scrollMode","handler","shouldTreatEventAsHandled","isDefaultPrevented","isPropagationStopped","HTMLInputElement","HTMLTextAreaElement","defaultPrevented","FocusedContext","SlateSelectorContext","_excluded","Slate","initialValue","setContext","v","selectorContext","handleSelectorChange","eventListeners","slateRef","listener","getSlate","useSelectorContext","onContextChange","prevContext","setIsFocused","doRectsIntersect","compareRect","middle","bottom","areRangesSameLine","range1","range2","rect1","rect2","ownKeys","_objectSpread","withReact","clipboardFormatKey","addMark","removeMark","parentBlockEntry","parentBlockPath","parentElementRange","currentLineRange","parentRange","parentRangeBoundary","positions","right","floor","findCurrentLineRange","newPath","transformTextDiff","Boolean","pendingAction","getMatches","prevPath","commonPath","attach","trim","r","cloneRange","setEndAfter","zw","isNewline","appendChild","fragment","getFragment","string","JSON","stringify","encoded","btoa","encodeURIComponent","setAttribute","setData","div","htmlData","getSlateFragmentAttribute","decoded","decodeURIComponent","atob","parsed","parse","insertFragment","lines","always","insertText"],"sourceRoot":""}