slate-vue3 0.2.12 → 0.3.0

package/dist/index.js

@@ -1,1768 +1,7 @@
-import { h, defineComponent, provide, ref, computed, onMounted, onUnmounted, renderSlot, inject, watch, renderList, Fragment, useAttrs, reactive, toRaw } from "vue";
-import { R as Range, N as Node, S as Scrubber, T as Text, P as Path, E as Editor, a as Element, c as Transforms } from "./batch-dirty-paths-DdGxRyrT.js";
+import { S as SLATE_USE_SELECTED, a as SLATE_STATE_SELECTION } from "./use-focused-C0jEAq2w.js";
+import { E, b, d, c, u, g, e, f } from "./use-focused-C0jEAq2w.js";
+import { inject } from "vue";
 import { t } from "./batch-dirty-paths-DdGxRyrT.js";
-import { p as isDOMNode, I as IS_ANDROID, D as DOMEditor, P as MARK_PLACEHOLDER_SYMBOL, d as EDITOR_TO_ON_CHANGE, x as IS_IOS, E as EDITOR_TO_KEY_TO_ELEMENT, J as ELEMENT_TO_NODE, Q as NODE_TO_ELEMENT, R as NODE_TO_INDEX, S as NODE_TO_PARENT, y as IS_WEBKIT, e as applyStringDiff, q as isDOMSelection, n as normalizeStringDiff, O as IS_READ_ONLY, h as getDefaultView, G as EDITOR_TO_WINDOW, F as EDITOR_TO_ELEMENT, H as HAS_BEFORE_INPUT_SUPPORT, C as CAN_USE_DOM, f as getActiveElement, j as getSelection, M as IS_FOCUSED, r as isPlainTextOnlyPaste, L as IS_COMPOSING, B as Hotkeys, u as IS_CHROME, v as IS_FIREFOX, w as IS_FIREFOX_LEGACY, A as IS_WECHATBROWSER, z as IS_UC_MOBILE, a as EDITOR_TO_USER_MARKS, o as isDOMElement, b as EDITOR_TO_USER_SELECTION } from "./hotkeys-CmyQAN4Q.js";
-const SLATE_USE_EDITOR = Symbol("SLATE_USE_EDITOR");
-const SLATE_USE_DECORATE = Symbol("SLATE_USE_DECORATE");
-const SLATE_USE_SELECTED = Symbol("SLATE_USE_SELECTED");
-const SLATE_STATE_FOCUS = Symbol("SLATE_STATE_FOCUS");
-const SLATE_STATE_COMPOSING = Symbol("SLATE_STATE_COMPOSING");
-const SLATE_STATE_READ_ONLY = Symbol("SLATE_STATE_READ_ONLY");
-const SLATE_STATE_SELECTION = Symbol("SLATE_STATE_SELECTION");
-const SLATE_INNER_RENDER_ELEMENT = Symbol("SLATE_INNER_RENDER_ELEMENT");
-const SLATE_INNER_RENDER_LEAF = Symbol("SLATE_INNER_RENDER_LEAF");
-const SLATE_INNER_RENDER_PLACEHOLDER = Symbol("SLATE_INNER_RENDER_PLACEHOLDER");
-const SLATE_INNER_CHANGE_EFFECT_INJECT = Symbol("SLATE_INNER_CHANGE_EFFECT_INJECT");
-const SLATE_INNER_MARK_PLACEHOLDER = Symbol("SLATE_INNER_MARK_PLACEHOLDER");
-const t2 = (t3) => "object" == typeof t3 && null != t3 && 1 === t3.nodeType, e$1 = (t3, e2) => (!e2 || "hidden" !== t3) && ("visible" !== t3 && "clip" !== t3), n = (t3, n2) => {
-  if (t3.clientHeight < t3.scrollHeight || t3.clientWidth < t3.scrollWidth) {
-    const o2 = getComputedStyle(t3, null);
-    return e$1(o2.overflowY, n2) || e$1(o2.overflowX, n2) || ((t4) => {
-      const e2 = ((t5) => {
-        if (!t5.ownerDocument || !t5.ownerDocument.defaultView) return null;
-        try {
-          return t5.ownerDocument.defaultView.frameElement;
-        } catch (t6) {
-          return null;
-        }
-      })(t4);
-      return !!e2 && (e2.clientHeight < t4.scrollHeight || e2.clientWidth < t4.scrollWidth);
-    })(t3);
-  }
-  return false;
-}, o$1 = (t3, e2, n2, o2, l2, r2, i, s) => r2 < t3 && i > e2 || r2 > t3 && i < e2 ? 0 : r2 <= t3 && s <= n2 || i >= e2 && s >= n2 ? r2 - t3 - o2 : i > e2 && s < n2 || r2 < t3 && s > n2 ? i - e2 + l2 : 0, l = (t3) => {
-  const e2 = t3.parentElement;
-  return null == e2 ? t3.getRootNode().host || null : e2;
-}, r = (e2, r2) => {
-  var i, s, d, h2;
-  if ("undefined" == typeof document) return [];
-  const { scrollMode: c, block: f, inline: u, boundary: a, skipOverflowHiddenElements: g } = r2, p = "function" == typeof a ? a : (t3) => t3 !== a;
-  if (!t2(e2)) throw new TypeError("Invalid target");
-  const m = document.scrollingElement || document.documentElement, w = [];
-  let W = e2;
-  for (; t2(W) && p(W); ) {
-    if (W = l(W), W === m) {
-      w.push(W);
-      break;
-    }
-    null != W && W === document.body && n(W) && !n(document.documentElement) || null != W && n(W, g) && w.push(W);
-  }
-  const b = null != (s = null == (i = window.visualViewport) ? void 0 : i.width) ? s : innerWidth, H = null != (h2 = null == (d = window.visualViewport) ? void 0 : d.height) ? h2 : innerHeight, { scrollX: y, scrollY: M } = window, { height: v, width: E, top: x, right: C, bottom: I, left: R } = e2.getBoundingClientRect(), { top: T, right: B, bottom: F, left: V } = ((t3) => {
-    const e3 = window.getComputedStyle(t3);
-    return { top: parseFloat(e3.scrollMarginTop) || 0, right: parseFloat(e3.scrollMarginRight) || 0, bottom: parseFloat(e3.scrollMarginBottom) || 0, left: parseFloat(e3.scrollMarginLeft) || 0 };
-  })(e2);
-  let k = "start" === f || "nearest" === f ? x - T : "end" === f ? I + F : x + v / 2 - T + F, D = "center" === u ? R + E / 2 - V + B : "end" === u ? C + B : R - V;
-  const L = [];
-  for (let t3 = 0; t3 < w.length; t3++) {
-    const e3 = w[t3], { height: n2, width: l2, top: r3, right: i2, bottom: s2, left: d2 } = e3.getBoundingClientRect();
-    if ("if-needed" === c && x >= 0 && R >= 0 && I <= H && C <= b && x >= r3 && I <= s2 && R >= d2 && C <= i2) return L;
-    const h3 = getComputedStyle(e3), a2 = parseInt(h3.borderLeftWidth, 10), g2 = parseInt(h3.borderTopWidth, 10), p2 = parseInt(h3.borderRightWidth, 10), W2 = parseInt(h3.borderBottomWidth, 10);
-    let T2 = 0, B2 = 0;
-    const F2 = "offsetWidth" in e3 ? e3.offsetWidth - e3.clientWidth - a2 - p2 : 0, V2 = "offsetHeight" in e3 ? e3.offsetHeight - e3.clientHeight - g2 - W2 : 0, S = "offsetWidth" in e3 ? 0 === e3.offsetWidth ? 0 : l2 / e3.offsetWidth : 0, X = "offsetHeight" in e3 ? 0 === e3.offsetHeight ? 0 : n2 / e3.offsetHeight : 0;
-    if (m === e3) T2 = "start" === f ? k : "end" === f ? k - H : "nearest" === f ? o$1(M, M + H, H, g2, W2, M + k, M + k + v, v) : k - H / 2, B2 = "start" === u ? D : "center" === u ? D - b / 2 : "end" === u ? D - b : o$1(y, y + b, b, a2, p2, y + D, y + D + E, E), T2 = Math.max(0, T2 + M), B2 = Math.max(0, B2 + y);
-    else {
-      T2 = "start" === f ? k - r3 - g2 : "end" === f ? k - s2 + W2 + V2 : "nearest" === f ? o$1(r3, s2, n2, g2, W2 + V2, k, k + v, v) : k - (r3 + n2 / 2) + V2 / 2, B2 = "start" === u ? D - d2 - a2 : "center" === u ? D - (d2 + l2 / 2) + F2 / 2 : "end" === u ? D - i2 + p2 + F2 : o$1(d2, i2, l2, a2, p2 + F2, D, D + E, E);
-      const { scrollLeft: t4, scrollTop: h4 } = e3;
-      T2 = 0 === X ? 0 : Math.max(0, Math.min(h4 + T2 / X, e3.scrollHeight - n2 / X + V2)), B2 = 0 === S ? 0 : Math.max(0, Math.min(t4 + B2 / S, e3.scrollWidth - l2 / S + F2)), k += h4 - T2, D += t4 - B2;
-    }
-    L.push({ el: e3, top: T2, left: B2 });
-  }
-  return L;
-};
-const o = (t3) => false === t3 ? { block: "end", inline: "nearest" } : ((t4) => t4 === Object(t4) && 0 !== Object.keys(t4).length)(t3) ? t3 : { block: "start", inline: "nearest" };
-function e(e2, r$1) {
-  if (!e2.isConnected || !((t3) => {
-    let o2 = t3;
-    for (; o2 && o2.parentNode; ) {
-      if (o2.parentNode === document) return true;
-      o2 = o2.parentNode instanceof ShadowRoot ? o2.parentNode.host : o2.parentNode;
-    }
-    return false;
-  })(e2)) return;
-  const n2 = ((t3) => {
-    const o2 = window.getComputedStyle(t3);
-    return { top: parseFloat(o2.scrollMarginTop) || 0, right: parseFloat(o2.scrollMarginRight) || 0, bottom: parseFloat(o2.scrollMarginBottom) || 0, left: parseFloat(o2.scrollMarginLeft) || 0 };
-  })(e2);
-  if (((t3) => "object" == typeof t3 && "function" == typeof t3.behavior)(r$1)) return r$1.behavior(r(e2, r$1));
-  const l2 = "boolean" == typeof r$1 || null == r$1 ? void 0 : r$1.behavior;
-  for (const { el: a, top: i, left: s } of r(e2, o(r$1))) {
-    const t3 = i - n2.top + n2.bottom, o2 = s - n2.left + n2.right;
-    a.scroll({ top: t3, left: o2, behavior: l2 });
-  }
-}
-const isEventHandled = (event, handler) => {
-  if (!handler) {
-    return false;
-  }
-  event.stopImmediatePropagation();
-  const shouldTreatEventAsHandled = handler(event);
-  if (shouldTreatEventAsHandled != null) {
-    return shouldTreatEventAsHandled;
-  }
-  return event.defaultPrevented || !event.bubbles;
-};
-const isDOMEventTargetInput = (event) => isDOMNode(event.target) && (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement);
-const isDOMEventHandled = (event, handler) => {
-  if (!handler) {
-    return false;
-  }
-  event.stopImmediatePropagation();
-  const shouldTreatEventAsHandled = handler(event);
-  if (shouldTreatEventAsHandled != null) {
-    return shouldTreatEventAsHandled;
-  }
-  return event.defaultPrevented;
-};
-const handleNativeHistoryEvents = (editor, event) => {
-  if (event.inputType === "historyUndo" && "undo" in editor && typeof editor.undo === "function") {
-    editor.undo();
-  }
-  if (event.inputType === "historyRedo" && "redo" in editor && typeof editor.redo === "function") {
-    editor.redo();
-  }
-};
-const defaultScrollSelectionIntoView = (editor, domRange) => {
-  if (domRange.getBoundingClientRect && (!editor.selection || editor.selection && Range.isCollapsed(editor.selection))) {
-    const leafEl = domRange.startContainer.parentElement;
-    leafEl.getBoundingClientRect = domRange.getBoundingClientRect.bind(domRange);
-    e(leafEl, {
-      scrollMode: "if-needed"
-    });
-    delete leafEl.getBoundingClientRect;
-  }
-};
-const defaultRenderLeaf = ({ attributes, children }) => {
-  return h(
-    "span",
-    attributes,
-    children
-  );
-};
-const defaultRenderPlaceHolder = ({ attributes, children }) => {
-  return h("span", attributes, [
-    children,
-    IS_ANDROID ? h("br") : void 0
-  ]);
-};
-const DEFAULT_DECORATE_FN = () => [];
-const Slate = defineComponent({
-  name: "slate-editor",
-  emits: ["change", "selectionchange", "valuechange"],
-  props: {
-    editor: {
-      type: Object,
-      require: true
-    },
-    decorate: {
-      type: Function,
-      default: DEFAULT_DECORATE_FN
-    },
-    renderElement: {
-      type: Function,
-      required: true
-    },
-    renderLeaf: {
-      type: Function,
-      required: true
-    },
-    renderPlaceholder: {
-      type: Function,
-      required: true
-    }
-  },
-  setup(props, { slots, emit }) {
-    const { editor, decorate, renderElement, renderLeaf, renderPlaceholder } = props;
-    if (!Node.isNodeList(editor.children)) {
-      throw new Error(
-        `[Slate] initialValue is invalid! Expected a list of elements but got: ${Scrubber.stringify(
-          editor.children
-        )}`
-      );
-    }
-    provide(SLATE_USE_EDITOR, editor);
-    provide(SLATE_USE_DECORATE, decorate);
-    provide(SLATE_INNER_RENDER_ELEMENT, renderElement);
-    provide(SLATE_INNER_RENDER_LEAF, renderLeaf);
-    provide(SLATE_INNER_RENDER_PLACEHOLDER, renderPlaceholder);
-    const isFocus = ref(DOMEditor.isFocused(editor));
-    const selection = computed(() => editor.selection);
-    provide(SLATE_STATE_FOCUS, isFocus);
-    provide(SLATE_STATE_COMPOSING, ref(false));
-    provide(SLATE_STATE_READ_ONLY, ref(false));
-    provide(SLATE_STATE_SELECTION, selection);
-    const focusCb = () => isFocus.value = DOMEditor.isFocused(editor);
-    const changeEffect = ref(0);
-    provide(SLATE_INNER_CHANGE_EFFECT_INJECT, changeEffect);
-    const markPlaceholder = computed(() => {
-      if (editor.selection && Range.isCollapsed(editor.selection) && editor.marks) {
-        const anchor = editor.selection.anchor;
-        const leaf = Node.leaf(editor, anchor.path);
-        const { text, ...rest } = leaf;
-        if (!Text.equals(leaf, editor.marks, { loose: true })) {
-          const unset = Object.fromEntries(
-            Object.keys(rest).map((mark) => [mark, null])
-          );
-          return {
-            [MARK_PLACEHOLDER_SYMBOL]: true,
-            ...unset,
-            ...editor.marks,
-            anchor,
-            focus: anchor
-          };
-        }
-      }
-      return null;
-    });
-    provide(SLATE_INNER_MARK_PLACEHOLDER, markPlaceholder);
-    onMounted(() => {
-      document.addEventListener("focusin", focusCb);
-      document.addEventListener("focusout", focusCb);
-      EDITOR_TO_ON_CHANGE.set(editor, (options) => {
-        var _a;
-        emit("change", options);
-        changeEffect.value++;
-        switch ((_a = options == null ? void 0 : options.operation) == null ? void 0 : _a.type) {
-          case "set_selection":
-            emit("selectionchange", options);
-            break;
-          default:
-            emit("valuechange", options);
-        }
-      });
-    });
-    onUnmounted(() => {
-      document.removeEventListener("focusin", focusCb);
-      document.removeEventListener("focusout", focusCb);
-      EDITOR_TO_ON_CHANGE.delete(editor);
-    });
-    return () => renderSlot(slots, "default");
-  }
-});
-const rtlRange = "֑-߿יִ-﷽ﹰ-ﻼ";
-const ltrRange = "A-Za-zÀ-ÖØ-öø-ʸ̀-֐ࠀ-῿‎Ⰰ-﬜︀-﹯﻽-￿";
-const rtl = new RegExp("^[^" + ltrRange + "]*[" + rtlRange + "]");
-const ltr = new RegExp("^[^" + rtlRange + "]*[" + ltrRange + "]");
-function direction(value) {
-  const source = String(value || "");
-  return rtl.test(source) ? "rtl" : ltr.test(source) ? "ltr" : "neutral";
-}
-const useDecorate = () => {
-  const decorate = inject(SLATE_USE_DECORATE);
-  if (decorate === void 0) {
-    throw new Error(
-      `The \`useDecorate\` hook must be used inside the <Slate> component's context.`
-    );
-  }
-  return decorate;
-};
-const useEditor = () => {
-  const editor = inject(SLATE_USE_EDITOR);
-  if (editor === void 0) {
-    throw new Error(
-      `The \`useEditor\` hook must be used inside the <Slate> component's context.`
-    );
-  }
-  return editor;
-};
-const StringComp = defineComponent({
-  name: "slate-string",
-  props: ["leaf", "text", "element", "isLast"],
-  setup(props) {
-    const { leaf, text, element, isLast } = props;
-    const editor = useEditor();
-    const getTextContent = computed(() => {
-      const text2 = leaf.text;
-      return (text2 ?? "") + (isLast && text2.at(-1) === "\n" ? "\n" : "");
-    });
-    const isLineBreak = computed(() => {
-      const pathParent = Path.parent(DOMEditor.findPath(editor, text));
-      return leaf.text === "" && element.children.at(-1) === text && !editor.isInline(element) && Editor.string(editor, pathParent) === "";
-    });
-    const zeroStringAttrs = computed(() => {
-      const length = Node.string(element).length || 0;
-      const isMarkPlaceholder = Boolean(leaf[MARK_PLACEHOLDER_SYMBOL]) || false;
-      const isVoidParent = editor.isVoid(element);
-      if (isVoidParent || isLineBreak.value || leaf.text === "") {
-        return {
-          "data-slate-zero-width": isLineBreak.value ? "n" : "z",
-          "data-slate-length": length,
-          "data-slate-mark-placeholder": isMarkPlaceholder ? true : void 0
-        };
-      }
-      return null;
-    });
-    return () => zeroStringAttrs.value ? h("span", zeroStringAttrs.value, [
-      !(IS_ANDROID || IS_IOS) || !isLineBreak.value ? "\uFEFF" : null,
-      isLineBreak.value ? h("br") : null
-    ]) : h("span", { "data-slate-string": true }, getTextContent.value);
-  }
-});
-const useRenderElement = () => {
-  const ELEMENT_RENDER = inject(
-    SLATE_INNER_RENDER_ELEMENT
-  );
-  if (ELEMENT_RENDER === void 0) {
-    throw new Error(
-      `The \`useRenderElement\` hook must be used inside the <Slate> component's context.`
-    );
-  }
-  return ELEMENT_RENDER;
-};
-const useRenderLeaf = () => {
-  const LEAF_RENDER = inject(
-    SLATE_INNER_RENDER_LEAF
-  );
-  if (LEAF_RENDER === void 0) {
-    throw new Error(
-      `The \`useRenderLeaf\` hook must be used inside the <Slate> component's context.`
-    );
-  }
-  return LEAF_RENDER;
-};
-const useRenderPlaceholder = () => {
-  const PLACEHOLDER_RENDER = inject(
-    SLATE_INNER_RENDER_PLACEHOLDER
-  );
-  if (PLACEHOLDER_RENDER === void 0) {
-    throw new Error(
-      `The \`useRenderPlaceholder\` hook must be used inside the <Slate> component's context.`
-    );
-  }
-  return PLACEHOLDER_RENDER;
-};
-const useChangeEffect = (fn) => {
-  const CHANGE_EFFECT_INJECT = inject(
-    SLATE_INNER_CHANGE_EFFECT_INJECT
-  );
-  if (CHANGE_EFFECT_INJECT === void 0) {
-    throw new Error(
-      `The \`useChangeEffect\` hook must be used inside the <Slate> component's context.`
-    );
-  }
-  watch(() => CHANGE_EFFECT_INJECT.value, fn);
-  return CHANGE_EFFECT_INJECT;
-};
-const useMarkPlaceholder = () => {
-  const MARK_PLACEHOLDER_INJECT = inject(SLATE_INNER_MARK_PLACEHOLDER);
-  if (MARK_PLACEHOLDER_INJECT === void 0) {
-    throw new Error(
-      `The \`useChangeEffect\` hook must be used inside the <Slate> component's context.`
-    );
-  }
-  return MARK_PLACEHOLDER_INJECT;
-};
-const TextComp = defineComponent({
-  name: "slate-text",
-  props: ["text", "element"],
-  setup(props) {
-    const { text, element } = props;
-    const editor = useEditor();
-    const spanRef = ref();
-    const decorate = useDecorate();
-    const markPlaceholder = useMarkPlaceholder();
-    const leaves = computed(() => {
-      if (decorate === DEFAULT_DECORATE_FN) {
-        return [text];
-      }
-      const elemPath = DOMEditor.findPath(editor, element);
-      const textPath = DOMEditor.findPath(editor, text);
-      const textDs = decorate([text, textPath]);
-      const elemDs = decorate([element, elemPath]);
-      const range = Editor.range(editor, textPath);
-      elemDs.forEach((dec) => {
-        textDs.push(Range.intersection(dec, range));
-      });
-      if (markPlaceholder.value) {
-        textDs.unshift(markPlaceholder.value);
-      }
-      const filterDs = textDs.filter(Boolean);
-      return Text.decorations(text, filterDs.length ? filterDs : []);
-    });
-    onMounted(() => {
-      const key = DOMEditor.findKey(editor, text);
-      if (spanRef.value) {
-        const KEY_TO_ELEMENT = EDITOR_TO_KEY_TO_ELEMENT.get(editor);
-        KEY_TO_ELEMENT == null ? void 0 : KEY_TO_ELEMENT.set(key, spanRef.value);
-        ELEMENT_TO_NODE.set(spanRef.value, text);
-        NODE_TO_ELEMENT.set(text, spanRef.value);
-      }
-    });
-    onUnmounted(() => {
-      NODE_TO_ELEMENT.delete(text);
-      if (spanRef.value) {
-        ELEMENT_TO_NODE.delete(spanRef.value);
-      }
-    });
-    const isLastText = computed(() => {
-      const isVoid = Editor.isVoid(editor, element);
-      const isLeafBlock = Element.isElement(element) && !editor.isInline(element) && Editor.hasInlines(editor, element);
-      return !isVoid && isLeafBlock && NODE_TO_INDEX.get(text) === element.children.length - 1;
-    });
-    const renderLeaf = useRenderLeaf();
-    return () => h(
-      "span",
-      { "data-slate-node": "text", ref: spanRef },
-      renderList(
-        leaves.value,
-        (leaf, i) => renderLeaf({
-          text,
-          leaf,
-          attributes: { "data-slate-leaf": true },
-          children: h(StringComp, {
-            text,
-            element,
-            leaf,
-            isLast: isLastText.value && i === leaves.value.length - 1,
-            key: `${text.text}-${leaf.text}-${i}`
-          })
-        })
-      )
-    );
-  }
-});
-const useReadOnly = () => {
-  const isReadOnly = inject(SLATE_STATE_READ_ONLY);
-  if (isReadOnly === void 0) {
-    throw new Error(
-      `The \`useFocused\` hook must be used inside the <Slate> component's context.`
-    );
-  }
-  return isReadOnly;
-};
-const VOID_CHILDREN_ATTRS = {
-  "data-slate-spacer": true,
-  style: {
-    height: "0",
-    color: "transparent",
-    outline: "none",
-    position: "absolute"
-  }
-};
-const ElementComp = defineComponent({
-  name: "slate-element",
-  props: ["element"],
-  setup(props) {
-    const element = props.element;
-    const editor = useEditor();
-    const selected = computed(() => {
-      const path = DOMEditor.findPath(editor, element);
-      if (!editor.selection) {
-        return false;
-      }
-      return !!Range.intersection(Editor.range(editor, path), editor.selection);
-    });
-    provide(SLATE_USE_SELECTED, selected);
-    const elementRef = ref(null);
-    onMounted(() => {
-      const key = DOMEditor.findKey(editor, element);
-      const KEY_TO_ELEMENT = EDITOR_TO_KEY_TO_ELEMENT.get(editor);
-      if (elementRef.value) {
-        KEY_TO_ELEMENT == null ? void 0 : KEY_TO_ELEMENT.set(key, elementRef.value);
-        NODE_TO_ELEMENT.set(element, elementRef.value);
-        ELEMENT_TO_NODE.set(elementRef.value, element);
-      }
-    });
-    onUnmounted(() => {
-      const key = DOMEditor.findKey(editor, element);
-      const KEY_TO_ELEMENT = EDITOR_TO_KEY_TO_ELEMENT.get(editor);
-      KEY_TO_ELEMENT == null ? void 0 : KEY_TO_ELEMENT.delete(key);
-      NODE_TO_ELEMENT.delete(element);
-    });
-    const isInline = computed(() => editor.isInline(element));
-    const readOnly = useReadOnly();
-    const attributes = computed(() => {
-      const attr = {
-        "data-slate-node": "element",
-        ref: elementRef
-      };
-      if (isInline.value) {
-        attr["data-slate-inline"] = true;
-      } else if (Editor.hasInlines(editor, element)) {
-        const text = Node.string(element);
-        const dir = direction(text);
-        if (dir === "rtl") {
-          attr.dir = dir;
-        }
-      }
-      if (Editor.isVoid(editor, element)) {
-        attr["data-slate-void"] = true;
-        if (!readOnly && isInline.value) {
-          attr.contenteditable = false;
-        }
-      }
-      return attr;
-    });
-    const children = computed(() => {
-      if (!Editor.isVoid(editor, element)) {
-        return h(Fragment, ChildrenFC(element, editor));
-      }
-      const [[text]] = Node.texts(element);
-      NODE_TO_INDEX.set(text, 0);
-      NODE_TO_PARENT.set(text, element);
-      const tag = isInline.value ? "span" : "div";
-      return h(tag, VOID_CHILDREN_ATTRS, h(TextComp, { element, text }));
-    });
-    const renderElement = useRenderElement();
-    return () => renderElement({
-      attributes: attributes.value,
-      children: children.value,
-      element
-    });
-  }
-});
-const ChildrenFC = (element, editor) => renderList(element.children, (child, i) => {
-  const key = DOMEditor.findKey(editor, child);
-  NODE_TO_INDEX.set(child, i);
-  NODE_TO_PARENT.set(child, element);
-  return Element.isElement(child) ? h(ElementComp, { element: child, key: key.id }) : h(TextComp, { text: child, element, key: key.id });
-});
-const useComposing = () => {
-  const isComposing = inject(SLATE_STATE_COMPOSING);
-  if (isComposing === void 0) {
-    throw new Error(
-      `The \`useFocused\` hook must be used inside the <Slate> component's context.`
-    );
-  }
-  return isComposing;
-};
-const style = {
-  position: "absolute",
-  top: 0,
-  pointerEvents: "none",
-  width: "100%",
-  maxWidth: "100%",
-  display: "block",
-  opacity: "0.333",
-  userSelect: "none",
-  textDecoration: "none",
-  // Fixes https://github.com/udecode/plate/issues/2315
-  WebkitUserModify: IS_WEBKIT ? "inherit" : void 0
-};
-const PlaceholderComp = defineComponent({
-  name: "slate-placeholder",
-  props: ["placeholder", "onPlaceholderResize"],
-  setup(props) {
-    const editor = useEditor();
-    const placeholderResizeObserver = ref();
-    const isComposing = useComposing();
-    const showPlaceholder = computed(
-      () => {
-        var _a;
-        return props.placeholder && ((_a = editor.children) == null ? void 0 : _a.length) === 1 && Array.from(Node.texts(editor)).length === 1 && Node.string(editor) === "" && !isComposing.value;
-      }
-    );
-    const attributes = computed(() => ({
-      "data-slate-placeholder": true,
-      style,
-      contenteditable: false,
-      onVnodeMounted(vNode) {
-        if (vNode.el) {
-          placeholderResizeObserver.value = new ResizeObserver(() => {
-            var _a, _b;
-            props.onPlaceholderResize(
-              (_b = (_a = vNode.el) == null ? void 0 : _a.getBoundingClientRect()) == null ? void 0 : _b.height
-            );
-          });
-          placeholderResizeObserver.value.observe(vNode.el);
-        }
-      },
-      onVnodeUnmounted() {
-        var _a;
-        (_a = placeholderResizeObserver.value) == null ? void 0 : _a.disconnect();
-        placeholderResizeObserver.value = void 0;
-        props.onPlaceholderResize();
-      }
-    }));
-    const renderPlaceholder = useRenderPlaceholder();
-    return () => showPlaceholder.value && renderPlaceholder({
-      children: props.placeholder,
-      attributes: attributes.value
-    });
-  }
-});
-const MUTATION_OBSERVER_CONFIG = {
-  subtree: true,
-  childList: true,
-  characterData: true,
-  characterDataOldValue: true
-};
-const useAndroidManager = (editableRef) => {
-  const editor = useEditor();
-  const mutationObserver = ref();
-  const schedule = ref();
-  let insertPositionHint = false;
-  onMounted(() => {
-    mutationObserver.value = new MutationObserver((mutations) => {
-      var _a, _b, _c;
-      (_a = mutationObserver.value) == null ? void 0 : _a.disconnect();
-      (_b = mutationObserver.value) == null ? void 0 : _b.takeRecords();
-      mutations.reverse().forEach((mutation) => {
-        if (mutation.type === "characterData") {
-          return;
-        }
-        mutation.removedNodes.forEach((node) => {
-          mutation.target.insertBefore(node, mutation.nextSibling);
-        });
-        mutation.addedNodes.forEach((node) => {
-          mutation.target.removeChild(node);
-        });
-      });
-      (_c = schedule.value) == null ? void 0 : _c.call(schedule);
-      schedule.value = void 0;
-    });
-  });
-  const scheduleAction = (run, at) => {
-    insertPositionHint = false;
-    schedule.value = run;
-  };
-  const storeDiff = (path, diff) => {
-    const target = Node.leaf(editor, path);
-    const normalized = normalizeStringDiff(target.text, diff);
-    if (!normalized) {
-      return;
-    }
-    scheduleAction(() => {
-      if (normalized.start !== normalized.end) {
-        if (normalized.text) {
-          Editor.deleteBackward(editor, { unit: "word" });
-        } else {
-          Editor.deleteBackward(editor, { unit: "character" });
-        }
-      }
-      Editor.insertText(editor, normalized.text);
-    });
-  };
-  const handleDOMBeforeInput = (event) => {
-    var _a;
-    (_a = mutationObserver.value) == null ? void 0 : _a.observe(
-      editableRef.value,
-      MUTATION_OBSERVER_CONFIG
-    );
-    const { inputType: type } = event;
-    let targetRange = null;
-    const data = event.dataTransfer || event.data || void 0;
-    if (insertPositionHint !== false && type !== "insertText" && type !== "insertCompositionText") {
-      insertPositionHint = false;
-    }
-    let [nativeTargetRange] = event.getTargetRanges();
-    if (nativeTargetRange) {
-      targetRange = DOMEditor.toSlateRange(editor, nativeTargetRange, {
-        exactMatch: false,
-        suppressThrow: true
-      });
-    }
-    const window2 = DOMEditor.getWindow(editor);
-    const domSelection = window2.getSelection();
-    if (!targetRange && domSelection) {
-      nativeTargetRange = domSelection;
-      targetRange = DOMEditor.toSlateRange(editor, domSelection, {
-        exactMatch: false,
-        suppressThrow: true
-      });
-    }
-    targetRange = targetRange ?? editor.selection;
-    if (!targetRange) {
-      return;
-    }
-    let canStoreDiff = true;
-    if (type.startsWith("delete")) {
-      if (Range.isExpanded(targetRange)) {
-        const [start2, end2] = Range.edges(targetRange);
-        const leaf2 = Node.leaf(editor, start2.path);
-        if (leaf2.text.length === start2.offset && end2.offset === 0) {
-          const next = Editor.next(editor, {
-            at: start2.path,
-            match: Text.isText
-          });
-          if (next && Path.equals(next[1], end2.path)) {
-            targetRange = { anchor: end2, focus: end2 };
-          }
-        }
-      }
-      const direction2 = type.endsWith("Backward") ? "backward" : "forward";
-      const [start, end] = Range.edges(targetRange);
-      const [leaf] = Editor.leaf(editor, start.path);
-      const diff = {
-        text: "",
-        start: start.offset,
-        end: end.offset
-      };
-      const diffs = [diff];
-      const text = applyStringDiff(leaf.text, ...diffs);
-      if (text.length === 0) {
-        canStoreDiff = false;
-      }
-      if (Range.isExpanded(targetRange)) {
-        if (canStoreDiff && Path.equals(targetRange.anchor.path, targetRange.focus.path)) {
-          const point = { path: targetRange.anchor.path, offset: start.offset };
-          Editor.range(editor, point, point);
-          return storeDiff(targetRange.anchor.path, {
-            text: "",
-            end: end.offset,
-            start: start.offset
-          });
-        }
-        return scheduleAction(
-          () => Editor.deleteFragment(editor, { direction: direction2 })
-        );
-      }
-    }
-    switch (type) {
-      case "deleteByComposition":
-      case "deleteByCut":
-      case "deleteByDrag": {
-        return scheduleAction(() => Editor.deleteFragment(editor));
-      }
-      case "deleteContent":
-      case "deleteContentForward": {
-        const { anchor } = targetRange;
-        if (canStoreDiff && Range.isCollapsed(targetRange)) {
-          const targetNode = Node.leaf(editor, anchor.path);
-          if (anchor.offset < targetNode.text.length) {
-            return storeDiff(anchor.path, {
-              text: "",
-              start: anchor.offset,
-              end: anchor.offset + 1
-            });
-          }
-        }
-        return scheduleAction(() => Editor.deleteForward(editor));
-      }
-      case "deleteContentBackward": {
-        const { anchor } = targetRange;
-        const nativeCollapsed = isDOMSelection(nativeTargetRange) ? nativeTargetRange.isCollapsed : !!(nativeTargetRange == null ? void 0 : nativeTargetRange.collapsed);
-        if (canStoreDiff && nativeCollapsed && Range.isCollapsed(targetRange) && anchor.offset > 0) {
-          return storeDiff(anchor.path, {
-            text: "",
-            start: anchor.offset - 1,
-            end: anchor.offset
-          });
-        }
-        return scheduleAction(() => Editor.deleteBackward(editor));
-      }
-      case "deleteEntireSoftLine": {
-        return scheduleAction(() => {
-          Editor.deleteBackward(editor, { unit: "line" });
-          Editor.deleteForward(editor, { unit: "line" });
-        });
-      }
-      case "deleteHardLineBackward": {
-        return scheduleAction(
-          () => Editor.deleteBackward(editor, { unit: "block" })
-        );
-      }
-      case "deleteSoftLineBackward": {
-        return scheduleAction(
-          () => Editor.deleteBackward(editor, { unit: "line" })
-        );
-      }
-      case "deleteHardLineForward": {
-        return scheduleAction(
-          () => Editor.deleteForward(editor, { unit: "block" })
-        );
-      }
-      case "deleteSoftLineForward": {
-        return scheduleAction(
-          () => Editor.deleteForward(editor, { unit: "line" })
-        );
-      }
-      case "deleteWordBackward": {
-        return scheduleAction(
-          () => Editor.deleteBackward(editor, { unit: "word" })
-        );
-      }
-      case "deleteWordForward": {
-        return scheduleAction(
-          () => Editor.deleteForward(editor, { unit: "word" })
-        );
-      }
-      case "insertLineBreak": {
-        return scheduleAction(
-          () => Editor.insertSoftBreak(editor)
-        );
-      }
-      case "insertParagraph": {
-        return scheduleAction(() => Editor.insertBreak(editor));
-      }
-      case "insertCompositionText":
-      case "deleteCompositionText":
-      case "insertFromComposition":
-      case "insertFromDrop":
-      case "insertFromPaste":
-      case "insertFromYank":
-      case "insertReplacementText":
-      case "insertText": {
-        if (data instanceof DataTransfer) {
-          return scheduleAction(
-            () => DOMEditor.insertData(editor, data)
-          );
-        }
-        let text = data ?? "";
-        if (type === "insertText" && /.*\n.*\n$/.test(text)) {
-          text = text.slice(0, -1);
-        }
-        if (text.includes("\n")) {
-          return scheduleAction(() => {
-            const parts = text.split("\n");
-            parts.forEach((line, i) => {
-              if (line) {
-                Editor.insertText(editor, line);
-              }
-              if (i !== parts.length - 1) {
-                Editor.insertSoftBreak(editor);
-              }
-            });
-          });
-        }
-        if (Path.equals(targetRange.anchor.path, targetRange.focus.path)) {
-          const [start, end] = Range.edges(targetRange);
-          const diff = {
-            start: start.offset,
-            end: end.offset,
-            text
-          };
-          if (text && insertPositionHint && type === "insertCompositionText") {
-            const hintPosition = insertPositionHint.start + insertPositionHint.text.search(/\S|$/);
-            const diffPosition = diff.start + diff.text.search(/\S|$/);
-            if (diffPosition === hintPosition + 1 && diff.end === insertPositionHint.start + insertPositionHint.text.length) {
-              diff.start -= 1;
-              insertPositionHint = null;
-            } else {
-              insertPositionHint = false;
-            }
-          } else if (type === "insertText") {
-            if (insertPositionHint === null) {
-              insertPositionHint = diff;
-            } else if (insertPositionHint && Range.isCollapsed(targetRange) && insertPositionHint.end + insertPositionHint.text.length === start.offset) {
-              insertPositionHint = {
-                ...insertPositionHint,
-                text: insertPositionHint.text + text
-              };
-            } else {
-              insertPositionHint = false;
-            }
-          } else {
-            insertPositionHint = false;
-          }
-          if (canStoreDiff) {
-            storeDiff(start.path, diff);
-            return;
-          }
-        }
-        return scheduleAction(
-          () => Editor.insertText(editor, text)
-        );
-      }
-    }
-  };
-  return {
-    handleDOMBeforeInput
-  };
-};
-const Editable = defineComponent({
-  name: "slate-editable",
-  props: {
-    scrollSelectionIntoView: {
-      type: Function,
-      required: false,
-      default: defaultScrollSelectionIntoView
-    },
-    placeholder: { type: String },
-    readOnly: {
-      type: Boolean,
-      default: () => false
-    },
-    role: { type: String },
-    style: {
-      type: Object,
-      default: () => {
-      }
-    },
-    is: {
-      type: String,
-      default: () => "div"
-    }
-  },
-  setup(props) {
-    const { placeholder, readOnly, scrollSelectionIntoView, is } = props;
-    const editor = useEditor();
-    const attributes = useAttrs();
-    const isComposing = useComposing();
-    const isReadOnly = useReadOnly();
-    watch(
-      () => readOnly,
-      (current) => {
-        IS_READ_ONLY.set(editor, current);
-        isReadOnly.value = current;
-      }
-    );
-    const state = reactive({
-      isDraggingInternally: false,
-      latestElement: null
-    });
-    const placeholderHeight = ref();
-    const onPlaceholderResize = (h2) => placeholderHeight.value = h2;
-    const processing = ref(false);
-    const onDOMSelectionChange = (event) => {
-      const target = event == null ? void 0 : event.target;
-      const targetElement = target instanceof HTMLElement ? target : null;
-      const targetTagName = targetElement == null ? void 0 : targetElement.tagName;
-      if (targetTagName === "INPUT" || targetTagName === "TEXTAREA") {
-        return;
-      }
-      const el = DOMEditor.toDOMNode(editor, editor);
-      const root = el.getRootNode();
-      if (!processing.value && IS_WEBKIT && root instanceof ShadowRoot) {
-        processing.value = true;
-        const active = getActiveElement();
-        if (active) {
-          document.execCommand("indent");
-        } else {
-          Transforms.deselect(editor);
-        }
-        return;
-      }
-      if ((IS_ANDROID || !DOMEditor.isComposing(editor)) && !state.isDraggingInternally) {
-        const root2 = DOMEditor.findDocumentOrShadowRoot(editor);
-        const { activeElement } = root2;
-        const el2 = DOMEditor.toDOMNode(editor, editor);
-        const domSelection = getSelection(root2);
-        if (activeElement === el2) {
-          state.latestElement = activeElement;
-          IS_FOCUSED.set(editor, true);
-        } else {
-          IS_FOCUSED.delete(editor);
-        }
-        if (!domSelection) {
-          return Transforms.deselect(editor);
-        }
-        const { anchorNode, focusNode } = domSelection;
-        const anchorNodeSelectable = DOMEditor.hasEditableTarget(editor, anchorNode) || DOMEditor.isTargetInsideNonReadonlyVoid(editor, anchorNode);
-        const focusNodeInEditor = DOMEditor.hasTarget(editor, focusNode);
-        if (anchorNodeSelectable && focusNodeInEditor) {
-          const range = DOMEditor.toSlateRange(editor, domSelection, {
-            exactMatch: false,
-            suppressThrow: true
-          });
-          if (range && !DOMEditor.isComposing(editor)) {
-            Transforms.select(editor, range);
-          }
-        }
-        if (readOnly && (!anchorNodeSelectable || !focusNodeInEditor)) {
-          Transforms.deselect(editor);
-        }
-      }
-    };
-    const editableRef = ref();
-    const androidManager = ref();
-    if (IS_ANDROID) {
-      androidManager.value = useAndroidManager(editableRef);
-    }
-    onMounted(() => {
-      let window2;
-      if (editableRef.value && (window2 = getDefaultView(editableRef.value))) {
-        EDITOR_TO_WINDOW.set(editor, window2);
-        EDITOR_TO_ELEMENT.set(editor, editableRef.value);
-        NODE_TO_ELEMENT.set(editor, editableRef.value);
-        ELEMENT_TO_NODE.set(editableRef.value, editor);
-      }
-    });
-    onUnmounted(() => {
-      EDITOR_TO_ELEMENT.delete(editor);
-      NODE_TO_ELEMENT.delete(editor);
-    });
-    const hasMarkPlaceholder = computed(() => {
-      if (editor.selection && Range.isCollapsed(editor.selection) && editor.marks) {
-        const anchor = editor.selection.anchor;
-        const leaf = Node.leaf(editor, anchor.path);
-        if (!Text.equals(leaf, editor.marks, { loose: true })) {
-          return true;
-        }
-      }
-      return false;
-    });
-    const setDomSelection = () => {
-      var _a;
-      const root = DOMEditor.findDocumentOrShadowRoot(editor);
-      const domSelection = getSelection(root);
-      if (!domSelection) {
-        return;
-      }
-      const hasDomSelection = domSelection.type !== "None";
-      if (!editor.selection && !hasDomSelection) {
-        return;
-      }
-      const focusNode = domSelection.focusNode;
-      let anchorNode;
-      if (IS_FIREFOX && domSelection.rangeCount > 1) {
-        const firstRange = domSelection.getRangeAt(0);
-        const lastRange = domSelection.getRangeAt(domSelection.rangeCount - 1);
-        if (firstRange.startContainer === focusNode) {
-          anchorNode = lastRange.endContainer;
-        } else {
-          anchorNode = firstRange.startContainer;
-        }
-      } else {
-        anchorNode = domSelection.anchorNode;
-      }
-      const editorElement = EDITOR_TO_ELEMENT.get(editor);
-      let hasDomSelectionInEditor = false;
-      if (editorElement.contains(anchorNode) && editorElement.contains(focusNode)) {
-        hasDomSelectionInEditor = true;
-      }
-      if (hasDomSelection && hasDomSelectionInEditor && editor.selection) {
-        const slateRange = DOMEditor.toSlateRange(editor, domSelection, {
-          exactMatch: true,
-          // domSelection is not necessarily a valid Slate range
-          // (e.g. when clicking on contenteditable:false element)
-          suppressThrow: true
-        });
-        if (slateRange && Range.equals(slateRange, editor.selection)) {
-          if (!hasMarkPlaceholder.value) {
-            return;
-          }
-          if ((_a = anchorNode == null ? void 0 : anchorNode.parentElement) == null ? void 0 : _a.hasAttribute(
-            "data-slate-mark-placeholder"
-          )) {
-            return;
-          }
-        }
-      }
-      if (editor.selection && !DOMEditor.hasRange(editor, editor.selection)) {
-        editor.selection = DOMEditor.toSlateRange(editor, domSelection, {
-          exactMatch: false,
-          suppressThrow: true
-        });
-        return;
-      }
-      let newDomRange = null;
-      try {
-        newDomRange = editor.selection && DOMEditor.toDOMRange(editor, editor.selection);
-      } catch (e2) {
-      }
-      if (newDomRange) {
-        if (DOMEditor.isComposing(editor) && !IS_ANDROID) {
-          domSelection.collapseToEnd();
-        } else if (Range.isBackward(editor.selection)) {
-          domSelection.setBaseAndExtent(
-            newDomRange.endContainer,
-            newDomRange.endOffset,
-            newDomRange.startContainer,
-            newDomRange.startOffset
-          );
-        } else {
-          domSelection.setBaseAndExtent(
-            newDomRange.startContainer,
-            newDomRange.startOffset,
-            newDomRange.endContainer,
-            newDomRange.endOffset
-          );
-        }
-        scrollSelectionIntoView(editor, newDomRange);
-      } else {
-        domSelection.removeAllRanges();
-      }
-      return newDomRange;
-    };
-    useChangeEffect(() => {
-      const root = DOMEditor.findDocumentOrShadowRoot(editor);
-      const domSelection = getSelection(root);
-      if (!domSelection || !DOMEditor.isFocused(editor)) {
-        return;
-      }
-      if (domSelection.rangeCount <= 1) {
-        setDomSelection();
-      }
-    });
-    const stoppedDragging = () => state.isDraggingInternally = false;
-    onMounted(() => {
-      const window2 = DOMEditor.getWindow(editor);
-      window2.document.addEventListener("selectionchange", onDOMSelectionChange);
-      window2.document.addEventListener("dragend", stoppedDragging);
-      window2.document.addEventListener("drop", stoppedDragging);
-    });
-    onUnmounted(() => {
-      const window2 = DOMEditor.getWindow(editor);
-      window2.document.removeEventListener(
-        "selectionchange",
-        onDOMSelectionChange
-      );
-      window2.document.removeEventListener("dragend", stoppedDragging);
-      window2.document.removeEventListener("drop", stoppedDragging);
-    });
-    const deferredOperations = ref([]);
-    const onBeforeinput = (event) => {
-      var _a, _b, _c, _d, _e;
-      const isInputEvent = event instanceof InputEvent;
-      if (!isInputEvent) {
-        return;
-      }
-      if (HAS_BEFORE_INPUT_SUPPORT) {
-        handleNativeHistoryEvents(editor, event);
-        const el = DOMEditor.toDOMNode(editor, editor);
-        const root = el.getRootNode();
-        if (processing.value && IS_WEBKIT && root instanceof ShadowRoot) {
-          const ranges = event.getTargetRanges();
-          const range = ranges[0];
-          const newRange = new window.Range();
-          let endContainer = range.endContainer;
-          let endOffset = range.endOffset;
-          if (endContainer.nodeType === 3 && endContainer.textContent === "" && endContainer.previousSibling) {
-            endContainer = endContainer.previousSibling;
-          }
-          while (endContainer instanceof HTMLElement && !endContainer.attributes.getNamedItem("data-slate-string") && endContainer.lastElementChild) {
-            endContainer = endContainer.lastElementChild;
-          }
-          if (endContainer instanceof HTMLElement && endContainer.attributes.getNamedItem("data-slate-string") && endContainer.lastChild) {
-            endContainer = endContainer.lastChild;
-          }
-          newRange.setStart(range.startContainer, range.startOffset);
-          newRange.setEnd(endContainer, endOffset);
-          const slateRange = DOMEditor.toSlateRange(editor, newRange, {
-            exactMatch: false,
-            suppressThrow: false
-          });
-          Transforms.select(editor, slateRange);
-          processing.value = false;
-          event.preventDefault();
-          event.stopImmediatePropagation();
-          return;
-        }
-        if (!readOnly && DOMEditor.hasEditableTarget(editor, event.target) && !isDOMEventHandled(event, attributes.onBeforeinput)) {
-          if (IS_ANDROID) {
-            return (_a = androidManager.value) == null ? void 0 : _a.handleDOMBeforeInput(event);
-          }
-          const { selection } = editor;
-          const { inputType } = event;
-          const data = event.dataTransfer || event.data || void 0;
-          const isCompositionChange = inputType === "insertCompositionText" || inputType === "deleteCompositionText";
-          if (isCompositionChange && DOMEditor.isComposing(editor)) {
-            return;
-          }
-          let native = false;
-          if (inputType === "insertText" && selection && Range.isCollapsed(selection) && // Only use native character insertion for single characters a-z or space for now.
-          // Long-press events (hold a + press 4 = ä) to choose a special character otherwise
-          // causes duplicate inserts.
-          event.data && event.data.length === 1 && /[a-z ]/i.test(event.data) && // Chrome has issues correctly editing the start of nodes: https://bugs.chromium.org/p/chromium/issues/detail?id=1249405
-          // When there is an inline element, e.g. a link, and you select
-          // right after it (the start of the next node).
-          selection.anchor.offset !== 0) {
-            native = true;
-            if (editor.marks) {
-              native = false;
-            }
-            const { anchor } = selection;
-            const [node, offset] = DOMEditor.toDOMPoint(editor, anchor);
-            const anchorNode = (_b = node.parentElement) == null ? void 0 : _b.closest("a");
-            const window2 = DOMEditor.getWindow(editor);
-            if (native && anchorNode && DOMEditor.hasDOMNode(editor, anchorNode)) {
-              const lastText = window2 == null ? void 0 : window2.document.createTreeWalker(anchorNode, NodeFilter.SHOW_TEXT).lastChild();
-              if (lastText === node && ((_c = lastText.textContent) == null ? void 0 : _c.length) === offset) {
-                native = false;
-              }
-            }
-            if (native && node.parentElement && ((_d = window2 == null ? void 0 : window2.getComputedStyle(node.parentElement)) == null ? void 0 : _d.whiteSpace) === "pre") {
-              const block = Editor.above(editor, {
-                at: anchor.path,
-                match: (n2) => Element.isElement(n2) && Editor.isBlock(editor, n2)
-              });
-              if (block && Node.string(block[0]).includes("	")) {
-                native = false;
-              }
-            }
-          }
-          if (!inputType.startsWith("delete") || inputType.startsWith("deleteBy")) {
-            const [targetRange] = event.getTargetRanges();
-            if (targetRange) {
-              const range = DOMEditor.toSlateRange(editor, targetRange, {
-                exactMatch: false,
-                suppressThrow: false
-              });
-              if (!selection || !Range.equals(selection, range)) {
-                native = false;
-                const selectionRef = !isCompositionChange && editor.selection && Editor.rangeRef(editor, editor.selection);
-                Transforms.select(editor, range);
-                if (selectionRef) {
-                  EDITOR_TO_USER_SELECTION.set(editor, selectionRef);
-                }
-              }
-            }
-          }
-          if (isCompositionChange) {
-            return;
-          }
-          if (!native) {
-            event.preventDefault();
-          }
-          if (selection && Range.isExpanded(selection) && inputType.startsWith("delete")) {
-            const direction2 = inputType.endsWith("Backward") ? "backward" : "forward";
-            Editor.deleteFragment(editor, { direction: direction2 });
-            return;
-          }
-          switch (inputType) {
-            case "deleteByComposition":
-            case "deleteByCut":
-            case "deleteByDrag": {
-              Editor.deleteFragment(editor);
-              break;
-            }
-            case "deleteContent":
-            case "deleteContentForward": {
-              Editor.deleteForward(editor);
-              break;
-            }
-            case "deleteContentBackward": {
-              Editor.deleteBackward(editor);
-              break;
-            }
-            case "deleteEntireSoftLine": {
-              Editor.deleteBackward(editor, { unit: "line" });
-              Editor.deleteForward(editor, { unit: "line" });
-              break;
-            }
-            case "deleteHardLineBackward": {
-              Editor.deleteBackward(editor, { unit: "block" });
-              break;
-            }
-            case "deleteSoftLineBackward": {
-              Editor.deleteBackward(editor, { unit: "line" });
-              break;
-            }
-            case "deleteHardLineForward": {
-              Editor.deleteForward(editor, { unit: "block" });
-              break;
-            }
-            case "deleteSoftLineForward": {
-              Editor.deleteForward(editor, { unit: "line" });
-              break;
-            }
-            case "deleteWordBackward": {
-              Editor.deleteBackward(editor, { unit: "word" });
-              break;
-            }
-            case "deleteWordForward": {
-              Editor.deleteForward(editor, { unit: "word" });
-              break;
-            }
-            case "insertLineBreak":
-              Editor.insertSoftBreak(editor);
-              break;
-            case "insertParagraph": {
-              Editor.insertBreak(editor);
-              break;
-            }
-            case "insertFromComposition":
-            case "insertFromDrop":
-            case "insertFromPaste":
-            case "insertFromYank":
-            case "insertReplacementText":
-            case "insertText": {
-              if (inputType === "insertFromComposition") {
-                if (DOMEditor.isComposing(editor)) {
-                  isComposing.value = false;
-                  IS_COMPOSING.set(editor, false);
-                }
-              }
-              if ((data == null ? void 0 : data.constructor.name) === "DataTransfer") {
-                DOMEditor.insertData(editor, data);
-              } else if (typeof data === "string") {
-                if (native) {
-                  deferredOperations.value.push(
-                    () => Editor.insertText(editor, data)
-                  );
-                } else {
-                  Editor.insertText(editor, data);
-                }
-              }
-              break;
-            }
-          }
-          const toRestore = (_e = EDITOR_TO_USER_SELECTION.get(editor)) == null ? void 0 : _e.unref();
-          EDITOR_TO_USER_SELECTION.delete(editor);
-          if (toRestore && (!editor.selection || !Range.equals(editor.selection, toRestore))) {
-            Transforms.select(editor, toRestore);
-          }
-        }
-      } else if (!readOnly && !isEventHandled(event, attributes.onBeforeinput) && DOMEditor.hasSelectableTarget(editor, event.target)) {
-        event.preventDefault();
-        if (!DOMEditor.isComposing(editor)) {
-          const text = event.data;
-          Editor.insertText(editor, text);
-        }
-      }
-    };
-    const onInput = (event) => {
-      if (IS_ANDROID || isEventHandled(event, attributes.onInput)) {
-        return;
-      }
-      for (const op of deferredOperations.value) {
-        op();
-      }
-      deferredOperations.value = [];
-      if (!DOMEditor.isFocused(editor)) {
-        handleNativeHistoryEvents(editor, event);
-      }
-    };
-    const onBlur = (event) => {
-      if (readOnly || !DOMEditor.hasSelectableTarget(editor, event.target) || isEventHandled(event, attributes.onBlur)) {
-        return;
-      }
-      const root = DOMEditor.findDocumentOrShadowRoot(editor);
-      if (state.latestElement === root.activeElement) {
-        return;
-      }
-      const { relatedTarget } = event;
-      const el = DOMEditor.toDOMNode(editor, editor);
-      if (relatedTarget === el) {
-        return;
-      }
-      if (isDOMElement(relatedTarget) && relatedTarget.hasAttribute("data-slate-spacer")) {
-        return;
-      }
-      if (relatedTarget != null && isDOMNode(relatedTarget) && DOMEditor.hasDOMNode(editor, relatedTarget)) {
-        const node = DOMEditor.toSlateNode(editor, relatedTarget);
-        if (Element.isElement(node) && !editor.isVoid(node)) {
-          return;
-        }
-      }
-      if (IS_WEBKIT) {
-        const domSelection = getSelection(root);
-        domSelection == null ? void 0 : domSelection.removeAllRanges();
-      }
-      IS_FOCUSED.delete(editor);
-    };
-    const onClick = (event) => {
-      if (DOMEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onClick) && isDOMNode(event.target)) {
-        const node = DOMEditor.toSlateNode(editor, event.target);
-        const path = DOMEditor.findPath(editor, node);
-        if (!Editor.hasPath(editor, path) || toRaw(Node.get(editor, path)) !== node) {
-          return;
-        }
-        if (event.detail === 3 && path.length >= 1) {
-          let blockPath = path;
-          if (!(Element.isElement(node) && Editor.isBlock(editor, node))) {
-            const block = Editor.above(editor, {
-              match: (n2) => Element.isElement(n2) && Editor.isBlock(editor, n2),
-              at: path
-            });
-            blockPath = (block == null ? void 0 : block[1]) ?? path.slice(0, 1);
-          }
-          const range = Editor.range(editor, blockPath);
-          Transforms.select(editor, range);
-          return;
-        }
-        if (readOnly) {
-          return;
-        }
-        const start = Editor.start(editor, path);
-        const end = Editor.end(editor, path);
-        const startVoid = Editor.void(editor, { at: start });
-        const endVoid = Editor.void(editor, { at: end });
-        if (startVoid && endVoid && Path.equals(startVoid[1], endVoid[1])) {
-          const range = Editor.range(editor, start);
-          Transforms.select(editor, range);
-        }
-      }
-    };
-    const onCompositionend = (event) => {
-      if (!DOMEditor.hasEditableTarget(editor, event.target) || DOMEditor.isTargetInsideNonReadonlyVoid(editor, event.target)) {
-        return;
-      }
-      if (DOMEditor.isComposing(editor)) {
-        isComposing.value = false;
-        IS_COMPOSING.set(editor, false);
-      }
-      if (IS_ANDROID || isEventHandled(event, attributes.onCompositionend)) {
-        return;
-      }
-      if (!IS_WEBKIT && !IS_FIREFOX_LEGACY && !IS_IOS && !IS_WECHATBROWSER && !IS_UC_MOBILE && event.data) {
-        Editor.insertText(editor, event.data);
-        const userMarks = EDITOR_TO_USER_MARKS.get(editor);
-        EDITOR_TO_USER_MARKS.delete(editor);
-        if (userMarks !== void 0) {
-          editor.marks = userMarks;
-        }
-      }
-    };
-    const onCompositionupdate = (event) => {
-      if (isEventHandled(event, attributes.onCompositionupdate)) {
-        return;
-      }
-      if (DOMEditor.hasSelectableTarget(editor, event.target)) {
-        if (!DOMEditor.isComposing(editor)) {
-          isComposing.value = true;
-          IS_COMPOSING.set(editor, true);
-        }
-      }
-    };
-    const onCompositionstart = (event) => {
-      if (DOMEditor.hasSelectableTarget(editor, event.target)) {
-        isComposing.value = true;
-        IS_COMPOSING.set(editor, true);
-        if (IS_ANDROID || isEventHandled(event, attributes.onCompositionstart)) {
-          return;
-        }
-        const { selection } = editor;
-        if (selection && Range.isExpanded(selection)) {
-          Editor.deleteFragment(editor);
-          return;
-        }
-      }
-    };
-    const onCopy = (event) => {
-      if (DOMEditor.hasSelectableTarget(editor, event.target) && !isEventHandled(event, attributes.onCopy) && !isDOMEventTargetInput(event)) {
-        event.preventDefault();
-        event.clipboardData && DOMEditor.setFragmentData(editor, event.clipboardData, "copy");
-      }
-    };
-    const onCut = (event) => {
-      if (!readOnly && DOMEditor.hasSelectableTarget(editor, event.target) && !isEventHandled(event, attributes.onCut) && !isDOMEventTargetInput(event)) {
-        event.preventDefault();
-        event.clipboardData && DOMEditor.setFragmentData(editor, event.clipboardData, "cut");
-        const selection = editor.selection;
-        if (selection) {
-          if (Range.isExpanded(selection)) {
-            Editor.deleteFragment(editor);
-          } else {
-            const node = Node.parent(editor, selection.anchor.path);
-            if (Editor.isVoid(editor, node)) {
-              Transforms.delete(editor);
-            }
-          }
-        }
-      }
-    };
-    const onDragover = (event) => {
-      if (DOMEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onDragover)) {
-        const node = DOMEditor.toSlateNode(editor, event.target);
-        if (Element.isElement(node) && Editor.isVoid(editor, node)) {
-          event.preventDefault();
-        }
-      }
-    };
-    const onDragstart = (event) => {
-      if (!readOnly && DOMEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onDragstart)) {
-        const node = DOMEditor.toSlateNode(editor, event.target);
-        const path = DOMEditor.findPath(editor, node);
-        const voidMatch = Element.isElement(node) && Editor.isVoid(editor, node) || Editor.void(editor, { at: path, voids: true });
-        if (voidMatch) {
-          const range = Editor.range(editor, path);
-          Transforms.select(editor, range);
-        }
-        state.isDraggingInternally = true;
-        event.dataTransfer && DOMEditor.setFragmentData(editor, event.dataTransfer, "drag");
-      }
-    };
-    const onDrop = (event) => {
-      if (!readOnly && DOMEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onDrop)) {
-        event.preventDefault();
-        const draggedRange = editor.selection;
-        const range = DOMEditor.findEventRange(editor, event);
-        const data = event.dataTransfer;
-        Transforms.select(editor, range);
-        if (state.isDraggingInternally) {
-          if (draggedRange && !Range.equals(draggedRange, range) && !Editor.void(editor, { at: range, voids: true })) {
-            Transforms.delete(editor, {
-              at: draggedRange
-            });
-          }
-        }
-        data && DOMEditor.insertData(editor, data);
-        if (!DOMEditor.isFocused(editor)) {
-          DOMEditor.focus(editor);
-        }
-      }
-    };
-    const onDragend = (event) => {
-      if (!readOnly && state.isDraggingInternally && attributes.onDragend && DOMEditor.hasTarget(editor, event.target)) {
-        attributes.onDragend(event);
-      }
-    };
-    const onFocus = (event) => {
-      if (!readOnly && DOMEditor.hasEditableTarget(editor, event.target) && !isEventHandled(event, attributes.onFocus)) {
-        const el = DOMEditor.toDOMNode(editor, editor);
-        const root = DOMEditor.findDocumentOrShadowRoot(editor);
-        state.latestElement = root.activeElement;
-        if (IS_FIREFOX && event.target !== el) {
-          el.focus();
-          return;
-        }
-        IS_FOCUSED.set(editor, true);
-      }
-    };
-    const onKeydown = (event) => {
-      if (!readOnly && DOMEditor.hasEditableTarget(editor, event.target)) {
-        if (DOMEditor.isComposing(editor) && event.isComposing === false) {
-          IS_COMPOSING.set(editor, false);
-          isComposing.value = false;
-        }
-        if (isEventHandled(event, attributes.onKeydown) || DOMEditor.isComposing(editor)) {
-          return;
-        }
-        const element = editor.children[editor.selection !== null ? editor.selection.focus.path[0] : 0];
-        const isRTL = direction(Node.string(element)) === "rtl";
-        if (Hotkeys.isRedo(event)) {
-          event.preventDefault();
-          const maybeHistoryEditor = editor;
-          if (typeof maybeHistoryEditor.redo === "function") {
-            maybeHistoryEditor.redo();
-          }
-          return;
-        }
-        if (Hotkeys.isUndo(event)) {
-          event.preventDefault();
-          const maybeHistoryEditor = editor;
-          if (typeof maybeHistoryEditor.undo === "function") {
-            maybeHistoryEditor.undo();
-          }
-          return;
-        }
-        if (Hotkeys.isMoveLineBackward(event)) {
-          event.preventDefault();
-          Transforms.move(editor, { unit: "line", reverse: true });
-          return;
-        }
-        if (Hotkeys.isMoveLineForward(event)) {
-          event.preventDefault();
-          Transforms.move(editor, { unit: "line" });
-          return;
-        }
-        if (Hotkeys.isExtendLineBackward(event)) {
-          event.preventDefault();
-          Transforms.move(editor, {
-            unit: "line",
-            edge: "focus",
-            reverse: true
-          });
-          return;
-        }
-        if (Hotkeys.isExtendLineForward(event)) {
-          event.preventDefault();
-          Transforms.move(editor, { unit: "line", edge: "focus" });
-          return;
-        }
-        if (Hotkeys.isMoveBackward(event)) {
-          event.preventDefault();
-          if (editor.selection && Range.isCollapsed(editor.selection)) {
-            Transforms.move(editor, { reverse: !isRTL });
-          } else {
-            Transforms.collapse(editor, {
-              edge: isRTL ? "end" : "start"
-            });
-          }
-          return;
-        }
-        if (Hotkeys.isMoveForward(event)) {
-          event.preventDefault();
-          if (editor.selection && Range.isCollapsed(editor.selection)) {
-            Transforms.move(editor, { reverse: isRTL });
-          } else {
-            Transforms.collapse(editor, {
-              edge: isRTL ? "start" : "end"
-            });
-          }
-          return;
-        }
-        if (Hotkeys.isMoveWordBackward(event)) {
-          event.preventDefault();
-          if (editor.selection && Range.isExpanded(editor.selection)) {
-            Transforms.collapse(editor, { edge: "focus" });
-          }
-          Transforms.move(editor, {
-            unit: "word",
-            reverse: !isRTL
-          });
-          return;
-        }
-        if (Hotkeys.isMoveWordForward(event)) {
-          event.preventDefault();
-          if (editor.selection && Range.isExpanded(editor.selection)) {
-            Transforms.collapse(editor, { edge: "focus" });
-          }
-          Transforms.move(editor, {
-            unit: "word",
-            reverse: isRTL
-          });
-          return;
-        }
-        if (!HAS_BEFORE_INPUT_SUPPORT) {
-          if (Hotkeys.isBold(event) || Hotkeys.isItalic(event) || Hotkeys.isTransposeCharacter(event)) {
-            event.preventDefault();
-            return;
-          }
-          if (Hotkeys.isSoftBreak(event)) {
-            event.preventDefault();
-            Editor.insertSoftBreak(editor);
-            return;
-          }
-          if (Hotkeys.isSplitBlock(event)) {
-            event.preventDefault();
-            Editor.insertBreak(editor);
-            return;
-          }
-          if (Hotkeys.isDeleteBackward(event)) {
-            event.preventDefault();
-            if (editor.selection && Range.isExpanded(editor.selection)) {
-              Editor.deleteFragment(editor, {
-                direction: "backward"
-              });
-            } else {
-              Editor.deleteBackward(editor);
-            }
-            return;
-          }
-          if (Hotkeys.isDeleteForward(event)) {
-            event.preventDefault();
-            if (editor.selection && Range.isExpanded(editor.selection)) {
-              Editor.deleteFragment(editor, {
-                direction: "forward"
-              });
-            } else {
-              Editor.deleteForward(editor);
-            }
-            return;
-          }
-          if (Hotkeys.isDeleteLineBackward(event)) {
-            event.preventDefault();
-            if (editor.selection && Range.isExpanded(editor.selection)) {
-              Editor.deleteFragment(editor, {
-                direction: "backward"
-              });
-            } else {
-              Editor.deleteBackward(editor, { unit: "line" });
-            }
-            return;
-          }
-          if (Hotkeys.isDeleteLineForward(event)) {
-            event.preventDefault();
-            if (editor.selection && Range.isExpanded(editor.selection)) {
-              Editor.deleteFragment(editor, {
-                direction: "forward"
-              });
-            } else {
-              Editor.deleteForward(editor, { unit: "line" });
-            }
-            return;
-          }
-          if (Hotkeys.isDeleteWordBackward(event)) {
-            event.preventDefault();
-            if (editor.selection && Range.isExpanded(editor.selection)) {
-              Editor.deleteFragment(editor, {
-                direction: "backward"
-              });
-            } else {
-              Editor.deleteBackward(editor, { unit: "word" });
-            }
-            return;
-          }
-          if (Hotkeys.isDeleteWordForward(event)) {
-            event.preventDefault();
-            if (editor.selection && Range.isExpanded(editor.selection)) {
-              Editor.deleteFragment(editor, {
-                direction: "forward"
-              });
-            } else {
-              Editor.deleteForward(editor, { unit: "word" });
-            }
-            return;
-          }
-        } else {
-          if (IS_CHROME || IS_WEBKIT) {
-            if (editor.selection && (Hotkeys.isDeleteBackward(event) || Hotkeys.isDeleteForward(event)) && Range.isCollapsed(editor.selection)) {
-              const currentNode = Node.parent(
-                editor,
-                editor.selection.anchor.path
-              );
-              if (Element.isElement(currentNode) && Editor.isVoid(editor, currentNode) && (Editor.isInline(editor, currentNode) || Editor.isBlock(editor, currentNode))) {
-                event.preventDefault();
-                Editor.deleteBackward(editor, { unit: "block" });
-                return;
-              }
-            }
-          }
-        }
-      }
-    };
-    const onPaste = (event) => {
-      if (!readOnly && DOMEditor.hasEditableTarget(editor, event.target) && !isEventHandled(event, attributes.onPaste)) {
-        if (!HAS_BEFORE_INPUT_SUPPORT || isPlainTextOnlyPaste(event) || IS_WEBKIT) {
-          event.preventDefault();
-          event.clipboardData && DOMEditor.insertData(editor, event.clipboardData);
-        }
-      }
-    };
-    const mergedEditableStyle = computed(() => ({
-      // Allow positioning relative to the editable element.
-      position: "relative",
-      // Preserve adjacent whitespace and new lines.
-      whiteSpace: "pre-wrap",
-      // Allow words to break if they are too long.
-      wordWrap: "break-word",
-      // Make the minimum height that of the placeholder.
-      minHeight: placeholderHeight.value ? placeholderHeight.value + "px" : void 0,
-      // Allow for passed-in styles to override anything.
-      ...props.style
-    }));
-    const spellcheck = computed(
-      () => HAS_BEFORE_INPUT_SUPPORT || !CAN_USE_DOM ? attributes.spellcheck : false
-    );
-    const autocorrect = computed(
-      () => HAS_BEFORE_INPUT_SUPPORT || !CAN_USE_DOM ? attributes.autocorrect : void 0
-    );
-    const autocapitalize = computed(
-      () => HAS_BEFORE_INPUT_SUPPORT || !CAN_USE_DOM ? attributes.autocapitalize : void 0
-    );
-    return () => h(
-      is,
-      {
-        role: readOnly ? void 0 : "textbox",
-        "aria-multiline": readOnly ? void 0 : true,
-        "data-slate-editor": true,
-        "data-slate-node": "value",
-        ...attributes,
-        zindex: -1,
-        spellcheck: spellcheck.value,
-        autocorrect: autocorrect.value,
-        autocapitalize: autocapitalize.value,
-        contenteditable: !readOnly,
-        ref: editableRef,
-        style: mergedEditableStyle.value,
-        onBeforeinput,
-        onInput,
-        onBlur,
-        onClick,
-        onCompositionend,
-        onCompositionupdate,
-        onCompositionstart,
-        onCopy,
-        onCut,
-        onDragover,
-        onDragstart,
-        onDrop,
-        onDragend,
-        onFocus,
-        onKeydown,
-        onPaste
-      },
-      [
-        ChildrenFC(editor, editor),
-        h(PlaceholderComp, {
-          placeholder,
-          onPlaceholderResize
-        })
-      ]
-    );
-  }
-});
-const useFocused = () => {
-  const isFocus = inject(SLATE_STATE_FOCUS);
-  if (isFocus === void 0) {
-    throw new Error(
-      `The \`useFocused\` hook must be used inside the <Slate> component's context.`
-    );
-  }
-  return isFocus;
-};
 const useSelected = () => {
   const selected = inject(SLATE_USE_SELECTED);
   if (selected === void 0) {
@@ -1795,16 +34,16 @@ const useInheritRef = (attribute) => {
   return attribute;
 };
 export {
-  Editable,
-  Slate,
-  defaultRenderLeaf,
-  defaultRenderPlaceHolder,
+  E as Editable,
+  b as Slate,
+  d as defaultRenderLeaf,
+  c as defaultRenderPlaceHolder,
   t as toRawWeakMap,
-  useComposing,
-  useEditor,
-  useFocused,
+  u as useComposing,
+  g as useEditor,
+  e as useFocused,
   useInheritRef,
-  useReadOnly,
+  f as useReadOnly,
   useSelected,
   useSelection
 };