{"version":3,"file":"slate-dom-CgCPnaaC.js","sources":["../../node_modules/slate-dom/dist/index.es.js"],"sourcesContent":["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"],"names":["_navigator$userAgent$","_navigator$userAgent$2","DOMNode","globalThis","Node","DOMText","Text","getDefaultView","value","ownerDocument","defaultView","isDOMElement","isDOMNode","nodeType","window","isDOMSelection","anchorNode","Selection","isDOMText","isPlainTextOnlyPaste","event","clipboardData","getData","types","length","getEditableChildAndIndex","parent","index","direction","childNodes","child","i","triedForward","triedBackward","getAttribute","getEditableChild","getPlainText","domNode","text","nodeValue","childNode","Array","from","display","getComputedStyle","getPropertyValue","tagName","catchSlateFragment","getSelection","root","document","isTrackedMutation","editor","mutation","batch","target","matches","DOMEditor","getWindow","contains","hasDOMNode","editable","parentMutation","find","_ref","addedNodes","removedNodes","node","_node","getActiveElement","activeElement","_activeElement","shadowRoot","_activeElement$shadow","_activeElement2","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","o","Symbol","iterator","constructor","_toPropertyKey","arg","key","input","hint","prim","toPrimitive","res","call","TypeError","String","Number","_toPrimitive","_defineProperty","obj","Object","defineProperty","enumerable","configurable","writable","n","Key","this","id","concat","IS_NODE_MAP_DIRTY","WeakMap","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","get","androidScheduleFlush","_EDITOR_TO_SCHEDULE_F","blur","el","toDOMNode","findDocumentOrShadowRoot","set","deselect","selection","domSelection","rangeCount","removeAllRanges","Transforms","getRootNode","Document","ShadowRoot","findEventRange","nativeEvent","clientX","x","clientY","y","Error","domRange","toSlateNode","path","findPath","Element","isElement","Editor","isVoid","rect","getBoundingClientRect","isPrev","isInline","left","width","top","height","edge","point","before","after","range","caretRangeFromPoint","position","caretPositionFromPoint","createRange","setStart","offsetNode","offset","setEnd","toSlateRange","exactMatch","suppressThrow","findKey","isEditor","unshift","Scrubber","stringify","focus","options","arguments","retries","operations","setTimeout","toDOMRange","addRange","select","start","preventScroll","targetEl","editorEl","parentElement","err","message","includes","closest","isContentEditable","hasEditableTarget","hasRange","anchor","hasPath","hasSelectableTarget","isTargetInsideNonReadonlyVoid","hasTarget","insertData","data","insertFragmentData","insertTextData","isComposing","isFocused","isReadOnly","slateNode","setFragmentData","originEvent","KEY_TO_ELEMENT","toDOMPoint","domPoint","void","at","texts","querySelectorAll","textContent","attr","end","nextText","hasAttribute","_nextText$textContent","domText","startsWith","Math","min","max","isBackward","Range","domAnchor","domFocus","isCollapsed","startNode","startOffset","endNode","endOffset","isStartAtZeroWidth","isEndAtZeroWidth","domEl","toSlatePoint","searchDirection","nearestNode","nearestOffset","isLast","normalizeDOMPoint","parentNode","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","startContainer","firstRange","getRangeAt","lastRange","HTMLTableRowElement","getLastChildren","element","childElementCount","children","firstNodeRow","lastNodeRow","firstNode","lastNode","HTMLElement","innerHTML","endContainer","toString","hasShadowRoot","collapsed","focusBeforeAnchor","isExpanded","isForward","mode","unhangRange","voids","verifyDiffState","textDiff","diff","isText","nextPath","Path","next","nextNode","applyStringDiff","_len","diffs","_key","reduce","normalizeStringDiff","targetText","removedText","prefixLength","str","another","charAt","longestCommonPrefixLength","suffixLength","longestCommonSuffixLength","normalized","mergeStringDiffs","a","b","overlap","applied","sliceEnd","targetRange","normalizePoint","parentBlock","above","isBlock","entry","isDescendant","normalizeRange","transformPendingPoint","op","pendingDiffs","equals","Point","transform","affinity","_anchor","_transformed","transformed","type","transformPendingRange","doRectsIntersect","compareRect","middle","bottom","areRangesSameLine","range1","range2","rect1","rect2","ownKeys","e","r","t","keys","getOwnPropertySymbols","filter","getOwnPropertyDescriptor","push","apply","_objectSpread","getOwnPropertyDescriptors","defineProperties","withDOM","clipboardFormatKey","onChange","deleteBackward","addMark","removeMark","_EDITOR_TO_PENDING_DI","delete","_EDITOR_TO_PENDING_DI2","unit","parentBlockEntry","parentBlockPath","parentElementRange","currentLineRange","parentRange","parentRangeBoundary","positions","right","floor","findCurrentLineRange","pathRefMatches","map","newPath","transformTextDiff","pendingSelection","pendingAction","isPoint","getMatches","_EDITOR_TO_USER_SELEC","unref","prevPath","previous","changedPath","commonPath","common","changedNode","changedNodeKey","changedPathRef","pathRef","edges","startVoid","endVoid","attach","trim","cloneRange","setEndAfter","zw","isNewline","span","style","whiteSpace","appendChild","fragment","getFragment","string","JSON","encoded","btoa","encodeURIComponent","setAttribute","setData","div","body","dataTransfer","htmlData","getSlateFragmentAttribute","decoded","decodeURIComponent","atob","parsed","parse","insertFragment","lines","split","line","splitNodes","always","insertText","onContextChange","p","levels","TRIPLE_CLICK","HOTKEYS","bold","compose","moveBackward","moveForward","moveWordBackward","moveWordForward","deleteForward","extendBackward","extendForward","italic","insertSoftBreak","splitBlock","undo","APPLE_HOTKEYS","moveLineBackward","moveLineForward","deleteLineBackward","deleteLineForward","deleteWordBackward","deleteWordForward","extendLineBackward","extendLineForward","redo","transposeCharacter","WINDOWS_HOTKEYS","create","generic","apple","windows","isGeneric","isHotkey","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","isElementDecorationsEqual","list","isTextDecorationsEqual"],"mappings":"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","x_google_ignoreList":[0]}