{"version":3,"file":"static/js/564_9aa7890e4ca1af9127eb.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/slate-history@0.110.3_slate@0.110.2/node_modules/slate-history/dist/index.es.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/scroll-into-view-if-needed@3.1.0/node_modules/scroll-into-view-if-needed/dist/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/slate-dom@0.111.0_slate@0.110.2/node_modules/slate-dom/dist/index.es.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/slate-react@0.111.0_odid62zgrwidw3rh3dyr4gxhaq/node_modules/slate-react/dist/index.es.js"],"sourcesContent":["import { isPlainObject } from 'is-plain-object';\nimport { Operation, Editor, Transforms, Path } from 'slate';\n\n// eslint-disable-next-line no-redeclare\nvar History = {\n  /**\n   * Check if a value is a `History` object.\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 * Weakmaps for attaching state to the editor.\n */\nvar HISTORY = new WeakMap();\nvar SAVING = new WeakMap();\nvar MERGING = new WeakMap();\nvar SPLITTING_ONCE = new WeakMap();\n// eslint-disable-next-line no-redeclare\nvar HistoryEditor = {\n  /**\n   * Check if a value is a `HistoryEditor` object.\n   */\n  isHistoryEditor(value) {\n    return History.isHistory(value.history) && Editor.isEditor(value);\n  },\n  /**\n   * Get the merge flag's current value.\n   */\n  isMerging(editor) {\n    return MERGING.get(editor);\n  },\n  /**\n   * Get the splitting once flag's current value.\n   */\n  isSplittingOnce(editor) {\n    return SPLITTING_ONCE.get(editor);\n  },\n  setSplittingOnce(editor, value) {\n    SPLITTING_ONCE.set(editor, value);\n  },\n  /**\n   * Get the saving flag's current value.\n   */\n  isSaving(editor) {\n    return SAVING.get(editor);\n  },\n  /**\n   * Redo to the previous saved state.\n   */\n  redo(editor) {\n    editor.redo();\n  },\n  /**\n   * Undo to the previous saved state.\n   */\n  undo(editor) {\n    editor.undo();\n  },\n  /**\n   * Apply a series of changes inside a synchronous `fn`, These operations will\n   * be merged into the previous history.\n   */\n  withMerging(editor, fn) {\n    var prev = HistoryEditor.isMerging(editor);\n    MERGING.set(editor, true);\n    fn();\n    MERGING.set(editor, prev);\n  },\n  /**\n   * Apply a series of changes inside a synchronous `fn`, ensuring that the first\n   * operation starts a new batch in the history. Subsequent operations will be\n   * merged as usual.\n   */\n  withNewBatch(editor, fn) {\n    var prev = HistoryEditor.isMerging(editor);\n    MERGING.set(editor, true);\n    SPLITTING_ONCE.set(editor, true);\n    fn();\n    MERGING.set(editor, prev);\n    SPLITTING_ONCE.delete(editor);\n  },\n  /**\n   * Apply a series of changes inside a synchronous `fn`, without merging any of\n   * the new operations into previous save point in the history.\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   * Apply a series of changes inside a synchronous `fn`, without saving any of\n   * their operations into the history.\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 * The `withHistory` plugin keeps track of the operation history of a Slate\n * editor as operations are applied to it, using undo and redo stacks.\n *\n * If you are using TypeScript, you must extend Slate's CustomTypes to use\n * this plugin.\n *\n * See https://docs.slatejs.org/concepts/11-typescript to learn how.\n */\nvar withHistory = editor => {\n  var e = editor;\n  var {\n    apply\n  } = e;\n  e.history = {\n    undos: [],\n    redos: []\n  };\n  e.redo = () => {\n    var {\n      history\n    } = e;\n    var {\n      redos\n    } = history;\n    if (redos.length > 0) {\n      var batch = redos[redos.length - 1];\n      if (batch.selectionBefore) {\n        Transforms.setSelection(e, batch.selectionBefore);\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  e.undo = () => {\n    var {\n      history\n    } = e;\n    var {\n      undos\n    } = history;\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          for (var op of inverseOps) {\n            e.apply(op);\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  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    if (save == null) {\n      save = shouldSave(op);\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      if (HistoryEditor.isSplittingOnce(e)) {\n        merge = false;\n        HistoryEditor.setSplittingOnce(e, undefined);\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      while (undos.length > 100) {\n        undos.shift();\n      }\n      history.redos = [];\n    }\n    apply(op);\n  };\n  e.writeHistory = (stack, batch) => {\n    e.history[stack].push(batch);\n  };\n  return e;\n};\n/**\n * Check whether to merge an operation into the previous operation.\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  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  return false;\n};\n/**\n * Check whether an operation needs to be saved to the history.\n */\nvar shouldSave = (op, prev) => {\n  if (op.type === 'set_selection') {\n    return false;\n  }\n  return true;\n};\n\nexport { HISTORY, History, HistoryEditor, MERGING, SAVING, SPLITTING_ONCE, withHistory };\n//# sourceMappingURL=index.es.js.map\n","import{compute as t}from\"compute-scroll-into-view\";const o=t=>!1===t?{block:\"end\",inline:\"nearest\"}:(t=>t===Object(t)&&0!==Object.keys(t).length)(t)?t:{block:\"start\",inline:\"nearest\"};function e(e,r){if(!e.isConnected||!(t=>{let o=t;for(;o&&o.parentNode;){if(o.parentNode===document)return!0;o=o.parentNode instanceof ShadowRoot?o.parentNode.host:o.parentNode}return!1})(e))return;const n=(t=>{const o=window.getComputedStyle(t);return{top:parseFloat(o.scrollMarginTop)||0,right:parseFloat(o.scrollMarginRight)||0,bottom:parseFloat(o.scrollMarginBottom)||0,left:parseFloat(o.scrollMarginLeft)||0}})(e);if((t=>\"object\"==typeof t&&\"function\"==typeof t.behavior)(r))return r.behavior(t(e,r));const l=\"boolean\"==typeof r||null==r?void 0:r.behavior;for(const{el:a,top:i,left:s}of t(e,o(r))){const t=i-n.top+n.bottom,o=s-n.left+n.right;a.scroll({top:t,left:o,behavior:l})}}export{e as default};//# sourceMappingURL=index.js.map\n","import { Transforms, Element, Editor, Scrubber, Range, Node, Text, Path, Point } from 'slate';\nimport { isHotkey } from 'is-hotkey';\n\n/**\n * Types.\n */\n// COMPAT: This is required to prevent TypeScript aliases from doing some very\n// weird things for Slate's types with the same name as globals. (2019/11/27)\n// https://github.com/microsoft/TypeScript/issues/35002\nvar DOMNode = globalThis.Node;\nvar DOMElement = globalThis.Element;\nvar DOMText = globalThis.Text;\nvar DOMRange = globalThis.Range;\nvar DOMSelection = globalThis.Selection;\nvar DOMStaticRange = globalThis.StaticRange;\n/**\n * Returns the host window of a DOM node\n */\nvar getDefaultView = value => {\n  return value && value.ownerDocument && value.ownerDocument.defaultView || null;\n};\n/**\n * Check if a DOM node is a comment node.\n */\nvar isDOMComment = value => {\n  return isDOMNode(value) && value.nodeType === 8;\n};\n/**\n * Check if a DOM node is an element node.\n */\nvar isDOMElement = value => {\n  return isDOMNode(value) && value.nodeType === 1;\n};\n/**\n * Check if a value is a DOM node.\n */\nvar isDOMNode = value => {\n  var window = getDefaultView(value);\n  return !!window && value instanceof window.Node;\n};\n/**\n * Check if a value is a DOM selection.\n */\nvar isDOMSelection = value => {\n  var window = value && value.anchorNode && getDefaultView(value.anchorNode);\n  return !!window && value instanceof window.Selection;\n};\n/**\n * Check if a DOM node is an element node.\n */\nvar isDOMText = value => {\n  return isDOMNode(value) && value.nodeType === 3;\n};\n/**\n * Checks whether a paste event is a plaintext-only event.\n */\nvar isPlainTextOnlyPaste = event => {\n  return event.clipboardData && event.clipboardData.getData('text/plain') !== '' && event.clipboardData.types.length === 1;\n};\n/**\n * Normalize a DOM point so that it always refers to a text node.\n */\nvar normalizeDOMPoint = domPoint => {\n  var [node, offset] = domPoint;\n  // 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  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');\n    // If the editable child found is in front of input offset, we instead seek to its end\n    isLast = index < offset;\n    // 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    while (isDOMElement(node) && node.childNodes.length) {\n      var i = isLast ? node.childNodes.length - 1 : 0;\n      node = getEditableChild(node, i, isLast ? 'backward' : 'forward');\n    }\n    // Determine the new offset inside the text node.\n    offset = isLast && node.textContent != null ? node.textContent.length : 0;\n  }\n  // Return the node and offset.\n  return [node, offset];\n};\n/**\n * Determines whether the active element is nested within a shadowRoot\n */\nvar hasShadowRoot = node => {\n  var parent = node && node.parentNode;\n  while (parent) {\n    if (parent.toString() === '[object ShadowRoot]') {\n      return true;\n    }\n    parent = parent.parentNode;\n  }\n  return false;\n};\n/**\n * Get the nearest editable child and index at `index` in a `parent`, preferring\n * `direction`.\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;\n  // 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  while (isDOMComment(child) || isDOMElement(child) && child.childNodes.length === 0 || isDOMElement(child) && child.getAttribute('contenteditable') === 'false') {\n    if (triedForward && triedBackward) {\n      break;\n    }\n    if (i >= childNodes.length) {\n      triedForward = true;\n      i = index - 1;\n      direction = 'backward';\n      continue;\n    }\n    if (i < 0) {\n      triedBackward = true;\n      i = index + 1;\n      direction = 'forward';\n      continue;\n    }\n    child = childNodes[i];\n    index = i;\n    i += direction === 'forward' ? 1 : -1;\n  }\n  return [child, index];\n};\n/**\n * Get the nearest editable child at `index` in a `parent`, preferring\n * `direction`.\n */\nvar getEditableChild = (parent, index, direction) => {\n  var [child] = getEditableChildAndIndex(parent, index, direction);\n  return child;\n};\n/**\n * Get a plaintext representation of the content of a node, accounting for block\n * elements which get a newline appended.\n *\n * The domNode must be attached to the DOM.\n */\nvar getPlainText = domNode => {\n  var text = '';\n  if (isDOMText(domNode) && domNode.nodeValue) {\n    return domNode.nodeValue;\n  }\n  if (isDOMElement(domNode)) {\n    for (var childNode of Array.from(domNode.childNodes)) {\n      text += getPlainText(childNode);\n    }\n    var display = getComputedStyle(domNode).getPropertyValue('display');\n    if (display === 'block' || display === 'list' || domNode.tagName === 'BR') {\n      text += '\\n';\n    }\n  }\n  return text;\n};\n/**\n * Get x-slate-fragment attribute from data-slate-fragment\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/**\n * Get the dom selection from Shadow Root if possible, otherwise from the document\n */\nvar getSelection = root => {\n  if (root.getSelection != null) {\n    return root.getSelection();\n  }\n  return document.getSelection();\n};\n/**\n * Check whether a mutation originates from a editable element inside the editor.\n */\nvar isTrackedMutation = (editor, mutation, batch) => {\n  var {\n    target\n  } = mutation;\n  if (isDOMElement(target) && target.matches('[contentEditable=\"false\"]')) {\n    return false;\n  }\n  var {\n    document\n  } = DOMEditor.getWindow(editor);\n  if (document.contains(target)) {\n    return DOMEditor.hasDOMNode(editor, target, {\n      editable: true\n    });\n  }\n  var parentMutation = batch.find(_ref => {\n    var {\n      addedNodes,\n      removedNodes\n    } = _ref;\n    for (var node of addedNodes) {\n      if (node === target || node.contains(target)) {\n        return true;\n      }\n    }\n    for (var _node of removedNodes) {\n      if (_node === target || _node.contains(target)) {\n        return true;\n      }\n    }\n  });\n  if (!parentMutation || parentMutation === mutation) {\n    return false;\n  }\n  // Target add/remove is tracked. Track the mutation if we track the parent mutation.\n  return isTrackedMutation(editor, parentMutation, batch);\n};\n/**\n * Retrieves the deepest active element in the DOM, considering nested shadow DOMs.\n */\nvar getActiveElement = () => {\n  var activeElement = document.activeElement;\n  while ((_activeElement = activeElement) !== null && _activeElement !== void 0 && _activeElement.shadowRoot && (_activeElement$shadow = activeElement.shadowRoot) !== null && _activeElement$shadow !== void 0 && _activeElement$shadow.activeElement) {\n    var _activeElement, _activeElement$shadow, _activeElement2;\n    activeElement = (_activeElement2 = activeElement) === null || _activeElement2 === void 0 || (_activeElement2 = _activeElement2.shadowRoot) === null || _activeElement2 === void 0 ? void 0 : _activeElement2.activeElement;\n  }\n  return activeElement;\n};\n/**\n * @returns `true` if `otherNode` is before `node` in the document; otherwise, `false`.\n */\nvar isBefore = (node, otherNode) => Boolean(node.compareDocumentPosition(otherNode) & DOMNode.DOCUMENT_POSITION_PRECEDING);\n/**\n * @returns `true` if `otherNode` is after `node` in the document; otherwise, `false`.\n */\nvar isAfter = (node, otherNode) => Boolean(node.compareDocumentPosition(otherNode) & DOMNode.DOCUMENT_POSITION_FOLLOWING);\n\nvar _navigator$userAgent$, _navigator$userAgent$2;\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);\n// \"modern\" Edge was released at 79.x\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);\n// Native `beforeInput` events don't work well with react on Chrome 75\n// and older, Chrome 76+ can use `beforeInput` though.\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);\n// Firefox did not support `beforeInput` until `v87`.\nvar IS_FIREFOX_LEGACY = typeof navigator !== 'undefined' && /^(?!.*Seamonkey)(?=.*Firefox\\/(?:[0-7][0-9]|[0-8][0-6])(?:\\.)).*/i.test(navigator.userAgent);\n// UC mobile browser\nvar IS_UC_MOBILE = typeof navigator !== 'undefined' && /.*UCBrowser/.test(navigator.userAgent);\n// Wechat browser (not including mac wechat)\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\nvar CAN_USE_DOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');\n// Check if the browser is Safari and older than 17\ntypeof navigator !== 'undefined' && /Safari/.test(navigator.userAgent) && /Version\\/(\\d+)/.test(navigator.userAgent) && ((_navigator$userAgent$ = navigator.userAgent.match(/Version\\/(\\d+)/)) !== null && _navigator$userAgent$ !== void 0 && _navigator$userAgent$[1] ? parseInt((_navigator$userAgent$2 = navigator.userAgent.match(/Version\\/(\\d+)/)) === null || _navigator$userAgent$2 === void 0 ? void 0 : _navigator$userAgent$2[1], 10) < 17 : false);\n// COMPAT: Firefox/Edge Legacy don't support the `beforeinput` event\n// Chrome Legacy doesn't support `beforeinput` correctly\nvar HAS_BEFORE_INPUT_SUPPORT = (!IS_CHROME_LEGACY || !IS_ANDROID_CHROME_LEGACY) && !IS_EDGE_LEGACY &&\n// globalThis is undefined in older browsers\ntypeof globalThis !== 'undefined' && globalThis.InputEvent &&\n// @ts-ignore The `getTargetRanges` property isn't recognized.\ntypeof globalThis.InputEvent.prototype.getTargetRanges === 'function';\n\nfunction _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}\n\nfunction _toPrimitive(input, hint) {\n  if (_typeof(input) !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (_typeof(res) !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}\n\nfunction _toPropertyKey(arg) {\n  var key = _toPrimitive(arg, \"string\");\n  return _typeof(key) === \"symbol\" ? key : String(key);\n}\n\nfunction _defineProperty(obj, key, value) {\n  key = _toPropertyKey(key);\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  return obj;\n}\n\n/**\n * An auto-incrementing identifier for keys.\n */\nvar n = 0;\n/**\n * A class that keeps track of a key string. We use a full class here because we\n * want to be able to use them as keys in `WeakMap` objects.\n */\nclass Key {\n  constructor() {\n    _defineProperty(this, \"id\", void 0);\n    this.id = \"\".concat(n++);\n  }\n}\n\n/**\n * Two weak maps that allow us rebuild a path given a node. They are populated\n * at render time such that after a render occurs we can always backtrack.\n */\nvar IS_NODE_MAP_DIRTY = new WeakMap();\nvar NODE_TO_INDEX = new WeakMap();\nvar NODE_TO_PARENT = new WeakMap();\n/**\n * Weak maps that allow us to go between Slate nodes and DOM nodes. These\n * are used to resolve DOM event-related logic into Slate actions.\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/**\n * Weak maps for storing editor-related state.\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/**\n * Weak map for associating the context `onChange` context with the plugin.\n */\nvar EDITOR_TO_ON_CHANGE = new WeakMap();\n/**\n * Weak maps for saving pending state on composition stage.\n */\nvar EDITOR_TO_SCHEDULE_FLUSH = new WeakMap();\nvar EDITOR_TO_PENDING_INSERTION_MARKS = new WeakMap();\nvar EDITOR_TO_USER_MARKS = new WeakMap();\n/**\n * Android input handling specific weak-maps\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/**\n * Symbols.\n */\nvar PLACEHOLDER_SYMBOL = Symbol('placeholder');\nvar MARK_PLACEHOLDER_SYMBOL = Symbol('mark-placeholder');\n\n// eslint-disable-next-line no-redeclare\nvar DOMEditor = {\n  androidPendingDiffs: editor => EDITOR_TO_PENDING_DIFFS.get(editor),\n  androidScheduleFlush: editor => {\n    var _EDITOR_TO_SCHEDULE_F;\n    (_EDITOR_TO_SCHEDULE_F = EDITOR_TO_SCHEDULE_FLUSH.get(editor)) === null || _EDITOR_TO_SCHEDULE_F === void 0 || _EDITOR_TO_SCHEDULE_F();\n  },\n  blur: editor => {\n    var el = DOMEditor.toDOMNode(editor, editor);\n    var root = DOMEditor.findDocumentOrShadowRoot(editor);\n    IS_FOCUSED.set(editor, false);\n    if (root.activeElement === el) {\n      el.blur();\n    }\n  },\n  deselect: editor => {\n    var {\n      selection\n    } = editor;\n    var root = DOMEditor.findDocumentOrShadowRoot(editor);\n    var domSelection = getSelection(root);\n    if (domSelection && domSelection.rangeCount > 0) {\n      domSelection.removeAllRanges();\n    }\n    if (selection) {\n      Transforms.deselect(editor);\n    }\n  },\n  findDocumentOrShadowRoot: editor => {\n    var el = DOMEditor.toDOMNode(editor, editor);\n    var root = el.getRootNode();\n    if (root instanceof Document || root instanceof ShadowRoot) {\n      return root;\n    }\n    return el.ownerDocument;\n  },\n  findEventRange: (editor, event) => {\n    if ('nativeEvent' in event) {\n      event = event.nativeEvent;\n    }\n    var {\n      clientX: x,\n      clientY: y,\n      target\n    } = event;\n    if (x == null || y == null) {\n      throw new Error(\"Cannot resolve a Slate range from a DOM event: \".concat(event));\n    }\n    var node = DOMEditor.toSlateNode(editor, event.target);\n    var path = DOMEditor.findPath(editor, node);\n    // 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    if (Element.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      if (point) {\n        var _range = Editor.range(editor, point);\n        return _range;\n      }\n    }\n    // Else resolve a range from the caret position where the drop occured.\n    var domRange;\n    var {\n      document\n    } = DOMEditor.getWindow(editor);\n    // COMPAT: In Firefox, `caretRangeFromPoint` doesn't exist. (2016/07/25)\n    if (document.caretRangeFromPoint) {\n      domRange = document.caretRangeFromPoint(x, y);\n    } else {\n      var position = document.caretPositionFromPoint(x, y);\n      if (position) {\n        domRange = document.createRange();\n        domRange.setStart(position.offsetNode, position.offset);\n        domRange.setEnd(position.offsetNode, position.offset);\n      }\n    }\n    if (!domRange) {\n      throw new Error(\"Cannot resolve a Slate range from a DOM event: \".concat(event));\n    }\n    // Resolve a Slate range from the DOM range.\n    var range = DOMEditor.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    if (!key) {\n      key = new Key();\n      NODE_TO_KEY.set(node, key);\n    }\n    return key;\n  },\n  findPath: (editor, node) => {\n    var path = [];\n    var child = node;\n    while (true) {\n      var parent = NODE_TO_PARENT.get(child);\n      if (parent == null) {\n        if (Editor.isEditor(child)) {\n          return path;\n        } else {\n          break;\n        }\n      }\n      var i = NODE_TO_INDEX.get(child);\n      if (i == null) {\n        break;\n      }\n      path.unshift(i);\n      child = parent;\n    }\n    throw new Error(\"Unable to find the path for Slate node: \".concat(Scrubber.stringify(node)));\n  },\n  focus: function focus(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {\n      retries: 5\n    };\n    // Return if already focused\n    if (IS_FOCUSED.get(editor)) {\n      return;\n    }\n    // Retry setting focus if the editor has pending operations.\n    // The DOM (selection) is unstable while changes are applied.\n    // Retry until retries are exhausted or editor is focused.\n    if (options.retries <= 0) {\n      throw new Error('Could not set focus, editor seems stuck with pending operations');\n    }\n    if (editor.operations.length > 0) {\n      setTimeout(() => {\n        DOMEditor.focus(editor, {\n          retries: options.retries - 1\n        });\n      }, 10);\n      return;\n    }\n    var el = DOMEditor.toDOMNode(editor, editor);\n    var root = DOMEditor.findDocumentOrShadowRoot(editor);\n    if (root.activeElement !== el) {\n      // Ensure that the DOM selection state is set to the editor's selection\n      if (editor.selection && root instanceof Document) {\n        var domSelection = getSelection(root);\n        var domRange = DOMEditor.toDOMRange(editor, editor.selection);\n        domSelection === null || domSelection === void 0 || domSelection.removeAllRanges();\n        domSelection === null || domSelection === void 0 || domSelection.addRange(domRange);\n      }\n      // Create a new selection in the top of the document if missing\n      if (!editor.selection) {\n        Transforms.select(editor, Editor.start(editor, []));\n      }\n      // IS_FOCUSED should be set before calling el.focus() to ensure that\n      // FocusedContext is updated to the correct value\n      IS_FOCUSED.set(editor, true);\n      el.focus({\n        preventScroll: true\n      });\n    }\n  },\n  getWindow: editor => {\n    var window = EDITOR_TO_WINDOW.get(editor);\n    if (!window) {\n      throw new Error('Unable to find a host window element for this editor');\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 = DOMEditor.toDOMNode(editor, editor);\n    var targetEl;\n    // 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    try {\n      targetEl = isDOMElement(target) ? target : target.parentElement;\n    } catch (err) {\n      if (err instanceof Error && !err.message.includes('Permission denied to access property \"nodeType\"')) {\n        throw err;\n      }\n    }\n    if (!targetEl) {\n      return false;\n    }\n    return targetEl.closest(\"[data-slate-editor]\") === editorEl && (!editable || targetEl.isContentEditable ? true : typeof targetEl.isContentEditable === 'boolean' &&\n    // 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) && DOMEditor.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) => DOMEditor.hasEditableTarget(editor, target) || DOMEditor.isTargetInsideNonReadonlyVoid(editor, target),\n  hasTarget: (editor, target) => isDOMNode(target) && DOMEditor.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 = DOMEditor.hasTarget(editor, target) && DOMEditor.toSlateNode(editor, target);\n    return Element.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(DOMEditor.findKey(editor, node));\n    if (!domNode) {\n      throw new Error(\"Cannot resolve a DOM node from Slate node: \".concat(Scrubber.stringify(node)));\n    }\n    return domNode;\n  },\n  toDOMPoint: (editor, point) => {\n    var [node] = Editor.node(editor, point.path);\n    var el = DOMEditor.toDOMNode(editor, node);\n    var domPoint;\n    // 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    if (Editor.void(editor, {\n      at: point\n    })) {\n      point = {\n        path: point.path,\n        offset: 0\n      };\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    var selector = \"[data-slate-string], [data-slate-zero-width]\";\n    var texts = Array.from(el.querySelectorAll(selector));\n    var start = 0;\n    for (var i = 0; i < texts.length; i++) {\n      var text = texts[i];\n      var domNode = text.childNodes[0];\n      if (domNode == null || domNode.textContent == null) {\n        continue;\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;\n      // Prefer putting the selection inside the mark placeholder to ensure\n      // composed text is displayed with the correct marks.\n      var nextText = texts[i + 1];\n      if (point.offset === end && nextText !== null && nextText !== void 0 && nextText.hasAttribute('data-slate-mark-placeholder')) {\n        var _nextText$textContent;\n        var domText = nextText.childNodes[0];\n        domPoint = [\n        // 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      if (point.offset <= end) {\n        var offset = Math.min(length, Math.max(0, point.offset - start));\n        domPoint = [domNode, offset];\n        break;\n      }\n      start = end;\n    }\n    if (!domPoint) {\n      throw new Error(\"Cannot resolve a DOM point from Slate point: \".concat(Scrubber.stringify(point)));\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 = DOMEditor.toDOMPoint(editor, anchor);\n    var domFocus = Range.isCollapsed(range) ? domAnchor : DOMEditor.toDOMPoint(editor, focus);\n    var window = DOMEditor.getWindow(editor);\n    var domRange = window.document.createRange();\n    var [startNode, startOffset] = isBackward ? domFocus : domAnchor;\n    var [endNode, endOffset] = isBackward ? domAnchor : domFocus;\n    // 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    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    if (domEl && !domEl.hasAttribute('data-slate-node')) {\n      domEl = domEl.closest(\"[data-slate-node]\");\n    }\n    var node = domEl ? ELEMENT_TO_NODE.get(domEl) : null;\n    if (!node) {\n      throw new Error(\"Cannot resolve a Slate node from DOM node: \".concat(domEl));\n    }\n    return node;\n  },\n  toSlatePoint: (editor, domPoint, options) => {\n    var {\n      exactMatch,\n      suppressThrow,\n      searchDirection = 'backward'\n    } = options;\n    var [nearestNode, nearestOffset] = exactMatch ? domPoint : normalizeDOMPoint(domPoint);\n    var parentNode = nearestNode.parentNode;\n    var textNode = null;\n    var offset = 0;\n    if (parentNode) {\n      var _domNode$textContent, _domNode$textContent2;\n      var editorEl = DOMEditor.toDOMNode(editor, editor);\n      var potentialVoidNode = parentNode.closest('[data-slate-void=\"true\"]');\n      // 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      var voidNode = potentialVoidNode && editorEl.contains(potentialVoidNode) ? potentialVoidNode : null;\n      var potentialNonEditableNode = parentNode.closest('[contenteditable=\"false\"]');\n      var nonEditableNode = potentialNonEditableNode && editorEl.contains(potentialNonEditableNode) ? potentialNonEditableNode : null;\n      var leafNode = parentNode.closest('[data-slate-leaf]');\n      var domNode = null;\n      // 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      if (leafNode) {\n        textNode = leafNode.closest('[data-slate-node=\"text\"]');\n        if (textNode) {\n          var window = DOMEditor.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              return;\n            }\n            el.parentNode.removeChild(el);\n          });\n          // COMPAT: Edge has a bug where Range.prototype.toString() will\n          // convert \\n into \\r\\n. The bug causes a loop when slate-dom\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          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        for (var index = 0; index < leafNodes.length; index++) {\n          var current = leafNodes[index];\n          if (DOMEditor.hasDOMNode(editor, current)) {\n            leafNode = current;\n            break;\n          }\n        }\n        // COMPAT: In read-only editors the leaf is not rendered.\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      } else if (nonEditableNode) {\n        // Find the edge of the nearest leaf in `searchDirection`\n        var getLeafNodes = node => node ? node.querySelectorAll(\n        // Exclude leaf nodes in nested editors\n        '[data-slate-leaf]:not(:scope [data-slate-editor] [data-slate-leaf])') : [];\n        var elementNode = nonEditableNode.closest('[data-slate-node=\"element\"]');\n        if (searchDirection === 'forward') {\n          var _leafNodes$find;\n          var _leafNodes = [...getLeafNodes(elementNode), ...getLeafNodes(elementNode === null || elementNode === void 0 ? void 0 : elementNode.nextElementSibling)];\n          leafNode = (_leafNodes$find = _leafNodes.find(leaf => isAfter(nonEditableNode, leaf))) !== null && _leafNodes$find !== void 0 ? _leafNodes$find : null;\n        } else {\n          var _leafNodes2$findLast;\n          var _leafNodes2 = [...getLeafNodes(elementNode === null || elementNode === void 0 ? void 0 : elementNode.previousElementSibling), ...getLeafNodes(elementNode)];\n          leafNode = (_leafNodes2$findLast = _leafNodes2.findLast(leaf => isBefore(nonEditableNode, leaf))) !== null && _leafNodes2$findLast !== void 0 ? _leafNodes2$findLast : null;\n        }\n        if (leafNode) {\n          textNode = leafNode.closest('[data-slate-node=\"text\"]');\n          domNode = leafNode;\n          if (searchDirection === 'forward') {\n            offset = 0;\n          } else {\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 &&\n      // 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') && (\n      // COMPAT: If the parent node is a Slate zero-width space, editor is\n      // because the text node should have no characters. However, during IME\n      // composition the ASCII characters will be prepended to the zero-width\n      // space, so subtract 1 from the offset to account for the zero-width\n      // space character.\n      parentNode.hasAttribute('data-slate-zero-width') ||\n      // COMPAT: In Firefox, `range.cloneContents()` returns an extra trailing '\\n'\n      // when the document ends with a new-line character. This results in the offset\n      // length being off by one, so we need to subtract one to account for this.\n      IS_FIREFOX && (_domNode$textContent2 = domNode.textContent) !== null && _domNode$textContent2 !== void 0 && _domNode$textContent2.endsWith('\\n\\n'))) {\n        offset--;\n      }\n    }\n    if (IS_ANDROID && !textNode && !exactMatch) {\n      var node = parentNode.hasAttribute('data-slate-node') ? parentNode : parentNode.closest('[data-slate-node]');\n      if (node && DOMEditor.hasDOMNode(editor, node, {\n        editable: true\n      })) {\n        var _slateNode = DOMEditor.toSlateNode(editor, node);\n        var {\n          path: _path,\n          offset: _offset\n        } = Editor.start(editor, DOMEditor.findPath(editor, _slateNode));\n        if (!node.querySelector('[data-slate-leaf]')) {\n          _offset = nearestOffset;\n        }\n        return {\n          path: _path,\n          offset: _offset\n        };\n      }\n    }\n    if (!textNode) {\n      if (suppressThrow) {\n        return null;\n      }\n      throw new Error(\"Cannot resolve a Slate point from DOM point: \".concat(domPoint));\n    }\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    var slateNode = DOMEditor.toSlateNode(editor, textNode);\n    var path = DOMEditor.findPath(editor, slateNode);\n    return {\n      path,\n      offset\n    };\n  },\n  toSlateRange: (editor, domRange, options) => {\n    var _focusNode$textConten;\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    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          var firstRange = domRange.getRangeAt(0);\n          var lastRange = domRange.getRangeAt(domRange.rangeCount - 1);\n          // Here we are in the contenteditable mode of a table in firefox\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            var firstNodeRow = firstRange.startContainer;\n            var lastNodeRow = lastRange.startContainer;\n            // This should never fail as \"The HTMLElement interface represents any HTML element.\"\n            var firstNode = getLastChildren(firstNodeRow.children[firstRange.startOffset]);\n            var lastNode = getLastChildren(lastNodeRow.children[lastRange.startOffset]);\n            // Zero, as we allways take the right one as the anchor point\n            focusOffset = 0;\n            if (lastNode.childNodes.length > 0) {\n              anchorNode = lastNode.childNodes[0];\n            } else {\n              anchorNode = lastNode;\n            }\n            if (firstNode.childNodes.length > 0) {\n              focusNode = firstNode.childNodes[0];\n            } else {\n              focusNode = firstNode;\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        }\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        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    if (anchorNode == null || focusNode == null || anchorOffset == null || focusOffset == null) {\n      throw new Error(\"Cannot resolve a Slate range from DOM range: \".concat(domRange));\n    }\n    // COMPAT: Firefox sometimes includes an extra \\n (rendered by TextString\n    // when isTrailing is true) in the focusOffset, resulting in an invalid\n    // Slate point. (2023/11/01)\n    if (IS_FIREFOX && (_focusNode$textConten = focusNode.textContent) !== null && _focusNode$textConten !== void 0 && _focusNode$textConten.endsWith('\\n\\n') && focusOffset === focusNode.textContent.length) {\n      focusOffset--;\n    }\n    var anchor = DOMEditor.toSlatePoint(editor, [anchorNode, anchorOffset], {\n      exactMatch,\n      suppressThrow\n    });\n    if (!anchor) {\n      return null;\n    }\n    var focusBeforeAnchor = isBefore(anchorNode, focusNode) || anchorNode === focusNode && focusOffset < anchorOffset;\n    var focus = isCollapsed ? anchor : DOMEditor.toSlatePoint(editor, [focusNode, focusOffset], {\n      exactMatch,\n      suppressThrow,\n      searchDirection: focusBeforeAnchor ? 'forward' : 'backward'\n    });\n    if (!focus) {\n      return null;\n    }\n    var range = {\n      anchor: anchor,\n      focus: focus\n    };\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    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    return range;\n  }\n};\n\n/**\n * Check whether a text diff was applied in a way we can perform the pending action on /\n * recover the pending selection.\n */\nfunction verifyDiffState(editor, textDiff) {\n  var {\n    path,\n    diff\n  } = textDiff;\n  if (!Editor.hasPath(editor, path)) {\n    return false;\n  }\n  var node = Node.get(editor, path);\n  if (!Text.isText(node)) {\n    return false;\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  var nextPath = Path.next(path);\n  if (!Editor.hasPath(editor, nextPath)) {\n    return false;\n  }\n  var nextNode = Node.get(editor, nextPath);\n  return Text.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  return diffs.reduce((text, diff) => text.slice(0, diff.start) + diff.text + text.slice(diff.end), text);\n}\nfunction longestCommonPrefixLength(str, another) {\n  var length = Math.min(str.length, another.length);\n  for (var i = 0; i < length; i++) {\n    if (str.charAt(i) !== another.charAt(i)) {\n      return i;\n    }\n  }\n  return length;\n}\nfunction longestCommonSuffixLength(str, another, max) {\n  var length = Math.min(str.length, another.length, max);\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  return length;\n}\n/**\n * Remove redundant changes from the diff so that it spans the minimal possible range\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  if (normalized.start === normalized.end && normalized.text.length === 0) {\n    return null;\n  }\n  return normalized;\n}\n/**\n * Return a string diff that is equivalent to applying b after a spanning the range of\n * both changes\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/**\n * Get the slate range the text diff spans.\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/**\n * Normalize a 'pending point' a.k.a a point based on the dom state before applying\n * the pending diffs. Since the pending diffs might have been inserted with different\n * marks we have to 'walk' the offset from the starting position to ensure we still\n * have a valid point inside the document\n */\nfunction normalizePoint(editor, point) {\n  var {\n    path,\n    offset\n  } = point;\n  if (!Editor.hasPath(editor, path)) {\n    return null;\n  }\n  var leaf = Node.get(editor, path);\n  if (!Text.isText(leaf)) {\n    return null;\n  }\n  var parentBlock = Editor.above(editor, {\n    match: n => Element.isElement(n) && Editor.isBlock(editor, n),\n    at: path\n  });\n  if (!parentBlock) {\n    return null;\n  }\n  while (offset > leaf.text.length) {\n    var entry = Editor.next(editor, {\n      at: path,\n      match: Text.isText\n    });\n    if (!entry || !Path.isDescendant(entry[1], parentBlock[1])) {\n      return null;\n    }\n    offset -= leaf.text.length;\n    leaf = entry[0];\n    path = entry[1];\n  }\n  return {\n    path,\n    offset\n  };\n}\n/**\n * Normalize a 'pending selection' to ensure it's valid in the current document state.\n */\nfunction normalizeRange(editor, range) {\n  var anchor = normalizePoint(editor, range.anchor);\n  if (!anchor) {\n    return null;\n  }\n  if (Range.isCollapsed(range)) {\n    return {\n      anchor,\n      focus: anchor\n    };\n  }\n  var focus = normalizePoint(editor, range.focus);\n  if (!focus) {\n    return null;\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  if (!textDiff || point.offset <= textDiff.diff.start) {\n    return Point.transform(point, op, {\n      affinity: 'backward'\n    });\n  }\n  var {\n    diff\n  } = textDiff;\n  // 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  if (point.offset <= diff.start + diff.text.length) {\n    var _anchor = {\n      path: point.path,\n      offset: diff.start\n    };\n    var _transformed = Point.transform(_anchor, op, {\n      affinity: 'backward'\n    });\n    if (!_transformed) {\n      return null;\n    }\n    return {\n      path: _transformed.path,\n      offset: _transformed.offset + point.offset - diff.start\n    };\n  }\n  // Point references location after the diff\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  if (!transformed) {\n    return null;\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  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  if (!anchor) {\n    return null;\n  }\n  if (Range.isCollapsed(range)) {\n    return {\n      anchor,\n      focus: anchor\n    };\n  }\n  var focus = transformPendingPoint(editor, range.focus, op);\n  if (!focus) {\n    return null;\n  }\n  return {\n    anchor,\n    focus\n  };\n}\nfunction transformTextDiff(textDiff, op) {\n  var {\n    path,\n    diff,\n    id\n  } = textDiff;\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        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        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    case 'remove_text':\n      {\n        if (!Path.equals(op.path, path) || op.offset >= diff.end) {\n          return textDiff;\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        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    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        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        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    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        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  var newPath = Path.transform(path, op);\n  if (!newPath) {\n    return null;\n  }\n  return {\n    diff,\n    path: newPath,\n    id\n  };\n}\n\n/**\n * Utilities for single-line deletion\n */\nvar doRectsIntersect = (rect, compareRect) => {\n  var middle = (compareRect.top + compareRect.bottom) / 2;\n  return rect.top <= middle && rect.bottom >= middle;\n};\nvar areRangesSameLine = (editor, range1, range2) => {\n  var rect1 = DOMEditor.toDOMRange(editor, range1).getBoundingClientRect();\n  var rect2 = DOMEditor.toDOMRange(editor, range2).getBoundingClientRect();\n  return doRectsIntersect(rect1, rect2) && doRectsIntersect(rect2, rect1);\n};\n/**\n * A helper utility that returns the end portion of a `Range`\n * which is located on a single line.\n *\n * @param {Editor} editor The editor object to compare against\n * @param {Range} parentRange The parent range to compare against\n * @returns {Range} A valid portion of the parentRange which is one a single line\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  if (areRangesSameLine(editor, Editor.range(editor, positions[left]), parentRangeBoundary)) {\n    return Editor.range(editor, positions[left], parentRangeBoundary);\n  }\n  if (positions.length < 2) {\n    return Editor.range(editor, positions[positions.length - 1], parentRangeBoundary);\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    middle = Math.floor((left + right) / 2);\n  }\n  return Editor.range(editor, positions[right], parentRangeBoundary);\n};\n\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\n/**\n * `withDOM` adds DOM specific behaviors to the editor.\n *\n * If you are using TypeScript, you must extend Slate's CustomTypes to use\n * this plugin.\n *\n * See https://docs.slatejs.org/concepts/11-typescript to learn how.\n */\nvar withDOM = function withDOM(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;\n  // 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  EDITOR_TO_KEY_TO_ELEMENT.set(e, new WeakMap());\n  e.addMark = (key, value) => {\n    var _EDITOR_TO_SCHEDULE_F, _EDITOR_TO_PENDING_DI;\n    (_EDITOR_TO_SCHEDULE_F = EDITOR_TO_SCHEDULE_FLUSH.get(e)) === null || _EDITOR_TO_SCHEDULE_F === void 0 || _EDITOR_TO_SCHEDULE_F();\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    EDITOR_TO_USER_MARKS.delete(e);\n    addMark(key, value);\n  };\n  e.removeMark = key => {\n    var _EDITOR_TO_PENDING_DI2;\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    EDITOR_TO_USER_MARKS.delete(e);\n    removeMark(key);\n  };\n  e.deleteBackward = unit => {\n    if (unit !== 'line') {\n      return deleteBackward(unit);\n    }\n    if (e.selection && Range.isCollapsed(e.selection)) {\n      var parentBlockEntry = Editor.above(e, {\n        match: n => Element.isElement(n) && Editor.isBlock(e, n),\n        at: e.selection\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        if (!Range.isCollapsed(currentLineRange)) {\n          Transforms.delete(e, {\n            at: currentLineRange\n          });\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  e.apply = op => {\n    var matches = [];\n    var pathRefMatches = [];\n    var pendingDiffs = EDITOR_TO_PENDING_DIFFS.get(e);\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    var pendingSelection = EDITOR_TO_PENDING_SELECTION.get(e);\n    if (pendingSelection) {\n      EDITOR_TO_PENDING_SELECTION.set(e, transformPendingRange(e, pendingSelection, op));\n    }\n    var pendingAction = EDITOR_TO_PENDING_ACTION.get(e);\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    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      case 'set_selection':\n        {\n          var _EDITOR_TO_USER_SELEC;\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 || _EDITOR_TO_USER_SELEC.unref();\n          EDITOR_TO_USER_SELECTION.delete(e);\n          break;\n        }\n      case 'insert_node':\n      case 'remove_node':\n        {\n          matches.push(...getMatches(e, Path.parent(op.path)));\n          break;\n        }\n      case 'merge_node':\n        {\n          var prevPath = Path.previous(op.path);\n          matches.push(...getMatches(e, prevPath));\n          break;\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          var changedPath;\n          if (Path.isBefore(op.path, op.newPath)) {\n            matches.push(...getMatches(e, Path.parent(op.path)));\n            changedPath = op.newPath;\n          } else {\n            matches.push(...getMatches(e, Path.parent(op.newPath)));\n            changedPath = op.path;\n          }\n          var changedNode = Node.get(editor, Path.parent(changedPath));\n          var changedNodeKey = DOMEditor.findKey(e, changedNode);\n          var changedPathRef = Editor.pathRef(e, Path.parent(changedPath));\n          pathRefMatches.push([changedPathRef, changedNodeKey]);\n          break;\n        }\n    }\n    apply(op);\n    switch (op.type) {\n      case 'insert_node':\n      case 'remove_node':\n      case 'merge_node':\n      case 'move_node':\n      case 'split_node':\n        {\n          IS_NODE_MAP_DIRTY.set(e, true);\n        }\n    }\n    for (var [path, key] of matches) {\n      var [node] = Editor.node(e, path);\n      NODE_TO_KEY.set(node, key);\n    }\n    for (var [pathRef, _key] of pathRefMatches) {\n      if (pathRef.current) {\n        var [_node] = Editor.node(e, pathRef.current);\n        NODE_TO_KEY.set(_node, _key);\n      }\n      pathRef.unref();\n    }\n  };\n  e.setFragmentData = data => {\n    var {\n      selection\n    } = e;\n    if (!selection) {\n      return;\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    if (Range.isCollapsed(selection) && !startVoid) {\n      return;\n    }\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    var domRange = DOMEditor.toDOMRange(e, selection);\n    var contents = domRange.cloneContents();\n    var attach = contents.childNodes[0];\n    // Make sure attach is non-empty, since empty nodes will not get copied.\n    contents.childNodes.forEach(node => {\n      if (node.textContent && node.textContent.trim() !== '') {\n        attach = node;\n      }\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    if (endVoid) {\n      var [voidNode] = endVoid;\n      var r = domRange.cloneRange();\n      var domNode = DOMEditor.toDOMNode(e, voidNode);\n      r.setEndAfter(domNode);\n      contents = r.cloneContents();\n    }\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    if (startVoid) {\n      attach = contents.querySelector('[data-slate-spacer]');\n    }\n    // Remove any zero-width space spans from the cloned DOM so that they don't\n    // show up elsewhere when pasted.\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    });\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    if (isDOMText(attach)) {\n      var span = attach.ownerDocument.createElement('span');\n      // 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      span.style.whiteSpace = 'pre';\n      span.appendChild(attach);\n      contents.appendChild(span);\n      attach = span;\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);\n    // Add the content to a <div> so that we can get its inner HTML.\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  e.insertData = data => {\n    if (!e.insertFragmentData(data)) {\n      e.insertTextData(data);\n    }\n  };\n  e.insertFragmentData = data => {\n    /**\n     * Checking copied fragment from application/x-slate-fragment or data-slate-fragment\n     */\n    var fragment = data.getData(\"application/\".concat(clipboardFormatKey)) || getSlateFragmentAttribute(data);\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    return false;\n  };\n  e.insertTextData = data => {\n    var text = data.getData('text/plain');\n    if (text) {\n      var lines = text.split(/\\r\\n|\\r|\\n/);\n      var split = false;\n      for (var line of lines) {\n        if (split) {\n          Transforms.splitNodes(e, {\n            always: true\n          });\n        }\n        e.insertText(line);\n        split = true;\n      }\n      return true;\n    }\n    return false;\n  };\n  e.onChange = options => {\n    var onContextChange = EDITOR_TO_ON_CHANGE.get(e);\n    if (onContextChange) {\n      onContextChange(options);\n    }\n    onChange(options);\n  };\n  return e;\n};\nvar getMatches = (e, path) => {\n  var matches = [];\n  for (var [n, p] of Editor.levels(e, {\n    at: path\n  })) {\n    var key = DOMEditor.findKey(e, n);\n    matches.push([p, key]);\n  }\n  return matches;\n};\n\nvar TRIPLE_CLICK = 3;\n\n/**\n * Hotkey mappings for each platform.\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/**\n * Create a platform-aware hotkey checker.\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/**\n * Hotkeys.\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\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\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  return target;\n}\n\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = _objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\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  return target;\n}\n\nvar _excluded = [\"anchor\", \"focus\"],\n  _excluded2 = [\"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]);\nvar isDecorationFlagsEqual = (range, other) => {\n  var rangeOwnProps = _objectWithoutProperties(range, _excluded);\n  var otherOwnProps = _objectWithoutProperties(other, _excluded2);\n  return range[PLACEHOLDER_SYMBOL] === other[PLACEHOLDER_SYMBOL] && shallowCompare(rangeOwnProps, otherOwnProps);\n};\n/**\n * Check if a list of decorator ranges are equal to another.\n *\n * PERF: this requires the two lists to also have the ranges inside them in the\n * same order, but this is an okay constraint for us since decorations are\n * kept in order, and the odd case where they aren't is okay to re-render for.\n */\nvar isElementDecorationsEqual = (list, another) => {\n  if (list.length !== another.length) {\n    return false;\n  }\n  for (var i = 0; i < list.length; i++) {\n    var range = list[i];\n    var other = another[i];\n    if (!Range.equals(range, other) || !isDecorationFlagsEqual(range, other)) {\n      return false;\n    }\n  }\n  return true;\n};\n/**\n * Check if a list of decorator ranges are equal to another.\n *\n * PERF: this requires the two lists to also have the ranges inside them in the\n * same order, but this is an okay constraint for us since decorations are\n * kept in order, and the odd case where they aren't is okay to re-render for.\n */\nvar isTextDecorationsEqual = (list, another) => {\n  if (list.length !== another.length) {\n    return false;\n  }\n  for (var i = 0; i < list.length; i++) {\n    var range = list[i];\n    var other = another[i];\n    // compare only offsets because paths doesn't matter for text\n    if (range.anchor.offset !== other.anchor.offset || range.focus.offset !== other.focus.offset || !isDecorationFlagsEqual(range, other)) {\n      return false;\n    }\n  }\n  return true;\n};\n\nexport { CAN_USE_DOM, DOMEditor, DOMElement, DOMNode, DOMRange, DOMSelection, DOMStaticRange, DOMText, EDITOR_TO_ELEMENT, EDITOR_TO_FORCE_RENDER, EDITOR_TO_KEY_TO_ELEMENT, EDITOR_TO_ON_CHANGE, EDITOR_TO_PENDING_ACTION, EDITOR_TO_PENDING_DIFFS, EDITOR_TO_PENDING_INSERTION_MARKS, EDITOR_TO_PENDING_SELECTION, EDITOR_TO_PLACEHOLDER_ELEMENT, EDITOR_TO_SCHEDULE_FLUSH, EDITOR_TO_USER_MARKS, EDITOR_TO_USER_SELECTION, EDITOR_TO_WINDOW, ELEMENT_TO_NODE, HAS_BEFORE_INPUT_SUPPORT, hotkeys as Hotkeys, IS_ANDROID, IS_CHROME, IS_COMPOSING, IS_FIREFOX, IS_FIREFOX_LEGACY, IS_FOCUSED, IS_IOS, IS_NODE_MAP_DIRTY, IS_READ_ONLY, IS_UC_MOBILE, IS_WEBKIT, IS_WECHATBROWSER, Key, MARK_PLACEHOLDER_SYMBOL, NODE_TO_ELEMENT, NODE_TO_INDEX, NODE_TO_KEY, NODE_TO_PARENT, PLACEHOLDER_SYMBOL, TRIPLE_CLICK, applyStringDiff, getActiveElement, getDefaultView, getSelection, hasShadowRoot, isAfter, isBefore, isDOMElement, isDOMNode, isDOMSelection, isElementDecorationsEqual, isPlainTextOnlyPaste, isTextDecorationsEqual, isTrackedMutation, mergeStringDiffs, normalizeDOMPoint, normalizePoint, normalizeRange, normalizeStringDiff, targetRange, verifyDiffState, withDOM };\n//# sourceMappingURL=index.es.js.map\n","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 { Editor, Range, Transforms, Node, Text as Text$1, Path, Point, Element as Element$1, Scrubber } from 'slate';\nimport { DOMEditor, EDITOR_TO_USER_MARKS, EDITOR_TO_PENDING_DIFFS, EDITOR_TO_PENDING_ACTION, EDITOR_TO_PENDING_INSERTION_MARKS, targetRange, verifyDiffState, EDITOR_TO_PENDING_SELECTION, IS_COMPOSING, IS_NODE_MAP_DIRTY, applyStringDiff, isDOMSelection, isTrackedMutation, EDITOR_TO_FORCE_RENDER, normalizeRange, normalizePoint, EDITOR_TO_PLACEHOLDER_ELEMENT, normalizeStringDiff, mergeStringDiffs, CAN_USE_DOM, IS_ANDROID, EDITOR_TO_SCHEDULE_FLUSH, MARK_PLACEHOLDER_SYMBOL, IS_IOS, PLACEHOLDER_SYMBOL, IS_WEBKIT, isTextDecorationsEqual, EDITOR_TO_KEY_TO_ELEMENT, NODE_TO_ELEMENT, ELEMENT_TO_NODE, isElementDecorationsEqual, NODE_TO_INDEX, NODE_TO_PARENT, IS_READ_ONLY, getActiveElement, getSelection, IS_FOCUSED, getDefaultView, EDITOR_TO_WINDOW, EDITOR_TO_ELEMENT, IS_FIREFOX, EDITOR_TO_USER_SELECTION, HAS_BEFORE_INPUT_SUPPORT, isDOMElement, isDOMNode, TRIPLE_CLICK, IS_FIREFOX_LEGACY, IS_WECHATBROWSER, IS_UC_MOBILE, Hotkeys, IS_CHROME, isPlainTextOnlyPaste, EDITOR_TO_ON_CHANGE, withDOM } from 'slate-dom';\nexport { NODE_TO_INDEX, NODE_TO_PARENT } from 'slate-dom';\nimport { ResizeObserver } from '@juggle/resize-observer';\nimport ReactDOM from 'react-dom';\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\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  return target;\n}\n\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = _objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\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  return target;\n}\n\nfunction _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}\n\nfunction _toPrimitive(input, hint) {\n  if (_typeof(input) !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (_typeof(res) !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}\n\nfunction _toPropertyKey(arg) {\n  var key = _toPrimitive(arg, \"string\");\n  return _typeof(key) === \"symbol\" ? key : String(key);\n}\n\nfunction _defineProperty(obj, key, value) {\n  key = _toPropertyKey(key);\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  return obj;\n}\n\n/**\n * A React context for sharing the editor object.\n */\nvar EditorContext = /*#__PURE__*/createContext(null);\n/**\n * Get the current editor object from the React context.\n */\nvar useSlateStatic = () => {\n  var editor = useContext(EditorContext);\n  if (!editor) {\n    throw new Error(\"The `useSlateStatic` hook must be used inside the <Slate> component's context.\");\n  }\n  return editor;\n};\n\n// eslint-disable-next-line no-redeclare\nvar ReactEditor = DOMEditor;\n\nfunction ownKeys$5(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread$5(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$5(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$5(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\n// https://github.com/facebook/draft-js/blob/main/src/component/handlers/composition/DraftEditorCompositionHandler.js#L41\n// When using keyboard English association function, conpositionEnd triggered too fast, resulting in after `insertText` still maintain association state.\nvar RESOLVE_DELAY = 25;\n// Time with no user interaction before the current user action is considered as done.\nvar FLUSH_DELAY = 200;\n// Replace with `const debug = console.log` to debug\nvar debug = function debug() {};\n// Type guard to check if a value is a DataTransfer\nvar isDataTransfer = value => (value === null || value === void 0 ? void 0 : value.constructor.name) === 'DataTransfer';\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  var applyPendingSelection = () => {\n    var pendingSelection = EDITOR_TO_PENDING_SELECTION.get(editor);\n    EDITOR_TO_PENDING_SELECTION.delete(editor);\n    if (pendingSelection) {\n      var {\n        selection\n      } = editor;\n      var normalized = normalizeRange(editor, pendingSelection);\n      if (normalized && (!selection || !Range.equals(normalized, selection))) {\n        Transforms.select(editor, normalized);\n      }\n    }\n  };\n  var performAction = () => {\n    var action = EDITOR_TO_PENDING_ACTION.get(editor);\n    EDITOR_TO_PENDING_ACTION.delete(editor);\n    if (!action) {\n      return;\n    }\n    if (action.at) {\n      var target = Point.isPoint(action.at) ? normalizePoint(editor, action.at) : normalizeRange(editor, action.at);\n      if (!target) {\n        return;\n      }\n      var _targetRange = Editor.range(editor, target);\n      if (!editor.selection || !Range.equals(editor.selection, _targetRange)) {\n        Transforms.select(editor, target);\n      }\n    }\n    action.run();\n  };\n  var flush = () => {\n    if (flushTimeoutId) {\n      clearTimeout(flushTimeoutId);\n      flushTimeoutId = null;\n    }\n    if (actionTimeoutId) {\n      clearTimeout(actionTimeoutId);\n      actionTimeoutId = null;\n    }\n    if (!hasPendingDiffs() && !hasPendingAction()) {\n      applyPendingSelection();\n      return;\n    }\n    if (!flushing) {\n      flushing = true;\n      setTimeout(() => flushing = false);\n    }\n    if (hasPendingAction()) {\n      flushing = 'action';\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    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      var pendingMarks = EDITOR_TO_PENDING_INSERTION_MARKS.get(editor);\n      if (pendingMarks !== undefined) {\n        EDITOR_TO_PENDING_INSERTION_MARKS.delete(editor);\n        editor.marks = pendingMarks;\n      }\n      if (pendingMarks && insertPositionHint === false) {\n        insertPositionHint = null;\n      }\n      var range = targetRange(diff);\n      if (!editor.selection || !Range.equals(editor.selection, range)) {\n        Transforms.select(editor, range);\n      }\n      if (diff.diff.text) {\n        Editor.insertText(editor, diff.diff.text);\n      } else {\n        Editor.deleteFragment(editor);\n      }\n      // Remove diff only after we have applied it to account for it when transforming\n      // pending ranges.\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      if (!verifyDiffState(editor, diff)) {\n        scheduleSelectionChange = false;\n        EDITOR_TO_PENDING_ACTION.delete(editor);\n        EDITOR_TO_USER_MARKS.delete(editor);\n        flushing = 'action';\n        // Ensure we don't restore the pending user (dom) selection\n        // since the document and dom state do not match.\n        EDITOR_TO_PENDING_SELECTION.delete(editor);\n        scheduleOnDOMSelectionChange.cancel();\n        onDOMSelectionChange.cancel();\n        selectionRef === null || selectionRef === void 0 || selectionRef.unref();\n      }\n    }\n    var selection = selectionRef === null || selectionRef === void 0 ? void 0 : selectionRef.unref();\n    if (selection && !EDITOR_TO_PENDING_SELECTION.get(editor) && (!editor.selection || !Range.equals(selection, editor.selection))) {\n      Transforms.select(editor, selection);\n    }\n    if (hasPendingAction()) {\n      performAction();\n      return;\n    }\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    if (scheduleSelectionChange) {\n      scheduleOnDOMSelectionChange();\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    if (userMarks !== undefined) {\n      editor.marks = userMarks;\n      editor.onChange();\n    }\n  };\n  var handleCompositionEnd = _event => {\n    if (compositionEndTimeoutId) {\n      clearTimeout(compositionEndTimeoutId);\n    }\n    compositionEndTimeoutId = setTimeout(() => {\n      IS_COMPOSING.set(editor, false);\n      flush();\n    }, RESOLVE_DELAY);\n  };\n  var handleCompositionStart = _event => {\n    IS_COMPOSING.set(editor, true);\n    if (compositionEndTimeoutId) {\n      clearTimeout(compositionEndTimeoutId);\n      compositionEndTimeoutId = null;\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    if (!placeholderElement) {\n      return;\n    }\n    if (hasPendingDiffs() || forceHide) {\n      placeholderElement.style.display = 'none';\n      return;\n    }\n    placeholderElement.style.removeProperty('display');\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    if (idx < 0) {\n      var normalized = normalizeStringDiff(target.text, diff);\n      if (normalized) {\n        pendingDiffs.push({\n          path,\n          diff,\n          id: idCounter++\n        });\n      }\n      updatePlaceholderVisibility();\n      return;\n    }\n    var merged = mergeStringDiffs(target.text, pendingDiffs[idx].diff, diff);\n    if (!merged) {\n      pendingDiffs.splice(idx, 1);\n      updatePlaceholderVisibility();\n      return;\n    }\n    pendingDiffs[idx] = _objectSpread$5(_objectSpread$5({}, pendingDiffs[idx]), {}, {\n      diff: merged\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    if (hasPendingAction()) {\n      flush();\n    }\n    EDITOR_TO_PENDING_ACTION.set(editor, {\n      at,\n      run\n    });\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    actionTimeoutId = setTimeout(flush);\n  };\n  var handleDOMBeforeInput = event => {\n    var _targetRange2;\n    if (flushTimeoutId) {\n      clearTimeout(flushTimeoutId);\n      flushTimeoutId = null;\n    }\n    if (IS_NODE_MAP_DIRTY.get(editor)) {\n      return;\n    }\n    var {\n      inputType: type\n    } = event;\n    var targetRange = null;\n    var data = event.dataTransfer || event.data || undefined;\n    if (insertPositionHint !== false && type !== 'insertText' && type !== 'insertCompositionText') {\n      insertPositionHint = false;\n    }\n    var [nativeTargetRange] = event.getTargetRanges();\n    if (nativeTargetRange) {\n      targetRange = ReactEditor.toSlateRange(editor, nativeTargetRange, {\n        exactMatch: false,\n        suppressThrow: true\n      });\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    var window = ReactEditor.getWindow(editor);\n    var domSelection = window.getSelection();\n    if (!targetRange && domSelection) {\n      nativeTargetRange = domSelection;\n      targetRange = ReactEditor.toSlateRange(editor, domSelection, {\n        exactMatch: false,\n        suppressThrow: true\n      });\n    }\n    targetRange = (_targetRange2 = targetRange) !== null && _targetRange2 !== void 0 ? _targetRange2 : editor.selection;\n    if (!targetRange) {\n      return;\n    }\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    var canStoreDiff = true;\n    if (type.startsWith('delete')) {\n      if (Range.isExpanded(targetRange)) {\n        var [_start, _end] = Range.edges(targetRange);\n        var _leaf = Node.leaf(editor, _start.path);\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          if (next && Path.equals(next[1], _end.path)) {\n            targetRange = {\n              anchor: _end,\n              focus: _end\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      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      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        return scheduleAction(() => Editor.deleteFragment(editor, {\n          direction\n        }), {\n          at: targetRange\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      case 'deleteContent':\n      case 'deleteContentForward':\n        {\n          var {\n            anchor\n          } = targetRange;\n          if (canStoreDiff && Range.isCollapsed(targetRange)) {\n            var targetNode = Node.leaf(editor, anchor.path);\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          return scheduleAction(() => Editor.deleteForward(editor), {\n            at: targetRange\n          });\n        }\n      case 'deleteContentBackward':\n        {\n          var _nativeTargetRange;\n          var {\n            anchor: _anchor\n          } = targetRange;\n          // 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          var nativeCollapsed = isDOMSelection(nativeTargetRange) ? nativeTargetRange.isCollapsed : !!((_nativeTargetRange = nativeTargetRange) !== null && _nativeTargetRange !== void 0 && _nativeTargetRange.collapsed);\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          return scheduleAction(() => Editor.deleteBackward(editor), {\n            at: targetRange\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      case 'deleteHardLineBackward':\n        {\n          return scheduleAction(() => Editor.deleteBackward(editor, {\n            unit: 'block'\n          }), {\n            at: targetRange\n          });\n        }\n      case 'deleteSoftLineBackward':\n        {\n          return scheduleAction(() => Editor.deleteBackward(editor, {\n            unit: 'line'\n          }), {\n            at: targetRange\n          });\n        }\n      case 'deleteHardLineForward':\n        {\n          return scheduleAction(() => Editor.deleteForward(editor, {\n            unit: 'block'\n          }), {\n            at: targetRange\n          });\n        }\n      case 'deleteSoftLineForward':\n        {\n          return scheduleAction(() => Editor.deleteForward(editor, {\n            unit: 'line'\n          }), {\n            at: targetRange\n          });\n        }\n      case 'deleteWordBackward':\n        {\n          return scheduleAction(() => Editor.deleteBackward(editor, {\n            unit: 'word'\n          }), {\n            at: targetRange\n          });\n        }\n      case 'deleteWordForward':\n        {\n          return scheduleAction(() => Editor.deleteForward(editor, {\n            unit: 'word'\n          }), {\n            at: targetRange\n          });\n        }\n      case 'insertLineBreak':\n        {\n          return scheduleAction(() => Editor.insertSoftBreak(editor), {\n            at: targetRange\n          });\n        }\n      case 'insertParagraph':\n        {\n          return scheduleAction(() => Editor.insertBreak(editor), {\n            at: targetRange\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          var _text = data !== null && data !== void 0 ? data : '';\n          // 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          if (EDITOR_TO_PENDING_INSERTION_MARKS.get(editor)) {\n            _text = _text.replace('\\uFEFF', '');\n          }\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          if (type === 'insertText' && /.*\\n.*\\n$/.test(_text)) {\n            _text = _text.slice(0, -1);\n          }\n          // If the text includes a newline, split it at newlines and paste each component\n          // string, with soft breaks in between each.\n          if (_text.includes('\\n')) {\n            return scheduleAction(() => {\n              var parts = _text.split('\\n');\n              parts.forEach((line, i) => {\n                if (line) {\n                  Editor.insertText(editor, line);\n                }\n                if (i !== parts.length - 1) {\n                  Editor.insertSoftBreak(editor);\n                }\n              });\n            }, {\n              at: targetRange\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            };\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            if (_text && insertPositionHint && type === 'insertCompositionText') {\n              var hintPosition = insertPositionHint.start + insertPositionHint.text.search(/\\S|$/);\n              var diffPosition = _diff.start + _diff.text.search(/\\S|$/);\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$5(_objectSpread$5({}, insertPositionHint), {}, {\n                  text: insertPositionHint.text + _text\n                });\n              } else {\n                insertPositionHint = false;\n              }\n            } else {\n              insertPositionHint = false;\n            }\n            if (canStoreDiff) {\n              storeDiff(_start2.path, _diff);\n              return;\n            }\n          }\n          return scheduleAction(() => Editor.insertText(editor, _text), {\n            at: targetRange\n          });\n        }\n    }\n  };\n  var hasPendingAction = () => {\n    return !!EDITOR_TO_PENDING_ACTION.get(editor);\n  };\n  var hasPendingDiffs = () => {\n    var _EDITOR_TO_PENDING_DI4;\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  var hasPendingChanges = () => {\n    return hasPendingAction() || hasPendingDiffs();\n  };\n  var isFlushing = () => {\n    return flushing;\n  };\n  var handleUserSelect = range => {\n    EDITOR_TO_PENDING_SELECTION.set(editor, range);\n    if (flushTimeoutId) {\n      clearTimeout(flushTimeoutId);\n      flushTimeoutId = null;\n    }\n    var {\n      selection\n    } = editor;\n    if (!range) {\n      return;\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    if (pathChanged && insertPositionHint || parentPathChanged) {\n      insertPositionHint = false;\n    }\n    if (pathChanged || hasPendingDiffs()) {\n      flushTimeoutId = setTimeout(flush, FLUSH_DELAY);\n    }\n  };\n  var handleInput = () => {\n    if (hasPendingAction() || !hasPendingDiffs()) {\n      flush();\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  var scheduleFlush = () => {\n    if (!hasPendingAction()) {\n      actionTimeoutId = setTimeout(flush);\n    }\n  };\n  var handleDomMutations = mutations => {\n    if (hasPendingDiffs() || hasPendingAction()) {\n      return;\n    }\n    if (mutations.some(mutation => isTrackedMutation(editor, mutation, mutations))) {\n      var _EDITOR_TO_FORCE_REND;\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 || _EDITOR_TO_FORCE_REND();\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/**\n * Prevent warning on SSR by falling back to useEffect when DOM isn't available\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    mutationObserver.observe(node.current, options);\n    return () => mutationObserver.disconnect();\n  }, [mutationObserver, node, options]);\n}\n\nvar _excluded$2 = [\"node\"];\nfunction ownKeys$4(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread$4(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$4(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$4(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\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$2);\n  if (!IS_ANDROID) {\n    return null;\n  }\n  var editor = useSlateStatic();\n  var isMounted = useIsMounted();\n  var [inputManager] = useState(() => createAndroidInputManager(_objectSpread$4({\n    editor\n  }, options)));\n  useMutationObserver(node, inputManager.handleDomMutations, MUTATION_OBSERVER_CONFIG$1);\n  EDITOR_TO_SCHEDULE_FLUSH.set(editor, inputManager.scheduleFlush);\n  if (isMounted) {\n    inputManager.flush();\n  }\n  return inputManager;\n};\n\nfunction ownKeys$3(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread$3(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$3(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$3(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\n/**\n * Leaf content strings.\n */\nvar String$1 = 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 = Boolean(leaf[MARK_PLACEHOLDER_SYMBOL]);\n  // 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  if (editor.isVoid(parent)) {\n    return /*#__PURE__*/React.createElement(ZeroWidthString, {\n      length: Node.string(parent).length\n    });\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  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  }\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  if (leaf.text === '') {\n    return /*#__PURE__*/React.createElement(ZeroWidthString, {\n      isMarkPlaceholder: isMarkPlaceholder\n    });\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  if (isLast && leaf.text.slice(-1) === '\\n') {\n    return /*#__PURE__*/React.createElement(TextString, {\n      isTrailing: true,\n      text: leaf.text\n    });\n  }\n  return /*#__PURE__*/React.createElement(TextString, {\n    text: leaf.text\n  });\n};\n/**\n * Leaf strings with text in them.\n */\nvar TextString = props => {\n  var {\n    text,\n    isTrailing = false\n  } = props;\n  var ref = useRef(null);\n  var getTextContent = () => {\n    return \"\".concat(text !== null && text !== void 0 ? text : '').concat(isTrailing ? '\\n' : '');\n  };\n  var [initialText] = useState(getTextContent);\n  // 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  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    if (ref.current && ref.current.textContent !== textWithTrailing) {\n      ref.current.textContent = textWithTrailing;\n    }\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  return /*#__PURE__*/React.createElement(MemoizedText$1, {\n    ref: ref\n  }, initialText);\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/**\n * Leaf strings without text, render as zero-width strings.\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  if (isMarkPlaceholder) {\n    attributes['data-slate-mark-placeholder'] = true;\n  }\n  return /*#__PURE__*/React.createElement(\"span\", _objectSpread$3({}, attributes), !(IS_ANDROID || IS_IOS) || !isLineBreak ? '\\uFEFF' : null, isLineBreak ? /*#__PURE__*/React.createElement(\"br\", null) : null);\n};\n\nfunction ownKeys$2(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread$2(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$2(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$2(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\n// Delay the placeholder on Android to prevent the keyboard from closing.\n// (https://github.com/ianstormtaylor/slate/pull/5368)\nvar PLACEHOLDER_DELAY = IS_ANDROID ? 300 : 0;\nfunction disconnectPlaceholderResizeObserver(placeholderResizeObserver, releaseObserver) {\n  if (placeholderResizeObserver.current) {\n    placeholderResizeObserver.current.disconnect();\n    if (releaseObserver) {\n      placeholderResizeObserver.current = null;\n    }\n  }\n}\nfunction clearTimeoutRef(timeoutRef) {\n  if (timeoutRef.current) {\n    clearTimeout(timeoutRef.current);\n    timeoutRef.current = null;\n  }\n}\n/**\n * Individual leaves in a text node with unique formatting.\n */\nvar Leaf = props => {\n  var {\n    leaf,\n    isLast,\n    text,\n    parent,\n    renderPlaceholder,\n    renderLeaf = props => /*#__PURE__*/React.createElement(DefaultLeaf, _objectSpread$2({}, 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    if (placeholderEl == null) {\n      var _leaf$onPlaceholderRe;\n      EDITOR_TO_PLACEHOLDER_ELEMENT.delete(editor);\n      (_leaf$onPlaceholderRe = leaf.onPlaceholderResize) === null || _leaf$onPlaceholderRe === void 0 || _leaf$onPlaceholderRe.call(leaf, null);\n    } else {\n      EDITOR_TO_PLACEHOLDER_ELEMENT.set(editor, placeholderEl);\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          (_leaf$onPlaceholderRe2 = leaf.onPlaceholderResize) === null || _leaf$onPlaceholderRe2 === void 0 || _leaf$onPlaceholderRe2.call(leaf, placeholderEl);\n        });\n      }\n      placeholderResizeObserver.current.observe(placeholderEl);\n      placeholderRef.current = placeholderEl;\n    }\n  }, [placeholderRef, leaf, editor]);\n  var children = /*#__PURE__*/React.createElement(String$1, {\n    isLast: isLast,\n    leaf: leaf,\n    parent: parent,\n    text: text\n  });\n  var leafIsPlaceholder = Boolean(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        }, PLACEHOLDER_DELAY);\n      }\n    } else {\n      clearTimeoutRef(showPlaceholderTimeoutRef);\n      setShowPlaceholder(false);\n    }\n    return () => clearTimeoutRef(showPlaceholderTimeoutRef);\n  }, [leafIsPlaceholder, setShowPlaceholder]);\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  }\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  var attributes = {\n    'data-slate-leaf': true\n  };\n  return renderLeaf({\n    attributes,\n    children,\n    leaf,\n    text\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\", _objectSpread$2({}, attributes), children);\n};\n\n/**\n * Text.\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  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  }\n  // Update element-related weak maps with the DOM element ref.\n  var callbackRef = useCallback(span => {\n    var KEY_TO_ELEMENT = EDITOR_TO_KEY_TO_ELEMENT.get(editor);\n    if (span) {\n      KEY_TO_ELEMENT === null || KEY_TO_ELEMENT === 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 || KEY_TO_ELEMENT.delete(key);\n      NODE_TO_ELEMENT.delete(text);\n      if (ref.current) {\n        ELEMENT_TO_NODE.delete(ref.current);\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};\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\nfunction ownKeys$1(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread$1(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$1(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\n/**\n * Element.\n */\nvar Element = props => {\n  var {\n    decorations,\n    element,\n    renderElement = p => /*#__PURE__*/React.createElement(DefaultElement, _objectSpread$1({}, 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    if (ref) {\n      KEY_TO_ELEMENT === null || KEY_TO_ELEMENT === 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 || 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  });\n  // Attributes that the developer must mix into the element in their\n  // custom node renderer component.\n  var attributes = {\n    'data-slate-node': 'element',\n    ref\n  };\n  if (isInline) {\n    attributes['data-slate-inline'] = true;\n  }\n  // If it's a block node with inline children, add the proper `dir` attribute\n  // for text direction.\n  if (!isInline && Editor.hasInlines(editor, element)) {\n    var text = Node.string(element);\n    var dir = getDirection(text);\n    if (dir === 'rtl') {\n      attributes.dir = dir;\n    }\n  }\n  // If it's a void node, wrap the children in extra void-specific elements.\n  if (Editor.isVoid(editor, element)) {\n    attributes['data-slate-void'] = true;\n    if (!readOnly && isInline) {\n      attributes.contentEditable = false;\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  return renderElement({\n    attributes,\n    children,\n    element\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/**\n * The default element renderer.\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, _objectSpread$1(_objectSpread$1({}, attributes), {}, {\n    style: {\n      position: 'relative'\n    }\n  }), children);\n};\n\n/**\n * A React context for sharing the `decorate` prop of the editable.\n */\nvar DecorateContext = /*#__PURE__*/createContext(() => []);\n/**\n * Get the current `decorate` prop of the editable.\n */\nvar useDecorate = () => {\n  return useContext(DecorateContext);\n};\n\n/**\n * A React context for sharing the `selected` state of an element.\n */\nvar SelectedContext = /*#__PURE__*/createContext(false);\n/**\n * Get the current `selected` state of an element.\n */\nvar useSelected = () => {\n  return useContext(SelectedContext);\n};\n\n/**\n * Children.\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  IS_NODE_MAP_DIRTY.set(editor, false);\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  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    for (var dec of decorations) {\n      var d = Range.intersection(dec, range);\n      if (d) {\n        ds.push(d);\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    NODE_TO_INDEX.set(n, i);\n    NODE_TO_PARENT.set(n, node);\n  }\n  return children;\n};\n\n/**\n * A React context for sharing the `readOnly` state of the editor.\n */\nvar ReadOnlyContext = /*#__PURE__*/createContext(false);\n/**\n * Get the current `readOnly` state of the editor.\n */\nvar useReadOnly = () => {\n  return useContext(ReadOnlyContext);\n};\n\nvar SlateContext = /*#__PURE__*/createContext(null);\n/**\n * Get the current editor object from the React context.\n */\nvar useSlate = () => {\n  var context = useContext(SlateContext);\n  if (!context) {\n    throw new Error(\"The `useSlate` hook must be used inside the <Slate> component's context.\");\n  }\n  var {\n    editor\n  } = context;\n  return editor;\n};\nvar useSlateWithV = () => {\n  var context = useContext(SlateContext);\n  if (!context) {\n    throw new Error(\"The `useSlate` hook must be used inside the <Slate> component's context.\");\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    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 createRestoreDomManager = (editor, receivedUserInput) => {\n  var bufferedMutations = [];\n  var clear = () => {\n    bufferedMutations = [];\n  };\n  var registerMutations = mutations => {\n    if (!receivedUserInput.current) {\n      return;\n    }\n    var trackedMutations = mutations.filter(mutation => isTrackedMutation(editor, mutation, mutations));\n    bufferedMutations.push(...trackedMutations);\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        mutation.removedNodes.forEach(node => {\n          mutation.target.insertBefore(node, mutation.nextSibling);\n        });\n        mutation.addedNodes.forEach(node => {\n          mutation.target.removeChild(node);\n        });\n      });\n      // Clear buffered mutations to ensure we don't undo them twice\n      clear();\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};\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.\nclass RestoreDOMComponent extends Component {\n  constructor() {\n    super(...arguments);\n    _defineProperty(this, \"context\", null);\n    _defineProperty(this, \"manager\", null);\n    _defineProperty(this, \"mutationObserver\", null);\n  }\n  observe() {\n    var _this$mutationObserve;\n    var {\n      node\n    } = this.props;\n    if (!node.current) {\n      throw new Error('Failed to attach MutationObserver, `node` is undefined');\n    }\n    (_this$mutationObserve = this.mutationObserver) === null || _this$mutationObserve === void 0 || _this$mutationObserve.observe(node.current, MUTATION_OBSERVER_CONFIG);\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  getSnapshotBeforeUpdate() {\n    var _this$mutationObserve2, _this$mutationObserve3, _this$manager2;\n    var pendingMutations = (_this$mutationObserve2 = this.mutationObserver) === null || _this$mutationObserve2 === void 0 ? void 0 : _this$mutationObserve2.takeRecords();\n    if (pendingMutations !== null && pendingMutations !== void 0 && pendingMutations.length) {\n      var _this$manager;\n      (_this$manager = this.manager) === null || _this$manager === void 0 || _this$manager.registerMutations(pendingMutations);\n    }\n    (_this$mutationObserve3 = this.mutationObserver) === null || _this$mutationObserve3 === void 0 || _this$mutationObserve3.disconnect();\n    (_this$manager2 = this.manager) === null || _this$manager2 === void 0 || _this$manager2.restoreDOM();\n    return null;\n  }\n  componentDidUpdate() {\n    var _this$manager3;\n    (_this$manager3 = this.manager) === null || _this$manager3 === void 0 || _this$manager3.clear();\n    this.observe();\n  }\n  componentWillUnmount() {\n    var _this$mutationObserve4;\n    (_this$mutationObserve4 = this.mutationObserver) === null || _this$mutationObserve4 === void 0 || _this$mutationObserve4.disconnect();\n  }\n  render() {\n    return this.props.children;\n  }\n}\n_defineProperty(RestoreDOMComponent, \"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\n/**\n * A React context for sharing the `composing` state of the editor.\n */\nvar ComposingContext = /*#__PURE__*/createContext(false);\n/**\n * Get the current `composing` state of the editor.\n */\nvar useComposing = () => {\n  return useContext(ComposingContext);\n};\n\nvar _excluded$1 = [\"autoFocus\", \"decorate\", \"onDOMBeforeInput\", \"placeholder\", \"readOnly\", \"renderElement\", \"renderLeaf\", \"renderPlaceholder\", \"scrollSelectionIntoView\", \"style\", \"as\", \"disableDefaultStyles\"],\n  _excluded2 = [\"text\"];\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nvar Children = props => /*#__PURE__*/React.createElement(React.Fragment, null, useChildren(props));\n/**\n * Editable.\n */\nvar Editable = /*#__PURE__*/forwardRef((props, forwardedRef) => {\n  var defaultRenderPlaceholder = useCallback(props => /*#__PURE__*/React.createElement(DefaultPlaceholder, _objectSpread({}, props)), []);\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  var editor = useSlate();\n  // Rerender editor when composition status changed\n  var [isComposing, setIsComposing] = useState(false);\n  var ref = useRef(null);\n  var deferredOperations = useRef([]);\n  var [placeholderHeight, setPlaceholderHeight] = useState();\n  var processing = useRef(false);\n  var {\n    onUserInput,\n    receivedUserInput\n  } = useTrackUserInput();\n  var [, forceRender] = useReducer(s => s + 1, 0);\n  EDITOR_TO_FORCE_RENDER.set(editor, forceRender);\n  // Update internal state on each render.\n  IS_READ_ONLY.set(editor, readOnly);\n  // Keep track of some state for the event handler logic.\n  var state = useMemo(() => ({\n    isDraggingInternally: false,\n    isUpdatingSelection: false,\n    latestElement: null,\n    hasMarkPlaceholder: false\n  }), []);\n  // The autoFocus TextareaHTMLAttribute doesn't do anything on a div, so it\n  // needs to be manually focused.\n  useEffect(() => {\n    if (ref.current && autoFocus) {\n      ref.current.focus();\n    }\n  }, [autoFocus]);\n  /**\n   * The AndroidInputManager object has a cyclical dependency on onDOMSelectionChange\n   *\n   * It is defined as a reference to simplify hook dependencies and clarify that\n   * it needs to be initialized.\n   */\n  var androidInputManagerRef = useRef();\n  // 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  var onDOMSelectionChange = useMemo(() => throttle(() => {\n    if (IS_NODE_MAP_DIRTY.get(editor)) {\n      onDOMSelectionChange();\n      return;\n    }\n    var el = ReactEditor.toDOMNode(editor, editor);\n    var root = el.getRootNode();\n    if (!processing.current && IS_WEBKIT && root instanceof ShadowRoot) {\n      processing.current = true;\n      var active = getActiveElement();\n      if (active) {\n        document.execCommand('indent');\n      } else {\n        Transforms.deselect(editor);\n      }\n      processing.current = false;\n      return;\n    }\n    var androidInputManager = androidInputManagerRef.current;\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 = getSelection(_root);\n      if (activeElement === _el) {\n        state.latestElement = activeElement;\n        IS_FOCUSED.set(editor, true);\n      } else {\n        IS_FOCUSED.delete(editor);\n      }\n      if (!domSelection) {\n        return Transforms.deselect(editor);\n      }\n      var {\n        anchorNode,\n        focusNode\n      } = domSelection;\n      var anchorNodeSelectable = ReactEditor.hasEditableTarget(editor, anchorNode) || ReactEditor.isTargetInsideNonReadonlyVoid(editor, anchorNode);\n      var focusNodeInEditor = ReactEditor.hasTarget(editor, focusNode);\n      if (anchorNodeSelectable && focusNodeInEditor) {\n        var range = ReactEditor.toSlateRange(editor, domSelection, {\n          exactMatch: false,\n          suppressThrow: true\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 || androidInputManager.handleUserSelect(range);\n          }\n        }\n      }\n      // Deselect the editor if the dom selection is not selectable in readonly mode\n      if (readOnly && (!anchorNodeSelectable || !focusNodeInEditor)) {\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    // Update element-related weak maps with the DOM element ref.\n    var window;\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    }\n    // Make sure the DOM selection state is in sync.\n    var {\n      selection\n    } = editor;\n    var root = ReactEditor.findDocumentOrShadowRoot(editor);\n    var domSelection = getSelection(root);\n    if (!domSelection || !ReactEditor.isFocused(editor) || (_androidInputManagerR = androidInputManagerRef.current) !== null && _androidInputManagerR !== void 0 && _androidInputManagerR.hasPendingAction()) {\n      return;\n    }\n    var setDomSelection = forceChange => {\n      var hasDomSelection = domSelection.type !== 'None';\n      // If the DOM selection is properly unset, we're done.\n      if (!selection && !hasDomSelection) {\n        return;\n      }\n      // Get anchorNode and focusNode\n      var focusNode = domSelection.focusNode;\n      var anchorNode;\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 && domSelection.rangeCount > 1) {\n        var firstRange = domSelection.getRangeAt(0);\n        var lastRange = domSelection.getRangeAt(domSelection.rangeCount - 1);\n        // Right to left\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      }\n      // verify that the dom selection is in the editor\n      var editorElement = EDITOR_TO_ELEMENT.get(editor);\n      var hasDomSelectionInEditor = false;\n      if (editorElement.contains(anchorNode) && editorElement.contains(focusNode)) {\n        hasDomSelectionInEditor = true;\n      }\n      // If the DOM selection is in the editor and the editor selection is already correct, we're done.\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        if (slateRange && Range.equals(slateRange, selection)) {\n          var _anchorNode;\n          if (!state.hasMarkPlaceholder) {\n            return;\n          }\n          // Ensure selection is inside the mark placeholder\n          if ((_anchorNode = anchorNode) !== null && _anchorNode !== void 0 && (_anchorNode = _anchorNode.parentElement) !== null && _anchorNode !== void 0 && _anchorNode.hasAttribute('data-slate-mark-placeholder')) {\n            return;\n          }\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      if (selection && !ReactEditor.hasRange(editor, selection)) {\n        editor.selection = ReactEditor.toSlateRange(editor, domSelection, {\n          exactMatch: false,\n          suppressThrow: true\n        });\n        return;\n      }\n      // Otherwise the DOM selection is out of sync, so update it.\n      state.isUpdatingSelection = true;\n      var newDomRange = selection && ReactEditor.toDOMRange(editor, selection);\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        scrollSelectionIntoView(editor, newDomRange);\n      } else {\n        domSelection.removeAllRanges();\n      }\n      return newDomRange;\n    };\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    if (domSelection.rangeCount <= 1) {\n      setDomSelection();\n    }\n    var ensureSelection = ((_androidInputManagerR2 = androidInputManagerRef.current) === null || _androidInputManagerR2 === void 0 ? void 0 : _androidInputManagerR2.isFlushing()) === 'action';\n    if (!IS_ANDROID || !ensureSelection) {\n      setTimeout(() => {\n        state.isUpdatingSelection = false;\n      });\n      return;\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) {\n            // Ignore, dom and state might be out of sync\n          }\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        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      if (timeoutId) {\n        clearTimeout(timeoutId);\n      }\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  var onDOMBeforeInput = useCallback(event => {\n    var el = ReactEditor.toDOMNode(editor, editor);\n    var root = el.getRootNode();\n    if (processing !== null && processing !== void 0 && processing.current && IS_WEBKIT && root instanceof ShadowRoot) {\n      var ranges = event.getTargetRanges();\n      var range = ranges[0];\n      var newRange = new window.Range();\n      newRange.setStart(range.startContainer, range.startOffset);\n      newRange.setEnd(range.endContainer, range.endOffset);\n      // Translate the DOM Range into a Slate Range\n      var slateRange = ReactEditor.toSlateRange(editor, newRange, {\n        exactMatch: false,\n        suppressThrow: false\n      });\n      Transforms.select(editor, slateRange);\n      event.preventDefault();\n      event.stopImmediatePropagation();\n      return;\n    }\n    onUserInput();\n    if (!readOnly && ReactEditor.hasEditableTarget(editor, event.target) && !isDOMEventHandled(event, propsOnDOMBeforeInput)) {\n      var _EDITOR_TO_USER_SELEC;\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      }\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      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';\n      // 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      if (isCompositionChange && ReactEditor.isComposing(editor)) {\n        return;\n      }\n      var native = false;\n      if (type === 'insertText' && selection && Range.isCollapsed(selection) &&\n      // 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) &&\n      // 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        native = true;\n        // Skip native if there are marks, as\n        // `insertText` will insert a node, not just text.\n        if (editor.marks) {\n          native = false;\n        }\n        // If the NODE_MAP is dirty, we can't trust the selection anchor (eg ReactEditor.toDOMPoint)\n        if (!IS_NODE_MAP_DIRTY.get(editor)) {\n          var _node$parentElement, _window$getComputedSt;\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          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          if (native && anchorNode && ReactEditor.hasDOMNode(editor, anchorNode)) {\n            var _lastText$textContent;\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            if (lastText === node && ((_lastText$textContent = lastText.textContent) === null || _lastText$textContent === void 0 ? void 0 : _lastText$textContent.length) === offset) {\n              native = false;\n            }\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          if (native && node.parentElement && (_window === null || _window === void 0 || (_window$getComputedSt = _window.getComputedStyle(node.parentElement)) === null || _window$getComputedSt === void 0 ? void 0 : _window$getComputedSt.whiteSpace) === 'pre') {\n            var block = Editor.above(editor, {\n              at: anchor.path,\n              match: n => Element$1.isElement(n) && Editor.isBlock(editor, n)\n            });\n            if (block && Node.string(block[0]).includes('\\t')) {\n              native = false;\n            }\n          }\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      // If the NODE_MAP is dirty, we can't trust the selection anchor (eg ReactEditor.toDOMPoint via ReactEditor.toSlateRange)\n      if ((!type.startsWith('delete') || type.startsWith('deleteBy')) && !IS_NODE_MAP_DIRTY.get(editor)) {\n        var [targetRange] = event.getTargetRanges();\n        if (targetRange) {\n          var _range = ReactEditor.toSlateRange(editor, targetRange, {\n            exactMatch: false,\n            suppressThrow: false\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            if (selectionRef) {\n              EDITOR_TO_USER_SELECTION.set(editor, selectionRef);\n            }\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      if (isCompositionChange) {\n        return;\n      }\n      if (!native) {\n        event.preventDefault();\n      }\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      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      switch (type) {\n        case 'deleteByComposition':\n        case 'deleteByCut':\n        case 'deleteByDrag':\n          {\n            Editor.deleteFragment(editor);\n            break;\n          }\n        case 'deleteContent':\n        case 'deleteContentForward':\n          {\n            Editor.deleteForward(editor);\n            break;\n          }\n        case 'deleteContentBackward':\n          {\n            Editor.deleteBackward(editor);\n            break;\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        case 'deleteHardLineBackward':\n          {\n            Editor.deleteBackward(editor, {\n              unit: 'block'\n            });\n            break;\n          }\n        case 'deleteSoftLineBackward':\n          {\n            Editor.deleteBackward(editor, {\n              unit: 'line'\n            });\n            break;\n          }\n        case 'deleteHardLineForward':\n          {\n            Editor.deleteForward(editor, {\n              unit: 'block'\n            });\n            break;\n          }\n        case 'deleteSoftLineForward':\n          {\n            Editor.deleteForward(editor, {\n              unit: 'line'\n            });\n            break;\n          }\n        case 'deleteWordBackward':\n          {\n            Editor.deleteBackward(editor, {\n              unit: 'word'\n            });\n            break;\n          }\n        case 'deleteWordForward':\n          {\n            Editor.deleteForward(editor, {\n              unit: 'word'\n            });\n            break;\n          }\n        case 'insertLineBreak':\n          Editor.insertSoftBreak(editor);\n          break;\n        case 'insertParagraph':\n          {\n            Editor.insertBreak(editor);\n            break;\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            }\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            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            break;\n          }\n      }\n      // Restore the actual user section if nothing manually set it.\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      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      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    ref.current = node;\n    if (typeof forwardedRef === 'function') {\n      forwardedRef(node);\n    } else if (forwardedRef) {\n      forwardedRef.current = node;\n    }\n  }, [onDOMSelectionChange, scheduleOnDOMSelectionChange, editor, onDOMBeforeInput, forwardedRef]);\n  useIsomorphicLayoutEffect(() => {\n    var window = ReactEditor.getWindow(editor);\n    // 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\n    // a leaky polyfill that only fires on keypresses or clicks. Instead, we\n    // want to fire for any change to the selection inside the editor.\n    // (2019/11/04) https://github.com/facebook/react/issues/5785\n    window.document.addEventListener('selectionchange', scheduleOnDOMSelectionChange);\n    // Listen for dragend and drop globally. In Firefox, if a drop handler\n    // initiates an operation that causes the originally dragged element to\n    // unmount, that element will not emit a dragend event. (2024/06/21)\n    var stoppedDragging = () => {\n      state.isDraggingInternally = false;\n    };\n    window.document.addEventListener('dragend', stoppedDragging);\n    window.document.addEventListener('drop', stoppedDragging);\n    return () => {\n      window.document.removeEventListener('selectionchange', scheduleOnDOMSelectionChange);\n      window.document.removeEventListener('dragend', stoppedDragging);\n      window.document.removeEventListener('drop', stoppedDragging);\n    };\n  }, [scheduleOnDOMSelectionChange, state]);\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      setPlaceholderHeight((_placeholderEl$getBou = placeholderEl.getBoundingClientRect()) === null || _placeholderEl$getBou === void 0 ? void 0 : _placeholderEl$getBou.height);\n    } else {\n      setPlaceholderHeight(undefined);\n    }\n  }, [showPlaceholder]);\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  var {\n    marks\n  } = editor;\n  state.hasMarkPlaceholder = false;\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    var rest = _objectWithoutProperties(leaf, _excluded2);\n    // While marks isn't a 'complete' text, we can still use loose Text.equals\n    // here which only compares marks anyway.\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(_objectSpread(_objectSpread({\n        [MARK_PLACEHOLDER_SYMBOL]: true\n      }, unset), marks), {}, {\n        anchor,\n        focus: anchor\n      }));\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  useEffect(() => {\n    setTimeout(() => {\n      var {\n        selection\n      } = editor;\n      if (selection) {\n        var {\n          anchor: _anchor\n        } = selection;\n        var _text = Node.leaf(editor, _anchor.path);\n        // While marks isn't a 'complete' text, we can still use loose Text.equals\n        // here which only compares marks anyway.\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      EDITOR_TO_PENDING_INSERTION_MARKS.delete(editor);\n    });\n  });\n  return /*#__PURE__*/React.createElement(ReadOnlyContext.Provider, {\n    value: readOnly\n  }, /*#__PURE__*/React.createElement(ComposingContext.Provider, {\n    value: isComposing\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, _objectSpread(_objectSpread({\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(_objectSpread({}, disableDefaultStyles ? {} : _objectSpread({\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        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      if (androidInputManagerRef.current) {\n        androidInputManagerRef.current.handleInput();\n        return;\n      }\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      for (var op of deferredOperations.current) {\n        op();\n      }\n      deferredOperations.current = [];\n      // COMPAT: Since `beforeinput` doesn't fully `preventDefault`,\n      // there's a chance that content might be placed in the browser's undo stack.\n      // This means undo can be triggered even when the div is not focused,\n      // and it only triggers the input event for the node. (2024/10/09)\n      if (!ReactEditor.isFocused(editor)) {\n        var native = event.nativeEvent;\n        var maybeHistoryEditor = editor;\n        if (native.inputType === 'historyUndo' && typeof maybeHistoryEditor.undo === 'function') {\n          maybeHistoryEditor.undo();\n          return;\n        }\n        if (native.inputType === 'historyRedo' && typeof maybeHistoryEditor.redo === 'function') {\n          maybeHistoryEditor.redo();\n          return;\n        }\n      }\n    }, [attributes.onInput, editor]),\n    onBlur: useCallback(event => {\n      if (readOnly || state.isUpdatingSelection || !ReactEditor.hasSelectableTarget(editor, event.target) || isEventHandled(event, attributes.onBlur)) {\n        return;\n      }\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      var root = ReactEditor.findDocumentOrShadowRoot(editor);\n      if (state.latestElement === root.activeElement) {\n        return;\n      }\n      var {\n        relatedTarget\n      } = event;\n      var el = ReactEditor.toDOMNode(editor, editor);\n      // 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      if (relatedTarget === el) {\n        return;\n      }\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      if (isDOMElement(relatedTarget) && relatedTarget.hasAttribute('data-slate-spacer')) {\n        return;\n      }\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      if (relatedTarget != null && isDOMNode(relatedTarget) && ReactEditor.hasDOMNode(editor, relatedTarget)) {\n        var node = ReactEditor.toSlateNode(editor, relatedTarget);\n        if (Element$1.isElement(node) && !editor.isVoid(node)) {\n          return;\n        }\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      if (IS_WEBKIT) {\n        var domSelection = getSelection(root);\n        domSelection === null || domSelection === void 0 || domSelection.removeAllRanges();\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);\n        // 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        if (!Editor.hasPath(editor, path) || Node.get(editor, path) !== node) {\n          return;\n        }\n        if (event.detail === TRIPLE_CLICK && path.length >= 1) {\n          var blockPath = path;\n          if (!(Element$1.isElement(node) && Editor.isBlock(editor, node))) {\n            var _block$;\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          var range = Editor.range(editor, blockPath);\n          Transforms.select(editor, range);\n          return;\n        }\n        if (readOnly) {\n          return;\n        }\n        var _start = Editor.start(editor, path);\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        if (startVoid && endVoid && Path.equals(startVoid[1], endVoid[1])) {\n          var _range2 = Editor.range(editor, _start);\n          Transforms.select(editor, _range2);\n        }\n      }\n    }, [editor, attributes.onClick, readOnly]),\n    onCompositionEnd: useCallback(event => {\n      if (ReactEditor.hasSelectableTarget(editor, event.target)) {\n        var _androidInputManagerR3;\n        if (ReactEditor.isComposing(editor)) {\n          Promise.resolve().then(() => {\n            setIsComposing(false);\n            IS_COMPOSING.set(editor, false);\n          });\n        }\n        (_androidInputManagerR3 = androidInputManagerRef.current) === null || _androidInputManagerR3 === void 0 || _androidInputManagerR3.handleCompositionEnd(event);\n        if (isEventHandled(event, attributes.onCompositionEnd) || IS_ANDROID) {\n          return;\n        }\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        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);\n          // Ensure we insert text with the marks the user was actually seeing\n          if (placeholderMarks !== undefined) {\n            EDITOR_TO_USER_MARKS.set(editor, editor.marks);\n            editor.marks = placeholderMarks;\n          }\n          Editor.insertText(editor, event.data);\n          var userMarks = EDITOR_TO_USER_MARKS.get(editor);\n          EDITOR_TO_USER_MARKS.delete(editor);\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        (_androidInputManagerR4 = androidInputManagerRef.current) === null || _androidInputManagerR4 === void 0 || _androidInputManagerR4.handleCompositionStart(event);\n        if (isEventHandled(event, attributes.onCompositionStart) || IS_ANDROID) {\n          return;\n        }\n        setIsComposing(true);\n        var {\n          selection\n        } = editor;\n        if (selection && Range.isExpanded(selection)) {\n          Editor.deleteFragment(editor);\n          return;\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        if (selection) {\n          if (Range.isExpanded(selection)) {\n            Editor.deleteFragment(editor);\n          } else {\n            var node = Node.parent(editor, selection.anchor.path);\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        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        });\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        if (voidMatch) {\n          var range = Editor.range(editor, path);\n          Transforms.select(editor, range);\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();\n        // Keep a reference to the dragged range before updating selection\n        var draggedRange = editor.selection;\n        // Find the range where the drop happened\n        var range = ReactEditor.findEventRange(editor, event);\n        var data = event.dataTransfer;\n        Transforms.select(editor, range);\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        ReactEditor.insertData(editor, data);\n        // When dragging from another source into the editor, it's possible\n        // that the current editor does not have focus.\n        if (!ReactEditor.isFocused(editor)) {\n          ReactEditor.focus(editor);\n        }\n      }\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      }\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;\n        // 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        if (IS_FIREFOX && event.target !== el) {\n          el.focus();\n          return;\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        (_androidInputManagerR5 = androidInputManagerRef.current) === null || _androidInputManagerR5 === void 0 || _androidInputManagerR5.handleKeyDown(event);\n        var {\n          nativeEvent\n        } = event;\n        // 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        if (ReactEditor.isComposing(editor) && nativeEvent.isComposing === false) {\n          IS_COMPOSING.set(editor, false);\n          setIsComposing(false);\n        }\n        if (isEventHandled(event, attributes.onKeyDown) || ReactEditor.isComposing(editor)) {\n          return;\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';\n        // 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        if (Hotkeys.isRedo(nativeEvent)) {\n          event.preventDefault();\n          var maybeHistoryEditor = editor;\n          if (typeof maybeHistoryEditor.redo === 'function') {\n            maybeHistoryEditor.redo();\n          }\n          return;\n        }\n        if (Hotkeys.isUndo(nativeEvent)) {\n          event.preventDefault();\n          var _maybeHistoryEditor = editor;\n          if (typeof _maybeHistoryEditor.undo === 'function') {\n            _maybeHistoryEditor.undo();\n          }\n          return;\n        }\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        if (Hotkeys.isMoveLineBackward(nativeEvent)) {\n          event.preventDefault();\n          Transforms.move(editor, {\n            unit: 'line',\n            reverse: true\n          });\n          return;\n        }\n        if (Hotkeys.isMoveLineForward(nativeEvent)) {\n          event.preventDefault();\n          Transforms.move(editor, {\n            unit: 'line'\n          });\n          return;\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        if (Hotkeys.isExtendLineForward(nativeEvent)) {\n          event.preventDefault();\n          Transforms.move(editor, {\n            unit: 'line',\n            edge: 'focus'\n          });\n          return;\n        }\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        if (Hotkeys.isMoveBackward(nativeEvent)) {\n          event.preventDefault();\n          if (selection && Range.isCollapsed(selection)) {\n            Transforms.move(editor, {\n              reverse: !isRTL\n            });\n          } else {\n            Transforms.collapse(editor, {\n              edge: isRTL ? 'end' : 'start'\n            });\n          }\n          return;\n        }\n        if (Hotkeys.isMoveForward(nativeEvent)) {\n          event.preventDefault();\n          if (selection && Range.isCollapsed(selection)) {\n            Transforms.move(editor, {\n              reverse: isRTL\n            });\n          } else {\n            Transforms.collapse(editor, {\n              edge: isRTL ? 'start' : 'end'\n            });\n          }\n          return;\n        }\n        if (Hotkeys.isMoveWordBackward(nativeEvent)) {\n          event.preventDefault();\n          if (selection && Range.isExpanded(selection)) {\n            Transforms.collapse(editor, {\n              edge: 'focus'\n            });\n          }\n          Transforms.move(editor, {\n            unit: 'word',\n            reverse: !isRTL\n          });\n          return;\n        }\n        if (Hotkeys.isMoveWordForward(nativeEvent)) {\n          event.preventDefault();\n          if (selection && Range.isExpanded(selection)) {\n            Transforms.collapse(editor, {\n              edge: 'focus'\n            });\n          }\n          Transforms.move(editor, {\n            unit: 'word',\n            reverse: isRTL\n          });\n          return;\n        }\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        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          if (Hotkeys.isSoftBreak(nativeEvent)) {\n            event.preventDefault();\n            Editor.insertSoftBreak(editor);\n            return;\n          }\n          if (Hotkeys.isSplitBlock(nativeEvent)) {\n            event.preventDefault();\n            Editor.insertBreak(editor);\n            return;\n          }\n          if (Hotkeys.isDeleteBackward(nativeEvent)) {\n            event.preventDefault();\n            if (selection && Range.isExpanded(selection)) {\n              Editor.deleteFragment(editor, {\n                direction: 'backward'\n              });\n            } else {\n              Editor.deleteBackward(editor);\n            }\n            return;\n          }\n          if (Hotkeys.isDeleteForward(nativeEvent)) {\n            event.preventDefault();\n            if (selection && Range.isExpanded(selection)) {\n              Editor.deleteFragment(editor, {\n                direction: 'forward'\n              });\n            } else {\n              Editor.deleteForward(editor);\n            }\n            return;\n          }\n          if (Hotkeys.isDeleteLineBackward(nativeEvent)) {\n            event.preventDefault();\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            return;\n          }\n          if (Hotkeys.isDeleteLineForward(nativeEvent)) {\n            event.preventDefault();\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            return;\n          }\n          if (Hotkeys.isDeleteWordBackward(nativeEvent)) {\n            event.preventDefault();\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            return;\n          }\n          if (Hotkeys.isDeleteWordForward(nativeEvent)) {\n            event.preventDefault();\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            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              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/**\n * The default placeholder element\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\", _objectSpread({}, attributes), children, IS_ANDROID && /*#__PURE__*/React.createElement(\"br\", null))\n  );\n};\n/**\n * A default memoized decorate function.\n */\nvar defaultDecorate = () => [];\n/**\n * A default implement to scroll dom range into view.\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    });\n    // @ts-expect-error an unorthodox delete D:\n    delete leafEl.getBoundingClientRect;\n  }\n};\n/**\n * Check if an event is overrided by a handler.\n */\nvar isEventHandled = (event, handler) => {\n  if (!handler) {\n    return false;\n  }\n  // The custom event handler may return a boolean to specify whether the event\n  // shall be treated as being handled or not.\n  var shouldTreatEventAsHandled = handler(event);\n  if (shouldTreatEventAsHandled != null) {\n    return shouldTreatEventAsHandled;\n  }\n  return event.isDefaultPrevented() || event.isPropagationStopped();\n};\n/**\n * Check if the event's target is an input element\n */\nvar isDOMEventTargetInput = event => {\n  return isDOMNode(event.target) && (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement);\n};\n/**\n * Check if a DOM event is overrided by a handler.\n */\nvar isDOMEventHandled = (event, handler) => {\n  if (!handler) {\n    return false;\n  }\n  // The custom event handler may return a boolean to specify whether the event\n  // shall be treated as being handled or not.\n  var shouldTreatEventAsHandled = handler(event);\n  if (shouldTreatEventAsHandled != null) {\n    return shouldTreatEventAsHandled;\n  }\n  return event.defaultPrevented;\n};\n\n/**\n * A React context for sharing the `focused` state of the editor.\n */\nvar FocusedContext = /*#__PURE__*/createContext(false);\n/**\n * Get the current `focused` state of the editor.\n */\nvar useFocused = () => {\n  return useContext(FocusedContext);\n};\n\nfunction isError(error) {\n  return error instanceof Error;\n}\n/**\n * A React context for sharing the editor selector context in a way to control rerenders\n */\nvar SlateSelectorContext = /*#__PURE__*/createContext({});\nvar refEquality = (a, b) => a === b;\n/**\n * use redux style selectors to prevent rerendering on every keystroke.\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.\n *\n * Example:\n * ```\n *  const isSelectionActive = useSlateSelector(editor => Boolean(editor.selection));\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  if (!context) {\n    throw new Error(\"The `useSlateSelector` hook must be used inside the <Slate> component's context.\");\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  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    throw err;\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        if (equalityFn(newSelectedState, latestSelectedState.current)) {\n          return;\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        if (err instanceof Error) {\n          latestSubscriptionCallbackError.current = err;\n        } else {\n          latestSubscriptionCallbackError.current = new Error(String(err));\n        }\n      }\n      forceRender();\n    }\n    var unsubscribe = addEventListener(checkForUpdates);\n    checkForUpdates();\n    return () => unsubscribe();\n  },\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/**\n * Create selector context with editor updating on every editor change\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 REACT_MAJOR_VERSION = parseInt(React.version.split('.')[0], 10);\n\nvar _excluded = [\"editor\", \"children\", \"onChange\", \"onSelectionChange\", \"onValueChange\", \"initialValue\"];\n/**\n * A wrapper around the provider to handle `onChange` events, because the editor\n * is a mutable singleton so it won't ever register as \"changed\" otherwise.\n */\nvar Slate = props => {\n  var {\n      editor,\n      children,\n      onChange,\n      onSelectionChange,\n      onValueChange,\n      initialValue\n    } = props,\n    rest = _objectWithoutProperties(props, _excluded);\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    if (!Editor.isEditor(editor)) {\n      throw new Error(\"[Slate] editor is invalid! You passed: \".concat(Scrubber.stringify(editor)));\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(options => {\n    var _options$operation;\n    if (onChange) {\n      onChange(editor.children);\n    }\n    switch (options === null || options === void 0 || (_options$operation = options.operation) === null || _options$operation === void 0 ? void 0 : _options$operation.type) {\n      case 'set_selection':\n        onSelectionChange === null || onSelectionChange === void 0 || onSelectionChange(editor.selection);\n        break;\n      default:\n        onValueChange === null || onValueChange === void 0 || onValueChange(editor.children);\n    }\n    setContext(prevContext => ({\n      v: prevContext.v + 1,\n      editor\n    }));\n    handleSelectorChange(editor);\n  }, [editor, handleSelectorChange, onChange, onSelectionChange, onValueChange]);\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    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/**\n * Get the current editor object from the React context.\n * @deprecated Use useSlateStatic instead.\n */\nvar useEditor = () => {\n  var editor = useContext(EditorContext);\n  if (!editor) {\n    throw new Error(\"The `useEditor` hook must be used inside the <Slate> component's context.\");\n  }\n  return editor;\n};\n\n/**\n * Get the current slate selection.\n * Only triggers a rerender when the selection actually changes\n */\nvar useSlateSelection = () => {\n  return useSlateSelector(editor => editor.selection, isSelectionEqual);\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/**\n * `withReact` adds React and DOM specific behaviors to the editor.\n *\n * If you are using TypeScript, you must extend Slate's CustomTypes to use\n * this plugin.\n *\n * See https://docs.slatejs.org/concepts/11-typescript to learn how.\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  e = withDOM(e, clipboardFormatKey);\n  var {\n    onChange\n  } = e;\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      onChange(options);\n    });\n  };\n  return e;\n};\n\nexport { DefaultElement, DefaultLeaf, DefaultPlaceholder, Editable, ReactEditor, Slate, useComposing, 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","SPLITTING_ONCE","HistoryEditor","isHistoryEditor","history","isMerging","editor","get","isSplittingOnce","setSplittingOnce","set","isSaving","redo","undo","withMerging","fn","prev","withNewBatch","delete","withoutMerging","withoutSaving","withHistory","e","apply","batch","selectionBefore","op","pop","writeHistory","inverseOps","map","reverse","lastBatch","lastOp","save","merge","shouldSave","shouldMerge","undefined","push","selection","shift","stack","type","offset","text","path","r","isConnected","t","o","parentNode","document","ShadowRoot","host","n","window","getComputedStyle","top","parseFloat","scrollMarginTop","right","scrollMarginRight","bottom","scrollMarginBottom","left","scrollMarginLeft","behavior","l","el","a","i","s","block","inline","Object","keys","scroll","_navigator$userAgent$","_navigator$userAgent$2","DOMNode","globalThis","Node","DOMText","Element","Text","getDefaultView","Range","Selection","StaticRange","ownerDocument","defaultView","isDOMElement","isDOMNode","nodeType","isDOMSelection","anchorNode","isDOMText","getEditableChildAndIndex","parent","index","direction","childNodes","child","triedForward","triedBackward","getAttribute","getEditableChild","getPlainText","domNode","nodeValue","childNode","from","display","getPropertyValue","tagName","catchSlateFragment","getSelection","root","isTrackedMutation","mutation","target","matches","DOMEditor","getWindow","contains","hasDOMNode","editable","parentMutation","find","_ref","addedNodes","removedNodes","node","_node","isBefore","otherNode","Boolean","compareDocumentPosition","DOCUMENT_POSITION_PRECEDING","IS_IOS","navigator","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","match","parseInt","HAS_BEFORE_INPUT_SUPPORT","InputEvent","prototype","getTargetRanges","_typeof","Symbol","iterator","constructor","_toPropertyKey","arg","key","input","hint","prim","toPrimitive","res","call","TypeError","String","Number","_toPrimitive","_defineProperty","obj","defineProperty","enumerable","configurable","writable","Key","this","id","concat","IS_NODE_MAP_DIRTY","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","MARK_PLACEHOLDER_SYMBOL","androidPendingDiffs","androidScheduleFlush","_EDITOR_TO_SCHEDULE_F","blur","toDOMNode","findDocumentOrShadowRoot","activeElement","deselect","domSelection","rangeCount","removeAllRanges","getRootNode","Document","findEventRange","event","nativeEvent","clientX","x","clientY","y","Error","domRange","toSlateNode","findPath","rect","getBoundingClientRect","isPrev","isInline","width","height","edge","point","caretRangeFromPoint","position","caretPositionFromPoint","createRange","setStart","offsetNode","setEnd","toSlateRange","exactMatch","suppressThrow","findKey","unshift","focus","options","arguments","retries","setTimeout","toDOMRange","addRange","preventScroll","targetEl","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","isBackward","domAnchor","domFocus","startNode","startOffset","endNode","endOffset","isStartAtZeroWidth","isEndAtZeroWidth","domEl","toSlatePoint","searchDirection","nearestNode","nearestOffset","isLast","normalizeDOMPoint","textNode","_domNode$textContent","_domNode$textContent2","potentialVoidNode","voidNode","potentialNonEditableNode","nonEditableNode","leafNode","contents","cloneContents","slice","forEach","textContext","removeChild","leafNodes","current","_leafNodes$find","_leafNodes2$findLast","getLeafNodes","elementNode","nextElementSibling","leaf","DOCUMENT_POSITION_FOLLOWING","isAfter","previousElementSibling","findLast","endsWith","_slateNode","_path","_offset","querySelector","_focusNode$textConten","anchorOffset","focusNode","focusOffset","isCollapsed","startContainer","firstRange","getRangeAt","lastRange","HTMLTableRowElement","getLastChildren","element","childElementCount","children","firstNodeRow","lastNodeRow","firstNode","lastNode","HTMLElement","innerHTML","endContainer","toString","hasShadowRoot","collapsed","focusBeforeAnchor","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","parentBlock","entry","normalizeRange","transformPendingPoint","pendingDiffs","affinity","_anchor","_transformed","transformed","transformPendingRange","doRectsIntersect","compareRect","middle","areRangesSameLine","range1","range2","rect1","rect2","ownKeys","getOwnPropertySymbols","filter","getOwnPropertyDescriptor","_objectSpread","getOwnPropertyDescriptors","defineProperties","withDOM","clipboardFormatKey","onChange","deleteBackward","addMark","removeMark","_EDITOR_TO_PENDING_DI","_EDITOR_TO_PENDING_DI2","unit","parentBlockEntry","parentBlockPath","parentElementRange","currentLineRange","parentRange","parentRangeBoundary","positions","floor","findCurrentLineRange","pathRefMatches","newPath","transformTextDiff","pendingSelection","pendingAction","getMatches","_EDITOR_TO_USER_SELEC","unref","prevPath","changedPath","commonPath","changedNode","changedNodeKey","changedPathRef","pathRef","startVoid","endVoid","attach","trim","cloneRange","setEndAfter","zw","isNewline","span","style","whiteSpace","appendChild","fragment","getFragment","string","JSON","stringify","encoded","btoa","encodeURIComponent","setAttribute","setData","div","body","getData","dataTransfer","htmlData","getSlateFragmentAttribute","decoded","decodeURIComponent","atob","parsed","parse","insertFragment","lines","split","line","always","insertText","onContextChange","p","HOTKEYS","bold","compose","moveBackward","moveForward","moveWordBackward","moveWordForward","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","_objectWithoutProperties","source","excluded","sourceKeys","indexOf","_objectWithoutPropertiesLoose","sourceSymbolKeys","propertyIsEnumerable","_excluded","_excluded2","isDecorationFlagsEqual","other","obj1","obj2","rangeOwnProps","otherOwnProps","every","hasOwnProperty","EditorContext","createContext","useSlateStatic","useContext","ReactEditor","ownKeys$5","_objectSpread$5","createAndroidInputManager","scheduleOnDOMSelectionChange","onDOMSelectionChange","flushing","compositionEndTimeoutId","flushTimeoutId","actionTimeoutId","idCounter","insertPositionHint","applyPendingSelection","flush","clearTimeout","hasPendingDiffs","hasPendingAction","selectionRef","marks","scheduleSelectionChange","pendingMarks","_ref2","cancel","action","_targetRange","run","performAction","userMarks","updatePlaceholderVisibility","forceHide","placeholderElement","removeProperty","storeDiff","_EDITOR_TO_PENDING_DI3","idx","findIndex","change","b","overlap","applied","sliceEnd","merged","splice","scheduleAction","_EDITOR_TO_PENDING_DI4","handleUserSelect","pathChanged","parentPathChanged","scheduleFlush","hasPendingChanges","isFlushing","handleCompositionEnd","_event","handleCompositionStart","handleDOMBeforeInput","_targetRange2","inputType","nativeTargetRange","canStoreDiff","_start","_end","next","relevantPendingDiffs","targetNode","_nativeTargetRange","nativeCollapsed","name","_text","replace","parts","_start2","_end2","_diff","hintPosition","search","handleKeyDown","_","handleDomMutations","mutations","_EDITOR_TO_FORCE_REND","some","handleInput","useIsomorphicLayoutEffect","useLayoutEffect","useEffect","_excluded$2","ownKeys$4","MUTATION_OBSERVER_CONFIG$1","subtree","childList","characterData","useAndroidInputManager","isMountedRef","isMounted","useRef","inputManager","useState","_objectSpread$4","callback","mutationObserver","MutationObserver","takeRecords","observe","disconnect","useMutationObserver","ownKeys$3","String$1","props","parentPath","isMarkPlaceholder","isVoid","ZeroWidthString","TextString","isTrailing","isLineBreak","ref","getTextContent","initialText","textWithTrailing","MemoizedText$1","memo","forwardRef","attributes","_objectSpread$3","ownKeys$2","_objectSpread$2","PLACEHOLDER_DELAY","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","MemoizedText","list","isTextDecorationsEqual","ownKeys$1","_objectSpread$1","renderElement","DefaultElement","readOnly","useReadOnly","useChildren","dir","Tag","color","outline","MemoizedElement","isElementDecorationsEqual","DecorateContext","SelectedContext","decorate","isLeafBlock","sel","ds","dec","d","Provider","ReadOnlyContext","SlateContext","useSlate","context","MUTATION_OBSERVER_CONFIG","characterDataOldValue","RestoreDOMComponent","Component","super","_this$mutationObserve","componentDidMount","receivedUserInput","manager","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","RestoreDOM","ComposingContext","_excluded$1","Children","Editable","forwardedRef","defaultRenderPlaceholder","DefaultPlaceholder","autoFocus","defaultDecorate","onDOMBeforeInput","propsOnDOMBeforeInput","scrollSelectionIntoView","defaultScrollSelectionIntoView","userStyle","as","disableDefaultStyles","setIsComposing","deferredOperations","placeholderHeight","setPlaceholderHeight","processing","onUserInput","animationFrameIdRef","cancelAnimationFrame","requestAnimationFrame","useTrackUserInput","forceRender","useReducer","state","useMemo","isDraggingInternally","isUpdatingSelection","latestElement","hasMarkPlaceholder","androidInputManagerRef","active","_activeElement","shadowRoot","_activeElement$shadow","_activeElement2","getActiveElement","execCommand","androidInputManager","_root","_el","anchorNodeSelectable","focusNodeInEditor","_androidInputManagerR","_androidInputManagerR2","setDomSelection","forceChange","hasDomSelection","editorElement","hasDomSelectionInEditor","slateRange","_anchorNode","newDomRange","collapseToEnd","setBaseAndExtent","ensureSelection","timeoutId","animationFrameId","ensureDomSelection","newRange","preventDefault","stopImmediatePropagation","isDOMEventHandled","isCompositionChange","native","_node$parentElement","_window$getComputedSt","_window","_lastText$textContent","lastText","createTreeWalker","NodeFilter","SHOW_TEXT","lastChild","_range","toRestore","removeEventListener","addEventListener","stoppedDragging","placeHolderResizeHandler","_placeholderEl$getBou","rest","loose","unset","fromEntries","mark","role","spellCheck","autoCorrect","autoCapitalize","zindex","suppressContentEditableWarning","wordWrap","minHeight","onBeforeInput","isEventHandled","_text2","onInput","maybeHistoryEditor","onBlur","relatedTarget","onClick","detail","blockPath","_block$","_range2","onCompositionEnd","_androidInputManagerR3","Promise","resolve","then","placeholderMarks","onCompositionUpdate","onCompositionStart","_androidInputManagerR4","onCopy","isDOMEventTargetInput","clipboardData","onCut","onDragOver","onDragStart","onDrop","draggedRange","onDragEnd","onFocus","onKeyDown","_androidInputManagerR5","isRTL","_maybeHistoryEditor","currentNode","onPaste","types","isPlainTextOnlyPaste","leafEl","bind","scrollMode","handler","shouldTreatEventAsHandled","isDefaultPrevented","isPropagationStopped","HTMLInputElement","HTMLTextAreaElement","defaultPrevented","FocusedContext","SlateSelectorContext","REACT_MAJOR_VERSION","Slate","onSelectionChange","onValueChange","initialValue","setContext","assign","v","selectorContext","handleSelectorChange","eventListeners","slateRef","listener","getSlate","useSelectorContext","_options$operation","operation","prevContext","setIsFocused","withReact"],"sourceRoot":""}