slate-vue3 0.12.2 → 0.13.1

package/dist/core.js

@@ -1,5 +1,5 @@
-import { a6, a7, a8, d, e, f, a, h, aj, c, i, j, k, ap, ak, l, m, o, p, q, g, b, r, t, u, v, w, x, aq, y, a9, z, A, B, C, D, E, F, G, H, I, J, aa, K, ab, al, ac, L, M, N, O, n, P, S, Q, R, V, T, U, W, X, _, Y, Z, $, ad, am, ae, a0, an, ao, a5, s, af, a1, a2, a3, ag, ah, a4, ai } from "./create-editor-CKqY-8iC.js";
-import { E as E2, a as a10, L as L2, N as N2, O as O2, P as P2, b as b2, R as R2, c as c2, S as S2, T as T2, d as d2, i as i2, e as e2 } from "./index-BzxeM0Pe.js";
+import { P, a, R, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Q, S, T, U, V, W, X, Y, Z, _, $, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq } from "./create-editor-DUZVKniJ.js";
+import { E as E2, a as a10, L as L2, N as N2, O as O2, P as P2, b as b2, R as R2, S as S2, c as c2, T as T2, d as d2, i as i2, e as e2 } from "./index-C2VZD0rk.js";
 export {
   E2 as Editor,
   a10 as Element,
@@ -7,93 +7,93 @@ export {
   N2 as Node,
   O2 as Operation,
   P2 as Path,
-  a6 as PathRef,
+  P as PathRef,
   b2 as Point,
-  a7 as PointRef,
+  a as PointRef,
   R2 as Range,
-  a8 as RangeRef,
-  c2 as Scrubber,
-  S2 as Span,
+  R as RangeRef,
+  S2 as Scrubber,
+  c2 as Span,
   T2 as Text,
   d2 as Transforms,
-  d as above,
-  e as addMark,
-  f as after,
-  a as apply,
-  h as before,
-  aj as collapse,
-  c as createEditor,
+  b as above,
+  c as addMark,
+  d as after,
+  e as apply,
+  f as before,
+  g as collapse,
+  h as createEditor,
   i as deleteBackward,
   j as deleteForward,
   k as deleteFragment,
-  ap as deleteText,
-  ak as deselect,
-  l as edges,
-  m as elementReadOnly,
-  o as end,
-  p as first,
-  q as fragment,
-  g as getDirtyPaths,
-  b as getFragment,
-  r as getVoid,
-  t as hasBlocks,
-  u as hasInlines,
-  v as hasPath,
-  w as hasTexts,
-  x as insertBreak,
-  aq as insertFragment,
-  y as insertNode,
-  a9 as insertNodes,
-  z as insertSoftBreak,
-  A as insertText,
-  B as isBlock,
-  C as isEdge,
+  l as deleteText,
+  m as deselect,
+  n as edges,
+  o as elementReadOnly,
+  p as end,
+  q as first,
+  r as fragment,
+  s as getDirtyPaths,
+  t as getFragment,
+  u as getVoid,
+  v as hasBlocks,
+  w as hasInlines,
+  x as hasPath,
+  y as hasTexts,
+  z as insertBreak,
+  A as insertFragment,
+  B as insertNode,
+  C as insertNodes,
+  D as insertSoftBreak,
+  E as insertText,
+  F as isBlock,
+  G as isEdge,
   i2 as isEditor,
-  D as isEmpty,
-  E as isEnd,
-  F as isNormalizing,
+  H as isEmpty,
+  I as isEnd,
+  J as isNormalizing,
   e2 as isObject,
-  G as isStart,
-  H as last,
-  I as leaf,
-  J as levels,
-  aa as liftNodes,
-  K as marks,
-  ab as mergeNodes,
-  al as move,
-  ac as moveNodes,
-  L as next,
-  M as node,
-  N as nodes,
-  O as normalize,
-  n as normalizeNode,
-  P as parent,
-  S as path,
-  Q as pathRef,
-  R as pathRefs,
-  V as point,
-  T as pointRef,
-  U as pointRefs,
-  W as positions,
-  X as previous,
-  _ as range,
-  Y as rangeRef,
-  Z as rangeRefs,
-  $ as removeMark,
-  ad as removeNodes,
-  am as select,
-  ae as setNodes,
-  a0 as setNormalizing,
-  an as setPoint,
-  ao as setSelection,
-  a5 as shouldMergeNodesRemovePrevNode,
-  s as shouldNormalize,
-  af as splitNodes,
-  a1 as start,
-  a2 as string,
-  a3 as unhangRange,
-  ag as unsetNodes,
-  ah as unwrapNodes,
-  a4 as withoutNormalizing,
-  ai as wrapNodes
+  K as isStart,
+  L as last,
+  M as leaf,
+  N as levels,
+  O as liftNodes,
+  Q as marks,
+  S as mergeNodes,
+  T as move,
+  U as moveNodes,
+  V as next,
+  W as node,
+  X as nodes,
+  Y as normalize,
+  Z as normalizeNode,
+  _ as parent,
+  $ as path,
+  a0 as pathRef,
+  a1 as pathRefs,
+  a2 as point,
+  a3 as pointRef,
+  a4 as pointRefs,
+  a5 as positions,
+  a6 as previous,
+  a7 as range,
+  a8 as rangeRef,
+  a9 as rangeRefs,
+  aa as removeMark,
+  ab as removeNodes,
+  ac as select,
+  ad as setNodes,
+  ae as setNormalizing,
+  af as setPoint,
+  ag as setSelection,
+  ah as shouldMergeNodesRemovePrevNode,
+  ai as shouldNormalize,
+  aj as splitNodes,
+  ak as start,
+  al as string,
+  am as unhangRange,
+  an as unsetNodes,
+  ao as unwrapNodes,
+  ap as withoutNormalizing,
+  aq as wrapNodes
 };

package/dist/{create-editor-CKqY-8iC.js → create-editor-DUZVKniJ.js}

@@ -1,4 +1,4 @@
-import { P as Path, b as Point, R as Range, E as Editor, d as Transforms, N as Node, T as Text, L as Location, g as getDefaultInsertLocation, c as Scrubber } from "./index-BzxeM0Pe.js";
+import { P as Path, b as Point, R as Range, E as Editor, d as Transforms, N as Node, T as Text, L as Location, g as getDefaultInsertLocation, S as Scrubber } from "./index-C2VZD0rk.js";
 import { shallowReactive, ref } from "vue";
 const PathRef = {
   transform(ref2, op) {
@@ -364,7 +364,6 @@ const apply = (editor, op) => {
   if (op.type === "set_selection") {
     editor.marks = null;
   }
-  editor.onImmediateChange({ operation: op });
   Promise.resolve().then(() => {
     editor.onChange({ operation: op });
     editor.operations = [];
@@ -977,7 +976,7 @@ const normalize = (editor, options = {}) => {
         const entry = Editor.node(editor, dirtyPath);
         const [node2, _] = entry;
         if (Node.isElement(node2) && node2.children.length === 0) {
-          editor.normalizeNode(entry, { operation });
+          editor.normalizeNode(entry, { operation, force });
         }
       }
     }
@@ -996,7 +995,7 @@ const normalize = (editor, options = {}) => {
       const dirtyPath = popDirtyPath(editor);
       if (Node.has(editor, dirtyPath)) {
         const entry = Editor.node(editor, dirtyPath);
-        editor.normalizeNode(entry, { operation });
+        editor.normalizeNode(entry, { operation, force });
       }
       iteration++;
       dirtyPaths = getDirtyPaths2(editor);
@@ -3148,8 +3147,6 @@ const createEditor = () => {
     markableVoid: () => false,
     onChange: () => {
     },
-    onImmediateChange: () => {
-    },
     // Core
     apply: (...args) => apply(editor, ...args),
     // Editor
@@ -3243,85 +3240,85 @@ const createEditor = () => {
   return editor;
 };
 export {
-  removeMark as $,
-  insertText as A,
-  isBlock as B,
-  isEdge as C,
-  isEmpty as D,
-  isEnd as E,
-  isNormalizing as F,
-  isStart as G,
-  last as H,
-  leaf as I,
-  levels as J,
-  marks as K,
-  next as L,
-  node as M,
-  nodes as N,
-  normalize as O,
-  parent as P,
-  pathRef as Q,
-  pathRefs as R,
-  path as S,
-  pointRef as T,
-  pointRefs as U,
-  point as V,
-  positions as W,
-  previous as X,
-  rangeRef as Y,
-  rangeRefs as Z,
-  range as _,
-  apply as a,
-  setNormalizing as a0,
-  start as a1,
-  string as a2,
-  unhangRange as a3,
-  withoutNormalizing as a4,
-  shouldMergeNodesRemovePrevNode as a5,
-  PathRef as a6,
-  PointRef as a7,
-  RangeRef as a8,
-  insertNodes as a9,
-  liftNodes as aa,
-  mergeNodes as ab,
-  moveNodes as ac,
-  removeNodes as ad,
-  setNodes as ae,
-  splitNodes as af,
-  unsetNodes as ag,
-  unwrapNodes as ah,
-  wrapNodes as ai,
-  collapse as aj,
-  deselect as ak,
-  move as al,
-  select as am,
-  setPoint as an,
-  setSelection as ao,
-  deleteText as ap,
-  insertFragment as aq,
-  getFragment as b,
-  createEditor as c,
-  above as d,
-  addMark as e,
-  after as f,
-  getDirtyPaths as g,
-  before as h,
+  path as $,
+  insertFragment as A,
+  insertNode as B,
+  insertNodes as C,
+  insertSoftBreak as D,
+  insertText as E,
+  isBlock as F,
+  isEdge as G,
+  isEmpty as H,
+  isEnd as I,
+  isNormalizing as J,
+  isStart as K,
+  last as L,
+  leaf as M,
+  levels as N,
+  liftNodes as O,
+  PathRef as P,
+  marks as Q,
+  RangeRef as R,
+  mergeNodes as S,
+  move as T,
+  moveNodes as U,
+  next as V,
+  node as W,
+  nodes as X,
+  normalize as Y,
+  normalizeNode as Z,
+  parent as _,
+  PointRef as a,
+  pathRef as a0,
+  pathRefs as a1,
+  point as a2,
+  pointRef as a3,
+  pointRefs as a4,
+  positions as a5,
+  previous as a6,
+  range as a7,
+  rangeRef as a8,
+  rangeRefs as a9,
+  removeMark as aa,
+  removeNodes as ab,
+  select as ac,
+  setNodes as ad,
+  setNormalizing as ae,
+  setPoint as af,
+  setSelection as ag,
+  shouldMergeNodesRemovePrevNode as ah,
+  shouldNormalize as ai,
+  splitNodes as aj,
+  start as ak,
+  string as al,
+  unhangRange as am,
+  unsetNodes as an,
+  unwrapNodes as ao,
+  withoutNormalizing as ap,
+  wrapNodes as aq,
+  above as b,
+  addMark as c,
+  after as d,
+  apply as e,
+  before as f,
+  collapse as g,
+  createEditor as h,
   deleteBackward as i,
   deleteForward as j,
   deleteFragment as k,
-  edges as l,
-  elementReadOnly as m,
-  normalizeNode as n,
-  end as o,
-  first as p,
-  fragment as q,
-  getVoid as r,
-  shouldNormalize as s,
-  hasBlocks as t,
-  hasInlines as u,
-  hasPath as v,
-  hasTexts as w,
-  insertBreak as x,
-  insertNode as y,
-  insertSoftBreak as z
+  deleteText as l,
+  deselect as m,
+  edges as n,
+  elementReadOnly as o,
+  end as p,
+  first as q,
+  fragment as r,
+  getDirtyPaths as s,
+  getFragment as t,
+  getVoid as u,
+  hasBlocks as v,
+  hasInlines as w,
+  hasPath as x,
+  hasTexts as y,
+  insertBreak as z
 };

package/dist/dom.js

@@ -1,6 +1,6 @@
-import { D as DOMEditor, E as EDITOR_TO_KEY_TO_ELEMENT, a as EDITOR_TO_USER_MARKS, g as getChunkTreeForNode, b as EDITOR_TO_USER_SELECTION, N as NODE_TO_KEY, i as isDOMText, c as getPlainText, d as getSlateFragmentAttribute, e as EDITOR_TO_ON_CHANGE, f as EDITOR_TO_ON_IMMEDIATE_CHANGE } from "./hotkeys-D6R9vfnD.js";
-import { R, $, _, a0, T, U, F, M, C, K, L, a4, J, G, O, a3, I, a2, S, P, H, Q, W, V, a5, a1, Y, Z, h, A, B, x, u, j, t, s, v, r, z, y, k, l, m, o, p, w, q, n, X } from "./hotkeys-D6R9vfnD.js";
-import { E as Editor, R as Range, N as Node, d as Transforms, P as Path } from "./index-BzxeM0Pe.js";
+import { D as DOMEditor, E as EDITOR_TO_KEY_TO_ELEMENT, a as EDITOR_TO_USER_MARKS, g as getChunkTreeForNode, b as EDITOR_TO_USER_SELECTION, N as NODE_TO_KEY, i as isDOMText, c as getPlainText, d as getSlateFragmentAttribute, e as EDITOR_TO_ON_CHANGE } from "./hotkeys-D-Urs0nl.js";
+import { C, f, h, j, H, k, I, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, K, A, M, B, F, G, J, L, O, P, Q, R, S, T, U, V, W, X, Y, Z, _, $, a0, a1, a2, a3, a4 } from "./hotkeys-D-Urs0nl.js";
+import { E as Editor, R as Range, N as Node, d as Transforms, P as Path } from "./index-C2VZD0rk.js";
 import "vue";
 const doRectsIntersect = (rect, compareRect) => {
   const middle = (compareRect.top + compareRect.bottom) / 2;
@@ -47,14 +47,7 @@ const findCurrentLineRange = (editor, parentRange) => {
 };
 const withDOM = (editor, clipboardFormatKey = "x-slate-fragment") => {
   const e = editor;
-  const {
-    apply,
-    onChange,
-    onImmediateChange,
-    deleteBackward,
-    addMark,
-    removeMark
-  } = e;
+  const { apply, onChange, deleteBackward, addMark, removeMark } = e;
   EDITOR_TO_KEY_TO_ELEMENT.set(e, /* @__PURE__ */ new WeakMap());
   e.addMark = (key, value) => {
     EDITOR_TO_USER_MARKS.delete(e);
@@ -252,13 +245,6 @@ const withDOM = (editor, clipboardFormatKey = "x-slate-fragment") => {
     }
     onChange(options);
   };
-  e.onImmediateChange = (options) => {
-    const onContextImmediateChange = EDITOR_TO_ON_IMMEDIATE_CHANGE.get(e);
-    if (onContextImmediateChange) {
-      onContextImmediateChange(options);
-    }
-    onImmediateChange(options);
-  };
   return e;
 };
 const getMatches = (e, path) => {
@@ -352,68 +338,67 @@ const splitDecorationsByChild = (editor, node, decorations) => {
   return decorationsByChild;
 };
 export {
-  R as CAN_USE_DOM,
+  C as CAN_USE_DOM,
   DOMEditor,
-  $ as EDITOR_TO_ELEMENT,
+  f as EDITOR_TO_ELEMENT,
   EDITOR_TO_KEY_TO_ELEMENT,
   EDITOR_TO_ON_CHANGE,
-  EDITOR_TO_ON_IMMEDIATE_CHANGE,
   EDITOR_TO_USER_MARKS,
   EDITOR_TO_USER_SELECTION,
-  _ as EDITOR_TO_WINDOW,
-  a0 as ELEMENT_TO_NODE,
-  T as HAS_BEFORE_INPUT_SUPPORT,
-  U as Hotkeys,
-  F as IS_ANDROID,
-  M as IS_ANDROID_CHROME_LEGACY,
-  C as IS_APPLE,
-  K as IS_CHROME,
-  L as IS_CHROME_LEGACY,
-  a4 as IS_COMPOSING,
-  J as IS_EDGE_LEGACY,
-  G as IS_FIREFOX,
-  O as IS_FIREFOX_LEGACY,
-  a3 as IS_FOCUSED,
-  I as IS_IOS,
-  a2 as IS_READ_ONLY,
-  S as IS_SAFARI_LEGACY,
-  P as IS_UC_MOBILE,
-  H as IS_WEBKIT,
-  Q as IS_WECHATBROWSER,
-  W as KEY_TO_CHUNK_TREE,
-  V as Key,
-  a5 as MARK_PLACEHOLDER_SYMBOL,
-  a1 as NODE_TO_ELEMENT,
-  Y as NODE_TO_INDEX,
+  h as EDITOR_TO_WINDOW,
+  j as ELEMENT_TO_NODE,
+  H as HAS_BEFORE_INPUT_SUPPORT,
+  k as Hotkeys,
+  I as IS_ANDROID,
+  l as IS_ANDROID_CHROME_LEGACY,
+  m as IS_APPLE,
+  n as IS_CHROME,
+  o as IS_CHROME_LEGACY,
+  p as IS_COMPOSING,
+  q as IS_EDGE_LEGACY,
+  r as IS_FIREFOX,
+  s as IS_FIREFOX_LEGACY,
+  t as IS_FOCUSED,
+  u as IS_IOS,
+  v as IS_READ_ONLY,
+  w as IS_SAFARI_LEGACY,
+  x as IS_UC_MOBILE,
+  y as IS_WEBKIT,
+  z as IS_WECHATBROWSER,
+  K as KEY_TO_CHUNK_TREE,
+  A as Key,
+  M as MARK_PLACEHOLDER_SYMBOL,
+  B as NODE_TO_ELEMENT,
+  F as NODE_TO_INDEX,
   NODE_TO_KEY,
-  Z as NODE_TO_PARENT,
-  h as applyStringDiff,
-  A as closestShadowAware,
-  B as containsShadowAware,
-  x as getActiveElement,
+  G as NODE_TO_PARENT,
+  J as applyStringDiff,
+  L as closestShadowAware,
+  O as containsShadowAware,
+  P as getActiveElement,
   getChunkTreeForNode,
-  u as getClipboardData,
-  j as getDefaultView,
-  t as getEditableChild,
-  s as getEditableChildAndIndex,
+  Q as getClipboardData,
+  R as getDefaultView,
+  S as getEditableChild,
+  T as getEditableChildAndIndex,
   getPlainText,
-  v as getSelection,
+  U as getSelection,
   getSlateFragmentAttribute,
-  r as hasShadowRoot,
-  z as isAfter,
-  y as isBefore,
-  k as isDOMComment,
-  l as isDOMElement,
-  m as isDOMNode,
-  o as isDOMSelection,
+  V as hasShadowRoot,
+  W as isAfter,
+  X as isBefore,
+  Y as isDOMComment,
+  Z as isDOMElement,
+  _ as isDOMNode,
+  $ as isDOMSelection,
   isDOMText,
   isElementDecorationsEqual,
-  p as isPlainTextOnlyPaste,
+  a0 as isPlainTextOnlyPaste,
   isTextDecorationsEqual,
-  w as isTrackedMutation,
-  q as normalizeDOMPoint,
-  n as normalizeStringDiff,
-  X as reconcileChildren,
+  a1 as isTrackedMutation,
+  a2 as normalizeDOMPoint,
+  a3 as normalizeStringDiff,
+  a4 as reconcileChildren,
   shallowCompare,
   splitDecorationsByChild,
   withDOM

package/dist/history.js

@@ -1,4 +1,4 @@
-import { e as isObject, O as Operation, E as Editor, d as Transforms, P as Path } from "./index-BzxeM0Pe.js";
+import { e as isObject, O as Operation, E as Editor, d as Transforms, P as Path } from "./index-C2VZD0rk.js";
 import { shallowReactive } from "vue";
 const History = {
   /**

package/dist/{hotkeys-D6R9vfnD.js → hotkeys-D-Urs0nl.js}

@@ -1,5 +1,5 @@
-import { shallowReactive } from "vue";
-import { c as Scrubber, R as Range, E as Editor, N as Node, d as Transforms, P as Path } from "./index-BzxeM0Pe.js";
+import { toRaw } from "vue";
+import { S as Scrubber, R as Range, E as Editor, N as Node, d as Transforms, P as Path } from "./index-C2VZD0rk.js";
 import { t as toRawWeakMap } from "./index-Ban80MbP.js";
 const getDefaultView = (value) => {
   return value && value.ownerDocument && value.ownerDocument.defaultView || null;
@@ -262,7 +262,6 @@ const IS_FOCUSED = /* @__PURE__ */ new WeakMap();
 const IS_COMPOSING = /* @__PURE__ */ new WeakMap();
 const EDITOR_TO_USER_SELECTION = /* @__PURE__ */ new WeakMap();
 const EDITOR_TO_ON_CHANGE = /* @__PURE__ */ new WeakMap();
-const EDITOR_TO_ON_IMMEDIATE_CHANGE = /* @__PURE__ */ new WeakMap();
 const EDITOR_TO_USER_MARKS = /* @__PURE__ */ new WeakMap();
 const MARK_PLACEHOLDER_SYMBOL = /* @__PURE__ */ Symbol(
   "mark-placeholder"
@@ -671,10 +670,16 @@ const DOMEditor = {
       const node = parentNode.hasAttribute("data-slate-node") ? parentNode : parentNode.closest("[data-slate-node]");
       if (node && DOMEditor.hasDOMNode(editor, node, { editable: true })) {
         const slateNode2 = DOMEditor.toSlateNode(editor, node);
-        const start = Editor.start(
-          editor,
-          DOMEditor.findPath(editor, slateNode2)
-        );
+        let nodePath;
+        try {
+          nodePath = DOMEditor.findPath(editor, slateNode2);
+        } catch (e) {
+          if (suppressThrow) {
+            return null;
+          }
+          throw e;
+        }
+        const start = Editor.start(editor, nodePath);
         const { path: path2 } = start;
         let { offset: offset2 } = start;
         if (!node.querySelector("[data-slate-leaf]")) {
@@ -692,7 +697,15 @@ const DOMEditor = {
       );
     }
     const slateNode = DOMEditor.toSlateNode(editor, textNode);
-    const path = DOMEditor.findPath(editor, slateNode);
+    let path;
+    try {
+      path = DOMEditor.findPath(editor, slateNode);
+    } catch (e) {
+      if (suppressThrow) {
+        return null;
+      }
+      throw e;
+    }
     return { path, offset };
   },
   toSlateRange: (editor, domRange, options) => {
@@ -802,7 +815,7 @@ const getChunkTreeForNode = (editor, node) => {
     chunkTree = {
       type: "root",
       movedNodeKeys: /* @__PURE__ */ new Set(),
-      children: shallowReactive([])
+      children: []
     };
     KEY_TO_CHUNK_TREE.set(key, chunkTree);
   }
@@ -1147,8 +1160,10 @@ class ChunkTreeHelper {
           parent,
           children: []
         };
-        chunk.children = shallowReactive(
-          groupIntoChunks(chunkNodes, chunk, perChunk / this.chunkSize)
+        chunk.children = groupIntoChunks(
+          chunkNodes,
+          chunk,
+          perChunk / this.chunkSize
         );
         chunks2.push(chunk);
       }
@@ -1208,6 +1223,7 @@ class ChunkTreeHelper {
 class ChildrenHelper {
   editor;
   children;
+  rawChildren;
   /**
    * Sparse array of Slate node keys, each index corresponding to an index in
    * the children array
@@ -1221,7 +1237,8 @@ class ChildrenHelper {
   pointerIndex;
   constructor(editor, children) {
     this.editor = editor;
-    this.children = children;
+    this.children = [...children];
+    this.rawChildren = toRaw(children);
     this.cachedKeys = new Array(children.length);
     this.pointerIndex = 0;
   }
@@ -1254,7 +1271,7 @@ class ChildrenHelper {
    * Whether all children have been read
    */
   get reachedEnd() {
-    return this.pointerIndex >= this.children.length;
+    return this.pointerIndex >= this.rawChildren.length;
   }
   /**
    * Determine whether a node with a given key appears in the unread part of the
@@ -1270,10 +1287,13 @@ class ChildrenHelper {
    * by one and compare it to the known key.
    */
   lookAhead(node, key) {
-    const elementResult = this.children.indexOf(node, this.pointerIndex);
+    const elementResult = this.rawChildren.indexOf(
+      toRaw(node),
+      this.pointerIndex
+    );
     if (elementResult > -1) return elementResult - this.pointerIndex;
-    for (let i = this.pointerIndex; i < this.children.length; i++) {
-      const candidateNode = this.children[i];
+    for (let i = this.pointerIndex; i < this.rawChildren.length; i++) {
+      const candidateNode = this.rawChildren[i];
       const candidateKey = this.findKey(candidateNode, i);
       if (candidateKey === key) return i - this.pointerIndex;
     }
@@ -1297,7 +1317,7 @@ class ChildrenHelper {
   findKey(node, index) {
     const cachedKey = this.cachedKeys[index];
     if (cachedKey) return cachedKey;
-    const key = DOMEditor.findKey(this.editor, node);
+    const key = DOMEditor.findKey(this.editor, toRaw(node));
     this.cachedKeys[index] = key;
     return key;
   }
@@ -1681,64 +1701,63 @@ const Hotkeys = {
   isUndo: create("undo")
 };
 export {
-  EDITOR_TO_ELEMENT as $,
-  closestShadowAware as A,
-  containsShadowAware as B,
-  IS_APPLE as C,
+  isDOMSelection as $,
+  Key as A,
+  NODE_TO_ELEMENT as B,
+  CAN_USE_DOM as C,
   DOMEditor as D,
   EDITOR_TO_KEY_TO_ELEMENT as E,
-  IS_ANDROID as F,
-  IS_FIREFOX as G,
-  IS_WEBKIT as H,
-  IS_IOS as I,
-  IS_EDGE_LEGACY as J,
-  IS_CHROME as K,
-  IS_CHROME_LEGACY as L,
-  IS_ANDROID_CHROME_LEGACY as M,
+  NODE_TO_INDEX as F,
+  NODE_TO_PARENT as G,
+  HAS_BEFORE_INPUT_SUPPORT as H,
+  IS_ANDROID as I,
+  applyStringDiff as J,
+  KEY_TO_CHUNK_TREE as K,
+  closestShadowAware as L,
+  MARK_PLACEHOLDER_SYMBOL as M,
   NODE_TO_KEY as N,
-  IS_FIREFOX_LEGACY as O,
-  IS_UC_MOBILE as P,
-  IS_WECHATBROWSER as Q,
-  CAN_USE_DOM as R,
-  IS_SAFARI_LEGACY as S,
-  HAS_BEFORE_INPUT_SUPPORT as T,
-  Hotkeys as U,
-  Key as V,
-  KEY_TO_CHUNK_TREE as W,
-  reconcileChildren as X,
-  NODE_TO_INDEX as Y,
-  NODE_TO_PARENT as Z,
-  EDITOR_TO_WINDOW as _,
+  containsShadowAware as O,
+  getActiveElement as P,
+  getClipboardData as Q,
+  getDefaultView as R,
+  getEditableChild as S,
+  getEditableChildAndIndex as T,
+  getSelection as U,
+  hasShadowRoot as V,
+  isAfter as W,
+  isBefore as X,
+  isDOMComment as Y,
+  isDOMElement as Z,
+  isDOMNode as _,
   EDITOR_TO_USER_MARKS as a,
-  ELEMENT_TO_NODE as a0,
-  NODE_TO_ELEMENT as a1,
-  IS_READ_ONLY as a2,
-  IS_FOCUSED as a3,
-  IS_COMPOSING as a4,
-  MARK_PLACEHOLDER_SYMBOL as a5,
+  isPlainTextOnlyPaste as a0,
+  isTrackedMutation as a1,
+  normalizeDOMPoint as a2,
+  normalizeStringDiff as a3,
+  reconcileChildren as a4,
   EDITOR_TO_USER_SELECTION as b,
   getPlainText as c,
   getSlateFragmentAttribute as d,
   EDITOR_TO_ON_CHANGE as e,
-  EDITOR_TO_ON_IMMEDIATE_CHANGE as f,
+  EDITOR_TO_ELEMENT as f,
   getChunkTreeForNode as g,
-  applyStringDiff as h,
+  EDITOR_TO_WINDOW as h,
   isDOMText as i,
-  getDefaultView as j,
-  isDOMComment as k,
-  isDOMElement as l,
-  isDOMNode as m,
-  normalizeStringDiff as n,
-  isDOMSelection as o,
-  isPlainTextOnlyPaste as p,
-  normalizeDOMPoint as q,
-  hasShadowRoot as r,
-  getEditableChildAndIndex as s,
-  getEditableChild as t,
-  getClipboardData as u,
-  getSelection as v,
-  isTrackedMutation as w,
-  getActiveElement as x,
-  isBefore as y,
-  isAfter as z
+  ELEMENT_TO_NODE as j,
+  Hotkeys as k,
+  IS_ANDROID_CHROME_LEGACY as l,
+  IS_APPLE as m,
+  IS_CHROME as n,
+  IS_CHROME_LEGACY as o,
+  IS_COMPOSING as p,
+  IS_EDGE_LEGACY as q,
+  IS_FIREFOX as r,
+  IS_FIREFOX_LEGACY as s,
+  IS_FOCUSED as t,
+  IS_IOS as u,
+  IS_READ_ONLY as v,
+  IS_SAFARI_LEGACY as w,
+  IS_UC_MOBILE as x,
+  IS_WEBKIT as y,
+  IS_WECHATBROWSER as z
 };

package/dist/hyperscript.js

@@ -1,5 +1,5 @@
-import { R as Range, N as Node, T as Text, a as Element, e as isObject } from "./index-BzxeM0Pe.js";
-import { c as createEditor$1 } from "./create-editor-CKqY-8iC.js";
+import { R as Range, N as Node, T as Text, a as Element, e as isObject } from "./index-C2VZD0rk.js";
+import { h as createEditor$1 } from "./create-editor-DUZVKniJ.js";
 import "vue";
 import { t as toRawWeakMap } from "./index-Ban80MbP.js";
 const ANCHOR = new toRawWeakMap();

package/dist/{index-BzxeM0Pe.js → index-C2VZD0rk.js}

@@ -1550,11 +1550,11 @@ export {
   Operation as O,
   Path as P,
   Range as R,
-  Span as S,
+  Scrubber as S,
   Text as T,
   Element as a,
   Point as b,
-  Scrubber as c,
+  Span as c,
   Transforms as d,
   isObject as e,
   getDefaultInsertLocation as g,

package/dist/index.js

@@ -1,8 +1,8 @@
-import { u as useElementIf, a as useEditor, S as SLATE_USE_SELECTION } from "./use-focused-rvrvwwCw.js";
-import { n, p, k, l, o, D, m, E, b, j, h, g, i, c, f, d, e } from "./use-focused-rvrvwwCw.js";
-import { E as Editor, R as Range } from "./index-BzxeM0Pe.js";
+import { u as useElementIf, a as useEditor, S as SLATE_USE_SELECTION } from "./use-focused-DBkYw-GW.js";
+import { D, b, c, d, e, f, g, E, h, i, j, k, l, m, n, o, p } from "./use-focused-DBkYw-GW.js";
+import { E as Editor, R as Range } from "./index-C2VZD0rk.js";
 import { computed, inject } from "vue";
-import { D as DOMEditor } from "./hotkeys-D6R9vfnD.js";
+import { D as DOMEditor } from "./hotkeys-D-Urs0nl.js";
 import { t } from "./index-Ban80MbP.js";
 const useSelected = () => {
   const element = useElementIf();
@@ -37,27 +37,27 @@ const useInheritRef = (attribute) => {
   return attribute;
 };
 export {
-  n as DEFAULT_CHUNK_RENDER,
-  p as DEFAULT_DECORATE_FN,
-  k as DEFAULT_ELEMENT_RENDER,
-  l as DEFAULT_LEAF_RENDER,
-  o as DEFAULT_PLACEHOLDER_RENDER,
-  D as DEFAULT_SCROLL_INTO_VIEW,
-  m as DEFAULT_TEXT_RENDER,
+  D as DEFAULT_CHUNK_RENDER,
+  b as DEFAULT_DECORATE_FN,
+  c as DEFAULT_ELEMENT_RENDER,
+  d as DEFAULT_LEAF_RENDER,
+  e as DEFAULT_PLACEHOLDER_RENDER,
+  f as DEFAULT_SCROLL_INTO_VIEW,
+  g as DEFAULT_TEXT_RENDER,
   E as Editable,
-  b as Slate,
-  j as handleNativeHistoryEvents,
-  h as isDOMEventHandled,
-  g as isDOMEventTargetInput,
-  i as isEventHandled,
+  h as Slate,
+  i as handleNativeHistoryEvents,
+  j as isDOMEventHandled,
+  k as isDOMEventTargetInput,
+  l as isEventHandled,
   t as toRawWeakMap,
-  c as useComposing,
+  m as useComposing,
   useEditor,
-  f as useElement,
+  n as useElement,
   useElementIf,
-  d as useFocused,
+  o as useFocused,
   useInheritRef,
-  e as useReadOnly,
+  p as useReadOnly,
   useSelected,
   useSelection
 };

package/dist/slate/interfaces/editor.d.ts

@@ -21,9 +21,7 @@ export interface BaseEditor {
     normalizeNode: (entry: NodeEntry, options?: {
         operation?: Operation;
         fallbackElement?: () => Element;
-    }) => void;
-    onImmediateChange: (options?: {
-        operation?: Operation;
+        force?: boolean;
     }) => void;
     onChange: (options?: {
         operation?: Operation;

package/dist/slate-dom/chunking/children-helper.d.ts

@@ -6,8 +6,9 @@ import { ChunkLeaf } from './types';
  * children array with a chunk tree
  */
 export declare class ChildrenHelper {
-    private editor;
-    private children;
+    private readonly editor;
+    private readonly children;
+    private readonly rawChildren;
     /**
      * Sparse array of Slate node keys, each index corresponding to an index in
      * the children array

package/dist/slate-dom/utils/weak-maps.d.ts

@@ -33,11 +33,5 @@ export declare const EDITOR_TO_USER_SELECTION: WeakMap<Editor, RangeRef | null>;
 export declare const EDITOR_TO_ON_CHANGE: WeakMap<import('../../slate/index.ts').BaseEditor, (options?: {
     operation?: Operation;
 }) => void>;
-/**
- * Weak map for trigger chunk tree reconciliation on immediate changes.
- */
-export declare const EDITOR_TO_ON_IMMEDIATE_CHANGE: WeakMap<import('../../slate/index.ts').BaseEditor, (options?: {
-    operation?: Operation;
-}) => void>;
 export declare const EDITOR_TO_USER_MARKS: WeakMap<Editor, Partial<Text> | null>;
 export declare const MARK_PLACEHOLDER_SYMBOL: string;

package/dist/slate-vue/components/children.d.ts

@@ -1,12 +1,9 @@
 import { Ancestor } from '../../slate/index.ts';
-import { VNode } from 'vue';
 /**
  * Children.
  */
 export declare const ChildrenComp: import('vue').DefineComponent<{
     element: Ancestor;
-}, (() => import('vue').VNodeChild[]) | (() => VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}>), {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+}, () => import('vue').VNodeChild[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     element: Ancestor;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/slate-vue/components/chunk.d.ts

@@ -1,6 +1,4 @@
 import { ChunkAncestor } from '../../slate-dom/index.ts';
-export declare const ChunkComp: import('vue').DefineComponent<{
-    ancestor: ChunkAncestor;
-}, () => import('vue').VNodeChild[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
-    ancestor: ChunkAncestor;
-}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+import { VNode } from 'vue';
+import { RenderChunkProps } from '../utils/interface';
+export declare const ChunkCompFc: (ancestor: ChunkAncestor, renderChunk: (props: RenderChunkProps) => VNode, highest?: boolean) => import('vue').VNodeChild[];

package/dist/slate-vue/render/version.d.ts

@@ -2,6 +2,3 @@ import { Ref } from 'vue';
 export declare const SLATE_INNER_EDITOR_VERSION: unique symbol;
 export declare const provideEditorVersion: (version: Ref<number>) => void;
 export declare const useEditorVersion: () => Ref<number, number>;
-export declare const SLATE_INNER_EDITOR_NODE_VERSION: unique symbol;
-export declare const provideEditorNodeVersion: (version: Ref<number>) => void;
-export declare const useEditorNodeVersion: () => Ref<number, number>;

package/dist/slate-vue/utils/interface.d.ts

@@ -9,6 +9,7 @@ export interface RenderChunkProps {
     children: any;
     attributes: {
         "data-slate-chunk": true;
+        key: string;
     };
 }
 /**

package/dist/{use-focused-rvrvwwCw.js → use-focused-DBkYw-GW.js}

@@ -1,6 +1,6 @@
 import { h, inject, provide, computed, defineComponent, ref, onMounted, onUnmounted, renderSlot, renderList, watch, onUpdated, useAttrs, reactive, toRaw } from "vue";
-import { R as Range, N as Node, c as Scrubber, T as Text, E as Editor, P as Path, d as Transforms, a as Element } from "./index-BzxeM0Pe.js";
-import { F as IS_ANDROID, m as isDOMNode, D as DOMEditor, a5 as MARK_PLACEHOLDER_SYMBOL, e as EDITOR_TO_ON_CHANGE, f as EDITOR_TO_ON_IMMEDIATE_CHANGE, H as IS_WEBKIT, E as EDITOR_TO_KEY_TO_ELEMENT, a0 as ELEMENT_TO_NODE, a1 as NODE_TO_ELEMENT, Y as NODE_TO_INDEX, Z as NODE_TO_PARENT, G as IS_FIREFOX, g as getChunkTreeForNode, X as reconcileChildren, h as applyStringDiff, o as isDOMSelection, n as normalizeStringDiff, a2 as IS_READ_ONLY, j as getDefaultView, _ as EDITOR_TO_WINDOW, $ as EDITOR_TO_ELEMENT, v as getSelection, T as HAS_BEFORE_INPUT_SUPPORT, R as CAN_USE_DOM, B as containsShadowAware, x as getActiveElement, a3 as IS_FOCUSED, p as isPlainTextOnlyPaste, a4 as IS_COMPOSING, U as Hotkeys, K as IS_CHROME, O as IS_FIREFOX_LEGACY, I as IS_IOS, Q as IS_WECHATBROWSER, P as IS_UC_MOBILE, a as EDITOR_TO_USER_MARKS, l as isDOMElement, b as EDITOR_TO_USER_SELECTION } from "./hotkeys-D6R9vfnD.js";
+import { R as Range, N as Node, S as Scrubber, T as Text, E as Editor, P as Path, d as Transforms, a as Element } from "./index-C2VZD0rk.js";
+import { I as IS_ANDROID, _ as isDOMNode, D as DOMEditor, M as MARK_PLACEHOLDER_SYMBOL, e as EDITOR_TO_ON_CHANGE, y as IS_WEBKIT, E as EDITOR_TO_KEY_TO_ELEMENT, j as ELEMENT_TO_NODE, B as NODE_TO_ELEMENT, F as NODE_TO_INDEX, G as NODE_TO_PARENT, r as IS_FIREFOX, g as getChunkTreeForNode, a4 as reconcileChildren, J as applyStringDiff, $ as isDOMSelection, a3 as normalizeStringDiff, v as IS_READ_ONLY, R as getDefaultView, h as EDITOR_TO_WINDOW, f as EDITOR_TO_ELEMENT, U as getSelection, H as HAS_BEFORE_INPUT_SUPPORT, C as CAN_USE_DOM, O as containsShadowAware, P as getActiveElement, t as IS_FOCUSED, a0 as isPlainTextOnlyPaste, p as IS_COMPOSING, k as Hotkeys, n as IS_CHROME, s as IS_FIREFOX_LEGACY, u as IS_IOS, z as IS_WECHATBROWSER, x as IS_UC_MOBILE, a as EDITOR_TO_USER_MARKS, Z as isDOMElement, b as EDITOR_TO_USER_SELECTION } from "./hotkeys-D-Urs0nl.js";
 const SLATE_USE_EDITOR = /* @__PURE__ */ Symbol("SLATE_USE_EDITOR");
 const SLATE_USE_ELEMENT = /* @__PURE__ */ Symbol("SLATE_USE_ELEMENT");
 const SLATE_USE_FOCUSED = /* @__PURE__ */ Symbol("SLATE_USE_FOCUSED");
@@ -267,21 +267,6 @@ const useEditorVersion = () => {
   }
   return EDITOR_VERSION;
 };
-const SLATE_INNER_EDITOR_NODE_VERSION = /* @__PURE__ */ Symbol(
-  "SLATE_INNER_EDITOR_NODE_VERSION"
-);
-const provideEditorNodeVersion = (version) => provide(SLATE_INNER_EDITOR_NODE_VERSION, version);
-const useEditorNodeVersion = () => {
-  const EDITOR_NODE_VERSION = inject(
-    SLATE_INNER_EDITOR_NODE_VERSION
-  );
-  if (EDITOR_NODE_VERSION === void 0) {
-    throw new Error(
-      `The \`useEditorNodeVersion\` hook must be used inside the <Slate> component's context.`
-    );
-  }
-  return EDITOR_NODE_VERSION;
-};
 const SLATE_INNER_PLACEHOLDER = /* @__PURE__ */ Symbol("SLATE_INNER_PLACEHOLDER");
 const providePlaceholder = (placeholder) => {
   provide(SLATE_INNER_PLACEHOLDER, placeholder);
@@ -369,15 +354,6 @@ const SLATE_INNER_STATIC_CHUNK_ROOT = /* @__PURE__ */ Symbol(
 const provideChunkRoot = (chunkRoot) => {
   provide(SLATE_INNER_STATIC_CHUNK_ROOT, chunkRoot);
 };
-const useChunkRoot = () => {
-  const CHUNK_STATIC_ROOT = inject(SLATE_INNER_STATIC_CHUNK_ROOT);
-  if (CHUNK_STATIC_ROOT === void 0) {
-    throw new Error(
-      `The \`useStaticChunk\` hook must be used inside the <Slate> component's context.`
-    );
-  }
-  return CHUNK_STATIC_ROOT;
-};
 const SLATE_INNER_RENDER_CHUNK = /* @__PURE__ */ Symbol("SLATE_INNER_RENDER_CHUNK");
 const provideRenderChunk = (fn) => provide(SLATE_INNER_RENDER_CHUNK, fn);
 const useRenderChunk = () => {
@@ -456,9 +432,7 @@ const Slate = defineComponent({
     provide(SLATE_USE_SELECTION, selection);
     const focusCb = () => isFocus.value = DOMEditor.isFocused(editor);
     const editorVersion = ref(0);
-    const editorNodeVersion = ref(0);
     provideEditorVersion(editorVersion);
-    provideEditorNodeVersion(editorNodeVersion);
     const markPlaceholder = computed(() => {
       if (editor.selection && Range.isCollapsed(editor.selection) && editor.marks) {
         const anchor = editor.selection.anchor;
@@ -493,16 +467,6 @@ const Slate = defineComponent({
           emit("valuechange", options);
         }
       });
-      EDITOR_TO_ON_IMMEDIATE_CHANGE.set(
-        editor,
-        (options) => {
-          const type = options?.operation?.type;
-          if (!type || ["set_selection", "insert_text", "remove_text"].includes(type)) {
-            return;
-          }
-          editorNodeVersion.value++;
-        }
-      );
     });
     onUnmounted(() => {
       document.removeEventListener("focusin", focusCb);
@@ -842,32 +806,20 @@ const ElementComp = defineComponent({
     });
   }
 });
-const ChunkComp = defineComponent({
-  name: "slate-chunk",
-  props: ["ancestor"],
-  setup(props) {
-    const ancestor = props.ancestor;
-    const root = useChunkRoot();
-    const renderChunk = useRenderChunk();
-    return () => renderList(ancestor.children, (chunkNode) => {
-      if (chunkNode.type === "chunk") {
-        return renderChunk({
-          highest: root === ancestor,
-          lowest: chunkNode.children.some((c) => c.type === "leaf"),
-          attributes: { "data-slate-chunk": true },
-          children: h(ChunkComp, {
-            ancestor: chunkNode,
-            key: chunkNode.key.id
-          })
-        });
-      }
-      return h(ElementComp, {
-        // @ts-expect-error Only blocks containing no inlines are chunked
-        element: chunkNode.node,
-        key: chunkNode.key.id
-      });
+const ChunkCompFc = (ancestor, renderChunk, highest) => renderList(ancestor.children, (chunkNode) => {
+  if (chunkNode.type === "chunk") {
+    return renderChunk({
+      highest: highest === true,
+      lowest: chunkNode.children.some((c) => c.type === "leaf"),
+      attributes: { "data-slate-chunk": true, key: chunkNode.key.id },
+      children: ChunkCompFc(chunkNode, renderChunk, false)
     });
   }
+  return h(ElementComp, {
+    // @ts-expect-error Only blocks containing no inlines are chunked
+    element: chunkNode.node,
+    key: chunkNode.key.id
+  });
 });
 const ChildrenComp = defineComponent({
   name: "slate-children",
@@ -895,10 +847,12 @@ const ChildrenComp = defineComponent({
       });
     }
     const cacheTree = getChunkTreeForNode(editor, props.element);
-    const editorNodeVersion = useEditorNodeVersion();
+    const version = ref(0);
     watch(
-      editorNodeVersion,
+      element.children,
       () => {
+        version.value++;
+        console.time("Reconcile children chunks");
         reconcileChildren(editor, element.children, {
           chunkTree: cacheTree,
           chunkSize,
@@ -914,15 +868,19 @@ const ChildrenComp = defineComponent({
             NODE_TO_INDEX.set(n2, i);
           }
         });
+        console.timeEnd("Reconcile children chunks");
       },
       {
+        deep: false,
         immediate: true
       }
     );
     provideChunkRoot(cacheTree);
-    return () => h(ChunkComp, {
-      ancestor: cacheTree
-    });
+    const renderChunk = useRenderChunk();
+    return () => {
+      version.value;
+      return ChunkCompFc(cacheTree, renderChunk, true);
+    };
   }
 });
 const useComposing = () => {
@@ -2130,24 +2088,24 @@ const useFocused = () => {
   return isFocus;
 };
 export {
-  DEFAULT_SCROLL_INTO_VIEW as D,
+  DEFAULT_CHUNK_RENDER as D,
   Editable as E,
   SLATE_USE_SELECTION as S,
   useEditor as a,
-  Slate as b,
-  useComposing as c,
-  useFocused as d,
-  useReadOnly as e,
-  useElement as f,
-  isDOMEventTargetInput as g,
-  isDOMEventHandled as h,
-  isEventHandled as i,
-  handleNativeHistoryEvents as j,
-  DEFAULT_ELEMENT_RENDER as k,
-  DEFAULT_LEAF_RENDER as l,
-  DEFAULT_TEXT_RENDER as m,
-  DEFAULT_CHUNK_RENDER as n,
-  DEFAULT_PLACEHOLDER_RENDER as o,
-  DEFAULT_DECORATE_FN as p,
+  DEFAULT_DECORATE_FN as b,
+  DEFAULT_ELEMENT_RENDER as c,
+  DEFAULT_LEAF_RENDER as d,
+  DEFAULT_PLACEHOLDER_RENDER as e,
+  DEFAULT_SCROLL_INTO_VIEW as f,
+  DEFAULT_TEXT_RENDER as g,
+  Slate as h,
+  handleNativeHistoryEvents as i,
+  isDOMEventHandled as j,
+  isDOMEventTargetInput as k,
+  isEventHandled as l,
+  useComposing as m,
+  useElement as n,
+  useFocused as o,
+  useReadOnly as p,
   useElementIf as u
 };

package/dist/yjs.js

@@ -1,8 +1,8 @@
-import { e as isObject, N as Node, P as Path, E as Editor, L as Location, d as Transforms, R as Range } from "./index-BzxeM0Pe.js";
+import { e as isObject, N as Node, P as Path, E as Editor, L as Location, d as Transforms, R as Range } from "./index-C2VZD0rk.js";
 import { ref, onMounted, onUnmounted, watch, onUpdated, computed } from "vue";
-import { XmlText, YTextEvent, createRelativePositionFromTypeIndex, createAbsolutePositionFromRelativePosition, createRelativePositionFromJSON, decodeRelativePosition, encodeRelativePosition, UndoManager, compareRelativePositions } from "yjs";
-import { a as useEditor, d as useFocused } from "./use-focused-rvrvwwCw.js";
-import { D as DOMEditor } from "./hotkeys-D6R9vfnD.js";
+import { XmlText, YTextEvent, createAbsolutePositionFromRelativePosition, createRelativePositionFromTypeIndex, createRelativePositionFromJSON, decodeRelativePosition, encodeRelativePosition, UndoManager, compareRelativePositions } from "yjs";
+import { a as useEditor, o as useFocused } from "./use-focused-DBkYw-GW.js";
+import { D as DOMEditor } from "./hotkeys-D-Urs0nl.js";
 function deepEquals(node, another) {
   for (const key in node) {
     const a = node[key];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slate-vue3",
-  "version": "0.12.2",
+  "version": "0.13.1",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -69,50 +69,50 @@
   "dependencies": {
     "direction": "^2.0.1",
     "is-hotkey": "^0.2.0",
-    "lodash-es": "^4.17.22",
+    "lodash-es": "^4.17.23",
     "scroll-into-view-if-needed": "^3.1.0"
   },
   "peerDependencies": {
     "vue": "^3.0.0"
   },
   "devDependencies": {
-    "@actions/core": "^2.0.2",
-    "@eslint/js": "^9.39.2",
-    "@faker-js/faker": "^10.2.0",
-    "@liveblocks/client": "^3.13.1",
-    "@liveblocks/yjs": "^3.13.1",
-    "@playwright/test": "^1.57.0",
+    "@actions/core": "^3.0.0",
+    "@eslint/js": "^10.0.1",
+    "@faker-js/faker": "^10.3.0",
+    "@liveblocks/client": "^3.13.4",
+    "@liveblocks/yjs": "^3.13.4",
+    "@playwright/test": "^1.58.2",
     "@testing-library/vue": "^8.1.0",
     "@types/is-hotkey": "^0.1.10",
     "@types/is-url": "^1.2.32",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^25.0.9",
-    "@types/prismjs": "^1.26.5",
-    "@vitejs/plugin-vue": "^6.0.3",
+    "@types/node": "^25.2.3",
+    "@types/prismjs": "^1.26.6",
+    "@vitejs/plugin-vue": "^6.0.4",
     "@vue/eslint-config-prettier": "^10.2.0",
     "babel-plugin-transform-regex": "^6.1.0",
-    "eslint": "^9.39.2",
+    "eslint": "^10.0.0",
     "eslint-plugin-vue": "^10.7.0",
-    "globals": "^17.0.0",
+    "globals": "^17.3.0",
     "husky": "^9.1.7",
     "image-extensions": "^1.1.0",
     "is-url": "^1.2.4",
     "jiti": "^2.6.1",
-    "jsdom": "^27.4.0",
+    "jsdom": "^28.0.0",
     "lint-staged": "^16.2.7",
     "prismjs": "^1.30.0",
     "remark-gfm": "^4.0.1",
     "remark-parse": "^11.0.0",
     "remark-slate-transformer": "^0.9.0",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.53.0",
+    "typescript-eslint": "^8.55.0",
     "unified": "^11.0.5",
     "vite": "^7.3.1",
-    "vite-plugin-babel": "^1.4.1",
+    "vite-plugin-babel": "^1.5.1",
     "vite-plugin-dts": "^4.5.4",
     "vite-plugin-eslint": "^1.8.1",
-    "vitest": "^4.0.17",
-    "vue-router": "^4.6.4",
+    "vitest": "^4.0.18",
+    "vue-router": "^5.0.2",
     "yjs": "^13.6.29"
   },
   "publishConfig": {