@superdoc-dev/cli 0.7.0-next.17 → 0.7.0-next.19

package/dist/index.js

@@ -76859,7 +76859,7 @@ function checkTextSelection($pos) {
 }
 function findSelectionIn(doc$2, node3, pos, index2, dir, text$2 = false) {
   if (node3.inlineContent)
-    return TextSelection2.create(doc$2, pos);
+    return TextSelection.create(doc$2, pos);
   for (let i$1 = index2 - (dir > 0 ? 0 : 1);dir > 0 ? i$1 < node3.childCount : i$1 >= 0; i$1 += dir) {
     let child = node3.child(i$1);
     if (!child.isAtom) {
@@ -80044,7 +80044,7 @@ function selectionToDOM(view, force = false) {
     selectCursorWrapper(view);
   else {
     let { anchor, head } = sel, resetEditableFrom, resetEditableTo;
-    if (brokenSelectBetweenUneditable && !(sel instanceof TextSelection2)) {
+    if (brokenSelectBetweenUneditable && !(sel instanceof TextSelection)) {
       if (!sel.$from.parent.inlineContent)
         resetEditableFrom = temporarilyEditableNear(view, sel.from);
       if (!sel.empty && !sel.$from.parent.inlineContent)
@@ -80145,7 +80145,7 @@ function clearNodeSelection(view) {
   }
 }
 function selectionBetween(view, $anchor, $head, bias) {
-  return view.someProp("createSelectionBetween", (f2) => f2(view, $anchor, $head)) || TextSelection2.between($anchor, $head, bias);
+  return view.someProp("createSelectionBetween", (f2) => f2(view, $anchor, $head)) || TextSelection.between($anchor, $head, bias);
 }
 function hasFocusAndSelection(view) {
   if (view.editable && !view.hasFocus())
@@ -80179,13 +80179,13 @@ function apply(view, sel) {
 }
 function selectHorizontally(view, dir, mods) {
   let sel = view.state.selection;
-  if (sel instanceof TextSelection2) {
+  if (sel instanceof TextSelection) {
     if (mods.indexOf("s") > -1) {
       let { $head } = sel, node3 = $head.textOffset ? null : dir < 0 ? $head.nodeBefore : $head.nodeAfter;
       if (!node3 || node3.isText || !node3.isLeaf)
         return false;
       let $newHead = view.state.doc.resolve($head.pos + node3.nodeSize * (dir < 0 ? -1 : 1));
-      return apply(view, new TextSelection2(sel.$anchor, $newHead));
+      return apply(view, new TextSelection(sel.$anchor, $newHead));
     } else if (!sel.empty)
       return false;
     else if (view.endOfTextblock(dir > 0 ? "forward" : "backward")) {
@@ -80203,12 +80203,12 @@ function selectHorizontally(view, dir, mods) {
       if (NodeSelection.isSelectable(node3))
         return apply(view, new NodeSelection(dir < 0 ? view.state.doc.resolve($head.pos - node3.nodeSize) : $head));
       else if (webkit)
-        return apply(view, new TextSelection2(view.state.doc.resolve(dir < 0 ? nodePos : nodePos + node3.nodeSize)));
+        return apply(view, new TextSelection(view.state.doc.resolve(dir < 0 ? nodePos : nodePos + node3.nodeSize)));
       else
         return false;
     }
   } else if (sel instanceof NodeSelection && sel.node.isInline)
-    return apply(view, new TextSelection2(dir > 0 ? sel.$to : sel.$from));
+    return apply(view, new TextSelection(dir > 0 ? sel.$to : sel.$from));
   else {
     let next = moveSelectionBlock(view.state, dir);
     if (next)
@@ -80397,7 +80397,7 @@ function findDirection(view, pos) {
 }
 function selectVertically(view, dir, mods) {
   let sel = view.state.selection;
-  if (sel instanceof TextSelection2 && !sel.empty || mods.indexOf("s") > -1)
+  if (sel instanceof TextSelection && !sel.empty || mods.indexOf("s") > -1)
     return false;
   if (mac$2 && mods.indexOf("m") > -1)
     return false;
@@ -80415,7 +80415,7 @@ function selectVertically(view, dir, mods) {
   return false;
 }
 function stopNativeHorizontalDelete(view, dir) {
-  if (!(view.state.selection instanceof TextSelection2))
+  if (!(view.state.selection instanceof TextSelection))
     return true;
   let { $head, $anchor, empty: empty$1 } = view.state.selection;
   if (!$head.sameParent($anchor))
@@ -80846,7 +80846,7 @@ function defaultTripleClick(view, inside, event) {
   let doc$2 = view.state.doc;
   if (inside == -1) {
     if (doc$2.inlineContent) {
-      updateSelection(view, TextSelection2.create(doc$2, 0, doc$2.content.size), "pointer");
+      updateSelection(view, TextSelection.create(doc$2, 0, doc$2.content.size), "pointer");
       return true;
     }
     return false;
@@ -80856,7 +80856,7 @@ function defaultTripleClick(view, inside, event) {
     let node3 = i$1 > $pos.depth ? $pos.nodeAfter : $pos.node(i$1);
     let nodePos = $pos.before(i$1);
     if (node3.inlineContent)
-      updateSelection(view, TextSelection2.create(doc$2, nodePos + 1, nodePos + 1 + node3.content.size), "pointer");
+      updateSelection(view, TextSelection.create(doc$2, nodePos + 1, nodePos + 1 + node3.content.size), "pointer");
     else if (NodeSelection.isSelectable(node3))
       updateSelection(view, NodeSelection.create(doc$2, nodePos), "pointer");
     else
@@ -81441,7 +81441,7 @@ function readDOMChange(view, from4, to, typeOver, addedNodes) {
     return;
   }
   if (!change)
-    if (typeOver && sel instanceof TextSelection2 && !sel.empty && sel.$head.sameParent(sel.$anchor) && !view.composing && !(parse$1.sel && parse$1.sel.anchor != parse$1.sel.head))
+    if (typeOver && sel instanceof TextSelection && !sel.empty && sel.$head.sameParent(sel.$anchor) && !view.composing && !(parse$1.sel && parse$1.sel.anchor != parse$1.sel.head))
       change = {
         start: sel.from,
         endA: sel.to,
@@ -81459,7 +81459,7 @@ function readDOMChange(view, from4, to, typeOver, addedNodes) {
       }
       return;
     }
-  if (view.state.selection.from < view.state.selection.to && change.start == change.endB && view.state.selection instanceof TextSelection2) {
+  if (view.state.selection.from < view.state.selection.to && change.start == change.endB && view.state.selection instanceof TextSelection) {
     if (change.start > view.state.selection.from && change.start <= view.state.selection.from + 2 && view.state.selection.from >= parse$1.from)
       change.start = view.state.selection.from;
     else if (change.endA < view.state.selection.to && change.endA >= view.state.selection.to - 2 && view.state.selection.to <= parse$1.to) {
@@ -82099,10 +82099,10 @@ function normalizeSelection(state, tr, allowTableNodeSelection) {
       const lastCell = start + map4.map[map4.width * map4.height - 1];
       normalize$1 = CellSelection.create(doc$2, start + 1, lastCell);
     }
-  } else if (sel instanceof TextSelection2 && isCellBoundarySelection(sel))
-    normalize$1 = TextSelection2.create(doc$2, sel.from);
-  else if (sel instanceof TextSelection2 && isTextSelectionAcrossCells(sel))
-    normalize$1 = TextSelection2.create(doc$2, sel.$from.start(), sel.$from.end());
+  } else if (sel instanceof TextSelection && isCellBoundarySelection(sel))
+    normalize$1 = TextSelection.create(doc$2, sel.from);
+  else if (sel instanceof TextSelection && isTextSelectionAcrossCells(sel))
+    normalize$1 = TextSelection.create(doc$2, sel.$from.start(), sel.$from.end());
   if (normalize$1)
     (tr || (tr = state.tr)).setSelection(normalize$1);
   return tr;
@@ -82632,7 +82632,7 @@ function goToNextCell(direction) {
       return false;
     if (dispatch) {
       const $cell = state.doc.resolve(cell);
-      dispatch(state.tr.setSelection(TextSelection2.between($cell, moveCellForward($cell))).scrollIntoView());
+      dispatch(state.tr.setSelection(TextSelection.between($cell, moveCellForward($cell))).scrollIntoView());
     }
     return true;
   };
@@ -83021,7 +83021,7 @@ function handleMouseDown$1(view, startEvent) {
   view.root.addEventListener("mousemove", move);
 }
 function atEndOfCell(view, axis, dir) {
-  if (!(view.state.selection instanceof TextSelection2))
+  if (!(view.state.selection instanceof TextSelection))
     return null;
   const { $head } = view.state.selection;
   for (let d = $head.depth - 1;d >= 0; d--) {
@@ -83521,7 +83521,7 @@ function stableStringifyInlineProps(inlineProps) {
 function createSelectionPreserver(tr, originalSelection, originalStoredMarks = null) {
   if (!originalSelection)
     return null;
-  const isTextSelection$1 = originalSelection instanceof TextSelection2;
+  const isTextSelection$1 = originalSelection instanceof TextSelection;
   let preservedAnchor = isTextSelection$1 ? originalSelection.anchor : null;
   let preservedHead = isTextSelection$1 ? originalSelection.head : null;
   const anchorAssoc = preservedAnchor != null && preservedHead != null && preservedAnchor <= preservedHead ? -1 : 1;
@@ -83561,7 +83561,7 @@ function createSelectionPreserver(tr, originalSelection, originalStoredMarks = n
     if (!tr.docChanged)
       return;
     if (isTextSelection$1 && preservedAnchor != null && preservedHead != null) {
-      tr.setSelection(TextSelection2.create(tr.doc, preservedAnchor, preservedHead));
+      tr.setSelection(TextSelection.create(tr.doc, preservedAnchor, preservedHead));
       if (preservedAnchor === preservedHead && originalStoredMarks !== null)
         tr.setStoredMarks(originalStoredMarks);
       return;
@@ -84817,7 +84817,7 @@ function canAllocateRels(editor) {
 function handlePlainTextUrlPaste(editor, view, plainText, detected) {
   const { state } = view;
   const { selection } = state;
-  if (!(selection instanceof TextSelection2))
+  if (!(selection instanceof TextSelection))
     return false;
   const linkMarkType = editor.schema.marks.link;
   const underlineMarkType = editor.schema.marks.underline;
@@ -104784,7 +104784,7 @@ var isRegExp = (value) => {
     }
   }
   static findFrom($pos, dir, textOnly = false) {
-    let inner = $pos.parent.inlineContent ? new TextSelection2($pos) : findSelectionIn($pos.node(0), $pos.parent, $pos.pos, $pos.index(), dir, textOnly);
+    let inner = $pos.parent.inlineContent ? new TextSelection($pos) : findSelectionIn($pos.node(0), $pos.parent, $pos.pos, $pos.index(), dir, textOnly);
     if (inner)
       return inner;
     for (let depth = $pos.depth - 1;depth >= 0; depth--) {
@@ -104819,14 +104819,14 @@ var isRegExp = (value) => {
     return selectionClass;
   }
   getBookmark() {
-    return TextSelection2.between(this.$anchor, this.$head).getBookmark();
+    return TextSelection.between(this.$anchor, this.$head).getBookmark();
   }
 }, SelectionRange = class {
   constructor($from, $to) {
     this.$from = $from;
     this.$to = $to;
   }
-}, warnedAboutTextSelection = false, TextSelection2, TextBookmark = class TextBookmark2 {
+}, warnedAboutTextSelection = false, TextSelection, TextBookmark = class TextBookmark2 {
   constructor(anchor, head) {
     this.anchor = anchor;
     this.head = head;
@@ -104835,7 +104835,7 @@ var isRegExp = (value) => {
     return new TextBookmark2(mapping.map(this.anchor), mapping.map(this.head));
   }
   resolve(doc$2) {
-    return TextSelection2.between(doc$2.resolve(this.anchor), doc$2.resolve(this.head));
+    return TextSelection.between(doc$2.resolve(this.anchor), doc$2.resolve(this.head));
   }
 }, NodeSelection, NodeBookmark = class NodeBookmark2 {
   constructor(anchor) {
@@ -109287,7 +109287,7 @@ var isRegExp = (value) => {
     return false;
   return group.split(" ").includes("list");
 }, isTextSelection = (value) => {
-  return value instanceof TextSelection2;
+  return value instanceof TextSelection;
 }, domIndex = function(node3) {
   for (var index2 = 0;; index2++) {
     node3 = node3.previousSibling;
@@ -133399,7 +133399,7 @@ var init_SuperConverter_BgwP1GeS_es = __esm(() => {
   TransformError.prototype.name = "TransformError";
   classesById = Object.create(null);
   Selection.prototype.visible = true;
-  TextSelection2 = class TextSelection3 extends Selection {
+  TextSelection = class TextSelection2 extends Selection {
     constructor($anchor, $head = $anchor) {
       checkTextSelection($anchor);
       checkTextSelection($head);
@@ -133413,7 +133413,7 @@ var init_SuperConverter_BgwP1GeS_es = __esm(() => {
       if (!$head.parent.inlineContent)
         return Selection.near($head);
       let $anchor = doc$2.resolve(mapping.map(this.anchor));
-      return new TextSelection3($anchor.parent.inlineContent ? $anchor : $head, $head);
+      return new TextSelection2($anchor.parent.inlineContent ? $anchor : $head, $head);
     }
     replace(tr, content$2 = Slice.empty) {
       super.replace(tr, content$2);
@@ -133424,7 +133424,7 @@ var init_SuperConverter_BgwP1GeS_es = __esm(() => {
       }
     }
     eq(other) {
-      return other instanceof TextSelection3 && other.anchor == this.anchor && other.head == this.head;
+      return other instanceof TextSelection2 && other.anchor == this.anchor && other.head == this.head;
     }
     getBookmark() {
       return new TextBookmark(this.anchor, this.head);
@@ -133439,7 +133439,7 @@ var init_SuperConverter_BgwP1GeS_es = __esm(() => {
     static fromJSON(doc$2, json) {
       if (typeof json.anchor != "number" || typeof json.head != "number")
         throw new RangeError("Invalid input for TextSelection.fromJSON");
-      return new TextSelection3(doc$2.resolve(json.anchor), doc$2.resolve(json.head));
+      return new TextSelection2(doc$2.resolve(json.anchor), doc$2.resolve(json.head));
     }
     static create(doc$2, anchor, head = anchor) {
       let $anchor = doc$2.resolve(anchor);
@@ -133464,10 +133464,10 @@ var init_SuperConverter_BgwP1GeS_es = __esm(() => {
           if ($anchor.pos < $head.pos != dPos < 0)
             $anchor = $head;
         }
-      return new TextSelection3($anchor, $head);
+      return new TextSelection2($anchor, $head);
     }
   };
-  Selection.jsonID("text", TextSelection2);
+  Selection.jsonID("text", TextSelection);
   NodeSelection = class NodeSelection2 extends Selection {
     constructor($pos) {
       let node3 = $pos.nodeAfter;
@@ -145118,7 +145118,7 @@ var init_SuperConverter_BgwP1GeS_es = __esm(() => {
     }
     localCompositionInfo(view, pos) {
       let { from: from4, to } = view.state.selection;
-      if (!(view.state.selection instanceof TextSelection2) || from4 < pos || to > pos + this.node.content.size)
+      if (!(view.state.selection instanceof TextSelection) || from4 < pos || to > pos + this.node.content.size)
         return null;
       let textNode = view.input.compositionNode;
       if (!textNode || !this.dom.contains(textNode.parentNode))
@@ -145380,7 +145380,7 @@ var init_SuperConverter_BgwP1GeS_es = __esm(() => {
       return;
     }
     let sel = view.state.selection;
-    if (!(sel instanceof TextSelection2) || !sel.$from.sameParent(sel.$to)) {
+    if (!(sel instanceof TextSelection) || !sel.$from.sameParent(sel.$to)) {
       let text$2 = String.fromCharCode(event.charCode);
       let deflt = () => view.state.tr.insertText(text$2).scrollIntoView();
       if (!/[\r\n]/.test(text$2) && !view.someProp("handleTextInput", (f2) => f2(view, sel.$from.pos, sel.$to.pos, text$2, deflt)))
@@ -145434,7 +145434,7 @@ var init_SuperConverter_BgwP1GeS_es = __esm(() => {
     if (!view.composing) {
       view.domObserver.flush();
       let { state } = view, $pos = state.selection.$to;
-      if (state.selection instanceof TextSelection2 && (state.storedMarks || !$pos.textOffset && $pos.parentOffset && $pos.nodeBefore.marks.some((m) => m.type.spec.inclusive === false) || chrome && windows$1 && selectionBeforeUneditable(view))) {
+      if (state.selection instanceof TextSelection && (state.storedMarks || !$pos.textOffset && $pos.parentOffset && $pos.nodeBefore.marks.some((m) => m.type.spec.inclusive === false) || chrome && windows$1 && selectionBeforeUneditable(view))) {
         view.markCursor = view.state.storedMarks || $pos.marks();
         endComposition(view, true);
         view.markCursor = null;
@@ -145767,7 +145767,7 @@ var init_SuperConverter_BgwP1GeS_es = __esm(() => {
         else
           return new CellSelection$1($anchorCell, $headCell);
       }
-      return TextSelection2.between($anchorCell, $headCell);
+      return TextSelection.between($anchorCell, $headCell);
     }
     content() {
       const table = this.$anchorCell.node(-1);
@@ -154465,7 +154465,7 @@ var init_SuperConverter_BgwP1GeS_es = __esm(() => {
   };
 });
 
-// ../../packages/superdoc/dist/chunks/create-headless-toolbar-zEz71NHQ.es.js
+// ../../packages/superdoc/dist/chunks/create-headless-toolbar-Dcw4Hyt2.es.js
 function parseSizeUnit(val = "0") {
   const length3 = val.toString() || "0";
   const value = Number.parseFloat(length3);
@@ -154476,7 +154476,7 @@ function getPreservedSelection(state) {
   return CustomSelectionPluginKey.getState(state)?.preservedSelection ?? null;
 }
 function createSelectionTrackingBookmark(selection) {
-  if (selection instanceof TextSelection2 && !selection.empty)
+  if (selection instanceof TextSelection && !selection.empty)
     return new InclusiveTextSelectionBookmark(selection.anchor, selection.head);
   return selection.getBookmark();
 }
@@ -154763,7 +154763,7 @@ var CSS_DIMENSION_REGEX, DOM_SIZE_UNITS, Extension = class Extension2 {
     return new InclusiveTextSelectionBookmark2(mapping.map(this.anchor, isForward ? -1 : 1), mapping.map(this.head, isForward ? 1 : -1));
   }
   resolve(doc2) {
-    return TextSelection2.between(doc2.resolve(this.anchor), doc2.resolve(this.head));
+    return TextSelection.between(doc2.resolve(this.anchor), doc2.resolve(this.head));
   }
 }, nextHandleId = 1, SelectionHandlePluginKey, DEFAULT_MIME_TYPE = "application/octet-stream", simpleHash2 = (str) => {
   let hash = 0;
@@ -156065,6 +156065,246 @@ var CSS_DIMENSION_REGEX, DOM_SIZE_UNITS, Extension = class Extension2 {
       comment: change.comment ?? null
     }) !== false;
   });
+}, resolveSurface = (activeEditor) => {
+  if (activeEditor?.options?.isHeaderOrFooter) {
+    const headerFooterType = activeEditor.options?.headerFooterType;
+    if (headerFooterType === "footer")
+      return "footer";
+    if (headerFooterType === "header")
+      return "header";
+  }
+  return "body";
+}, resolveSelectionEmpty = (editor) => {
+  return editor.state?.selection?.empty ?? true;
+}, createEditorToolbarTarget = (editor) => {
+  return {
+    commands: editor.commands ?? {},
+    doc: editor.doc
+  };
+}, createPresentationToolbarTarget = (editor) => {
+  return {
+    commands: editor.commands ?? {},
+    doc: editor.getActiveEditor()?.doc
+  };
+}, resolvePresentationEditor = (superdoc) => {
+  const documentId = superdoc.activeEditor?.options?.documentId;
+  if (!documentId)
+    return null;
+  return (superdoc.superdocStore?.documents ?? []).find((doc2) => doc2.getEditor?.()?.options?.documentId === documentId)?.getPresentationEditor?.() ?? null;
+}, resolveToolbarSources = (superdoc) => {
+  const presentationEditor = resolvePresentationEditor(superdoc);
+  if (presentationEditor) {
+    const routedEditor = presentationEditor.getActiveEditor();
+    return {
+      activeEditor: routedEditor ?? null,
+      presentationEditor,
+      context: {
+        target: createPresentationToolbarTarget(presentationEditor),
+        surface: resolveSurface(routedEditor),
+        isEditable: presentationEditor.isEditable,
+        selectionEmpty: resolveSelectionEmpty(presentationEditor),
+        editor: routedEditor ?? undefined,
+        presentationEditor
+      }
+    };
+  }
+  const activeEditor = superdoc.activeEditor;
+  if (!activeEditor)
+    return {
+      activeEditor: null,
+      presentationEditor: null,
+      context: null
+    };
+  return {
+    activeEditor,
+    presentationEditor: null,
+    context: {
+      target: createEditorToolbarTarget(activeEditor),
+      surface: "body",
+      isEditable: activeEditor.isEditable,
+      selectionEmpty: resolveSelectionEmpty(activeEditor),
+      editor: activeEditor
+    }
+  };
+}, buildCommandStateMap = ({ commands = [], superdoc, context, toolbarRegistry }) => {
+  const entries2 = commands.map((command) => {
+    const entry = toolbarRegistry[command];
+    if (!entry)
+      return [command, {
+        active: false,
+        disabled: true
+      }];
+    return [command, entry.state({
+      context,
+      superdoc
+    })];
+  });
+  return Object.fromEntries(entries2);
+}, createToolbarSnapshot = ({ superdoc, commands = [], toolbarRegistry }) => {
+  const { context } = resolveToolbarSources(superdoc);
+  return {
+    context,
+    commands: buildCommandStateMap({
+      commands,
+      superdoc,
+      context,
+      toolbarRegistry
+    })
+  };
+}, subscribeToSuperdocEvents = (superdoc, onChange3) => {
+  if (!superdoc?.on || !superdoc?.off)
+    return null;
+  superdoc.on("editorCreate", onChange3);
+  superdoc.on("document-mode-change", onChange3);
+  superdoc.on("zoomChange", onChange3);
+  return () => {
+    superdoc.off?.("editorCreate", onChange3);
+    superdoc.off?.("document-mode-change", onChange3);
+    superdoc.off?.("zoomChange", onChange3);
+  };
+}, subscribeToEditorEvents = (editor, onChange3) => {
+  if (!editor?.on || !editor?.off)
+    return null;
+  editor.on("focus", onChange3);
+  editor.on("selectionUpdate", onChange3);
+  editor.on("transaction", onChange3);
+  return () => {
+    editor.off?.("focus", onChange3);
+    editor.off?.("selectionUpdate", onChange3);
+    editor.off?.("transaction", onChange3);
+  };
+}, subscribeToPresentationEvents = (presentationEditor, onChange3) => {
+  if (!presentationEditor?.on || !presentationEditor?.off)
+    return null;
+  presentationEditor.on("headerFooterEditingContext", onChange3);
+  presentationEditor.on("headerFooterUpdate", onChange3);
+  presentationEditor.on("headerFooterTransaction", onChange3);
+  return () => {
+    presentationEditor.off?.("headerFooterEditingContext", onChange3);
+    presentationEditor.off?.("headerFooterUpdate", onChange3);
+    presentationEditor.off?.("headerFooterTransaction", onChange3);
+  };
+}, subscribeToolbarEvents = (options, onChange3) => {
+  const { activeEditor: editor, presentationEditor } = resolveToolbarSources(options.superdoc);
+  const unbindSuperdocEvents = subscribeToSuperdocEvents(options.superdoc, onChange3);
+  const unbindEditorEvents = subscribeToEditorEvents(editor, onChange3);
+  const unbindPresentationEvents = subscribeToPresentationEvents(presentationEditor, onChange3);
+  return () => {
+    unbindEditorEvents?.();
+    unbindPresentationEvents?.();
+    unbindSuperdocEvents?.();
+  };
+}, resolveStateEditor = (context) => {
+  if (!context)
+    return null;
+  return context.editor ?? context.presentationEditor?.getActiveEditor() ?? null;
+}, getCurrentParagraphParent = (context) => {
+  const stateEditor = resolveStateEditor(context);
+  const selection = stateEditor?.state?.selection;
+  if (!stateEditor || !selection)
+    return null;
+  return findParentNode((node3) => node3.type.name === "paragraph")(selection);
+}, getCurrentResolvedParagraphProperties = (context) => {
+  const paragraphParent = getCurrentParagraphParent(context);
+  const stateEditor = resolveStateEditor(context);
+  if (!stateEditor || !paragraphParent)
+    return null;
+  return calculateResolvedParagraphProperties(stateEditor, paragraphParent.node, stateEditor.state.doc.resolve(paragraphParent.pos));
+}, isFieldAnnotationSelection = (context) => {
+  const selection = resolveStateEditor(context)?.state?.selection;
+  return selection instanceof NodeSelection && selection?.node?.type?.name === "fieldAnnotation";
+}, isCommandDisabled = (context) => {
+  if (!context || !context.isEditable)
+    return true;
+  return (context.presentationEditor?.editor ?? context.editor)?.options?.documentMode === "viewing";
+}, createDisabledStateDeriver = (options) => ({ context }) => {
+  const disabled = isCommandDisabled(context);
+  if (options?.withValue)
+    return {
+      active: false,
+      disabled,
+      value: null
+    };
+  return {
+    active: false,
+    disabled
+  };
+}, createDirectCommandExecute = (commandName) => ({ context, payload }) => {
+  const editor = resolveStateEditor(context);
+  const command = commandName ? editor?.commands[commandName] : null;
+  if (typeof command !== "function")
+    return false;
+  const result = payload === undefined ? command() : command(payload);
+  return Boolean(result);
+}, getCurrentUndoDepth = (context) => {
+  const stateEditor = resolveStateEditor(context);
+  if (!stateEditor?.state)
+    return 0;
+  try {
+    if (stateEditor.options?.ydoc)
+      return yUndoPluginKey.getState(stateEditor.state)?.undoManager?.undoStack?.length ?? 0;
+    return undoDepth(stateEditor.state);
+  } catch {
+    return 0;
+  }
+}, getCurrentRedoDepth = (context) => {
+  const stateEditor = resolveStateEditor(context);
+  if (!stateEditor?.state)
+    return 0;
+  try {
+    if (stateEditor.options?.ydoc)
+      return yUndoPluginKey.getState(stateEditor.state)?.undoManager?.redoStack?.length ?? 0;
+    return redoDepth(stateEditor.state);
+  } catch {
+    return 0;
+  }
+}, createHistoryStateDeriver = (kind) => ({ context }) => {
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true
+    };
+  return {
+    active: false,
+    disabled: (kind === "undo" ? getCurrentUndoDepth(context) : getCurrentRedoDepth(context)) === 0
+  };
+}, createRulerStateDeriver = () => ({ context, superdoc }) => {
+  return {
+    active: Boolean(superdoc?.config?.rulers),
+    disabled: isCommandDisabled(context)
+  };
+}, createZoomStateDeriver = () => ({ context, superdoc }) => {
+  return {
+    active: false,
+    disabled: !context,
+    value: typeof superdoc?.getZoom === "function" ? superdoc.getZoom() : 100
+  };
+}, createDocumentModeStateDeriver = () => ({ context, superdoc }) => {
+  return {
+    active: false,
+    disabled: !context,
+    value: superdoc?.config?.documentMode ?? "editing"
+  };
+}, createRulerExecute = () => ({ superdoc }) => {
+  superdoc.toggleRuler?.();
+  return true;
+}, createZoomExecute = () => ({ superdoc, payload }) => {
+  const normalizedPayload = Number.parseInt(String(payload), 10);
+  if (!Number.isFinite(normalizedPayload) || normalizedPayload <= 0)
+    return false;
+  superdoc.setZoom?.(normalizedPayload);
+  return true;
+}, createDocumentModeExecute = () => ({ superdoc, payload }) => {
+  const validModes = [
+    "editing",
+    "suggesting",
+    "viewing"
+  ];
+  const normalizedPayload = typeof payload === "string" ? payload.toLowerCase() : payload;
+  if (typeof superdoc?.setDocumentMode !== "function" || typeof normalizedPayload !== "string" || !validModes.includes(normalizedPayload))
+    return false;
+  superdoc.setDocumentMode(normalizedPayload);
+  return true;
 }, isOffValue = (value) => {
   if (value == null)
     return false;
@@ -156075,8 +156315,749 @@ var CSS_DIMENSION_REGEX, DOM_SIZE_UNITS, Extension = class Extension2 {
   if (typeof checker !== "function")
     return false;
   return Boolean(checker(attrs));
+}, normalizeFontSizeValue = (value) => {
+  if (typeof value === "number")
+    return `${value}pt`;
+  if (typeof value === "string") {
+    const [numericValue, unit] = parseSizeUnit(value);
+    if (!Number.isNaN(numericValue))
+      return `${numericValue}${unit || "pt"}`;
+  }
+  return value;
+}, normalizeFontFamilyValue = (value) => {
+  if (typeof value !== "string")
+    return value;
+  return value;
+}, normalizeLinkHrefValue = (value) => {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}, normalizeColorValue = (value) => {
+  if (typeof value === "string" && value.length > 0)
+    return value.toLowerCase();
+  return null;
+}, isFormattingActivatedFromLinkedStyle = (context, styleKey) => {
+  const stateEditor = resolveStateEditor(context);
+  if (!stateEditor?.state?.selection?.$from)
+    return false;
+  const styleId = getCurrentResolvedParagraphProperties(context)?.styleId;
+  const linkedStyle = stateEditor?.converter?.linkedStyles?.find((style) => style.id === styleId);
+  return Boolean(linkedStyle?.definition?.styles && styleKey in linkedStyle.definition.styles);
+}, hasNegatedFormattingMark = (formatting, markName) => {
+  const rawActiveMark = formatting.find((mark) => mark.name === markName);
+  return rawActiveMark ? isNegatedMark(rawActiveMark.name, rawActiveMark.attrs) : false;
+}, createBoldStateDeriver = () => ({ context }) => {
+  const stateEditor = resolveStateEditor(context);
+  const formatting = stateEditor ? getActiveFormatting(stateEditor) : [];
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true
+    };
+  const isActiveFromMark = formatting.some((mark) => mark.name === "bold");
+  const markNegated = hasNegatedFormattingMark(formatting, "bold");
+  const activeFromLinkedStyle = !isActiveFromMark && !markNegated ? isFormattingActivatedFromLinkedStyle(context, "bold") : false;
+  return {
+    active: isActiveFromMark || activeFromLinkedStyle,
+    disabled: false
+  };
+}, createItalicStateDeriver = () => ({ context }) => {
+  const stateEditor = resolveStateEditor(context);
+  const formatting = stateEditor ? getActiveFormatting(stateEditor) : [];
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true
+    };
+  return {
+    active: !hasNegatedFormattingMark(formatting, "italic") && formatting.some((mark) => mark.name === "italic"),
+    disabled: false
+  };
+}, createUnderlineStateDeriver = () => ({ context }) => {
+  const stateEditor = resolveStateEditor(context);
+  const formatting = stateEditor ? getActiveFormatting(stateEditor) : [];
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true
+    };
+  return {
+    active: !hasNegatedFormattingMark(formatting, "underline") && formatting.some((mark) => mark.name === "underline"),
+    disabled: false
+  };
+}, createStrikethroughStateDeriver = () => ({ context }) => {
+  const stateEditor = resolveStateEditor(context);
+  const formatting = stateEditor ? getActiveFormatting(stateEditor) : [];
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true
+    };
+  return {
+    active: !hasNegatedFormattingMark(formatting, "strike") && formatting.some((mark) => mark.name === "strike"),
+    disabled: false
+  };
+}, createFontSizeStateDeriver = () => ({ context }) => {
+  const stateEditor = resolveStateEditor(context);
+  const formatting = stateEditor ? getActiveFormatting(stateEditor) : [];
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true,
+      value: null
+    };
+  const normalizedValues = formatting.filter((mark) => mark.name === "fontSize").map((mark) => mark.attrs?.fontSize).filter((value$1) => value$1 != null).map((value$1) => normalizeFontSizeValue(value$1));
+  const uniqueValues = [...new Set(normalizedValues)];
+  const hasDirectValue = uniqueValues.length > 0;
+  const canUseLinkedStyle = !hasDirectValue && isFormattingActivatedFromLinkedStyle(context, "font-size");
+  const paragraphProps = canUseLinkedStyle ? getCurrentResolvedParagraphProperties(context) : null;
+  const documentEditor = context?.presentationEditor?.editor ?? context?.editor ?? null;
+  const linkedStyleValue = normalizeFontSizeValue((canUseLinkedStyle ? documentEditor?.converter?.linkedStyles?.find((style) => style.id === paragraphProps?.styleId) : null)?.definition?.styles?.["font-size"]) ?? null;
+  const value = uniqueValues.length === 1 ? uniqueValues[0] : linkedStyleValue;
+  return {
+    active: hasDirectValue || linkedStyleValue != null,
+    disabled: false,
+    value
+  };
+}, createFontFamilyStateDeriver = () => ({ context }) => {
+  const stateEditor = resolveStateEditor(context);
+  const formatting = stateEditor ? getActiveFormatting(stateEditor) : [];
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true,
+      value: null
+    };
+  const normalizedValues = formatting.filter((mark) => mark.name === "fontFamily").map((mark) => mark.attrs?.fontFamily).filter((value$1) => value$1 != null).map((value$1) => normalizeFontFamilyValue(value$1));
+  const uniqueValues = [...new Set(normalizedValues)];
+  const canUseLinkedStyle = !(uniqueValues.length > 0) && isFormattingActivatedFromLinkedStyle(context, "font-family");
+  const paragraphProps = canUseLinkedStyle ? getCurrentResolvedParagraphProperties(context) : null;
+  const documentEditor = context?.presentationEditor?.editor ?? context?.editor ?? null;
+  const linkedStyleValue = normalizeFontFamilyValue((canUseLinkedStyle ? documentEditor?.converter?.linkedStyles?.find((style) => style.id === paragraphProps?.styleId) : null)?.definition?.styles?.["font-family"]) ?? null;
+  const value = uniqueValues.length === 1 ? uniqueValues[0] : linkedStyleValue;
+  return {
+    active: uniqueValues.length > 0 || linkedStyleValue != null,
+    disabled: false,
+    value
+  };
+}, createTextColorStateDeriver = () => ({ context }) => {
+  const stateEditor = resolveStateEditor(context);
+  const formatting = stateEditor ? getActiveFormatting(stateEditor) : [];
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true,
+      value: null
+    };
+  const values = formatting.filter((mark) => mark.name === "color").map((mark) => mark.attrs?.color).filter((value$1) => value$1 != null);
+  const markNegated = hasNegatedFormattingMark(formatting, "color");
+  const normalizedValues = values.map((value$1) => normalizeColorValue(value$1));
+  const uniqueValues = [...new Set(normalizedValues)];
+  const value = uniqueValues.length === 1 ? uniqueValues[0] : null;
+  return {
+    active: !markNegated && uniqueValues.length > 0,
+    disabled: false,
+    value
+  };
+}, createHighlightColorStateDeriver = () => ({ context }) => {
+  const stateEditor = resolveStateEditor(context);
+  const formatting = stateEditor ? getActiveFormatting(stateEditor) : [];
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true,
+      value: null
+    };
+  const values = formatting.filter((mark) => mark.name === "highlight").map((mark) => mark.attrs?.color).filter((value$1) => value$1 != null);
+  const markNegated = hasNegatedFormattingMark(formatting, "highlight");
+  const normalizedValues = values.map((value$1) => normalizeColorValue(value$1));
+  const uniqueValues = [...new Set(normalizedValues)];
+  const value = uniqueValues.length === 1 ? uniqueValues[0] : null;
+  return {
+    active: !markNegated && uniqueValues.length > 0,
+    disabled: false,
+    value
+  };
+}, createLinkStateDeriver = () => ({ context }) => {
+  const stateEditor = resolveStateEditor(context);
+  const formatting = stateEditor ? getActiveFormatting(stateEditor) : [];
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true,
+      value: null
+    };
+  const normalizedValues = formatting.filter((mark) => mark.name === "link").map((mark) => mark.attrs?.href).filter((value$1) => value$1 != null).map((value$1) => normalizeLinkHrefValue(value$1));
+  const uniqueValues = [...new Set(normalizedValues)];
+  const value = uniqueValues.length === 1 ? uniqueValues[0] : null;
+  return {
+    active: uniqueValues.length > 0,
+    disabled: false,
+    value
+  };
+}, createBoldExecute = () => ({ context, payload }) => {
+  const editor = resolveStateEditor(context);
+  if (isFieldAnnotationSelection(context)) {
+    editor?.commands?.toggleFieldAnnotationsFormat?.("bold", true);
+    return true;
+  }
+  if (!createDirectCommandExecute("toggleBold")({
+    context,
+    payload
+  }))
+    return false;
+  editor?.commands?.toggleFieldAnnotationsFormat?.("bold", true);
+  return true;
+}, createItalicExecute = () => ({ context, payload }) => {
+  const editor = resolveStateEditor(context);
+  if (isFieldAnnotationSelection(context)) {
+    editor?.commands?.toggleFieldAnnotationsFormat?.("italic", true);
+    return true;
+  }
+  if (!createDirectCommandExecute("toggleItalic")({
+    context,
+    payload
+  }))
+    return false;
+  editor?.commands?.toggleFieldAnnotationsFormat?.("italic", true);
+  return true;
+}, createUnderlineExecute = () => ({ context, payload }) => {
+  const editor = resolveStateEditor(context);
+  if (isFieldAnnotationSelection(context)) {
+    editor?.commands?.toggleFieldAnnotationsFormat?.("underline", true);
+    return true;
+  }
+  if (!createDirectCommandExecute("toggleUnderline")({
+    context,
+    payload
+  }))
+    return false;
+  editor?.commands?.toggleFieldAnnotationsFormat?.("underline", true);
+  return true;
+}, createFontSizeExecute = () => ({ context, payload }) => {
+  if (payload === undefined)
+    return false;
+  const editor = resolveStateEditor(context);
+  if (isFieldAnnotationSelection(context)) {
+    editor?.commands?.setFieldAnnotationsFontSize?.(payload, true);
+    return true;
+  }
+  if (!createDirectCommandExecute("setFontSize")({
+    context,
+    payload
+  }))
+    return false;
+  editor?.commands?.setFieldAnnotationsFontSize?.(payload, true);
+  return true;
+}, createFontFamilyExecute = () => ({ context, payload }) => {
+  if (payload === undefined)
+    return false;
+  const editor = resolveStateEditor(context);
+  if (isFieldAnnotationSelection(context)) {
+    editor?.commands?.setFieldAnnotationsFontFamily?.(payload, true);
+    return true;
+  }
+  if (!createDirectCommandExecute("setFontFamily")({
+    context,
+    payload
+  }))
+    return false;
+  editor?.commands?.setFieldAnnotationsFontFamily?.(payload, true);
+  return true;
+}, createTextColorExecute = () => ({ context, payload }) => {
+  const editor = resolveStateEditor(context);
+  if (typeof payload !== "string" || payload.length === 0)
+    return false;
+  const isNone = payload === "none";
+  const inlineValue = isNone ? "inherit" : payload;
+  const result = createDirectCommandExecute("setColor")({
+    context,
+    payload: inlineValue
+  });
+  editor?.commands?.setFieldAnnotationsTextColor?.(isNone ? null : payload, true);
+  return result;
+}, createHighlightColorExecute = () => ({ context, payload }) => {
+  const editor = resolveStateEditor(context);
+  if (typeof payload !== "string" || payload.length === 0)
+    return false;
+  const isNone = payload === "none";
+  const inlineValue = isNone ? "transparent" : payload;
+  const result = createDirectCommandExecute("setHighlight")({
+    context,
+    payload: inlineValue
+  });
+  const argValue = isNone ? null : payload;
+  editor?.commands?.setFieldAnnotationsTextHighlight?.(argValue, true);
+  editor?.commands?.setCellBackground?.(argValue);
+  return result;
+}, applyLinkPostExecute = (editor) => {
+  const { view } = editor;
+  let selection = view.state.selection;
+  if (editor.options?.isHeaderOrFooter && editor.options?.lastSelection)
+    selection = editor.options.lastSelection;
+  const endPos = selection?.$to?.pos;
+  if (typeof endPos !== "number")
+    return;
+  try {
+    const newSelection = new TextSelection(view.state.doc.resolve(endPos));
+    const tr = view.state.tr.setSelection(newSelection);
+    const state = view.state.apply(tr);
+    view.updateState(state);
+    if (!editor.options?.isHeaderOrFooter)
+      setTimeout(() => {
+        view.focus();
+      }, 100);
+  } catch {
+    return;
+  }
+}, createLinkExecute = () => ({ context, payload }) => {
+  const editor = resolveStateEditor(context);
+  const result = createDirectCommandExecute("toggleLink")({
+    context,
+    payload
+  });
+  if (!result || !editor?.view)
+    return result;
+  applyLinkPostExecute(editor);
+  return true;
+}, createImageExecute = () => ({ context }) => {
+  const editor = resolveStateEditor(context);
+  if (!editor?.view)
+    return false;
+  getFileOpener()().then(async (result) => {
+    if (!result?.file)
+      return;
+    await processAndInsertImageFile({
+      file: result.file,
+      editor,
+      view: editor.view,
+      editorOptions: editor.options,
+      getMaxContentSize: () => editor.getMaxContentSize()
+    });
+  }).catch((err) => {
+    const originalError = err instanceof Error ? err : new Error(String(err));
+    const error3 = /* @__PURE__ */ new Error(`[headless-toolbar] Image insertion failed: ${originalError.message}`);
+    editor?.emit?.("exception", {
+      error: error3,
+      editor
+    });
+    console.error(error3, originalError);
+  });
+  return true;
+}, getCurrentParagraphJustification = (context) => {
+  const justification = getCurrentResolvedParagraphProperties(context)?.justification ?? null;
+  if (justification === "both")
+    return "justify";
+  return justification;
+}, createTextAlignStateDeriver = () => ({ context }) => {
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true,
+      value: null
+    };
+  const value = getCurrentParagraphJustification(context) ?? null;
+  return {
+    active: value != null,
+    disabled: false,
+    value
+  };
+}, createLineHeightStateDeriver = () => ({ context }) => {
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true,
+      value: null
+    };
+  const line = getCurrentResolvedParagraphProperties(context)?.spacing?.line;
+  const value = line != null ? twipsToLines(line) : null;
+  return {
+    active: value != null,
+    disabled: false,
+    value
+  };
+}, createLinkedStyleStateDeriver = () => ({ context }) => {
+  const isDisabled = isCommandDisabled(context);
+  const stateEditor = resolveStateEditor(context);
+  if (isDisabled || !stateEditor)
+    return {
+      active: false,
+      disabled: true,
+      value: null
+    };
+  if (!getQuickFormatList(stateEditor).length)
+    return {
+      active: false,
+      disabled: true,
+      value: null
+    };
+  const value = getCurrentResolvedParagraphProperties(context)?.styleId ?? null;
+  return {
+    active: value != null,
+    disabled: false,
+    value
+  };
+}, createListStateDeriver = (numberingType) => ({ context }) => {
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true
+    };
+  const paragraphNode = getCurrentParagraphParent(context)?.node ?? null;
+  const paragraphProperties = getCurrentResolvedParagraphProperties(context);
+  const activeNumberingType = isList(paragraphNode) || Boolean(paragraphProperties?.numberingProperties && paragraphNode?.attrs?.listRendering) ? paragraphNode?.attrs?.listRendering?.numberingType : null;
+  return {
+    active: numberingType === "bullet" ? activeNumberingType === "bullet" : activeNumberingType != null && activeNumberingType !== "bullet",
+    disabled: false
+  };
+}, createIndentIncreaseExecute = () => ({ context }) => {
+  if (resolveStateEditor(context)?.commands?.increaseListIndent?.())
+    return true;
+  return createDirectCommandExecute("increaseTextIndent")({ context });
+}, createIndentDecreaseExecute = () => ({ context }) => {
+  if (resolveStateEditor(context)?.commands?.decreaseListIndent?.())
+    return true;
+  return createDirectCommandExecute("decreaseTextIndent")({ context });
+}, createTableActionsStateDeriver = () => ({ context }) => {
+  const editor = resolveStateEditor(context);
+  const inTable = editor?.state?.selection?.$head ? isInTable(editor.state) : false;
+  return {
+    active: false,
+    disabled: isCommandDisabled(context) || !inTable
+  };
+}, enrichTrackedChanges = (trackedChanges = [], superdoc) => {
+  if (!trackedChanges.length)
+    return trackedChanges;
+  const store = superdoc?.commentsStore;
+  if (!store?.getComment)
+    return trackedChanges;
+  return trackedChanges.map((change) => {
+    const commentId = change.id;
+    if (!commentId)
+      return change;
+    const storeComment = store.getComment(commentId);
+    if (!storeComment)
+      return change;
+    const comment = typeof storeComment.getValues === "function" ? storeComment.getValues() : storeComment;
+    return {
+      ...change,
+      comment
+    };
+  });
+}, createTrackChangesSelectionActionStateDeriver = (action) => ({ context, superdoc }) => {
+  if (isCommandDisabled(context))
+    return {
+      active: false,
+      disabled: true
+    };
+  const editor = resolveStateEditor(context);
+  const state = editor?.state;
+  const selection = state?.selection;
+  if (!editor || !state?.doc || !selection)
+    return {
+      active: false,
+      disabled: true
+    };
+  const trackedChanges = enrichTrackedChanges(collectTrackedChanges({
+    state,
+    from: selection.from,
+    to: selection.to
+  }), superdoc);
+  if (!trackedChanges.length)
+    return {
+      active: false,
+      disabled: true
+    };
+  return {
+    active: false,
+    disabled: !isTrackedChangeActionAllowed({
+      editor,
+      action,
+      trackedChanges
+    })
+  };
+}, createToolbarRegistry = () => {
+  return {
+    bold: {
+      id: "bold",
+      directCommandName: "toggleBold",
+      state: createBoldStateDeriver(),
+      execute: createBoldExecute()
+    },
+    italic: {
+      id: "italic",
+      directCommandName: "toggleItalic",
+      state: createItalicStateDeriver(),
+      execute: createItalicExecute()
+    },
+    underline: {
+      id: "underline",
+      directCommandName: "toggleUnderline",
+      state: createUnderlineStateDeriver(),
+      execute: createUnderlineExecute()
+    },
+    strikethrough: {
+      id: "strikethrough",
+      directCommandName: "toggleStrike",
+      state: createStrikethroughStateDeriver()
+    },
+    "font-size": {
+      id: "font-size",
+      directCommandName: "setFontSize",
+      state: createFontSizeStateDeriver(),
+      execute: createFontSizeExecute()
+    },
+    "font-family": {
+      id: "font-family",
+      directCommandName: "setFontFamily",
+      state: createFontFamilyStateDeriver(),
+      execute: createFontFamilyExecute()
+    },
+    "text-color": {
+      id: "text-color",
+      directCommandName: "setColor",
+      state: createTextColorStateDeriver(),
+      execute: createTextColorExecute()
+    },
+    "highlight-color": {
+      id: "highlight-color",
+      directCommandName: "setHighlight",
+      state: createHighlightColorStateDeriver(),
+      execute: createHighlightColorExecute()
+    },
+    link: {
+      id: "link",
+      directCommandName: "toggleLink",
+      state: createLinkStateDeriver(),
+      execute: createLinkExecute()
+    },
+    "text-align": {
+      id: "text-align",
+      directCommandName: "setTextAlign",
+      state: createTextAlignStateDeriver()
+    },
+    "line-height": {
+      id: "line-height",
+      directCommandName: "setLineHeight",
+      state: createLineHeightStateDeriver()
+    },
+    "linked-style": {
+      id: "linked-style",
+      directCommandName: "setLinkedStyle",
+      state: createLinkedStyleStateDeriver(),
+      execute: createDirectCommandExecute("setLinkedStyle")
+    },
+    "bullet-list": {
+      id: "bullet-list",
+      directCommandName: "toggleBulletList",
+      state: createListStateDeriver("bullet")
+    },
+    "numbered-list": {
+      id: "numbered-list",
+      directCommandName: "toggleOrderedList",
+      state: createListStateDeriver("ordered")
+    },
+    "indent-increase": {
+      id: "indent-increase",
+      state: createDisabledStateDeriver(),
+      execute: createIndentIncreaseExecute()
+    },
+    "indent-decrease": {
+      id: "indent-decrease",
+      state: createDisabledStateDeriver(),
+      execute: createIndentDecreaseExecute()
+    },
+    undo: {
+      id: "undo",
+      directCommandName: "undo",
+      state: createHistoryStateDeriver("undo")
+    },
+    redo: {
+      id: "redo",
+      directCommandName: "redo",
+      state: createHistoryStateDeriver("redo")
+    },
+    ruler: {
+      id: "ruler",
+      state: createRulerStateDeriver(),
+      execute: createRulerExecute()
+    },
+    zoom: {
+      id: "zoom",
+      state: createZoomStateDeriver(),
+      execute: createZoomExecute()
+    },
+    "document-mode": {
+      id: "document-mode",
+      state: createDocumentModeStateDeriver(),
+      execute: createDocumentModeExecute()
+    },
+    "clear-formatting": {
+      id: "clear-formatting",
+      directCommandName: "clearFormat",
+      state: createDisabledStateDeriver()
+    },
+    "copy-format": {
+      id: "copy-format",
+      directCommandName: "copyFormat",
+      state: createDisabledStateDeriver()
+    },
+    "track-changes-accept-selection": {
+      id: "track-changes-accept-selection",
+      directCommandName: "acceptTrackedChangeFromToolbar",
+      state: createTrackChangesSelectionActionStateDeriver("accept")
+    },
+    "track-changes-reject-selection": {
+      id: "track-changes-reject-selection",
+      directCommandName: "rejectTrackedChangeFromToolbar",
+      state: createTrackChangesSelectionActionStateDeriver("reject")
+    },
+    image: {
+      id: "image",
+      state: createDisabledStateDeriver(),
+      execute: createImageExecute()
+    },
+    "table-insert": {
+      id: "table-insert",
+      directCommandName: "insertTable",
+      state: createDisabledStateDeriver(),
+      execute: createDirectCommandExecute("insertTable")
+    },
+    "table-add-row-before": {
+      id: "table-add-row-before",
+      directCommandName: "addRowBefore",
+      state: createTableActionsStateDeriver()
+    },
+    "table-add-row-after": {
+      id: "table-add-row-after",
+      directCommandName: "addRowAfter",
+      state: createTableActionsStateDeriver()
+    },
+    "table-delete-row": {
+      id: "table-delete-row",
+      directCommandName: "deleteRow",
+      state: createTableActionsStateDeriver()
+    },
+    "table-add-column-before": {
+      id: "table-add-column-before",
+      directCommandName: "addColumnBefore",
+      state: createTableActionsStateDeriver()
+    },
+    "table-add-column-after": {
+      id: "table-add-column-after",
+      directCommandName: "addColumnAfter",
+      state: createTableActionsStateDeriver()
+    },
+    "table-delete-column": {
+      id: "table-delete-column",
+      directCommandName: "deleteColumn",
+      state: createTableActionsStateDeriver()
+    },
+    "table-delete": {
+      id: "table-delete",
+      directCommandName: "deleteTable",
+      state: createTableActionsStateDeriver()
+    },
+    "table-merge-cells": {
+      id: "table-merge-cells",
+      directCommandName: "mergeCells",
+      state: createTableActionsStateDeriver()
+    },
+    "table-split-cell": {
+      id: "table-split-cell",
+      directCommandName: "splitCell",
+      state: createTableActionsStateDeriver()
+    },
+    "table-remove-borders": {
+      id: "table-remove-borders",
+      directCommandName: "deleteCellAndTableBorders",
+      state: createTableActionsStateDeriver()
+    },
+    "table-fix": {
+      id: "table-fix",
+      directCommandName: "fixTables",
+      state: createTableActionsStateDeriver()
+    }
+  };
+}, executeDirectCommand = (id2, snapshot2, toolbarRegistry, payload) => {
+  const commandName = toolbarRegistry[id2]?.directCommandName;
+  const command = commandName ? snapshot2.context?.target?.commands?.[commandName] : null;
+  if (typeof command !== "function")
+    return false;
+  const result = payload === undefined ? command() : command(payload);
+  return typeof result === "boolean" ? result : Boolean(result);
+}, executeRegistryCommand = (id2, superdoc, snapshot2, toolbarRegistry, payload) => {
+  const entry = toolbarRegistry[id2];
+  if (!entry)
+    return false;
+  if (typeof entry.execute === "function")
+    return entry.execute({
+      context: snapshot2.context,
+      superdoc,
+      payload
+    });
+  return executeDirectCommand(id2, snapshot2, toolbarRegistry, payload);
+}, createHeadlessToolbar = (options) => {
+  const listeners = /* @__PURE__ */ new Set;
+  const toolbarRegistry = createToolbarRegistry();
+  const buildSnapshot = () => {
+    return createToolbarSnapshot({
+      ...options,
+      toolbarRegistry
+    });
+  };
+  let snapshot2 = buildSnapshot();
+  let destroyed = false;
+  let unsubscribeEvents = null;
+  const notifyListeners = () => {
+    listeners.forEach((listener) => listener({ snapshot: snapshot2 }));
+  };
+  const rebindEvents = () => {
+    unsubscribeEvents?.();
+    unsubscribeEvents = subscribeToolbarEvents(options, handleChange);
+  };
+  const rebuildSnapshot = () => {
+    snapshot2 = buildSnapshot();
+  };
+  const refreshControllerState = () => {
+    rebuildSnapshot();
+    rebindEvents();
+    notifyListeners();
+  };
+  const handleChange = () => {
+    if (destroyed)
+      return;
+    refreshControllerState();
+  };
+  rebindEvents();
+  return {
+    getSnapshot() {
+      return snapshot2;
+    },
+    subscribe(listener) {
+      if (destroyed)
+        return () => {};
+      listeners.add(listener);
+      listener({ snapshot: snapshot2 });
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    execute(id2, payload) {
+      const result = executeRegistryCommand(id2, options.superdoc, snapshot2, toolbarRegistry, payload);
+      if (result && !destroyed)
+        refreshControllerState();
+      return result;
+    },
+    destroy() {
+      if (destroyed)
+        return;
+      destroyed = true;
+      unsubscribeEvents?.();
+      unsubscribeEvents = null;
+      listeners.clear();
+    }
+  };
 };
-var init_create_headless_toolbar_zEz71NHQ_es = __esm(() => {
+var init_create_headless_toolbar_Dcw4Hyt2_es = __esm(() => {
   init_SuperConverter_BgwP1GeS_es();
   init_constants_CGhJRd87_es();
   init_dist_B8HfvhaK_es();
@@ -204515,7 +205496,7 @@ var init_remark_gfm_eZN6yzWQ_es = __esm(() => {
   init_remark_gfm_BhnWr3yf_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-DjgWBzME.es.js
+// ../../packages/superdoc/dist/chunks/src-DlMaB1h-.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -205240,9 +206221,9 @@ function mapPreservedSelection(selection, tr) {
 function applySelectionCleanup(editor, tr) {
   let cleaned = tr.setMeta(CustomSelectionPluginKey, DEFAULT_SELECTION_STATE);
   const sel = cleaned.selection;
-  if (sel && sel instanceof TextSelection2 && !sel.empty)
+  if (sel && sel instanceof TextSelection && !sel.empty)
     try {
-      const collapsed = TextSelection2.create(cleaned.doc, sel.head);
+      const collapsed = TextSelection.create(cleaned.doc, sel.head);
       cleaned = cleaned.setSelection(collapsed);
     } catch {}
   editor.setOptions({
@@ -205355,7 +206336,7 @@ function arrow$1(axis, dir) {
   return function(state, dispatch, view) {
     let sel = state.selection;
     let $start = dir > 0 ? sel.$to : sel.$from, mustMove = sel.empty;
-    if (sel instanceof TextSelection2) {
+    if (sel instanceof TextSelection) {
       if (!view.endOfTextblock(dirStr) || $start.depth == 0)
         return false;
       mustMove = false;
@@ -205395,7 +206376,7 @@ function beforeinput(view, event) {
   for (let i4 = insert.length - 1;i4 >= 0; i4--)
     frag = Fragment.from(insert[i4].createAndFill(null, frag));
   let tr = view.state.tr.replace($from.pos, $from.pos, new Slice(frag, 0, 0));
-  tr.setSelection(TextSelection2.near(tr.doc.resolve($from.pos + 1)));
+  tr.setSelection(TextSelection.near(tr.doc.resolve($from.pos + 1)));
   view.dispatch(tr);
   return false;
 }
@@ -206282,7 +207263,7 @@ function createStructuredContentSelectPlugin(editor) {
         for (let od = old$pos.depth;od > 0; od--)
           if (old$pos.node(od).type.name === "structuredContent" && old$pos.before(od) === sdtStart)
             return null;
-        return newState.tr.setSelection(TextSelection2.create(newState.doc, contentFrom, contentTo));
+        return newState.tr.setSelection(TextSelection.create(newState.doc, contentFrom, contentTo));
       }
     return null;
   } });
@@ -206493,7 +207474,7 @@ function splitBlockPatch(state, dispatch, editor) {
     }
   }
   let tr = state.tr;
-  if (state.selection instanceof TextSelection2 || state.selection instanceof AllSelection)
+  if (state.selection instanceof TextSelection || state.selection instanceof AllSelection)
     tr.deleteSelection();
   let splitPos = tr.mapping.map($from.pos);
   let can = canSplit(tr.doc, splitPos, types3.length, types3);
@@ -206698,7 +207679,7 @@ function splitBlockAs(splitNode) {
         types3.unshift(null);
       }
     let tr = state.tr;
-    if (state.selection instanceof TextSelection2 || state.selection instanceof AllSelection)
+    if (state.selection instanceof TextSelection || state.selection instanceof AllSelection)
       tr.deleteSelection();
     let splitPos = tr.mapping.map($from.pos);
     let can = canSplit(tr.doc, splitPos, types3.length, types3);
@@ -206796,7 +207777,7 @@ function selectTextblockSide(side) {
     if (!$pos.node(depth).isTextblock)
       return false;
     if (dispatch)
-      dispatch(state.tr.setSelection(TextSelection2.create(state.doc, side < 0 ? $pos.start(depth) : $pos.end(depth))));
+      dispatch(state.tr.setSelection(TextSelection.create(state.doc, side < 0 ? $pos.start(depth) : $pos.end(depth))));
     return true;
   };
 }
@@ -207124,7 +208105,7 @@ function skipTab(dir) {
       return false;
     const nextPos = dir > 0 ? Math.min($nextPos.pos + nextNode.nodeSize + 1, state.doc.nodeSize) : Math.max(0, $nextPos.pos - nextNode.nodeSize - 1);
     if (dispatch)
-      dispatch(state.tr.setSelection(TextSelection2.create(state.doc, nextPos)));
+      dispatch(state.tr.setSelection(TextSelection.create(state.doc, nextPos)));
     return true;
   };
 }
@@ -208844,7 +209825,7 @@ function getTableBoundaryExitSelection(state, dir) {
   const boundaryPos = helpers.getTableBoundaryPos(context);
   const targetPos = helpers.findTextPosAcrossBoundary(state, boundaryPos);
   if (targetPos != null)
-    return TextSelection2.create(state.doc, targetPos);
+    return TextSelection.create(state.doc, targetPos);
   return findSelectionNearBoundary(state, boundaryPos, dir);
 }
 function getAdjacentTableEntrySelection(state, dir) {
@@ -208865,13 +209846,13 @@ function getAdjacentTableEntrySelection(state, dir) {
   if (dir > 0) {
     const targetPos$1 = findFirstTextPosInNode(adjacentNode, boundaryPos);
     if (targetPos$1 != null)
-      return TextSelection2.create(state.doc, targetPos$1);
+      return TextSelection.create(state.doc, targetPos$1);
     return findSelectionNearBoundary(state, boundaryPos, 1);
   }
   const tablePos = boundaryPos - adjacentNode.nodeSize;
   const targetPos = findLastTextPosInNode(adjacentNode, tablePos);
   if (targetPos != null)
-    return TextSelection2.create(state.doc, targetPos);
+    return TextSelection.create(state.doc, targetPos);
   return findSelectionNearBoundary(state, tablePos + adjacentNode.nodeSize, -1);
 }
 function createTableBoundaryNavigationPlugin() {
@@ -209215,7 +210196,7 @@ function insertRowAtIndex({ tr, tablePos, tableNode, sourceRowIndex, insertIndex
     if (newRow) {
       tr.insert(insertPos, newRow);
       const cursorPos = insertPos + ROW_START_TO_TEXT_OFFSET;
-      tr.setSelection(TextSelection2.create(tr.doc, cursorPos));
+      tr.setSelection(TextSelection.create(tr.doc, cursorPos));
       const firstTextNode = newCells[0].firstChild?.firstChild;
       if (firstTextNode?.marks?.length)
         tr.setStoredMarks(firstTextNode.marks);
@@ -209224,7 +210205,7 @@ function insertRowAtIndex({ tr, tablePos, tableNode, sourceRowIndex, insertIndex
     }
   } else if (cellsToExtend.length > 0) {
     const cursorPos = cellsToExtend[0].pos + CELL_TO_TEXT_OFFSET;
-    tr.setSelection(TextSelection2.create(tr.doc, cursorPos));
+    tr.setSelection(TextSelection.create(tr.doc, cursorPos));
   }
   return true;
 }
@@ -212955,7 +213936,7 @@ function findCommand(wrap5, dir) {
     let next2 = dir > 0 ? nextMatch(search$1, state, wrap5, from$1, to) : prevMatch(search$1, state, wrap5, from$1, to);
     if (!next2)
       return false;
-    let selection = TextSelection2.create(state.doc, next2.from, next2.to);
+    let selection = TextSelection.create(state.doc, next2.from, next2.to);
     if (dispatch)
       dispatch(state.tr.setSelection(selection).scrollIntoView());
     return true;
@@ -212980,14 +213961,14 @@ function replaceCommand(wrap5, moveForward) {
       }
       let after2 = moveForward && nextMatch(search$1, state, wrap5, next2.from, next2.to);
       if (after2)
-        tr.setSelection(TextSelection2.create(tr.doc, tr.mapping.map(after2.from, 1), tr.mapping.map(after2.to, -1)));
+        tr.setSelection(TextSelection.create(tr.doc, tr.mapping.map(after2.from, 1), tr.mapping.map(after2.to, -1)));
       else
-        tr.setSelection(TextSelection2.create(tr.doc, next2.from, tr.mapping.map(next2.to, 1)));
+        tr.setSelection(TextSelection.create(tr.doc, next2.from, tr.mapping.map(next2.to, 1)));
       dispatch(tr.scrollIntoView());
     } else if (!moveForward)
       return false;
     else
-      dispatch(state.tr.setSelection(TextSelection2.create(state.doc, next2.from, next2.to)).scrollIntoView());
+      dispatch(state.tr.setSelection(TextSelection.create(state.doc, next2.from, next2.to)).scrollIntoView());
     return true;
   };
 }
@@ -213057,9 +214038,9 @@ function buildSelection(state, pos, extend) {
   const clamped = Math.max(0, Math.min(pos, doc$12.content.size));
   if (extend) {
     const anchor = selection.anchor ?? selection.from;
-    return TextSelection2.create(doc$12, anchor, clamped);
+    return TextSelection.create(doc$12, anchor, clamped);
   }
-  return TextSelection2.create(doc$12, clamped);
+  return TextSelection.create(doc$12, clamped);
 }
 function findLineElementAtPoint(doc$12, x, y$1) {
   if (typeof doc$12?.elementsFromPoint !== "function")
@@ -216221,13 +217202,6 @@ function scrollToElement(targetElement, options = {
     behavior: options.behavior
   });
 }
-function getParagraphFontFamilyFromProperties(paragraphProps, convertedXml = {}) {
-  const fontFamilyProps = paragraphProps?.runProperties?.fontFamily;
-  if (!fontFamilyProps)
-    return null;
-  const [markDef] = encodeMarksFromRPr({ fontFamily: fontFamilyProps }, convertedXml);
-  return markDef?.attrs?.fontFamily ?? null;
-}
 function getDefaultExportFromCjs2(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
@@ -222241,6 +223215,124 @@ function normalizeReplacementText(text5, stepId) {
     throw planError("INVALID_INPUT", "replacement text normalized to zero blocks", stepId);
   return chunks;
 }
+function tokenizeWords(text5) {
+  const tokens = [];
+  const regex = /(\s+|\S+)/g;
+  let match$1;
+  while ((match$1 = regex.exec(text5)) !== null)
+    tokens.push({
+      text: match$1[0],
+      offset: match$1.index
+    });
+  return tokens;
+}
+function getWordChanges(oldText, newText) {
+  if (oldText === newText)
+    return [];
+  const oldTokens = tokenizeWords(oldText);
+  const newTokens = tokenizeWords(newText);
+  if (oldTokens.length === 0 && newTokens.length === 0)
+    return [];
+  if (oldTokens.length === 0)
+    return [{
+      type: "insert",
+      insertAt: 0,
+      newText
+    }];
+  if (newTokens.length === 0)
+    return [{
+      type: "delete",
+      oldFrom: 0,
+      oldTo: oldText.length
+    }];
+  const ops = myersDiff(oldTokens, newTokens, (a2, b$1) => a2.text === b$1.text);
+  const steps = [];
+  let oldIdx = 0;
+  let newIdx = 0;
+  for (const op of ops) {
+    steps.push({
+      type: op,
+      oldIdx,
+      newIdx
+    });
+    if (op === "equal") {
+      oldIdx++;
+      newIdx++;
+    } else if (op === "delete")
+      oldIdx++;
+    else
+      newIdx++;
+  }
+  const result = [];
+  let i4 = 0;
+  while (i4 < steps.length) {
+    if (steps[i4].type === "equal") {
+      i4++;
+      continue;
+    }
+    let deleteStart = -1;
+    let deleteEnd = -1;
+    let insertText2 = "";
+    while (i4 < steps.length && (steps[i4].type === "delete" || steps[i4].type === "insert")) {
+      const s2 = steps[i4];
+      if (s2.type === "delete") {
+        const token$1 = oldTokens[s2.oldIdx];
+        if (deleteStart === -1)
+          deleteStart = token$1.offset;
+        deleteEnd = token$1.offset + token$1.text.length;
+      } else
+        insertText2 += newTokens[s2.newIdx].text;
+      i4++;
+    }
+    if (deleteStart !== -1 && insertText2.length > 0)
+      result.push({
+        type: "replace",
+        oldFrom: deleteStart,
+        oldTo: deleteEnd,
+        newText: insertText2
+      });
+    else if (deleteStart !== -1)
+      result.push({
+        type: "delete",
+        oldFrom: deleteStart,
+        oldTo: deleteEnd
+      });
+    else if (insertText2.length > 0) {
+      const prevStep = i4 > 0 ? steps[i4 - 1] : null;
+      let insertAt = 0;
+      if (prevStep && prevStep.type === "equal") {
+        const prevToken = oldTokens[prevStep.oldIdx];
+        insertAt = prevToken.offset + prevToken.text.length;
+      } else if (result.length > 0) {
+        const lastOp = result[result.length - 1];
+        insertAt = "oldTo" in lastOp ? lastOp.oldTo : ("insertAt" in lastOp) ? lastOp.insertAt : 0;
+      }
+      result.push({
+        type: "insert",
+        insertAt,
+        newText: insertText2
+      });
+    }
+  }
+  return result;
+}
+function charOffsetToDocPos(doc$12, rangeFrom, rangeTo, charOffset) {
+  let count2 = 0;
+  let foundPos = -1;
+  doc$12.nodesBetween(rangeFrom, rangeTo, (node3, pos) => {
+    if (foundPos >= 0)
+      return false;
+    if (!node3.isText)
+      return true;
+    const textStart = Math.max(pos, rangeFrom);
+    const textLen = Math.min(pos + node3.nodeSize, rangeTo) - textStart;
+    if (count2 + textLen >= charOffset)
+      foundPos = textStart + (charOffset - count2);
+    count2 += textLen;
+    return false;
+  });
+  return foundPos >= 0 ? foundPos : rangeTo;
+}
 function debugTextRewrite(message, details) {
   if (!DEBUG_TEXT_REWRITE)
     return;
@@ -222729,8 +223821,58 @@ function executeTextRewrite(editor, tr, target, step3, mapping) {
       });
     }
   }
-  const textNode = editor.state.schema.text(replacementText, asProseMirrorMarks(marks));
-  tr.replaceWith(absFrom, absTo, textNode);
+  const originalText = tr.doc.textBetween(absFrom, absTo, "", "");
+  const origLen = originalText.length;
+  const replLen = replacementText.length;
+  let prefix2 = 0;
+  while (prefix2 < origLen && prefix2 < replLen && originalText[prefix2] === replacementText[prefix2])
+    prefix2++;
+  if (prefix2 === origLen && prefix2 === replLen)
+    return { changed: false };
+  let suffix = 0;
+  while (suffix < origLen - prefix2 && suffix < replLen - prefix2 && originalText[origLen - 1 - suffix] === replacementText[replLen - 1 - suffix])
+    suffix++;
+  const trimmedFrom = charOffsetToDocPos(tr.doc, absFrom, absTo, prefix2);
+  const trimmedTo = charOffsetToDocPos(tr.doc, absFrom, absTo, origLen - suffix);
+  const trimmedOld = originalText.slice(prefix2, origLen - suffix);
+  const trimmedNew = replacementText.slice(prefix2, replLen - suffix);
+  const wordChanges = getWordChanges(trimmedOld, trimmedNew);
+  if (wordChanges.length > 1) {
+    const doc$12 = tr.doc;
+    const baseSteps = tr.steps.length;
+    const mapped = wordChanges.map((change) => {
+      if (change.type === "insert")
+        return {
+          ...change,
+          docPos: charOffsetToDocPos(doc$12, trimmedFrom, trimmedTo, change.insertAt)
+        };
+      return {
+        ...change,
+        docFrom: charOffsetToDocPos(doc$12, trimmedFrom, trimmedTo, change.oldFrom),
+        docTo: charOffsetToDocPos(doc$12, trimmedFrom, trimmedTo, change.oldTo)
+      };
+    });
+    for (let i4 = 0;i4 < mapped.length; i4++) {
+      const change = mapped[i4];
+      const remap = (pos) => {
+        for (let s2 = baseSteps;s2 < tr.steps.length; s2++)
+          pos = tr.steps[s2].getMap().map(pos);
+        return pos;
+      };
+      if (change.type === "delete")
+        tr.delete(remap(change.docFrom), remap(change.docTo));
+      else if (change.type === "insert") {
+        const node3 = editor.state.schema.text(change.newText, asProseMirrorMarks(marks));
+        tr.insert(remap(change.docPos), node3);
+      } else {
+        const node3 = editor.state.schema.text(change.newText, asProseMirrorMarks(marks));
+        tr.replaceWith(remap(change.docFrom), remap(change.docTo), node3);
+      }
+    }
+  } else {
+    const textNode = editor.state.schema.text(trimmedNew, asProseMirrorMarks(marks));
+    tr.replaceWith(trimmedFrom, trimmedTo, textNode);
+  }
   return { changed: replacementText !== target.text };
 }
 function executeTextInsert(editor, tr, target, step3, mapping) {
@@ -226332,7 +227474,7 @@ function applyTextSelection(editor, from$1, to) {
   }
   if (editor.state?.tr && typeof editor.dispatch === "function")
     try {
-      const tr = editor.state.tr.setSelection(TextSelection2.create(editor.state.doc, from$1, to)).setMeta("inputType", "programmatic");
+      const tr = editor.state.tr.setSelection(TextSelection.create(editor.state.doc, from$1, to)).setMeta("inputType", "programmatic");
       editor.dispatch(tr);
       return true;
     } catch {
@@ -238785,7 +239927,7 @@ function createWrapper(editor, input2, options) {
     if (input2.at) {
       const { absFrom, absTo } = resolveSelectionTarget(editor, input2.at);
       const { tr } = editor.state;
-      tr.setSelection(TextSelection2.create(tr.doc, absFrom, absTo));
+      tr.setSelection(TextSelection.create(tr.doc, absFrom, absTo));
       dispatchTransaction(editor, tr);
     }
     const cmd = editor.commands?.[commandName];
@@ -254938,13 +256080,13 @@ function normalizeFieldAnnotationMetadata(attrs) {
     displayLabel: toOptionalString(attrs.displayLabel),
     defaultDisplayLabel: toOptionalString(attrs.defaultDisplayLabel),
     alias: toOptionalString(attrs.alias),
-    fieldColor: normalizeColorValue(attrs.fieldColor),
-    borderColor: normalizeColorValue(attrs.borderColor),
+    fieldColor: normalizeColorValue2(attrs.fieldColor),
+    borderColor: normalizeColorValue2(attrs.borderColor),
     highlighted: toBoolean$2(attrs.highlighted, true),
     fontFamily: toNullableString(attrs.fontFamily),
     fontSize: normalizeFontSize$1(attrs.fontSize),
-    textColor: normalizeColorValue(attrs.textColor) ?? null,
-    textHighlight: normalizeColorValue(attrs.textHighlight) ?? null,
+    textColor: normalizeColorValue2(attrs.textColor) ?? null,
+    textHighlight: normalizeColorValue2(attrs.textHighlight) ?? null,
     linkUrl: toNullableString(attrs.linkUrl),
     imageSrc: toNullableString(attrs.imageSrc),
     rawHtml: attrs.rawHtml ?? undefined,
@@ -255028,7 +256170,7 @@ function normalizeVisibility(value) {
   if (normalized === "visible" || normalized === "hidden")
     return normalized;
 }
-function normalizeColorValue(value) {
+function normalizeColorValue2(value) {
   if (typeof value !== "string")
     return;
   const trimmed = value.trim();
@@ -262063,7 +263205,7 @@ var Node$13 = class Node$14 {
       const anchor = relativePositionToAbsolutePosition(binding.doc, binding.type, relSel.anchor, binding.mapping);
       const head = relativePositionToAbsolutePosition(binding.doc, binding.type, relSel.head, binding.mapping);
       if (anchor !== null && head !== null) {
-        const sel = TextSelection2.between(tr.doc.resolve(anchor), tr.doc.resolve(head));
+        const sel = TextSelection.between(tr.doc.resolve(anchor), tr.doc.resolve(head));
         tr.setSelection(sel);
       }
     }
@@ -262148,7 +263290,7 @@ var Node$13 = class Node$14 {
       if (sel) {
         const clampedAnchor = min$1(max$1(sel.anchor, 0), tr.doc.content.size);
         const clampedHead = min$1(max$1(sel.head, 0), tr.doc.content.size);
-        tr.setSelection(TextSelection2.create(tr.doc, clampedAnchor, clampedHead));
+        tr.setSelection(TextSelection.create(tr.doc, clampedAnchor, clampedHead));
       }
       this.prosemirrorView.dispatch(tr.setMeta(ySyncPluginKey, {
         isChangeOrigin: true,
@@ -264036,19 +265178,19 @@ var Node$13 = class Node$14 {
   const leftRun = runType.create(run2.attrs, leftFrag, run2.marks);
   const rightRun = runType.create(run2.attrs, rightFrag, run2.marks);
   const gapPos = runStart + leftRun.nodeSize;
-  tr.replaceWith(runStart, runEnd, [leftRun, rightRun]).setSelection(TextSelection2.create(tr.doc, gapPos));
+  tr.replaceWith(runStart, runEnd, [leftRun, rightRun]).setSelection(TextSelection.create(tr.doc, gapPos));
   if (dispatch)
     dispatch(tr);
   return true;
 }, cleanupEmptyRunsPlugin, preserveStoredMarks = (state, tr) => {
-  if (!(tr.selection instanceof TextSelection2) || !tr.selection.empty)
+  if (!(tr.selection instanceof TextSelection) || !tr.selection.empty)
     return;
   if (state.storedMarks === null)
     return;
   tr.setStoredMarks(state.storedMarks);
 }, normalizeSelectionIntoRun = (tr, runType) => {
   const selection = tr.selection;
-  if (!(selection instanceof TextSelection2))
+  if (!(selection instanceof TextSelection))
     return;
   if (selection.from !== selection.to)
     return;
@@ -264059,14 +265201,14 @@ var Node$13 = class Node$14 {
   if (nodeAfter?.type === runType && nodeAfter.content.size > 0) {
     const nextPos = selection.from + 1;
     if (nextPos <= tr.doc.content.size)
-      tr.setSelection(TextSelection2.create(tr.doc, nextPos));
+      tr.setSelection(TextSelection.create(tr.doc, nextPos));
     return;
   }
   const nodeBefore = $pos.nodeBefore;
   if (nodeBefore?.type === runType && nodeBefore.content.size > 0) {
     const prevPos = selection.from - 1;
     if (prevPos >= 0)
-      tr.setSelection(TextSelection2.create(tr.doc, prevPos));
+      tr.setSelection(TextSelection.create(tr.doc, prevPos));
   }
 }, copyRunPropertiesFromParagraph = (state, pos, textNode, runType, editor) => {
   let updatedTextNode = textNode;
@@ -264204,7 +265346,7 @@ var Node$13 = class Node$14 {
       const runProperties = getSplitRunProperties(state, $from);
       newAttrs = syncSplitParagraphRunProperties(newAttrs, runProperties);
     }
-    if (selection instanceof TextSelection2)
+    if (selection instanceof TextSelection)
       tr.deleteSelection();
     const deflt = $from.depth === 0 ? null : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
     let types3 = atEnd && deflt ? [{
@@ -264276,7 +265418,7 @@ var Node$13 = class Node$14 {
   const { from: from$1 } = tr.selection;
   const tabText = state.schema.text("\t");
   tr = tr.replaceSelectionWith(tabText);
-  tr = tr.setSelection(TextSelection2.create(tr.doc, from$1 + 1));
+  tr = tr.setSelection(TextSelection.create(tr.doc, from$1 + 1));
   if (dispatch)
     dispatch(tr);
   return true;
@@ -264304,7 +265446,7 @@ var Node$13 = class Node$14 {
       newPos = tr.selection.from;
     }
   tr.insert(newPos, tabNode);
-  tr = tr.setSelection(TextSelection2.create(tr.doc, newPos + tabNode.nodeSize));
+  tr = tr.setSelection(TextSelection.create(tr.doc, newPos + tabNode.nodeSize));
   if (dispatch)
     dispatch(tr);
   return true;
@@ -264473,7 +265615,7 @@ var Node$13 = class Node$14 {
   if (dispatch) {
     let side = (!$from.parentOffset && $to.index() < $to.parent.childCount ? $from : $to).pos;
     let tr = state.tr.insert(side, type.createAndFill());
-    tr.setSelection(TextSelection2.create(tr.doc, side + 1));
+    tr.setSelection(TextSelection.create(tr.doc, side + 1));
     dispatch(tr.scrollIntoView());
   }
   return true;
@@ -265201,7 +266343,7 @@ var Node$13 = class Node$14 {
     const paraPos = $from.before();
     let tr = state.tr.deleteRange(paraPos, paraPos + para.nodeSize).scrollIntoView();
     const targetPos = Math.max(1, Math.min(paraPos - 1, tr.doc.content.size));
-    tr = tr.setSelection(TextSelection2.create(tr.doc, targetPos));
+    tr = tr.setSelection(TextSelection.create(tr.doc, targetPos));
     dispatch(tr);
   }
   return true;
@@ -265467,7 +266609,7 @@ var Node$13 = class Node$14 {
         if (selection.empty && paragraphsInSelection.length === 1)
           tr.setSelection(Selection.near(tr.doc.resolve(restoredSelectionRange.to), -1));
         else
-          tr.setSelection(TextSelection2.create(tr.doc, restoredSelectionRange.from, restoredSelectionRange.to));
+          tr.setSelection(TextSelection.create(tr.doc, restoredSelectionRange.from, restoredSelectionRange.to));
       } catch {}
   }
   dispatch(tr);
@@ -265576,7 +266718,7 @@ var Node$13 = class Node$14 {
   return true;
 }, restoreSelection = () => ({ editor, state, tr }) => {
   if (editor.options.lastSelection) {
-    tr.setSelection(TextSelection2.create(state.doc, editor.options.lastSelection.from, editor.options.lastSelection.to));
+    tr.setSelection(TextSelection.create(state.doc, editor.options.lastSelection.from, editor.options.lastSelection.to));
     return true;
   }
   return false;
@@ -265588,7 +266730,7 @@ var Node$13 = class Node$14 {
   const nextFrom = clamp$1(typeof from$1 === "number" ? from$1 : state.selection.from, 0, docSize);
   const nextTo = clamp$1(typeof to === "number" ? to : nextFrom, 0, docSize);
   const [head, anchor] = nextFrom <= nextTo ? [nextFrom, nextTo] : [nextTo, nextFrom];
-  const selection = TextSelection2.create(doc$12, head, anchor);
+  const selection = TextSelection.create(doc$12, head, anchor);
   if (dispatch)
     dispatch(state.tr.setSelection(selection));
   if (editor?.view?.dom && typeof editor.view.dom.focus === "function")
@@ -269736,9 +270878,9 @@ var Node$13 = class Node$14 {
 }, syncSelectionFromTransaction = ({ targetTr, sourceSelection }) => {
   const boundedFrom = Math.max(0, Math.min(sourceSelection.from, targetTr.doc.content.size));
   const boundedTo = Math.max(0, Math.min(sourceSelection.to, targetTr.doc.content.size));
-  if (sourceSelection instanceof TextSelection2)
+  if (sourceSelection instanceof TextSelection)
     try {
-      targetTr.setSelection(TextSelection2.create(targetTr.doc, boundedFrom, boundedTo));
+      targetTr.setSelection(TextSelection.create(targetTr.doc, boundedFrom, boundedTo));
       return;
     } catch {
       targetTr.setSelection(Selection.near(targetTr.doc.resolve(boundedFrom), -1));
@@ -270449,29 +271591,29 @@ var Node$13 = class Node$14 {
     const boundedPos = Math.max(0, Math.min(trackMeta.selectionPos, newTr.doc.content.size));
     const $pos = newTr.doc.resolve(boundedPos);
     if ($pos.parent.inlineContent)
-      newTr.setSelection(TextSelection2.create(newTr.doc, boundedPos));
+      newTr.setSelection(TextSelection.create(newTr.doc, boundedPos));
     else
-      newTr.setSelection(TextSelection2.near($pos, -1));
+      newTr.setSelection(TextSelection.near($pos, -1));
   } else if (tr.selectionSet)
-    if (tr.selection instanceof TextSelection2 && (tr.selection.from < state.selection.from || tr.getMeta("inputType") === "deleteContentBackward")) {
+    if (tr.selection instanceof TextSelection && (tr.selection.from < state.selection.from || tr.getMeta("inputType") === "deleteContentBackward")) {
       const caretPos = map$12.map(tr.selection.from, -1);
-      newTr.setSelection(new TextSelection2(newTr.doc.resolve(caretPos)));
+      newTr.setSelection(new TextSelection(newTr.doc.resolve(caretPos)));
     } else if (trackMeta?.insertedTo !== undefined) {
       const boundedInsertedTo = Math.max(0, Math.min(trackMeta.insertedTo, newTr.doc.content.size));
       const $insertPos = newTr.doc.resolve(boundedInsertedTo);
-      newTr.setSelection(TextSelection2.near($insertPos, 1));
+      newTr.setSelection(TextSelection.near($insertPos, 1));
     } else {
       const deletionMarkSchema = state.schema.marks[TrackDeleteMarkName];
       const deletionMark = findMark(state, deletionMarkSchema, false);
       if (tr.selection.from > state.selection.from && deletionMark) {
         const caretPos = map$12.map(deletionMark.to + 1, 1);
-        newTr.setSelection(new TextSelection2(newTr.doc.resolve(caretPos)));
+        newTr.setSelection(new TextSelection(newTr.doc.resolve(caretPos)));
       } else
         newTr.setSelection(tr.selection.map(newTr.doc, map$12));
     }
   else if (state.selection.from - tr.selection.from > 1 && tr.selection.$head.depth > 1) {
     const caretPos = map$12.map(tr.selection.from - 2, -1);
-    newTr.setSelection(new TextSelection2(newTr.doc.resolve(caretPos)));
+    newTr.setSelection(new TextSelection(newTr.doc.resolve(caretPos)));
   }
   if (tr.storedMarksSet)
     newTr.setStoredMarks(tr.storedMarks);
@@ -270942,7 +272084,7 @@ var Node$13 = class Node$14 {
         to
       });
     else if (this.#editor.state) {
-      const tr = this.#editor.state.tr.setSelection(TextSelection2.create(this.#editor.state.doc, from$1, to)).scrollIntoView();
+      const tr = this.#editor.state.tr.setSelection(TextSelection.create(this.#editor.state.doc, from$1, to)).scrollIntoView();
       this.#editor.dispatch(tr);
     }
     const presentationEditor = this.#editor.presentationEditor;
@@ -272215,7 +273357,7 @@ var Node$13 = class Node$14 {
 }, icons, getAvailableColorOptions = () => {
   return icons.flat().map((item) => item.value);
 }, _hoisted_1$14, _hoisted_2$10, ROW_SIZE = 5, TableGrid_default, _hoisted_1$13, _hoisted_2$9, _hoisted_3$7, _hoisted_4$5, _hoisted_5$2, TableActions_default, check_default = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><!--!Font Awesome Free 6.7.2 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2025 Fonticons, Inc.--><path d="M438.6 105.4c12.5 12.5 12.5 32.8 0 45.3l-256 256c-12.5 12.5-32.8 12.5-45.3 0l-128-128c-12.5-12.5-12.5-32.8 0-45.3s32.8-12.5 45.3 0L160 338.7 393.4 105.4c12.5-12.5 32.8-12.5 45.3 0z"/></svg>
-`, _hoisted_1$12, _hoisted_2$8, _hoisted_3$6, SearchInput_default, TOOLBAR_FONTS, TOOLBAR_FONT_SIZES, closeDropdown = (dropdown) => {
+`, _hoisted_1$12, _hoisted_2$8, _hoisted_3$6, SearchInput_default, TOOLBAR_FONTS, TOOLBAR_FONT_SIZES, HEADLESS_ITEM_MAP, TABLE_ACTION_COMMAND_MAP, TABLE_ACTION_COMMAND_IDS, HEADLESS_TOOLBAR_COMMANDS, NON_HEADLESS_EXECUTE_ITEM_NAMES, HEADLESS_EXECUTE_ITEMS, closeDropdown = (dropdown) => {
   dropdown.expand.value = false;
 }, makeDefaultItems = ({ superToolbar, toolbarIcons: toolbarIcons$1, toolbarTexts: toolbarTexts$1, toolbarFonts, hideButtons, availableWidth, role, isDev = false } = {}) => {
   const bold2 = useToolbarItem({
@@ -272854,16 +273996,6 @@ var Node$13 = class Node$14 {
     group: "left",
     attributes: { ariaLabel: "Redo" }
   });
-  const toggleTrackChanges = useToolbarItem({
-    type: "button",
-    disabled: false,
-    name: "toggleTrackChanges",
-    tooltip: toolbarTexts$1.trackChanges,
-    command: "toggleTrackChanges",
-    icon: toolbarIcons$1.trackChanges,
-    group: "left",
-    attributes: { ariaLabel: "Track changes" }
-  });
   const acceptTrackedChangeBySelection = useToolbarItem({
     type: "button",
     disabled: false,
@@ -272884,26 +274016,6 @@ var Node$13 = class Node$14 {
     group: "left",
     attributes: { ariaLabel: "Reject tracked changes" }
   });
-  const toggleTrackChangesOriginal = useToolbarItem({
-    type: "button",
-    disabled: false,
-    name: "toggleTrackChangesShowOriginal",
-    tooltip: toolbarTexts$1.trackChangesOriginal,
-    command: "toggleTrackChangesShowOriginal",
-    icon: toolbarIcons$1.trackChangesOriginal,
-    group: "left",
-    attributes: { ariaLabel: "Toggle tracked changes show original" }
-  });
-  const toggleTrackChangesFinal = useToolbarItem({
-    type: "button",
-    disabled: false,
-    name: "toggleTrackChangesShowFinal",
-    tooltip: toolbarTexts$1.trackChangesFinal,
-    command: "toggleTrackChangesShowFinal",
-    icon: toolbarIcons$1.trackChangesFinal,
-    group: "left",
-    attributes: { ariaLabel: "Toggle tracked changes show final" }
-  });
   const clearFormatting = useToolbarItem({
     type: "button",
     name: "clearFormatting",
@@ -273183,11 +274295,7 @@ var Node$13 = class Node$14 {
     ];
     toolbarItems = toolbarItems.filter((item) => !filterItems.includes(item.name.value));
   }
-  const devItems = [
-    toggleTrackChanges,
-    toggleTrackChangesOriginal,
-    toggleTrackChangesFinal
-  ];
+  const devItems = [];
   if (!isDev) {
     if (role === "viewer")
       devItems.push(...[acceptTrackedChangeBySelection, rejectTrackedChangeOnSelection]);
@@ -273232,7 +274340,24 @@ var Node$13 = class Node$14 {
     defaultItems: visibleItems,
     overflowItems: overflowItems.filter((item) => item.type !== "separator")
   };
-}, _hoisted_1$11, _hoisted_2$7, ToolbarButtonIcon_default, _hoisted_1$10, _hoisted_2$6, _hoisted_3$5, _hoisted_4$4, _hoisted_5$1, _hoisted_6, _hoisted_7, _hoisted_8, ToolbarButton_default, _hoisted_1$9, ToolbarSeparator_default, _hoisted_1$8, _hoisted_2$5, _hoisted_3$4, OverflowMenu_default, _hoisted_1$7, _hoisted_2$4, _hoisted_3$3, _hoisted_4$3, ToolbarDropdown_default, SdTooltip_default, _hoisted_1$6, _hoisted_2$3, _hoisted_3$2, _hoisted_4$2, ButtonGroup_default, DEFAULT_UI_FONT_FAMILY = "Arial, Helvetica, sans-serif", Toolbar_default, toolbarTexts, SuperToolbar, Schema3 = class Schema4 {
+}, _hoisted_1$11, _hoisted_2$7, ToolbarButtonIcon_default, _hoisted_1$10, _hoisted_2$6, _hoisted_3$5, _hoisted_4$4, _hoisted_5$1, _hoisted_6, _hoisted_7, _hoisted_8, ToolbarButton_default, _hoisted_1$9, ToolbarSeparator_default, _hoisted_1$8, _hoisted_2$5, _hoisted_3$4, OverflowMenu_default, _hoisted_1$7, _hoisted_2$4, _hoisted_3$3, _hoisted_4$3, ToolbarDropdown_default, SdTooltip_default, _hoisted_1$6, _hoisted_2$3, _hoisted_3$2, _hoisted_4$2, ButtonGroup_default, DEFAULT_UI_FONT_FAMILY = "Arial, Helvetica, sans-serif", Toolbar_default, toolbarTexts, getParagraphFontFamilyFromProperties = (paragraphProps, convertedXml = {}) => {
+  const fontFamilyProps = paragraphProps?.runProperties?.fontFamily;
+  if (!fontFamilyProps)
+    return null;
+  const [markDef] = encodeMarksFromRPr({ fontFamily: fontFamilyProps }, convertedXml);
+  return markDef?.attrs?.fontFamily ?? null;
+}, findElementBySelector = (selector) => {
+  let el = null;
+  if (selector) {
+    if (selector.startsWith("#") || selector.startsWith("."))
+      el = document.querySelector(selector);
+    else
+      el = document.getElementById(selector);
+    if (!el)
+      return null;
+  }
+  return el;
+}, SuperToolbar, Schema3 = class Schema4 {
   static createSchemaByExtensions(extensions, editor) {
     const nodeExtensions = extensions.filter((e) => e.type === "node");
     const markExtensions = extensions.filter((e) => e.type === "mark");
@@ -284645,7 +285770,7 @@ var Node$13 = class Node$14 {
       if (isolatingDepth > 0) {
         const boundary = forward ? $head.before(isolatingDepth) : $head.after(isolatingDepth);
         const near = Selection.near(doc$12.resolve(boundary), forward ? -1 : 1);
-        if (near instanceof TextSelection2)
+        if (near instanceof TextSelection)
           return near.head;
         return anchor;
       }
@@ -284992,7 +286117,7 @@ var Node$13 = class Node$14 {
       const resolved = this.#resolveStructuredContentInlineFromElement(doc$12, inlineStructuredContentLabel);
       if (resolved) {
         try {
-          const tr = editor.state.tr.setSelection(TextSelection2.create(doc$12, resolved.start, resolved.end));
+          const tr = editor.state.tr.setSelection(TextSelection.create(doc$12, resolved.start, resolved.end));
           editor.view?.dispatch(tr);
         } catch {}
         this.#callbacks.scheduleSelectionUpdate?.();
@@ -285006,7 +286131,7 @@ var Node$13 = class Node$14 {
       if (resolved) {
         try {
           const contentRange = this.#findStructuredContentBlockContentRange(resolved);
-          const selection = contentRange != null ? TextSelection2.create(doc$12, contentRange.from, contentRange.to) : NodeSelection.create(editor.state.doc, resolved.pos);
+          const selection = contentRange != null ? TextSelection.create(doc$12, contentRange.from, contentRange.to) : NodeSelection.create(editor.state.doc, resolved.pos);
           const tr = editor.state.tr.setSelection(selection);
           editor.view?.dispatch(tr);
         } catch {}
@@ -285097,12 +286222,12 @@ var Node$13 = class Node$14 {
         if (sdtBlock)
           nextSelection = NodeSelection.create(doc$12, sdtBlock.pos);
         else {
-          nextSelection = TextSelection2.create(doc$12, hit.pos);
+          nextSelection = TextSelection.create(doc$12, hit.pos);
           if (!nextSelection.$from.parent.inlineContent)
             nextSelection = Selection.near(doc$12.resolve(hit.pos), 1);
         }
         const tr = editor.state.tr.setSelection(nextSelection);
-        if (nextSelection instanceof TextSelection2 && nextSelection.empty && editor.state.storedMarks)
+        if (nextSelection instanceof TextSelection && nextSelection.empty && editor.state.storedMarks)
           tr.setStoredMarks(editor.state.storedMarks);
         editor.view?.dispatch(tr);
       } catch {}
@@ -285532,7 +286657,7 @@ var Node$13 = class Node$14 {
     const anchor = editor.state.selection.anchor;
     const { selAnchor, selHead } = this.#calculateExtendedSelection(anchor, headPos, this.#dragExtensionMode);
     try {
-      const tr = editor.state.tr.setSelection(TextSelection2.create(editor.state.doc, selAnchor, selHead));
+      const tr = editor.state.tr.setSelection(TextSelection.create(editor.state.doc, selAnchor, selHead));
       editor.view?.dispatch(tr);
       this.#callbacks.scheduleSelectionUpdate?.();
     } catch (error3) {
@@ -285615,7 +286740,7 @@ var Node$13 = class Node$14 {
       head = this.#clampHeadAtIsolatingBoundary(doc$12, anchor, head);
     const { selAnchor, selHead } = this.#calculateExtendedSelection(anchor, head, this.#dragExtensionMode);
     try {
-      const tr = editor.state.tr.setSelection(TextSelection2.create(editor.state.doc, selAnchor, selHead));
+      const tr = editor.state.tr.setSelection(TextSelection.create(editor.state.doc, selAnchor, selHead));
       editor.view?.dispatch(tr);
       this.#callbacks.scheduleSelectionUpdate?.();
     } catch (error3) {
@@ -285646,7 +286771,7 @@ var Node$13 = class Node$14 {
       const head = hit.pos;
       const { selAnchor, selHead } = this.#calculateExtendedSelection(anchor, head, this.#dragExtensionMode);
       try {
-        const tr = editor.state.tr.setSelection(TextSelection2.create(editor.state.doc, selAnchor, selHead));
+        const tr = editor.state.tr.setSelection(TextSelection.create(editor.state.doc, selAnchor, selHead));
         editor.view?.dispatch(tr);
         this.#callbacks.scheduleSelectionUpdate?.();
       } catch {}
@@ -285693,7 +286818,7 @@ var Node$13 = class Node$14 {
     if (pendingMarginClick.kind === "aboveFirstLine") {
       const pos = this.#getFirstTextPosition();
       try {
-        const tr = editor.state.tr.setSelection(TextSelection2.create(doc$12, pos));
+        const tr = editor.state.tr.setSelection(TextSelection.create(doc$12, pos));
         editor.view?.dispatch(tr);
         this.#callbacks.scheduleSelectionUpdate?.();
       } catch {}
@@ -285717,7 +286842,7 @@ var Node$13 = class Node$14 {
       }
       const caretPos = Math.max(0, Math.min(mappedEnd$1.pos, doc$12.content.size));
       try {
-        const tr = editor.state.tr.setSelection(TextSelection2.create(doc$12, caretPos));
+        const tr = editor.state.tr.setSelection(TextSelection.create(doc$12, caretPos));
         editor.view?.dispatch(tr);
         this.#callbacks.scheduleSelectionUpdate?.();
       } catch {}
@@ -285742,7 +286867,7 @@ var Node$13 = class Node$14 {
     const selFrom = Math.max(0, Math.min(Math.min(mappedStart.pos, mappedEnd.pos), doc$12.content.size));
     const selTo = Math.max(0, Math.min(Math.max(mappedStart.pos, mappedEnd.pos), doc$12.content.size));
     try {
-      const tr = editor.state.tr.setSelection(TextSelection2.create(doc$12, selFrom, selTo));
+      const tr = editor.state.tr.setSelection(TextSelection.create(doc$12, selFrom, selTo));
       editor.view?.dispatch(tr);
       this.#callbacks.scheduleSelectionUpdate?.();
     } catch {}
@@ -285780,7 +286905,7 @@ var Node$13 = class Node$14 {
     const doc$12 = editor?.state?.doc;
     if (doc$12)
       try {
-        const tr = editor.state.tr.setSelection(TextSelection2.create(doc$12, validPos));
+        const tr = editor.state.tr.setSelection(TextSelection.create(doc$12, validPos));
         editor.view?.dispatch(tr);
       } catch {}
     editorDom.focus();
@@ -286278,10 +287403,10 @@ var Node$13 = class Node$14 {
       return;
     const pos = Math.min(Math.max(hit.pos, 1), doc$12.content.size);
     const currentSelection = activeEditor.state.selection;
-    if (currentSelection instanceof TextSelection2 && currentSelection.from === pos && currentSelection.to === pos)
+    if (currentSelection instanceof TextSelection && currentSelection.from === pos && currentSelection.to === pos)
       return;
     try {
-      const tr = activeEditor.state.tr.setSelection(TextSelection2.create(doc$12, pos)).setMeta("addToHistory", false);
+      const tr = activeEditor.state.tr.setSelection(TextSelection.create(doc$12, pos)).setMeta("addToHistory", false);
       activeEditor.view?.dispatch(tr);
       this.#deps.scheduleSelectionUpdate();
     } catch {}
@@ -286335,7 +287460,7 @@ var Node$13 = class Node$14 {
       return;
     const clampedPos = Math.min(Math.max(pos, 1), doc$12.content.size);
     try {
-      const tr = activeEditor.state.tr.setSelection(TextSelection2.create(doc$12, clampedPos)).setMeta("addToHistory", false);
+      const tr = activeEditor.state.tr.setSelection(TextSelection.create(doc$12, clampedPos)).setMeta("addToHistory", false);
       activeEditor.view?.dispatch(tr);
     } catch {}
   }
@@ -286416,7 +287541,7 @@ var Node$13 = class Node$14 {
     if (attributes && isValidFieldAnnotationAttributes(attributes)) {
       activeEditor.commands?.addFieldAnnotation?.(pos, attributes, true);
       const posAfter = Math.min(pos + 1, activeEditor.state?.doc?.content.size ?? pos + 1);
-      const tr = activeEditor.state?.tr.setSelection(TextSelection2.create(activeEditor.state.doc, posAfter));
+      const tr = activeEditor.state?.tr.setSelection(TextSelection.create(activeEditor.state.doc, posAfter));
       if (tr)
         activeEditor.view?.dispatch(tr);
       this.#deps.scheduleSelectionUpdate();
@@ -288158,12 +289283,12 @@ var Node$13 = class Node$14 {
     return;
   console.log(...args$1);
 }, HEADER_FOOTER_INIT_BUDGET_MS = 200, MAX_ZOOM_WARNING_THRESHOLD = 10, MAX_SELECTION_RECTS_PER_USER = 100, SEMANTIC_RESIZE_DEBOUNCE_MS = 120, MIN_SEMANTIC_CONTENT_WIDTH_PX = 1, GLOBAL_PERFORMANCE, PresentationEditor, ICONS, TEXTS, tableActionsOptions;
-var init_src_DjgWBzME_es = __esm(() => {
+var init_src_DlMaB1h_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
   init_SuperConverter_BgwP1GeS_es();
   init_jszip_C49i9kUs_es();
   init_uuid_qzgm05fK_es();
-  init_create_headless_toolbar_zEz71NHQ_es();
+  init_create_headless_toolbar_Dcw4Hyt2_es();
   init_constants_CGhJRd87_es();
   init_dist_B8HfvhaK_es();
   init_unified_Dsuw2be5_es();
@@ -288835,7 +289960,7 @@ ${err.toString()}`);
                 }));
                 if (!selection.empty && !this.editor.options.element?.contains(target)) {
                   this.editor.setOptions({ lastSelection: selection });
-                  const clearSelectionTr = view.state.tr.setSelection(TextSelection2.create(view.state.doc, 0));
+                  const clearSelectionTr = view.state.tr.setSelection(TextSelection.create(view.state.doc, 0));
                   view.dispatch(clearSelectionTr);
                 }
               }
@@ -290206,7 +291331,7 @@ ${err.toString()}`);
                 fragments.push(runType.create(parentRun.attrs, rightContent, parentRun.marks));
               tr.replaceWith(runStart, runEnd, fragments);
               const cursorPos = runStart + (leftContent.size > 0 ? leftContent.size + 2 : 0) + node3.nodeSize;
-              tr.setSelection(TextSelection2.create(tr.doc, cursorPos));
+              tr.setSelection(TextSelection.create(tr.doc, cursorPos));
             } else
               tr.replaceWith(from$1, to, node3);
           }
@@ -290785,7 +291910,7 @@ ${err.toString()}`);
       return null;
     const tr = newState.tr;
     toDelete.sort((a2, b$1) => b$1.from - a2.from).forEach(({ from: from$1, to }) => tr.deleteRange(from$1, to));
-    if (tr.selection instanceof TextSelection2 && tr.selection.empty && newState.storedMarks !== null)
+    if (tr.selection instanceof TextSelection && tr.selection.empty && newState.storedMarks !== null)
       tr.setStoredMarks(newState.storedMarks);
     return tr.docChanged ? tr : null;
   } });
@@ -291147,7 +292272,7 @@ ${err.toString()}`);
           if (findParentNode(isList)(state.selection))
             return null;
           const { tr } = state;
-          tr.delete(range.from, range.to).setSelection(TextSelection2.create(tr.doc, range.from));
+          tr.delete(range.from, range.to).setSelection(TextSelection.create(tr.doc, range.from));
           ListHelpers.createNewList({
             listType: type,
             tr,
@@ -291604,7 +292729,7 @@ ${err.toString()}`);
           const { from: from$1 } = findRangeById(state.doc, id2) || {};
           if (from$1 != null) {
             const tr = state.tr;
-            tr.setSelection(TextSelection2.create(state.doc, from$1));
+            tr.setSelection(TextSelection.create(state.doc, from$1));
             if (options.activeCommentId)
               tr.setMeta(CommentsPluginKey, {
                 type: "setActiveComment",
@@ -292299,7 +293424,7 @@ ${err.toString()}`);
               const { from: from$1, to, tablePos } = structuredContentInsertion;
               tr.replaceWith(from$1, to, node3);
               const selectionPos$1 = getFirstTableCellTextPos(tablePos, node3);
-              tr.scrollIntoView().setSelection(TextSelection2.near(tr.doc.resolve(selectionPos$1)));
+              tr.scrollIntoView().setSelection(TextSelection.near(tr.doc.resolve(selectionPos$1)));
               return true;
             }
             let offset$1;
@@ -292329,7 +293454,7 @@ ${err.toString()}`);
             if (!inserted)
               return false;
             const selectionPos = getFirstTableCellTextPos(offset$1, node3);
-            tr.scrollIntoView().setSelection(TextSelection2.near(tr.doc.resolve(selectionPos)));
+            tr.scrollIntoView().setSelection(TextSelection.near(tr.doc.resolve(selectionPos)));
           }
           return true;
         },
@@ -305812,7 +306937,7 @@ function print() { __p += __j.call(arguments, '') }
             if (typeof from$1 !== "number" || typeof to !== "number")
               return false;
             editor.view.focus();
-            const tr$1 = state.tr.setSelection(TextSelection2.create(state.doc, from$1, to)).scrollIntoView();
+            const tr$1 = state.tr.setSelection(TextSelection.create(state.doc, from$1, to)).scrollIntoView();
             if (dispatch)
               dispatch(tr$1);
             const presentationEditor$1 = editor.presentationEditor;
@@ -305835,7 +306960,7 @@ function print() { __p += __j.call(arguments, '') }
             return false;
           const firstDeco = decorations[0];
           editor.view.focus();
-          const tr = state.tr.setSelection(TextSelection2.create(state.doc, firstDeco.from, firstDeco.to)).scrollIntoView();
+          const tr = state.tr.setSelection(TextSelection.create(state.doc, firstDeco.from, firstDeco.to)).scrollIntoView();
           if (dispatch)
             dispatch(tr);
           const presentationEditor = editor.presentationEditor;
@@ -305902,7 +307027,7 @@ function print() { __p += __j.call(arguments, '') }
           from$1 = normalized.from;
           to = normalized.to;
           editor.view.focus();
-          const tr = state.tr.setSelection(TextSelection2.create(state.doc, from$1, to)).scrollIntoView();
+          const tr = state.tr.setSelection(TextSelection.create(state.doc, from$1, to)).scrollIntoView();
           if (dispatch)
             dispatch(tr);
           const presentationEditor = editor.presentationEditor;
@@ -306633,7 +307758,7 @@ function print() { __p += __j.call(arguments, '') }
             if (selectionState.value) {
               const { state } = props.editor;
               const { from: from$1, to } = selectionState.value;
-              const tr = state.tr.setSelection(TextSelection2.create(state.doc, from$1, to));
+              const tr = state.tr.setSelection(TextSelection.create(state.doc, from$1, to));
               props.editor.view.dispatch(tr);
             } else
               console.warn("[AIWriter] No stored selection to restore");
@@ -307271,7 +308396,7 @@ function print() { __p += __j.call(arguments, '') }
             text: finalText
           });
         const endPos = editor.view.state.selection.$to.pos;
-        editor.view.dispatch(editor.view.state.tr.setSelection(new TextSelection2(editor.view.state.doc.resolve(endPos))));
+        editor.view.dispatch(editor.view.state.tr.setSelection(new TextSelection(editor.view.state.doc.resolve(endPos))));
         setTimeout(() => editor.view.focus(), 100);
         props.closePopover();
       };
@@ -307898,6 +309023,52 @@ function print() { __p += __j.call(arguments, '') }
       props: { "data-item": "btn-fontSize-option" }
     }
   ];
+  HEADLESS_ITEM_MAP = {
+    undo: "undo",
+    redo: "redo",
+    bold: "bold",
+    italic: "italic",
+    underline: "underline",
+    strike: "strikethrough",
+    acceptTrackedChangeBySelection: "track-changes-accept-selection",
+    rejectTrackedChangeOnSelection: "track-changes-reject-selection",
+    ruler: "ruler",
+    zoom: "zoom",
+    documentMode: "document-mode",
+    link: "link",
+    fontFamily: "font-family",
+    fontSize: "font-size",
+    list: "bullet-list",
+    numberedlist: "numbered-list",
+    table: "table-insert",
+    image: "image",
+    color: "text-color",
+    highlight: "highlight-color",
+    textAlign: "text-align",
+    lineHeight: "line-height",
+    linkedStyles: "linked-style",
+    indentleft: "indent-decrease",
+    indentright: "indent-increase",
+    clearFormatting: "clear-formatting",
+    copyFormat: "copy-format"
+  };
+  TABLE_ACTION_COMMAND_MAP = {
+    addRowBefore: "table-add-row-before",
+    addRowAfter: "table-add-row-after",
+    deleteRow: "table-delete-row",
+    addColumnBefore: "table-add-column-before",
+    addColumnAfter: "table-add-column-after",
+    deleteColumn: "table-delete-column",
+    deleteTable: "table-delete",
+    deleteCellAndTableBorders: "table-remove-borders",
+    mergeCells: "table-merge-cells",
+    splitCell: "table-split-cell",
+    fixTables: "table-fix"
+  };
+  TABLE_ACTION_COMMAND_IDS = Object.values(TABLE_ACTION_COMMAND_MAP);
+  HEADLESS_TOOLBAR_COMMANDS = [...new Set([...Object.values(HEADLESS_ITEM_MAP), ...TABLE_ACTION_COMMAND_IDS])];
+  NON_HEADLESS_EXECUTE_ITEM_NAMES = new Set(["link"]);
+  HEADLESS_EXECUTE_ITEMS = new Set(Object.keys(HEADLESS_ITEM_MAP).filter((itemName) => !NON_HEADLESS_EXECUTE_ITEM_NAMES.has(itemName)));
   _hoisted_1$11 = { class: "toolbar-icon" };
   _hoisted_2$7 = ["innerHTML"];
   ToolbarButtonIcon_default = /* @__PURE__ */ __plugin_vue_export_helper_default({
@@ -309281,11 +310452,13 @@ function print() { __p += __j.call(arguments, '') }
       };
       this.toolbarItems = [];
       this.overflowItems = [];
-      this.documentMode = config2.documentMode || "editing";
       this.isDev = config2.isDev || false;
       this.superdoc = config2.superdoc;
       this.role = config2.role || "editor";
       this.toolbarContainer = null;
+      this.controller = null;
+      this.snapshot = null;
+      this._unsubscribeController = null;
       if (this.config.editor)
         this.config.mode = this.config.editor.options.mode;
       this.config.icons = {
@@ -309308,7 +310481,7 @@ function print() { __p += __j.call(arguments, '') }
       this._restoreFocusTimeoutId = null;
       if (!this.config.selector && this.config.element)
         this.config.selector = this.config.element;
-      this.toolbarContainer = this.findElementBySelector(this.config.selector);
+      this.toolbarContainer = findElementBySelector(this.config.selector);
       if (this.toolbarContainer) {
         const uiFontFamily = (this.config?.uiDisplayFallbackFont || "").toString().trim() || "Arial, Helvetica, sans-serif";
         this.toolbarContainer.style.setProperty("--sd-ui-font-family", uiFontFamily);
@@ -309330,215 +310503,39 @@ function print() { __p += __j.call(arguments, '') }
       if (this.toolbarContainer)
         this.toolbar = this.app.mount(this.toolbarContainer);
       this.activeEditor = config2.editor || null;
+      this.initHeadlessToolbar();
       this.updateToolbarState();
     }
-    findElementBySelector(selector) {
-      let el = null;
-      if (selector) {
-        if (selector.startsWith("#") || selector.startsWith("."))
-          el = document.querySelector(selector);
-        else
-          el = document.getElementById(selector);
-        if (!el)
-          return null;
-      }
-      return el;
+    createHeadlessToolbar() {
+      if (!this.superdoc)
+        return null;
+      return createHeadlessToolbar({
+        superdoc: this.superdoc,
+        commands: HEADLESS_TOOLBAR_COMMANDS
+      });
+    }
+    initHeadlessToolbar() {
+      if (!this.superdoc)
+        return;
+      this.destroyHeadlessToolbar();
+      this.controller = this.createHeadlessToolbar();
+      this.snapshot = this.controller.getSnapshot();
+      this._unsubscribeController = this.controller.subscribe(({ snapshot: snapshot2 }) => {
+        this.snapshot = snapshot2;
+        this.updateToolbarState();
+      });
+    }
+    destroyHeadlessToolbar() {
+      this._unsubscribeController?.();
+      this.controller?.destroy();
+      this.controller = null;
+      this.snapshot = null;
+      this._unsubscribeController = null;
     }
     #initToolbarGroups() {
       if (this.config.groups && !Array.isArray(this.config.groups) && Object.keys(this.config.groups).length)
         this.config.toolbarGroups = Object.keys(this.config.groups);
     }
-    #interceptedCommands = {
-      setZoom: ({ item, argument }) => {
-        if (!argument)
-          return;
-        item.onActivate({ zoom: argument });
-        this.emit("superdoc-command", {
-          item,
-          argument
-        });
-        this.superdoc.superdocStore.activeZoom = parseInt(argument, 10);
-      },
-      setDocumentMode: ({ item, argument }) => {
-        if (!argument)
-          return;
-        this.emit("superdoc-command", {
-          item,
-          argument
-        });
-      },
-      setFontSize: ({ item, argument }) => {
-        if (this.#isFieldAnnotationSelection() && argument) {
-          this.activeEditor?.commands.setFieldAnnotationsFontSize(argument, true);
-          this.updateToolbarState();
-          return;
-        }
-        this.#runCommandWithArgumentOnly({
-          item,
-          argument
-        }, () => {
-          this.activeEditor?.commands.setFieldAnnotationsFontSize(argument, true);
-        });
-      },
-      setFontFamily: ({ item, argument }) => {
-        if (this.#isFieldAnnotationSelection() && argument) {
-          this.activeEditor?.commands.setFieldAnnotationsFontFamily(argument, true);
-          this.updateToolbarState();
-          return;
-        }
-        this.#runCommandWithArgumentOnly({
-          item,
-          argument
-        }, () => {
-          this.activeEditor?.commands.setFieldAnnotationsFontFamily(argument, true);
-        });
-      },
-      setColor: ({ argument }) => {
-        if (!argument || !this.activeEditor)
-          return;
-        const isNone = argument === "none";
-        const value = isNone ? "inherit" : argument;
-        if (this.activeEditor?.commands?.setColor)
-          this.activeEditor.commands.setColor(value);
-        const argValue = isNone ? null : argument;
-        this.activeEditor?.commands.setFieldAnnotationsTextColor(argValue, true);
-        this.updateToolbarState();
-      },
-      setHighlight: ({ argument }) => {
-        if (!argument || !this.activeEditor)
-          return;
-        const inlineColor = argument !== "none" ? argument : "transparent";
-        if (this.activeEditor?.commands?.setHighlight)
-          this.activeEditor.commands.setHighlight(inlineColor);
-        const argValue = argument !== "none" ? argument : null;
-        this.activeEditor?.commands.setFieldAnnotationsTextHighlight(argValue, true);
-        this.activeEditor?.commands.setCellBackground(argValue);
-        this.updateToolbarState();
-      },
-      toggleRuler: () => {
-        this.superdoc.toggleRuler();
-        this.updateToolbarState();
-      },
-      startImageUpload: async () => {
-        try {
-          let result = await getFileOpener()();
-          if (!result?.file)
-            return;
-          await processAndInsertImageFile({
-            file: result.file,
-            editor: this.activeEditor,
-            view: this.activeEditor.view,
-            editorOptions: this.activeEditor.options,
-            getMaxContentSize: () => this.activeEditor.getMaxContentSize()
-          });
-        } catch (error3) {
-          const err = /* @__PURE__ */ new Error("[super-toolbar \uD83C\uDFA8] Image upload failed");
-          this.emit("exception", {
-            error: err,
-            editor: this.activeEditor,
-            originalError: error3
-          });
-          console.error(err, error3);
-        }
-      },
-      increaseTextIndent: ({ item, argument }) => {
-        let command$1 = item.command;
-        if (this.activeEditor.commands.increaseListIndent?.())
-          return true;
-        if (command$1 in this.activeEditor.commands)
-          this.activeEditor.commands[command$1](argument);
-      },
-      decreaseTextIndent: ({ item, argument }) => {
-        let command$1 = item.command;
-        if (this.activeEditor.commands.decreaseListIndent?.())
-          return true;
-        if (command$1 in this.activeEditor.commands)
-          this.activeEditor.commands[command$1](argument);
-      },
-      toggleBold: ({ item, argument }) => {
-        if (this.#isFieldAnnotationSelection()) {
-          this.activeEditor?.commands.toggleFieldAnnotationsFormat("bold", true);
-          this.updateToolbarState();
-          return;
-        }
-        let command$1 = item.command;
-        if (command$1 in this.activeEditor.commands) {
-          this.activeEditor.commands[command$1](argument);
-          this.activeEditor.commands.toggleFieldAnnotationsFormat("bold", true);
-        }
-        this.updateToolbarState();
-      },
-      toggleItalic: ({ item, argument }) => {
-        if (this.#isFieldAnnotationSelection()) {
-          this.activeEditor?.commands.toggleFieldAnnotationsFormat("italic", true);
-          this.updateToolbarState();
-          return;
-        }
-        let command$1 = item.command;
-        if (command$1 in this.activeEditor.commands) {
-          this.activeEditor.commands[command$1](argument);
-          this.activeEditor.commands.toggleFieldAnnotationsFormat("italic", true);
-        }
-        this.updateToolbarState();
-      },
-      toggleUnderline: ({ item, argument }) => {
-        if (this.#isFieldAnnotationSelection()) {
-          this.activeEditor?.commands.toggleFieldAnnotationsFormat("underline", true);
-          this.updateToolbarState();
-          return;
-        }
-        let command$1 = item.command;
-        if (command$1 in this.activeEditor.commands) {
-          this.activeEditor.commands[command$1](argument);
-          this.activeEditor.commands.toggleFieldAnnotationsFormat("underline", true);
-        }
-        this.updateToolbarState();
-      },
-      toggleLink: ({ item, argument }) => {
-        let command$1 = item.command;
-        if (command$1 in this.activeEditor.commands) {
-          this.activeEditor.commands[command$1](argument);
-          const { view } = this.activeEditor;
-          let { selection } = view.state;
-          if (this.activeEditor.options.isHeaderOrFooter)
-            selection = this.activeEditor.options.lastSelection;
-          const endPos = selection.$to.pos;
-          const newSelection = new TextSelection(view.state.doc.resolve(endPos));
-          const tr = view.state.tr.setSelection(newSelection);
-          const state = view.state.apply(tr);
-          view.updateState(state);
-          if (!this.activeEditor.options.isHeaderOrFooter)
-            setTimeout(() => {
-              view.focus();
-            }, 100);
-        }
-        this.updateToolbarState();
-      },
-      insertTable: ({ item, argument }) => {
-        this.#runCommandWithArgumentOnly({
-          item,
-          argument
-        });
-      },
-      executeTableCommand: ({ argument }) => {
-        if (!argument)
-          return;
-        let command$1 = argument.command;
-        if (command$1 in this.activeEditor.commands)
-          this.activeEditor.commands[command$1](argument);
-        this.updateToolbarState();
-      }
-    };
-    log(...args$1) {
-      console.debug("[\uD83C\uDFA8 super-toolbar]", ...args$1);
-    }
-    setZoom(percent_int) {
-      const item = [...this.toolbarItems, ...this.overflowItems].find((item$1) => item$1.name.value === "zoom");
-      this.#interceptedCommands.setZoom({
-        item,
-        argument: percent_int
-      });
-    }
     setActiveEditor(editor) {
       if (this.activeEditor && this._boundEditorHandlers.transaction) {
         this.activeEditor.off("transaction", this._boundEditorHandlers.transaction);
@@ -309626,7 +310623,7 @@ function print() { __p += __j.call(arguments, '') }
       const documentModeItem = this.getToolbarItemByName("documentMode");
       if (!documentModeItem)
         return;
-      const mode = (this.documentMode || "editing").toLowerCase();
+      const mode = (this.snapshot?.commands?.["document-mode"]?.value || "editing").toLowerCase();
       const texts = this.config.texts || {};
       const icons$1 = this.config.icons || {};
       const map$12 = {
@@ -309651,12 +310648,127 @@ function print() { __p += __j.call(arguments, '') }
       if (documentModeItem.icon?.value !== undefined && next2.icon)
         documentModeItem.icon.value = next2.icon;
     }
+    #getFontFamilyFallbackValue() {
+      if (!this.activeEditor?.state)
+        return null;
+      const { state } = this.activeEditor;
+      const selection = state.selection;
+      if (!selection?.empty)
+        return null;
+      const paragraphParent = findParentNode((n) => n.type.name === "paragraph")(selection);
+      if (!paragraphParent || paragraphParent.node?.content?.size !== 0)
+        return null;
+      return getParagraphFontFamilyFromProperties(calculateResolvedParagraphProperties(this.activeEditor, paragraphParent.node, state.doc.resolve(paragraphParent.pos)), this.activeEditor?.converter?.convertedXml ?? {}) || null;
+    }
+    #isFontSizeMixedState(commandState) {
+      return Boolean(commandState?.active) && commandState?.value == null;
+    }
+    #applyHeadlessState(item) {
+      if (item.name.value === "tableActions") {
+        const hasAnyEnabled = TABLE_ACTION_COMMAND_IDS.map((commandId$1) => this.snapshot?.commands?.[commandId$1]).some((state) => state && !state.disabled);
+        item.setDisabled(!hasAnyEnabled);
+        return true;
+      }
+      const commandId = HEADLESS_ITEM_MAP[item.name.value];
+      if (!commandId)
+        return false;
+      const commandState = this.snapshot?.commands?.[commandId];
+      const setDisabled = () => {
+        item.setDisabled(Boolean(commandState?.disabled));
+      };
+      const handlers3 = {
+        textAlign: () => {
+          if (commandState?.value)
+            item.activate({ textAlign: commandState.value });
+          else
+            item.deactivate();
+        },
+        lineHeight: () => {
+          item.selectedValue.value = commandState?.value != null ? commandState.value : "";
+        },
+        zoom: () => {
+          if (commandState?.value != null) {
+            const value = typeof commandState.value === "number" ? `${commandState.value}%` : String(commandState.value);
+            item.onActivate({ zoom: value });
+          }
+        },
+        documentMode: () => {
+          this.#syncDocumentModeUi();
+        },
+        link: () => {
+          item.active.value = Boolean(commandState?.active);
+          item.attributes.value = commandState?.value ? { href: commandState.value } : {};
+        },
+        fontFamily: () => {
+          if (commandState?.value != null) {
+            item.activate({ fontFamily: commandState.value });
+            return;
+          }
+          const fallbackFontFamily = this.#getFontFamilyFallbackValue();
+          if (fallbackFontFamily) {
+            item.activate({ fontFamily: fallbackFontFamily });
+            return;
+          }
+          item.deactivate();
+        },
+        fontSize: () => {
+          if (commandState?.value != null) {
+            item.activate({ fontSize: commandState.value });
+            return;
+          }
+          if (this.#isFontSizeMixedState(commandState)) {
+            item.activate({}, true);
+            return;
+          }
+          item.deactivate();
+        },
+        color: () => {
+          if (commandState?.value != null)
+            item.activate({ color: commandState.value });
+          else
+            item.deactivate();
+        },
+        highlight: () => {
+          if (commandState?.value != null)
+            item.activate({ color: commandState.value });
+          else
+            item.deactivate();
+        },
+        linkedStyles: () => {
+          if (commandState?.value != null)
+            item.activate({ styleId: commandState.value });
+          else
+            item.label.value = this.config.texts?.formatText || "Format text";
+        },
+        default: () => {
+          if (commandState?.active)
+            item.activate();
+          else
+            item.deactivate();
+        }
+      };
+      const handler2 = handlers3[item.name.value] ?? handlers3.default;
+      setDisabled();
+      handler2();
+      return true;
+    }
+    #executeHeadlessCommand(item, argument) {
+      const isTableActions = item?.name?.value === "tableActions";
+      const commandId = isTableActions ? TABLE_ACTION_COMMAND_MAP[argument?.command] : HEADLESS_ITEM_MAP[item?.name?.value];
+      if (!commandId || !this.controller?.execute)
+        return false;
+      if (isTableActions)
+        this.controller.execute(commandId);
+      else
+        this.controller.execute(commandId, argument);
+      return true;
+    }
     updateToolbarState() {
       this.#syncDocumentModeUi();
-      this.#updateToolbarHistory();
       this.#initDefaultFonts();
       this.#updateHighlightColors();
-      if (!this.activeEditor || this.documentMode === "viewing") {
+      const currentMode = this.snapshot?.commands?.["document-mode"]?.value || "editing";
+      if (!this.activeEditor || currentMode === "viewing") {
         this.#deactivateAll();
         return;
       }
@@ -309665,96 +310777,9 @@ function print() { __p += __j.call(arguments, '') }
         this.#deactivateAll();
         return;
       }
-      const selection = state.selection;
-      const selectionTrackedChanges = this.#enrichTrackedChanges(collectTrackedChanges({
-        state,
-        from: selection.from,
-        to: selection.to
-      }));
-      const hasValidSelection = selectionTrackedChanges.length > 0;
-      const canAcceptTrackedChanges = hasValidSelection && isTrackedChangeActionAllowed({
-        editor: this.activeEditor,
-        action: "accept",
-        trackedChanges: selectionTrackedChanges
-      });
-      const canRejectTrackedChanges = hasValidSelection && isTrackedChangeActionAllowed({
-        editor: this.activeEditor,
-        action: "reject",
-        trackedChanges: selectionTrackedChanges
-      });
-      const marks = getActiveFormatting(this.activeEditor);
-      const inTable = isInTable(this.activeEditor.state);
-      const paragraphParent = findParentNode((n) => n.type.name === "paragraph")(selection);
-      const paragraphProps = paragraphParent ? calculateResolvedParagraphProperties(this.activeEditor, paragraphParent.node, state.doc.resolve(paragraphParent.pos)) : null;
-      const selectionIsCollapsed = selection.empty;
-      const paragraphIsEmpty = paragraphParent?.node?.content?.size === 0;
-      const paragraphFontFamily = getParagraphFontFamilyFromProperties(paragraphProps, this.activeEditor?.converter?.convertedXml ?? {});
       this.toolbarItems.forEach((item) => {
         item.resetDisabled();
-        let activatedFromLinkedStyle = false;
-        if (item.name.value === "undo")
-          item.setDisabled(this.undoDepth === 0);
-        if (item.name.value === "redo")
-          item.setDisabled(this.redoDepth === 0);
-        if (item.name.value === "acceptTrackedChangeBySelection")
-          item.setDisabled(!canAcceptTrackedChanges);
-        if (item.name.value === "rejectTrackedChangeOnSelection")
-          item.setDisabled(!canRejectTrackedChanges);
-        if (item.name.value === "linkedStyles")
-          if (this.activeEditor && !getQuickFormatList(this.activeEditor).length)
-            return item.deactivate();
-          else
-            return item.activate({ styleId: paragraphProps?.styleId || null });
-        const rawActiveMark = marks.find((mark2) => mark2.name === item.name.value);
-        const markNegated = rawActiveMark ? isNegatedMark(rawActiveMark.name, rawActiveMark.attrs) : false;
-        const activeMark = markNegated ? null : rawActiveMark;
-        if (activeMark)
-          if (activeMark.name === "fontSize") {
-            const fontSizes = marks.filter((i4) => i4.name === "fontSize").map((i4) => i4.attrs.fontSize);
-            const isMultiple = [...new Set(fontSizes)].length > 1;
-            item.activate(activeMark.attrs, isMultiple);
-          } else
-            item.activate(activeMark.attrs);
-        else
-          item.deactivate();
-        if (!activeMark && !markNegated && paragraphParent && paragraphProps?.styleId) {
-          const markToStyleMap = {
-            fontSize: "font-size",
-            fontFamily: "font-family",
-            bold: "bold"
-          };
-          const linkedStyles = this.activeEditor.converter?.linkedStyles.find((style2) => style2.id === paragraphProps.styleId);
-          if (linkedStyles && linkedStyles.definition && linkedStyles.definition.styles && markToStyleMap[item.name.value] in linkedStyles.definition.styles) {
-            const linkedStylesItem = linkedStyles.definition.styles[markToStyleMap[item.name.value]];
-            const value = { [item.name.value]: linkedStylesItem };
-            item.activate(value);
-            activatedFromLinkedStyle = true;
-          }
-        }
-        if (item.name.value === "textAlign" && paragraphProps?.justification)
-          item.activate({ textAlign: paragraphProps.justification });
-        if (item.name.value === "fontFamily" && selectionIsCollapsed && paragraphIsEmpty && !activeMark && !markNegated && !activatedFromLinkedStyle && paragraphFontFamily)
-          item.activate({ fontFamily: paragraphFontFamily });
-        if (item.name.value === "lineHeight")
-          if (paragraphProps?.spacing)
-            item.selectedValue.value = twipsToLines(paragraphProps.spacing.line);
-          else
-            item.selectedValue.value = "";
-        if (item.name.value === "tableActions")
-          item.disabled.value = !inTable;
-        const listParent = isList(paragraphParent?.node) ? paragraphParent.node : null;
-        if (listParent) {
-          const numberingType = listParent.attrs.listRendering.numberingType;
-          if (item.name.value === "list" && numberingType === "bullet")
-            item.activate();
-          else if (item.name.value === "numberedlist" && numberingType !== "bullet")
-            item.activate();
-        }
-        if (item.name.value === "ruler")
-          if (this.superdoc?.config?.rulers)
-            item.activate();
-          else
-            item.deactivate();
+        this.#applyHeadlessState(item);
       });
     }
     onToolbarResize = () => {
@@ -309779,48 +310804,22 @@ function print() { __p += __j.call(arguments, '') }
         item.setDisabled(true);
       });
     }
-    #updateToolbarHistory() {
-      if (!this.activeEditor?.state)
-        return;
-      try {
-        if (this.activeEditor.options.ydoc) {
-          const undoManager = yUndoPluginKey.getState(this.activeEditor.state)?.undoManager;
-          this.undoDepth = undoManager?.undoStack.length || 0;
-          this.redoDepth = undoManager?.redoStack.length || 0;
-        } else {
-          this.undoDepth = undoDepth(this.activeEditor.state);
-          this.redoDepth = redoDepth(this.activeEditor.state);
-        }
-      } catch {
-        this.undoDepth = 0;
-        this.redoDepth = 0;
-      }
-    }
-    #enrichTrackedChanges(trackedChanges = []) {
-      if (!trackedChanges?.length)
-        return trackedChanges;
-      const store = this.superdoc?.commentsStore;
-      if (!store?.getComment)
-        return trackedChanges;
-      return trackedChanges.map((change) => {
-        const commentId = change.id;
-        if (!commentId)
-          return change;
-        const storeComment = store.getComment(commentId);
-        if (!storeComment)
-          return change;
-        const comment2 = typeof storeComment.getValues === "function" ? storeComment.getValues() : storeComment;
-        return {
-          ...change,
-          comment: comment2
-        };
-      });
-    }
     onEditorTransaction({ transaction }) {
       if (!transaction.docChanged && !transaction.selectionSet)
         return;
       this.updateToolbarState();
     }
+    #scheduleRestoreEditorFocus() {
+      if (!this.activeEditor || this.activeEditor.options.isHeaderOrFooter)
+        return;
+      clearTimeout(this._restoreFocusTimeoutId);
+      this._restoreFocusTimeoutId = setTimeout(() => {
+        this._restoreFocusTimeoutId = null;
+        if (!this.activeEditor || this.activeEditor.options.isHeaderOrFooter)
+          return;
+        this.activeEditor.focus();
+      }, 0);
+    }
     emitCommand({ item, argument, option }) {
       const hasFocusFn = this.activeEditor?.view?.hasFocus;
       const wasFocused = Boolean(typeof hasFocusFn === "function" && hasFocusFn.call(this.activeEditor.view));
@@ -309851,14 +310850,21 @@ function print() { __p += __j.call(arguments, '') }
         this.activeEditor.focus();
       if (!command$1)
         return;
-      if (command$1 in this.#interceptedCommands) {
-        const result = this.#interceptedCommands[command$1]({
-          item,
-          argument
-        });
-        if (isMarkToggle)
-          this.#syncStickyMarksFromState();
-        return result;
+      if (item?.name?.value === "tableActions") {
+        if (this.#executeHeadlessCommand(item, argument)) {
+          this.updateToolbarState();
+          return;
+        }
+      }
+      if (HEADLESS_EXECUTE_ITEMS.has(item?.name?.value)) {
+        if (this.#executeHeadlessCommand(item, argument)) {
+          if (isMarkToggle)
+            this.#syncStickyMarksFromState();
+          this.updateToolbarState();
+          if (shouldRestoreFocus)
+            this.#scheduleRestoreEditorFocus();
+          return;
+        }
       }
       if (this.activeEditor && this.activeEditor.commands && command$1 in this.activeEditor.commands)
         this.activeEditor.commands[command$1](argument);
@@ -309879,13 +310885,8 @@ function print() { __p += __j.call(arguments, '') }
       if (isMarkToggle)
         this.#syncStickyMarksFromState();
       this.updateToolbarState();
-      if (shouldRestoreFocus && this.activeEditor && !this.activeEditor.options.isHeaderOrFooter)
-        this._restoreFocusTimeoutId = setTimeout(() => {
-          this._restoreFocusTimeoutId = null;
-          if (!this.activeEditor || this.activeEditor.options.isHeaderOrFooter)
-            return;
-          this.activeEditor.focus();
-        }, 0);
+      if (shouldRestoreFocus)
+        this.#scheduleRestoreEditorFocus();
     }
     onEditorSelectionUpdate() {
       if (!this.activeEditor)
@@ -309897,12 +310898,16 @@ function print() { __p += __j.call(arguments, '') }
           if (!command$1)
             return;
           try {
-            if (command$1 in this.#interceptedCommands)
-              this.#interceptedCommands[command$1]({
-                item,
-                argument
-              });
-            else if (this.activeEditor.commands && command$1 in this.activeEditor.commands)
+            if (HEADLESS_EXECUTE_ITEMS.has(item?.name?.value)) {
+              if (this.#executeHeadlessCommand(item, argument)) {
+                this.#ensureStoredMarksForMarkToggle({
+                  command: command$1,
+                  argument
+                });
+                return;
+              }
+            }
+            if (this.activeEditor.commands && command$1 in this.activeEditor.commands)
               this.activeEditor.commands[command$1](argument);
             this.#ensureStoredMarksForMarkToggle({
               command: command$1,
@@ -309937,25 +310942,6 @@ function print() { __p += __j.call(arguments, '') }
       const name = item?.name?.value;
       return SuperToolbar2.#MARK_TOGGLE_NAMES.has(name);
     }
-    #runCommandWithArgumentOnly({ item, argument, noArgumentCallback = false }, callback) {
-      if (!argument || !this.activeEditor)
-        return;
-      let command$1 = item.command;
-      const noArgumentCommand = item.noArgumentCommand;
-      if (argument === "none" && this.activeEditor && this.activeEditor.commands && noArgumentCommand in this.activeEditor.commands) {
-        this.activeEditor.commands[noArgumentCommand]();
-        if (typeof callback === "function" && noArgumentCallback)
-          callback(argument);
-        this.updateToolbarState();
-        return;
-      }
-      if (this.activeEditor && this.activeEditor.commands && command$1 in this.activeEditor.commands) {
-        this.activeEditor.commands[command$1](argument);
-        if (typeof callback === "function")
-          callback(argument);
-        this.updateToolbarState();
-      }
-    }
     #syncStickyMarksFromState() {
       if (!this.activeEditor)
         return;
@@ -310005,15 +310991,12 @@ function print() { __p += __j.call(arguments, '') }
       const tr = state.tr.setStoredMarks([mark2]);
       view.dispatch(tr);
     }
-    #isFieldAnnotationSelection() {
-      const selection = this.activeEditor?.state?.selection;
-      return selection instanceof NodeSelection && selection?.node?.type?.name === "fieldAnnotation";
-    }
     destroy() {
       if (this._restoreFocusTimeoutId !== null) {
         clearTimeout(this._restoreFocusTimeoutId);
         this._restoreFocusTimeoutId = null;
       }
+      this.destroyHeadlessToolbar();
     }
   };
   Commands = Extension.create({
@@ -320832,7 +321815,7 @@ function print() { __p += __j.call(arguments, '') }
       const range = computeWordSelectionRangeAt(state, pos);
       if (!range)
         return false;
-      const tr = state.tr.setSelection(TextSelection2.create(state.doc, range.from, range.to));
+      const tr = state.tr.setSelection(TextSelection.create(state.doc, range.from, range.to));
       try {
         this.#editor.view?.dispatch(tr);
         return true;
@@ -320849,7 +321832,7 @@ function print() { __p += __j.call(arguments, '') }
       const range = computeParagraphSelectionRangeAt(state, pos);
       if (!range)
         return false;
-      const tr = state.tr.setSelection(TextSelection2.create(state.doc, range.from, range.to));
+      const tr = state.tr.setSelection(TextSelection.create(state.doc, range.from, range.to));
       try {
         this.#editor.view?.dispatch(tr);
         return true;
@@ -321672,8 +322655,8 @@ function print() { __p += __j.call(arguments, '') }
       }
       try {
         this.#localSelectionLayer.innerHTML = "";
-        const isFieldAnnotationSelection = selection instanceof NodeSelection && selection.node?.type?.name === "fieldAnnotation";
-        if (domRects.length > 0 && !isFieldAnnotationSelection)
+        const isFieldAnnotationSelection2 = selection instanceof NodeSelection && selection.node?.type?.name === "fieldAnnotation";
+        if (domRects.length > 0 && !isFieldAnnotationSelection2)
           renderSelectionRects({
             localSelectionLayer: this.#localSelectionLayer,
             rects: domRects,
@@ -322104,7 +323087,7 @@ function print() { __p += __j.call(arguments, '') }
       if (current.from === desiredFrom && current.to === desiredTo)
         return;
       try {
-        const tr = this.#editor.state.tr.setSelection(TextSelection2.create(this.#editor.state.doc, selAnchor, selHead));
+        const tr = this.#editor.state.tr.setSelection(TextSelection.create(this.#editor.state.doc, selAnchor, selHead));
         this.#editor.view?.dispatch(tr);
         this.#scheduleSelectionUpdate();
       } catch {}
@@ -322918,11 +323901,11 @@ var init_zipper_DbkgrypV_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_DjgWBzME_es();
+  init_src_DlMaB1h_es();
   init_SuperConverter_BgwP1GeS_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
-  init_create_headless_toolbar_zEz71NHQ_es();
+  init_create_headless_toolbar_Dcw4Hyt2_es();
   init_constants_CGhJRd87_es();
   init_dist_B8HfvhaK_es();
   init_unified_Dsuw2be5_es();