superdoc 1.0.0-beta.15 → 1.0.0-beta.17

package/dist/superdoc.umd.js

@@ -19785,7 +19785,7 @@
       return runProperties;
     }
     marks.forEach((mark2) => {
-      switch (mark2.type) {
+      switch (mark2.type.name ?? mark2.type) {
         case "strike":
         case "italic":
         case "bold":
@@ -20851,6 +20851,11 @@
         runs2.push(trackedClone);
         return;
       }
+      if (child.name === "w:commentRangeStart" || child.name === "w:commentRangeEnd") {
+        const commentRangeClone = cloneXmlNode(child);
+        runs2.push(commentRangeClone);
+        return;
+      }
       const runWrapper = { name: XML_NODE_NAME$i, elements: [] };
       applyBaseRunProps(runWrapper);
       if (!Array.isArray(runWrapper.elements)) runWrapper.elements = [];
@@ -27976,9 +27981,11 @@
     const newAttrs = {
       ...paragraphNode.attrs,
       paragraphProperties: newProperties,
-      numberingProperties: newProperties.numberingProperties,
-      listRendering: null
+      numberingProperties: newProperties.numberingProperties
     };
+    if (!newNumberingProperties) {
+      newAttrs.listRendering = null;
+    }
     tr.setNodeMarkup(pos, null, newAttrs);
   }
   const generateNewListDefinition = ({ numId, listType, level, start: start2, text: text2, fmt, editor }) => {
@@ -28510,13 +28517,36 @@
       extractAndRemoveConditionalPrefix(item);
     });
     transformWordLists(tempDiv, editor);
-    const doc2 = DOMParser$1.fromSchema(editor.schema).parse(tempDiv);
+    let doc2 = DOMParser$1.fromSchema(editor.schema).parse(tempDiv);
+    doc2 = wrapTextsInRuns(doc2);
     tempDiv.remove();
     const { dispatch } = editor.view;
     if (!dispatch) return false;
     dispatch(view.state.tr.replaceSelectionWith(doc2, true));
     return true;
   };
+  const wrapTextsInRuns = (doc2) => {
+    const runType = doc2.type?.schema?.nodes?.run;
+    if (!runType) return doc2;
+    const wrapNode = (node2, parent) => {
+      if (node2.isText) {
+        if (parent?.type?.name === "run") return node2;
+        const runProperties = decodeRPrFromMarks(node2.marks);
+        return runType.create({ runProperties }, [node2]);
+      }
+      if (!node2.childCount) return node2;
+      let changed = false;
+      const wrappedChildren = [];
+      node2.forEach((child) => {
+        const wrappedChild = wrapNode(child, node2);
+        if (wrappedChild !== child) changed = true;
+        wrappedChildren.push(wrappedChild);
+      });
+      if (!changed) return node2;
+      return node2.copy(Fragment$1.fromArray(wrappedChildren));
+    };
+    return wrapNode(doc2, null);
+  };
   const transformWordLists = (container, editor) => {
     const listItems = Array.from(container.querySelectorAll("[data-num-id]"));
     const lists = {};
@@ -28946,7 +28976,8 @@
     tempDiv.innerHTML = cleanedHtml;
     const htmlWithMergedLists = mergeSeparateLists(tempDiv);
     const flattenHtml = flattenListsInHtml(htmlWithMergedLists, editor);
-    const doc2 = DOMParser$1.fromSchema(editor.schema).parse(flattenHtml);
+    let doc2 = DOMParser$1.fromSchema(editor.schema).parse(flattenHtml);
+    doc2 = wrapTextsInRuns(doc2);
     tempDiv.remove();
     const { dispatch } = editor.view;
     if (!dispatch) return false;
@@ -29279,7 +29310,8 @@
   function handleHtmlPaste(html2, editor, source) {
     let cleanedHtml;
     cleanedHtml = htmlHandler(html2, editor);
-    const doc2 = DOMParser$1.fromSchema(editor.schema).parse(cleanedHtml);
+    let doc2 = DOMParser$1.fromSchema(editor.schema).parse(cleanedHtml);
+    doc2 = wrapTextsInRuns(doc2);
     const { dispatch, state: state2 } = editor.view;
     if (!dispatch) return false;
     const { $from } = state2.selection;
@@ -29384,7 +29416,9 @@
     } else {
       parsedContent = content2;
     }
-    return DOMParser$1.fromSchema(editor.schema).parse(parsedContent);
+    let doc2 = DOMParser$1.fromSchema(editor.schema).parse(parsedContent);
+    doc2 = wrapTextsInRuns(doc2);
+    return doc2;
   }
   function L() {
     return { async: false, breaks: false, extensions: null, gfm: true, hooks: null, pedantic: false, renderer: null, silent: false, tokenizer: null, walkTokens: null };
@@ -30508,9 +30542,11 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         para.textContent = content2;
         wrapper.appendChild(para);
         doc2 = DOMParser$1.fromSchema(editor.schema).parse(wrapper);
+        doc2 = wrapTextsInRuns(doc2);
         break;
       case "schema":
         doc2 = editor.schema.nodeFromJSON(content2);
+        doc2 = wrapTextsInRuns(doc2);
         break;
       default:
         throw new Error(`Unknown content type: ${type2}`);
@@ -36267,7 +36303,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     static getStoredSuperdocVersion(docx) {
       return _SuperConverter2.getStoredCustomProperty(docx, "SuperdocVersion");
     }
-    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-beta.15") {
+    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-beta.17") {
       return _SuperConverter2.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
     }
     /**
@@ -55535,6 +55571,83 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     tr.insertText("	", tr.selection.from, tr.selection.to);
     return true;
   };
+  const splitRunToParagraph = () => (props) => {
+    const { state: state2, view, tr } = props;
+    const { $from, empty: empty2 } = state2.selection;
+    if (!empty2) return false;
+    if ($from.parent.type.name !== "run") return false;
+    const handled = splitBlockPatch(state2, (transaction) => {
+      view.dispatch(transaction);
+    });
+    if (handled) {
+      tr.setMeta("preventDispatch", true);
+    }
+    return handled;
+  };
+  function splitBlockPatch(state2, dispatch) {
+    let { $from } = state2.selection;
+    if (state2.selection instanceof NodeSelection && state2.selection.node.isBlock) {
+      if (!$from.parentOffset || !canSplit(state2.doc, $from.pos)) return false;
+      if (dispatch) dispatch(state2.tr.split($from.pos).scrollIntoView());
+      return true;
+    }
+    if (!$from.depth) return false;
+    let types2 = [];
+    let splitDepth, deflt, atEnd = false, atStart = false;
+    for (let d2 = $from.depth; ; d2--) {
+      let node2 = $from.node(d2);
+      if (node2.isBlock) {
+        atEnd = $from.end(d2) == $from.pos + ($from.depth - d2);
+        atStart = $from.start(d2) == $from.pos - ($from.depth - d2);
+        deflt = defaultBlockAt$1($from.node(d2 - 1).contentMatchAt($from.indexAfter(d2 - 1)));
+        types2.unshift(null);
+        splitDepth = d2;
+        break;
+      } else {
+        if (d2 == 1) return false;
+        types2.unshift(null);
+      }
+    }
+    let tr = state2.tr;
+    if (state2.selection instanceof TextSelection$1 || state2.selection instanceof AllSelection) tr.deleteSelection();
+    let splitPos = tr.mapping.map($from.pos);
+    let can = canSplit(tr.doc, splitPos, types2.length, types2);
+    if (!can) {
+      types2[0] = deflt ? { type: deflt } : null;
+      can = canSplit(tr.doc, splitPos, types2.length, types2);
+    }
+    if (!can) return false;
+    tr.split(splitPos, types2.length, types2);
+    if (!atEnd && atStart && $from.node(splitDepth).type != deflt) {
+      let first2 = tr.mapping.map($from.before(splitDepth)), $first = tr.doc.resolve(first2);
+      if (deflt && $from.node(splitDepth - 1).canReplaceWith($first.index(), $first.index() + 1, deflt))
+        tr.setNodeMarkup(tr.mapping.map($from.before(splitDepth)), deflt);
+    }
+    if (dispatch) dispatch(tr.scrollIntoView());
+    return true;
+  }
+  const splitRunAtCursor = () => (props) => {
+    let { state: state2, dispatch, tr } = props;
+    const sel = state2.selection;
+    if (!sel.empty) return false;
+    const $pos = sel.$from;
+    const runType = state2.schema.nodes.run;
+    if ($pos.parent.type !== runType) return false;
+    const run2 = $pos.parent;
+    const offset2 = $pos.parentOffset;
+    const runStart = $pos.before();
+    const runEnd = runStart + run2.nodeSize;
+    const leftFrag = run2.content.cut(0, offset2);
+    const rightFrag = run2.content.cut(offset2);
+    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(TextSelection$1.create(tr.doc, gapPos));
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  };
   const insertTabCharacter = ({ tr, state: state2, dispatch }) => {
     const { from: from2 } = tr.selection;
     const tabText = state2.schema.text("	");
@@ -55544,10 +55657,23 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     return true;
   };
   const insertTabNode = () => ({ tr, state: state2, dispatch }) => {
-    const newPos = tr.selection.from;
+    let newPos = tr.selection.from;
     const tabNode = state2.schema?.nodes?.tab?.create();
     if (!tabNode) return insertTabCharacter({ tr, state: state2, dispatch });
+    const { from: from2 } = tr.selection;
+    const $pos = tr.doc.resolve(from2);
+    if ($pos.parent.type === state2.schema.nodes.run) {
+      if (from2 === $pos.end()) {
+        newPos = $pos.end() + 1;
+      } else if (from2 === $pos.start()) {
+        newPos = $pos.start() - 1;
+      } else {
+        splitRunAtCursor()({ tr, state: state2 });
+        newPos = tr.selection.from;
+      }
+    }
     tr.insert(newPos, tabNode);
+    tr = tr.setSelection(TextSelection$1.create(tr.doc, newPos + tabNode.nodeSize));
     if (dispatch) dispatch(tr);
     return true;
   };
@@ -57003,6 +57129,139 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       "paragraphProperties.spacing.lineRule"
     );
   };
+  const backspaceEmptyRunParagraph = () => ({ state: state2, dispatch }) => {
+    const { $from } = state2.selection;
+    if (!state2.selection.empty) return false;
+    const paraType = state2.schema.nodes.paragraph;
+    const runType = state2.schema.nodes.run;
+    const para = $from.parent;
+    if (para.type !== paraType || para.childCount !== 1 || para.firstChild.type !== runType || para.firstChild.content.size)
+      return false;
+    if (state2.doc.childCount === 1 && $from.depth === 1) return false;
+    if (dispatch) {
+      const paraPos = $from.before();
+      let tr = state2.tr.deleteRange(paraPos, paraPos + para.nodeSize).scrollIntoView();
+      const targetPos = Math.max(1, Math.min(paraPos - 1, tr.doc.content.size));
+      tr = tr.setSelection(TextSelection$1.create(tr.doc, targetPos));
+      dispatch(tr);
+    }
+    return true;
+  };
+  const backspaceSkipEmptyRun = () => ({ state: state2, dispatch }) => {
+    const sel = state2.selection;
+    if (!sel.empty) return false;
+    const runType = state2.schema.nodes.run;
+    const $pos = sel.$from;
+    const emptyRun = (n) => n && n.type === runType && n.content.size === 0;
+    if ($pos.parent.type !== runType || $pos.pos !== $pos.end() || !emptyRun(state2.doc.nodeAt($pos.pos + 1))) {
+      return false;
+    }
+    const leftTextSel = Selection.findFrom($pos, -1, true);
+    if (!leftTextSel) return false;
+    const pos = leftTextSel.$from.pos;
+    if (dispatch) {
+      dispatch(state2.tr.delete(pos - 1, pos).scrollIntoView());
+    }
+    return true;
+  };
+  const backspaceNextToRun = () => ({ state: state2, tr, dispatch }) => {
+    const sel = state2.selection;
+    if (!sel.empty) return false;
+    const runType = state2.schema.nodes.run;
+    const $pos = sel.$from;
+    if ($pos.nodeBefore?.type !== runType && $pos.pos !== $pos.start()) return false;
+    if ($pos.nodeBefore) {
+      if ($pos.nodeBefore.content.size === 0) return false;
+      tr.delete($pos.pos - 2, $pos.pos - 1).setSelection(Selection.near(tr.doc.resolve($pos.pos - 2)));
+      if (dispatch) {
+        dispatch(tr.scrollIntoView());
+      }
+    } else {
+      const prevNode = state2.doc.resolve($pos.start() - 1).nodeBefore;
+      if (prevNode?.type !== runType || prevNode.content.size === 0) return false;
+      tr.delete($pos.pos - 3, $pos.pos - 2).setSelection(Selection.near(tr.doc.resolve($pos.pos - 3)));
+      if (dispatch) {
+        dispatch(tr.scrollIntoView());
+      }
+    }
+    return true;
+  };
+  const deleteSkipEmptyRun = () => ({ state: state2, dispatch }) => {
+    const sel = state2.selection;
+    if (!sel.empty) return false;
+    const runType = state2.schema.nodes.run;
+    const $pos = sel.$from;
+    const emptyRun = (n) => n && n.type === runType && n.content.size === 0;
+    if ($pos.parent.type === runType && emptyRun(state2.doc.nodeAt($pos.end() + 1))) {
+      if ($pos.pos === $pos.end()) {
+        return deleteFromEndOfRun(state2, dispatch, $pos);
+      } else if ($pos.pos === $pos.end() - 1) {
+        return deleteFromLastCharacter(state2, dispatch, $pos);
+      }
+      return false;
+    }
+    return false;
+  };
+  function deleteFromEndOfRun(state2, dispatch, $pos) {
+    const rightRun = state2.doc.nodeAt($pos.pos + 1);
+    const $afterRightRunPos = state2.doc.resolve($pos.pos + 2 + rightRun.nodeSize);
+    const rightTextSel = Selection.findFrom($afterRightRunPos, 1, true);
+    if (!rightTextSel) return false;
+    const pos = rightTextSel.$from.pos;
+    if (dispatch) {
+      dispatch(state2.tr.delete(pos, pos + 1).scrollIntoView());
+    }
+    return true;
+  }
+  function deleteFromLastCharacter(state2, dispatch, $pos) {
+    if (dispatch) {
+      dispatch(state2.tr.delete($pos.pos, $pos.pos + 1).scrollIntoView());
+    }
+    return true;
+  }
+  const deleteNextToRun = () => ({ state: state2, tr, dispatch }) => {
+    const sel = state2.selection;
+    if (!sel.empty) return false;
+    const runType = state2.schema.nodes.run;
+    const $pos = sel.$from;
+    if ($pos.nodeAfter?.type !== runType && $pos.pos !== $pos.end()) return false;
+    if ($pos.nodeAfter) {
+      if ($pos.nodeAfter.content.size === 0) return false;
+      tr.delete($pos.pos + 1, $pos.pos + 2).setSelection(Selection.near(tr.doc.resolve($pos.pos + 1)));
+      if (dispatch) {
+        dispatch(tr.scrollIntoView());
+      }
+    } else {
+      const nextNode = state2.doc.resolve($pos.end() + 1).nodeAfter;
+      if (nextNode?.type !== runType || nextNode.content.size === 0) return false;
+      tr.delete($pos.pos + 2, $pos.pos + 3).setSelection(Selection.near(tr.doc.resolve($pos.pos + 2)));
+      if (dispatch) {
+        dispatch(tr.scrollIntoView());
+      }
+    }
+    return true;
+  };
+  function skipTab(dir) {
+    return ({ state: state2, dispatch }) => {
+      const tab = state2.schema.nodes.tab;
+      const run2 = state2.schema.nodes.run;
+      const sel = state2.selection;
+      if (!tab || !sel.empty) return false;
+      const $pos = sel.$from;
+      if ($pos.parent.type !== run2) return false;
+      if (dir > 0 && $pos.pos < $pos.end()) return false;
+      if (dir < 0 && $pos.pos > $pos.start()) return false;
+      const step = dir > 0 ? 1 : -1;
+      let $nextPos = state2.doc.resolve($pos.pos + step);
+      const nextNode = dir > 0 ? $nextPos.nodeAfter : $nextPos.nodeBefore;
+      if (!nextNode || nextNode.type !== tab) return false;
+      const nextPos = dir > 0 ? Math.min($nextPos.pos + nextNode.nodeSize + 1, state2.doc.nodeSize) : Math.max(0, $nextPos.pos - nextNode.nodeSize - 1);
+      if (dispatch) {
+        dispatch(state2.tr.setSelection(TextSelection$1.create(state2.doc, nextPos)));
+      }
+      return true;
+    };
+  }
   const toggleList = (listType) => ({ editor, state: state2, tr, dispatch }) => {
     let predicate;
     if (listType === "orderedList") {
@@ -57078,6 +57337,13 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       }
       updateNumberingProperties(sharedNumberingProperties, node2, pos, editor, tr);
     }
+    const newTo = tr.mapping.map(to);
+    if (newTo >= 0 && newTo <= tr.doc.content.size) {
+      try {
+        tr.setSelection(state2.selection.constructor.near(tr.doc.resolve(newTo)));
+      } catch {
+      }
+    }
     if (dispatch) dispatch(tr);
     return true;
   };
@@ -57196,6 +57462,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   };
   const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     __proto__: null,
+    backspaceEmptyRunParagraph,
+    backspaceNextToRun,
+    backspaceSkipEmptyRun,
     changeListLevel,
     clearNodes,
     command,
@@ -57203,7 +57472,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     decreaseListIndent,
     decreaseTextIndent,
     defaultStyleDetector,
+    deleteNextToRun,
     deleteSelection,
+    deleteSkipEmptyRun,
     exitCode,
     first,
     getEffectiveStyleId,
@@ -57241,6 +57512,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     setSectionHeaderFooterAtSelection,
     setTextIndentation,
     setTextSelection,
+    skipTab,
     splitBlock: splitBlock$1,
     toggleList,
     toggleMark,
@@ -57262,7 +57534,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   });
   const handleEnter = (editor) => {
     return editor.commands.first(({ commands: commands2 }) => [
-      () => commands2.splitRun(),
+      () => commands2.splitRunToParagraph(),
       () => commands2.newlineInCode(),
       () => commands2.createParagraphNear(),
       () => commands2.liftEmptyBlock(),
@@ -57276,6 +57548,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         tr.setMeta("inputType", "deleteContentBackward");
         return false;
       },
+      () => commands2.backspaceEmptyRunParagraph(),
+      () => commands2.backspaceSkipEmptyRun(),
+      () => commands2.backspaceNextToRun(),
       () => commands2.deleteSelection(),
       () => commands2.removeNumberingProperties(),
       () => commands2.joinBackward(),
@@ -57284,6 +57559,8 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   };
   const handleDelete$1 = (editor) => {
     return editor.commands.first(({ commands: commands2 }) => [
+      () => commands2.deleteSkipEmptyRun(),
+      () => commands2.deleteNextToRun(),
       () => commands2.deleteSelection(),
       () => commands2.joinForward(),
       () => commands2.selectNodeForward()
@@ -57302,7 +57579,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         Delete: () => handleDelete$1(this.editor),
         "Mod-Delete": () => handleDelete$1(this.editor),
         "Mod-a": () => this.editor.commands.selectAll(),
-        Tab: () => this.editor.commands.insertTabNode()
+        Tab: () => this.editor.commands.insertTabNode(),
+        ArrowLeft: () => this.editor.commands.skipTab(-1),
+        ArrowRight: () => this.editor.commands.skipTab(1)
       };
       const pcBaseKeymap = {
         ...baseKeymap
@@ -60852,7 +61131,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   const shouldSkipNodeView = (editor) => {
     return isHeadless(editor);
   };
-  const summaryVersion = "1.0.0-beta.15";
+  const summaryVersion = "1.0.0-beta.17";
   const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
   const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
   function mapAttributes(attrs) {
@@ -61362,12 +61641,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       if (!this.schema) {
         throw new Error("Schema is not initialized.");
       }
-      const topNodeName = this.schema.topNodeType?.name || "doc";
-      const normalizedDoc = Array.isArray(doc2) ? { type: topNodeName, content: doc2 } : doc2 && typeof doc2 === "object" && doc2.type ? doc2.type === topNodeName || doc2.type === "doc" ? doc2 : { type: topNodeName, content: [doc2] } : (() => {
-        throw new Error("Invalid document shape: expected a node object or an array of node objects.");
-      })();
       try {
-        return this.schema.nodeFromJSON(normalizedDoc);
+        if (Array.isArray(doc2)) return doc2.map((d2) => this.schema.nodeFromJSON(d2));
+        return this.schema.nodeFromJSON(doc2);
       } catch (error) {
         const detail = error instanceof Error ? error.message : String(error);
         const validationError = new Error(`Invalid document for current schema: ${detail}`);
@@ -61631,7 +61907,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         { default: remarkStringify2 },
         { default: remarkGfm2 }
       ] = await Promise.all([
-        Promise.resolve().then(() => indexBds7gW4r),
+        Promise.resolve().then(() => indexVCeRjVPO),
         Promise.resolve().then(() => indexDRCvimau),
         Promise.resolve().then(() => indexC_x_N6Uh),
         Promise.resolve().then(() => indexD_sWOSiG),
@@ -61836,7 +62112,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
      * Process collaboration migrations
      */
     processCollaborationMigrations() {
-      console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.15");
+      console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.17");
       if (!this.options.ydoc) return;
       const metaMap = this.options.ydoc.getMap("meta");
       let docVersion = metaMap.get("version");
@@ -62911,7 +63187,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const normalized = value.trim().toLowerCase();
     return normalized || void 0;
   };
-  const normalizeColor = (value) => {
+  const normalizeColor$1 = (value) => {
     if (typeof value !== "string") return void 0;
     const trimmed = value.trim();
     if (!trimmed || trimmed === "auto" || trimmed === "none") return void 0;
@@ -63551,14 +63827,14 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   const resolveColorFromAttributes = (attrs, themeColors) => {
     if (!attrs) return void 0;
     if (typeof attrs.color === "string") {
-      const normalized = normalizeColor(attrs.color);
+      const normalized = normalizeColor$1(attrs.color);
       if (normalized) {
         return normalized;
       }
     }
     const theme = resolveThemeColor(attrs, themeColors);
     if (theme) {
-      return normalizeColor(theme);
+      return normalizeColor$1(theme);
     }
     return void 0;
   };
@@ -63993,13 +64269,8 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   const borderSizeToPx = (size2) => {
     if (!isFiniteNumber(size2)) return void 0;
     if (size2 <= 0) return 0;
-    let pixelValue;
-    if (size2 < EIGHTHS_PER_POINT) {
-      pixelValue = size2;
-    } else {
-      const points = size2 / EIGHTHS_PER_POINT;
-      pixelValue = points * PX_PER_PT;
-    }
+    const points = size2 / EIGHTHS_PER_POINT;
+    const pixelValue = points * PX_PER_PT;
     return Math.min(MAX_BORDER_SIZE_PX, Math.max(MIN_BORDER_SIZE_PX, pixelValue));
   };
   const normalizeColorWithDefault = (color2) => {
@@ -64138,7 +64409,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (style2 === "none") return void 0;
     const width = pickNumber(raw.size);
     const widthPx = borderSizeToPx(width);
-    const color2 = normalizeColor(raw.color);
+    const color2 = normalizeColor$1(raw.color);
     const space = pickNumber(raw.space);
     if (!style2 && widthPx == null && space == null && !color2) {
       return void 0;
@@ -64194,7 +64465,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     return Object.keys(shading).length > 0 ? shading : void 0;
   };
   const normalizeShadingColor = (value) => {
-    const normalized = normalizeColor(value);
+    const normalized = normalizeColor$1(value);
     if (!normalized) return void 0;
     if (normalized.toLowerCase() === "#auto") {
       return void 0;
@@ -65357,11 +65628,11 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     baselineOffsetPx: markerRun.baselineShift ?? 0,
     gutterWidthPx: markerBoxWidthPx,
     justification: numbering.lvlJc ?? "left",
-    suffix: normalizeSuffix(numbering.suffix) ?? "tab",
+    suffix: normalizeSuffix$1(numbering.suffix) ?? "tab",
     run: markerRun,
     path: numbering.path
   });
-  const normalizeSuffix = (suffix2) => {
+  const normalizeSuffix$1 = (suffix2) => {
     if (suffix2 === "tab" || suffix2 === "space" || suffix2 === "nothing") {
       return suffix2;
     }
@@ -65815,6 +66086,154 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   };
   const { resolveSpacingIndent } = Engines;
   const DEFAULT_DECIMAL_SEPARATOR$2 = ".";
+  const asOoxmlElement = (value) => {
+    if (!value || typeof value !== "object") return void 0;
+    const element2 = value;
+    if (element2.name == null && element2.attributes == null && element2.elements == null) return void 0;
+    return element2;
+  };
+  const findChild = (parent, name) => {
+    return parent?.elements?.find((child) => child?.name === name);
+  };
+  const getAttribute = (element2, key2) => {
+    if (!element2?.attributes) return void 0;
+    const attrs = element2.attributes;
+    return attrs[key2] ?? attrs[key2.startsWith("w:") ? key2.slice(2) : `w:${key2}`];
+  };
+  const parseNumberAttr = (value) => {
+    if (value == null) return void 0;
+    const num = typeof value === "number" ? value : Number.parseInt(String(value), 10);
+    return Number.isFinite(num) ? num : void 0;
+  };
+  const normalizeNumFmt = (value) => {
+    if (typeof value !== "string") return void 0;
+    switch (value) {
+      case "decimal":
+        return "decimal";
+      case "lowerLetter":
+        return "lowerLetter";
+      case "upperLetter":
+        return "upperLetter";
+      case "lowerRoman":
+        return "lowerRoman";
+      case "upperRoman":
+        return "upperRoman";
+      case "bullet":
+        return "bullet";
+      default:
+        return void 0;
+    }
+  };
+  const normalizeSuffix = (value) => {
+    if (typeof value !== "string") return void 0;
+    if (value === "tab" || value === "space" || value === "nothing") {
+      return value;
+    }
+    return void 0;
+  };
+  const normalizeJustification = (value) => {
+    if (typeof value !== "string") return void 0;
+    if (value === "start") return "left";
+    if (value === "end") return "right";
+    if (value === "left" || value === "center" || value === "right") return value;
+    return void 0;
+  };
+  const extractIndentFromLevel = (lvl) => {
+    const pPr = findChild(lvl, "w:pPr");
+    const ind = findChild(pPr, "w:ind");
+    if (!ind) return void 0;
+    const left2 = parseNumberAttr(getAttribute(ind, "w:left"));
+    const right2 = parseNumberAttr(getAttribute(ind, "w:right"));
+    const firstLine = parseNumberAttr(getAttribute(ind, "w:firstLine"));
+    const hanging = parseNumberAttr(getAttribute(ind, "w:hanging"));
+    const indent2 = {};
+    if (left2 != null) indent2.left = left2;
+    if (right2 != null) indent2.right = right2;
+    if (firstLine != null) indent2.firstLine = firstLine;
+    if (hanging != null) indent2.hanging = hanging;
+    return Object.keys(indent2).length ? indent2 : void 0;
+  };
+  const normalizeColor = (value) => {
+    if (typeof value !== "string") return void 0;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.toLowerCase() === "auto") return void 0;
+    const upper = trimmed.startsWith("#") ? trimmed.slice(1) : trimmed;
+    return `#${upper.toUpperCase()}`;
+  };
+  const extractMarkerRun = (lvl) => {
+    const rPr = findChild(lvl, "w:rPr");
+    if (!rPr) return void 0;
+    const run2 = {};
+    const rFonts = findChild(rPr, "w:rFonts");
+    const font = getAttribute(rFonts, "w:ascii") ?? getAttribute(rFonts, "w:hAnsi") ?? getAttribute(rFonts, "w:eastAsia");
+    if (typeof font === "string" && font.trim()) {
+      run2.fontFamily = font;
+    }
+    const sz = parseNumberAttr(getAttribute(findChild(rPr, "w:sz"), "w:val")) ?? parseNumberAttr(getAttribute(findChild(rPr, "w:szCs"), "w:val"));
+    if (sz != null) {
+      run2.fontSize = sz / 2;
+    }
+    const color2 = normalizeColor(getAttribute(findChild(rPr, "w:color"), "w:val"));
+    if (color2) run2.color = color2;
+    if (findChild(rPr, "w:b")) run2.bold = true;
+    if (findChild(rPr, "w:i")) run2.italic = true;
+    const spacingTwips = parseNumberAttr(getAttribute(findChild(rPr, "w:spacing"), "w:val"));
+    if (spacingTwips != null && Number.isFinite(spacingTwips)) {
+      run2.letterSpacing = twipsToPx$1(spacingTwips);
+    }
+    return Object.keys(run2).length ? run2 : void 0;
+  };
+  const findNumFmtElement = (lvl) => {
+    if (!lvl) return void 0;
+    const direct = findChild(lvl, "w:numFmt");
+    if (direct) return direct;
+    const alternate = findChild(lvl, "mc:AlternateContent");
+    const choice = findChild(alternate, "mc:Choice");
+    if (choice) {
+      return findChild(choice, "w:numFmt");
+    }
+    return void 0;
+  };
+  const resolveNumberingFromContext = (numId, ilvl, numbering) => {
+    const definitions = numbering?.definitions;
+    const abstracts = numbering?.abstracts;
+    if (!definitions || !abstracts) return void 0;
+    const numDef = asOoxmlElement(definitions[String(numId)]);
+    if (!numDef) return void 0;
+    const abstractId = getAttribute(findChild(numDef, "w:abstractNumId"), "w:val");
+    if (abstractId == null) return void 0;
+    const abstract = asOoxmlElement(abstracts[String(abstractId)]);
+    if (!abstract) return void 0;
+    let levelDef = abstract.elements?.find(
+      (el) => el?.name === "w:lvl" && parseNumberAttr(el.attributes?.["w:ilvl"]) === ilvl
+    );
+    const override = numDef.elements?.find(
+      (el) => el?.name === "w:lvlOverride" && parseNumberAttr(el.attributes?.["w:ilvl"]) === ilvl
+    );
+    const overrideLvl = findChild(override, "w:lvl");
+    if (overrideLvl) {
+      levelDef = overrideLvl;
+    }
+    const startOverride = parseNumberAttr(getAttribute(findChild(override, "w:startOverride"), "w:val"));
+    if (!levelDef) return void 0;
+    const numFmtEl = findNumFmtElement(levelDef);
+    const lvlText = getAttribute(findChild(levelDef, "w:lvlText"), "w:val");
+    const start2 = startOverride ?? parseNumberAttr(getAttribute(findChild(levelDef, "w:start"), "w:val"));
+    const suffix2 = normalizeSuffix(getAttribute(findChild(levelDef, "w:suff"), "w:val"));
+    const lvlJc = normalizeJustification(getAttribute(findChild(levelDef, "w:lvlJc"), "w:val"));
+    const indent2 = extractIndentFromLevel(levelDef);
+    const markerRun = extractMarkerRun(levelDef);
+    const numFmt = normalizeNumFmt(getAttribute(numFmtEl, "w:val"));
+    return {
+      format: numFmt,
+      lvlText,
+      start: start2,
+      suffix: suffix2,
+      lvlJc,
+      resolvedLevelIndent: indent2,
+      resolvedMarkerRpr: markerRun
+    };
+  };
   const isTruthy = (value) => {
     if (value === true || value === 1) return true;
     if (typeof value === "string") {
@@ -66447,6 +66866,30 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       const ilvl = Number.isFinite(numberingProps.ilvl) ? Math.max(0, Math.floor(Number(numberingProps.ilvl))) : 0;
       const listRendering = normalizeListRenderingAttrs(attrs.listRendering);
       const numericNumId = typeof numId === "number" ? numId : void 0;
+      const resolvedLevel = resolveNumberingFromContext(numId, ilvl, converterContext?.numbering);
+      if (resolvedLevel) {
+        if (resolvedLevel.format && numberingProps.format == null) {
+          numberingProps.format = resolvedLevel.format;
+        }
+        if (resolvedLevel.lvlText && numberingProps.lvlText == null) {
+          numberingProps.lvlText = resolvedLevel.lvlText;
+        }
+        if (resolvedLevel.start != null && numberingProps.start == null) {
+          numberingProps.start = resolvedLevel.start;
+        }
+        if (resolvedLevel.suffix && numberingProps.suffix == null) {
+          numberingProps.suffix = resolvedLevel.suffix;
+        }
+        if (resolvedLevel.lvlJc && numberingProps.lvlJc == null) {
+          numberingProps.lvlJc = resolvedLevel.lvlJc;
+        }
+        if (resolvedLevel.resolvedLevelIndent && !numberingProps.resolvedLevelIndent) {
+          numberingProps.resolvedLevelIndent = resolvedLevel.resolvedLevelIndent;
+        }
+        if (resolvedLevel.resolvedMarkerRpr && !numberingProps.resolvedMarkerRpr) {
+          numberingProps.resolvedMarkerRpr = resolvedLevel.resolvedMarkerRpr;
+        }
+      }
       let counterValue = 1;
       if (listCounterContext && typeof numericNumId === "number") {
         counterValue = listCounterContext.incrementListCounter(numericNumId, ilvl);
@@ -67672,41 +68115,45 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         }
         return;
       }
-      if (node2.type === "hardBreak") {
-        flushParagraph();
-        blocks2.push({
-          kind: "pageBreak",
-          id: nextId(),
-          attrs: node2.attrs || {}
-        });
-        return;
-      }
-      if (node2.type === "lineBreak") {
+      if (node2.type === "hardBreak" || node2.type === "lineBreak") {
         const attrs = node2.attrs ?? {};
-        if (attrs.lineBreakType === "column") {
+        const breakType = attrs.pageBreakType ?? attrs.lineBreakType ?? "line";
+        if (breakType === "page") {
+          flushParagraph();
+          blocks2.push({
+            kind: "pageBreak",
+            id: nextId(),
+            attrs: node2.attrs || {}
+          });
+          return;
+        }
+        if (breakType === "column") {
           flushParagraph();
           blocks2.push({
             kind: "columnBreak",
             id: nextId(),
             attrs: node2.attrs || {}
           });
+          return;
+        }
+        const lineBreakRun = { kind: "lineBreak", attrs: {} };
+        const lbAttrs = {};
+        if (attrs.lineBreakType) lbAttrs.lineBreakType = String(attrs.lineBreakType);
+        if (attrs.clear) lbAttrs.clear = String(attrs.clear);
+        if (Object.keys(lbAttrs).length > 0) {
+          lineBreakRun.attrs = lbAttrs;
         } else {
-          const lineBreakRun = { kind: "lineBreak", attrs: {} };
-          const lbAttrs = {};
-          if (attrs.lineBreakType) lbAttrs.lineBreakType = String(attrs.lineBreakType);
-          if (attrs.clear) lbAttrs.clear = String(attrs.clear);
-          if (Object.keys(lbAttrs).length > 0) {
-            lineBreakRun.attrs = lbAttrs;
-          } else {
-            delete lineBreakRun.attrs;
-          }
-          const pos = positions.get(node2);
-          if (pos) {
-            lineBreakRun.pmStart = pos.start;
-            lineBreakRun.pmEnd = pos.end;
-          }
-          currentRuns.push(lineBreakRun);
+          delete lineBreakRun.attrs;
+        }
+        const pos = positions.get(node2);
+        if (pos) {
+          lineBreakRun.pmStart = pos.start;
+          lineBreakRun.pmEnd = pos.end;
+        }
+        if (activeSdt) {
+          lineBreakRun.sdt = activeSdt;
         }
+        currentRuns.push(lineBreakRun);
         return;
       }
     };
@@ -68299,6 +68746,22 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   };
   const isTableRowNode = (node2) => node2.type === "tableRow" || node2.type === "table_row";
   const isTableCellNode = (node2) => node2.type === "tableCell" || node2.type === "table_cell" || node2.type === "tableHeader" || node2.type === "table_header";
+  const normalizeRowHeight = (rowProps) => {
+    if (!rowProps || typeof rowProps !== "object") return void 0;
+    const rawRowHeight = rowProps.rowHeight;
+    if (!rawRowHeight || typeof rawRowHeight !== "object") return void 0;
+    const heightObj = rawRowHeight;
+    const rawValue = pickNumber(heightObj.value ?? heightObj.val);
+    if (rawValue == null) return void 0;
+    const rawRule = heightObj.rule ?? heightObj.hRule;
+    const rule = rawRule === "exact" || rawRule === "atLeast" || rawRule === "auto" ? rawRule : "atLeast";
+    const isLikelyTwips = rawValue >= 300 || Math.abs(rawValue % 15) < 1e-6;
+    const valuePx = isLikelyTwips ? twipsToPx$1(rawValue) : rawValue;
+    return {
+      value: valuePx,
+      rule
+    };
+  };
   const parseTableCell = (args) => {
     const { cellNode, rowIndex, cellIndex, context, defaultCellPadding } = args;
     if (!isTableCellNode(cellNode) || !Array.isArray(cellNode.content)) {
@@ -68336,8 +68799,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const padding = extractCellPadding(cellNode.attrs ?? {}) ?? (defaultCellPadding ? { ...defaultCellPadding } : void 0);
     if (padding) cellAttrs.padding = padding;
     const verticalAlign = cellNode.attrs?.verticalAlign;
-    if (verticalAlign === "top" || verticalAlign === "middle" || verticalAlign === "bottom") {
-      cellAttrs.verticalAlign = verticalAlign;
+    const normalizedVerticalAlign = verticalAlign === "middle" ? "center" : verticalAlign === "center" ? "center" : verticalAlign;
+    if (normalizedVerticalAlign === "top" || normalizedVerticalAlign === "center" || normalizedVerticalAlign === "bottom") {
+      cellAttrs.verticalAlign = normalizedVerticalAlign;
     }
     const background = cellNode.attrs?.background;
     if (background && typeof background.color === "string") {
@@ -68380,15 +68844,89 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     });
     if (cells.length === 0) return null;
     const rowProps = rowNode.attrs?.tableRowProperties;
+    const rowHeight = normalizeRowHeight(rowProps);
     const attrs = rowProps && typeof rowProps === "object" ? {
-      tableRowProperties: rowProps
-    } : void 0;
+      tableRowProperties: rowProps,
+      ...rowHeight ? { rowHeight } : {}
+    } : rowHeight ? { rowHeight } : void 0;
     return {
       id: context.nextBlockId(`row-${rowIndex}`),
       cells,
       attrs
     };
   };
+  function extractFloatingTableAnchorWrap(node2) {
+    const tableProperties = node2.attrs?.tableProperties;
+    const floatingProps = tableProperties?.floatingTableProperties;
+    if (!floatingProps) {
+      return {};
+    }
+    const hasPositioning = floatingProps.tblpX !== void 0 || floatingProps.tblpY !== void 0 || floatingProps.tblpXSpec !== void 0 || floatingProps.tblpYSpec !== void 0 || floatingProps.horzAnchor !== void 0 || floatingProps.vertAnchor !== void 0;
+    if (!hasPositioning) {
+      return {};
+    }
+    const mapHorzAnchor = (val) => {
+      switch (val) {
+        case "page":
+          return "page";
+        case "margin":
+          return "margin";
+        case "text":
+        default:
+          return "column";
+      }
+    };
+    const mapVertAnchor = (val) => {
+      switch (val) {
+        case "page":
+          return "page";
+        case "margin":
+          return "margin";
+        case "text":
+        default:
+          return "paragraph";
+      }
+    };
+    const anchor = {
+      isAnchored: true,
+      hRelativeFrom: mapHorzAnchor(floatingProps.horzAnchor),
+      vRelativeFrom: mapVertAnchor(floatingProps.vertAnchor)
+    };
+    if (floatingProps.tblpXSpec) {
+      anchor.alignH = floatingProps.tblpXSpec;
+    }
+    if (floatingProps.tblpYSpec) {
+      anchor.alignV = floatingProps.tblpYSpec;
+    }
+    if (floatingProps.tblpX !== void 0) {
+      anchor.offsetH = twipsToPx$1(floatingProps.tblpX);
+    }
+    if (floatingProps.tblpY !== void 0) {
+      anchor.offsetV = twipsToPx$1(floatingProps.tblpY);
+    }
+    const hasDistances = floatingProps.leftFromText !== void 0 || floatingProps.rightFromText !== void 0 || floatingProps.topFromText !== void 0 || floatingProps.bottomFromText !== void 0;
+    const wrap2 = {
+      type: "Square",
+      // Floating tables with text distances use square wrapping
+      wrapText: "bothSides"
+      // Default to text on both sides
+    };
+    if (hasDistances) {
+      if (floatingProps.topFromText !== void 0) {
+        wrap2.distTop = twipsToPx$1(floatingProps.topFromText);
+      }
+      if (floatingProps.bottomFromText !== void 0) {
+        wrap2.distBottom = twipsToPx$1(floatingProps.bottomFromText);
+      }
+      if (floatingProps.leftFromText !== void 0) {
+        wrap2.distLeft = twipsToPx$1(floatingProps.leftFromText);
+      }
+      if (floatingProps.rightFromText !== void 0) {
+        wrap2.distRight = twipsToPx$1(floatingProps.rightFromText);
+      }
+    }
+    return { anchor, wrap: wrap2 };
+  }
   function tableNodeToBlock$1(node2, nextBlockId, positions, defaultFont, defaultSize, _styleContext, trackedChanges, bookmarks, hyperlinkConfig, themeColors, paragraphToFlowBlocks2, converterContext) {
     if (!Array.isArray(node2.content) || node2.content.length === 0) return null;
     if (!paragraphToFlowBlocks2) return null;
@@ -68453,6 +68991,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (tableLayout) {
       tableAttrs.tableLayout = tableLayout;
     }
+    const tableProperties = node2.attrs?.tableProperties;
+    if (tableProperties && typeof tableProperties === "object") {
+      tableAttrs.tableProperties = tableProperties;
+    }
     let columnWidths = void 0;
     const twipsToPixels2 = (twips) => {
       const PIXELS_PER_INCH2 = 96;
@@ -68496,12 +69038,15 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         columnWidths = void 0;
       }
     }
+    const { anchor, wrap: wrap2 } = extractFloatingTableAnchorWrap(node2);
     const tableBlock = {
       kind: "table",
       id: nextBlockId("table"),
       rows,
       attrs: Object.keys(tableAttrs).length > 0 ? tableAttrs : void 0,
-      columnWidths
+      columnWidths,
+      ...anchor ? { anchor } : {},
+      ...wrap2 ? { wrap: wrap2 } : {}
     };
     return tableBlock;
   }
@@ -68837,7 +69382,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     return measurementCtx;
   }
   function getRunFontString(run2) {
-    if (run2.kind === "tab" || run2.kind === "lineBreak" || "src" in run2) {
+    if (run2.kind === "tab" || run2.kind === "lineBreak" || run2.kind === "break" || "src" in run2) {
       return "normal normal 16px Arial";
     }
     const style2 = run2.italic ? "italic" : "normal";
@@ -68864,6 +69409,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         result.push(run2);
         continue;
       }
+      if (run2.kind === "break") {
+        result.push(run2);
+        continue;
+      }
       const text2 = run2.text ?? "";
       const isFirstRun = runIndex === line.fromRun;
       const isLastRun = runIndex === line.toRun;
@@ -68897,7 +69446,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         1,
         runs22.reduce((sum, run2) => {
           if (isTabRun$1(run2)) return sum + TAB_CHAR_LENGTH;
-          if ("src" in run2 || run2.kind === "lineBreak") return sum;
+          if ("src" in run2 || run2.kind === "lineBreak" || run2.kind === "break") return sum;
           return sum + (run2.text ?? "").length;
         }, 0)
       );
@@ -68918,7 +69467,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         currentCharOffset += runLength2;
         continue;
       }
-      const text2 = "src" in run2 || run2.kind === "lineBreak" ? "" : run2.text ?? "";
+      const text2 = "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" ? "" : run2.text ?? "";
       const runLength = text2.length;
       if (currentCharOffset + runLength >= charOffset) {
         const offsetInRun = charOffset - currentCharOffset;
@@ -68961,7 +69510,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         if (isTabRun$1(run2)) {
           return segmentBaseX + (offsetInSegment > 0 ? segment.width ?? 0 : 0);
         }
-        if ("src" in run2 || run2.kind === "lineBreak") {
+        if ("src" in run2 || run2.kind === "lineBreak" || run2.kind === "break") {
           return segmentBaseX + (offsetInSegment >= segmentChars ? segment.width ?? 0 : 0);
         }
         const text2 = run2.text ?? "";
@@ -68984,7 +69533,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         1,
         runs22.reduce((sum, run2) => {
           if (isTabRun$1(run2)) return sum + TAB_CHAR_LENGTH;
-          if ("src" in run2 || run2.kind === "lineBreak") return sum;
+          if ("src" in run2 || run2.kind === "lineBreak" || run2.kind === "break") return sum;
           return sum + (run2.text ?? "").length;
         }, 0)
       );
@@ -69019,7 +69568,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         currentCharOffset += TAB_CHAR_LENGTH;
         continue;
       }
-      const text2 = "src" in run2 || run2.kind === "lineBreak" ? "" : run2.text ?? "";
+      const text2 = "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" ? "" : run2.text ?? "";
       const runLength = text2.length;
       if (runLength === 0) continue;
       ctx2.font = getRunFontString(run2);
@@ -69452,6 +70001,40 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         };
         zones.push(zone);
       },
+      registerTable(tableBlock, measure, anchorY, columnIndex, pageNumber) {
+        if (!tableBlock.anchor?.isAnchored) {
+          return;
+        }
+        const { wrap: wrap2, anchor } = tableBlock;
+        const wrapType = wrap2?.type ?? "None";
+        if (wrapType === "None") {
+          return;
+        }
+        const tableWidth = measure.totalWidth ?? 0;
+        const tableHeight = measure.totalHeight ?? 0;
+        const x2 = computeTableAnchorX(anchor, columnIndex, columns, tableWidth, margins, pageWidth);
+        const y2 = anchorY + (anchor.offsetV ?? 0);
+        const zone = {
+          imageBlockId: tableBlock.id,
+          // Reusing imageBlockId field for table id
+          pageNumber,
+          columnIndex,
+          bounds: {
+            x: x2,
+            y: y2,
+            width: tableWidth,
+            height: tableHeight
+          },
+          distances: {
+            top: wrap2?.distTop ?? 0,
+            bottom: wrap2?.distBottom ?? 0,
+            left: wrap2?.distLeft ?? 0,
+            right: wrap2?.distRight ?? 0
+          },
+          wrapMode: computeTableWrapMode(wrap2)
+        };
+        zones.push(zone);
+      },
       getExclusionsForLine(lineY, lineHeight2, columnIndex, pageNumber) {
         const result = zones.filter((zone) => {
           if (zone.pageNumber !== pageNumber || zone.columnIndex !== columnIndex) {
@@ -69559,6 +70142,49 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (wrapText === "largest") return "largest";
     return "both";
   }
+  function computeTableAnchorX(anchor, columnIndex, columns, tableWidth, margins, pageWidth) {
+    const alignH = anchor.alignH ?? "left";
+    const offsetH = anchor.offsetH ?? 0;
+    const marginLeft = Math.max(0, margins?.left ?? 0);
+    const marginRight = Math.max(0, margins?.right ?? 0);
+    const contentWidth = pageWidth != null ? Math.max(1, pageWidth - (marginLeft + marginRight)) : columns.width;
+    const contentLeft = marginLeft;
+    const columnLeft = contentLeft + columnIndex * (columns.width + columns.gap);
+    const relativeFrom = anchor.hRelativeFrom ?? "column";
+    let baseX;
+    let availableWidth;
+    if (relativeFrom === "page") {
+      if (columns.count === 1) {
+        baseX = contentLeft;
+        availableWidth = contentWidth;
+      } else {
+        baseX = 0;
+        availableWidth = pageWidth != null ? pageWidth : contentWidth;
+      }
+    } else if (relativeFrom === "margin") {
+      baseX = contentLeft;
+      availableWidth = contentWidth;
+    } else {
+      baseX = columnLeft;
+      availableWidth = columns.width;
+    }
+    let effectiveAlignH = alignH;
+    if (alignH === "inside") effectiveAlignH = "left";
+    if (alignH === "outside") effectiveAlignH = "right";
+    const result = effectiveAlignH === "left" ? baseX + offsetH : effectiveAlignH === "right" ? baseX + availableWidth - tableWidth - offsetH : effectiveAlignH === "center" ? baseX + (availableWidth - tableWidth) / 2 + offsetH : baseX;
+    return result;
+  }
+  function computeTableWrapMode(wrap2) {
+    if (!wrap2) return "none";
+    if (wrap2.type === "None") {
+      return "none";
+    }
+    const wrapText = wrap2.wrapText ?? "bothSides";
+    if (wrapText === "left") return "right";
+    if (wrapText === "right") return "left";
+    if (wrapText === "largest") return "largest";
+    return "both";
+  }
   function computeNextSectionPropsAtBreak(blocks2) {
     const nextSectionPropsAtBreak = /* @__PURE__ */ new Map();
     const docxBreakIndexes = [];
@@ -69977,6 +70603,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       };
       if (measure.marker) {
         fragment.markerWidth = measure.marker.markerWidth;
+        if (measure.marker.markerTextWidth != null) {
+          fragment.markerTextWidth = measure.marker.markerTextWidth;
+        }
       }
       state2.page.fragments.push(fragment);
       state2.trailingSpacing = 0;
@@ -70078,6 +70707,12 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       };
       if (measure.marker && fromLine === 0) {
         fragment.markerWidth = measure.marker.markerWidth;
+        if (measure.marker.markerTextWidth != null) {
+          fragment.markerTextWidth = measure.marker.markerTextWidth;
+        }
+        if (measure.kind === "paragraph" && measure.marker?.gutterWidth != null) {
+          fragment.markerGutter = measure.marker.gutterWidth;
+        }
       }
       if (fromLine > 0) fragment.continuesFromPrev = true;
       if (slice2.toLine < lines.length) fragment.continuesOnNext = true;
@@ -70255,6 +70890,206 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return boundaries;
   }
+  function countHeaderRows(block) {
+    let count = 0;
+    for (let i2 = 0; i2 < block.rows.length; i2++) {
+      const row2 = block.rows[i2];
+      const repeatHeader = row2.attrs?.tableRowProperties?.repeatHeader;
+      if (repeatHeader === true) {
+        count++;
+      } else {
+        break;
+      }
+    }
+    return count;
+  }
+  function sumRowHeights(rows, fromRow, toRow) {
+    let total = 0;
+    for (let i2 = fromRow; i2 < toRow && i2 < rows.length; i2++) {
+      total += rows[i2].height;
+    }
+    return total;
+  }
+  function calculateFragmentHeight(fragment, measure, _headerCount) {
+    let height = 0;
+    if (fragment.repeatHeaderCount && fragment.repeatHeaderCount > 0) {
+      height += sumRowHeights(measure.rows, 0, fragment.repeatHeaderCount);
+    }
+    height += sumRowHeights(measure.rows, fragment.fromRow, fragment.toRow);
+    return height;
+  }
+  const MIN_PARTIAL_ROW_HEIGHT = 20;
+  function getCellLines(cell2) {
+    if (cell2.blocks && cell2.blocks.length > 0) {
+      const allLines = [];
+      for (const block of cell2.blocks) {
+        if (block.kind === "paragraph") {
+          if (block.kind === "paragraph" && "lines" in block) {
+            const paraBlock = block;
+            if (paraBlock.lines) {
+              allLines.push(...paraBlock.lines);
+            }
+          }
+        }
+      }
+      return allLines;
+    }
+    if (cell2.paragraph?.lines) {
+      return cell2.paragraph.lines;
+    }
+    return [];
+  }
+  function getCellPadding(cellIdx, blockRow) {
+    const padding = blockRow?.cells?.[cellIdx]?.attrs?.padding ?? {};
+    return {
+      top: padding.top ?? 2,
+      bottom: padding.bottom ?? 2,
+      left: padding.left ?? 4,
+      right: padding.right ?? 4
+    };
+  }
+  function getCellTotalLines(cell2) {
+    return getCellLines(cell2).length;
+  }
+  function computePartialRow(rowIndex, blockRow, measure, availableHeight, fromLineByCell) {
+    const row2 = measure.rows[rowIndex];
+    if (!row2) {
+      throw new Error(`Invalid rowIndex ${rowIndex}: measure.rows has ${measure.rows.length} rows`);
+    }
+    const cellCount = row2.cells.length;
+    const startLines = fromLineByCell || new Array(cellCount).fill(0);
+    const toLineByCell = [];
+    const heightByCell = [];
+    const cellPaddings = row2.cells.map((_2, idx) => getCellPadding(idx, blockRow));
+    for (let cellIdx = 0; cellIdx < cellCount; cellIdx++) {
+      const cell2 = row2.cells[cellIdx];
+      const startLine = startLines[cellIdx] || 0;
+      const cellPadding = cellPaddings[cellIdx];
+      const availableForLines = Math.max(0, availableHeight - (cellPadding.top + cellPadding.bottom));
+      const lines = getCellLines(cell2);
+      let cumulativeHeight = 0;
+      let cutLine = startLine;
+      for (let i2 = startLine; i2 < lines.length; i2++) {
+        const lineHeight2 = lines[i2].lineHeight || 0;
+        if (cumulativeHeight + lineHeight2 > availableForLines) {
+          break;
+        }
+        cumulativeHeight += lineHeight2;
+        cutLine = i2 + 1;
+      }
+      toLineByCell.push(cutLine);
+      heightByCell.push(cumulativeHeight);
+    }
+    const positiveHeights = heightByCell.filter((h2) => h2 > 0);
+    const minHeight = positiveHeights.length > 0 ? Math.min(...positiveHeights) : 0;
+    let actualPartialHeight = 0;
+    let maxPaddingTotal = 0;
+    for (let cellIdx = 0; cellIdx < cellCount; cellIdx++) {
+      const cell2 = row2.cells[cellIdx];
+      const startLine = startLines[cellIdx] || 0;
+      const lines = getCellLines(cell2);
+      const cellPadding = cellPaddings[cellIdx];
+      const paddingTotal = cellPadding.top + cellPadding.bottom;
+      maxPaddingTotal = Math.max(maxPaddingTotal, paddingTotal);
+      let cumulativeHeight = 0;
+      let cutLine = startLine;
+      for (let i2 = startLine; i2 < lines.length; i2++) {
+        const lineHeight2 = lines[i2].lineHeight || 0;
+        if (cumulativeHeight + lineHeight2 > minHeight) {
+          break;
+        }
+        cumulativeHeight += lineHeight2;
+        cutLine = i2 + 1;
+      }
+      toLineByCell[cellIdx] = cutLine;
+      actualPartialHeight = Math.max(actualPartialHeight, cumulativeHeight + paddingTotal);
+    }
+    const madeProgress = toLineByCell.some((cutLine, idx) => cutLine > (startLines[idx] || 0));
+    const isFirstPart = startLines.every((l) => l === 0);
+    const allCellsExhausted = toLineByCell.every((cutLine, idx) => {
+      const totalLines = getCellTotalLines(row2.cells[idx]);
+      return cutLine >= totalLines;
+    });
+    const isLastPart = allCellsExhausted || !madeProgress;
+    if (actualPartialHeight === 0 && isFirstPart) {
+      actualPartialHeight = maxPaddingTotal;
+    }
+    return {
+      rowIndex,
+      fromLineByCell: startLines,
+      toLineByCell,
+      isFirstPart,
+      isLastPart,
+      partialHeight: actualPartialHeight
+    };
+  }
+  function findSplitPoint(block, measure, startRow, availableHeight, fullPageHeight, _pendingPartialRow) {
+    let accumulatedHeight = 0;
+    let lastFitRow = startRow;
+    for (let i2 = startRow; i2 < block.rows.length; i2++) {
+      const row2 = block.rows[i2];
+      const rowHeight = measure.rows[i2]?.height || 0;
+      const cantSplit = row2.attrs?.tableRowProperties?.cantSplit === true;
+      if (accumulatedHeight + rowHeight <= availableHeight) {
+        accumulatedHeight += rowHeight;
+        lastFitRow = i2 + 1;
+      } else {
+        const remainingHeight = availableHeight - accumulatedHeight;
+        if (fullPageHeight && rowHeight > fullPageHeight) {
+          const partialRow = computePartialRow(i2, block.rows[i2], measure, remainingHeight);
+          return { endRow: i2 + 1, partialRow };
+        }
+        if (cantSplit) {
+          if (lastFitRow === startRow) {
+            return { endRow: startRow, partialRow: null };
+          }
+          return { endRow: lastFitRow, partialRow: null };
+        }
+        if (remainingHeight >= MIN_PARTIAL_ROW_HEIGHT) {
+          const partialRow = computePartialRow(i2, block.rows[i2], measure, remainingHeight);
+          const hasContent = partialRow.toLineByCell.some(
+            (cutLine, idx) => cutLine > (partialRow.fromLineByCell[idx] || 0)
+          );
+          if (hasContent) {
+            return { endRow: i2 + 1, partialRow };
+          }
+        }
+        return { endRow: lastFitRow, partialRow: null };
+      }
+    }
+    return { endRow: block.rows.length, partialRow: null };
+  }
+  function generateFragmentMetadata(measure, _fromRow, _toRow, _repeatHeaderCount) {
+    return {
+      columnBoundaries: generateColumnBoundaries(measure),
+      coordinateSystem: "fragment"
+    };
+  }
+  function layoutMonolithicTable(context) {
+    let state2 = context.ensurePage();
+    if (state2.cursorY + context.measure.totalHeight > state2.contentBottom && state2.page.fragments.length > 0) {
+      state2 = context.advanceColumn(state2);
+    }
+    state2 = context.ensurePage();
+    const height = Math.min(context.measure.totalHeight, state2.contentBottom - state2.cursorY);
+    const metadata = {
+      columnBoundaries: generateColumnBoundaries(context.measure),
+      coordinateSystem: "fragment"
+    };
+    const fragment = {
+      kind: "table",
+      blockId: context.block.id,
+      fromRow: 0,
+      toRow: context.block.rows.length,
+      x: context.columnX(state2.columnIndex),
+      y: state2.cursorY,
+      width: Math.min(context.columnWidth, context.measure.totalWidth || context.columnWidth),
+      height,
+      metadata
+    };
+    state2.page.fragments.push(fragment);
+    state2.cursorY += height;
+  }
   function layoutTableBlock({
     block,
     measure,
@@ -70263,30 +71098,176 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     advanceColumn,
     columnX
   }) {
+    if (block.anchor?.isAnchored) {
+      return;
+    }
+    const tableProps = block.attrs?.tableProperties;
+    const floatingProps = tableProps?.floatingTableProperties;
+    if (floatingProps && Object.keys(floatingProps).length > 0) {
+      layoutMonolithicTable({ block, measure, columnWidth, ensurePage, advanceColumn, columnX });
+      return;
+    }
+    const headerCount = countHeaderRows(block);
+    const headerHeight = headerCount > 0 ? sumRowHeights(measure.rows, 0, headerCount) : 0;
     let state2 = ensurePage();
-    if (state2.cursorY + measure.totalHeight > state2.contentBottom && state2.page.fragments.length > 0) {
-      state2 = advanceColumn(state2);
+    let currentRow = 0;
+    let isTableContinuation = false;
+    let pendingPartialRow = null;
+    while (currentRow < block.rows.length || pendingPartialRow !== null) {
+      state2 = ensurePage();
+      const availableHeight = state2.contentBottom - state2.cursorY;
+      let repeatHeaderCount = 0;
+      if (currentRow === 0 && !pendingPartialRow) {
+        repeatHeaderCount = 0;
+      } else {
+        if (headerCount > 0 && headerHeight <= availableHeight) {
+          repeatHeaderCount = headerCount;
+        } else if (headerCount > 0 && headerHeight > availableHeight) {
+          repeatHeaderCount = 0;
+        }
+      }
+      const availableForBody = repeatHeaderCount > 0 ? availableHeight - headerHeight : availableHeight;
+      const fullPageHeight = state2.contentBottom;
+      if (pendingPartialRow !== null) {
+        const rowIndex = pendingPartialRow.rowIndex;
+        const fromLineByCell = pendingPartialRow.toLineByCell;
+        const continuationPartialRow = computePartialRow(
+          rowIndex,
+          block.rows[rowIndex],
+          measure,
+          availableForBody,
+          fromLineByCell
+        );
+        const madeProgress = continuationPartialRow.toLineByCell.some(
+          (toLine, idx) => toLine > (fromLineByCell[idx] || 0)
+        );
+        const hasRemainingLinesAfterContinuation = continuationPartialRow.toLineByCell.some(
+          (toLine, idx) => {
+            const totalLines = getCellTotalLines(measure.rows[rowIndex].cells[idx]);
+            return toLine < totalLines;
+          }
+        );
+        const hadRemainingLinesBefore = fromLineByCell.some((fromLine, idx) => {
+          const totalLines = getCellTotalLines(measure.rows[rowIndex].cells[idx]);
+          return fromLine < totalLines;
+        });
+        const fragmentHeight2 = continuationPartialRow.partialHeight + (repeatHeaderCount > 0 ? headerHeight : 0);
+        if (fragmentHeight2 > 0) {
+          const fragment2 = {
+            kind: "table",
+            blockId: block.id,
+            fromRow: rowIndex,
+            toRow: rowIndex + 1,
+            x: columnX(state2.columnIndex),
+            y: state2.cursorY,
+            width: Math.min(columnWidth, measure.totalWidth || columnWidth),
+            height: fragmentHeight2,
+            continuesFromPrev: true,
+            continuesOnNext: hasRemainingLinesAfterContinuation || rowIndex + 1 < block.rows.length,
+            repeatHeaderCount,
+            partialRow: continuationPartialRow,
+            metadata: generateFragmentMetadata(measure)
+          };
+          state2.page.fragments.push(fragment2);
+          state2.cursorY += fragmentHeight2;
+        }
+        const rowComplete = !hasRemainingLinesAfterContinuation;
+        if (rowComplete) {
+          currentRow = rowIndex + 1;
+          pendingPartialRow = null;
+        } else if (!madeProgress && hadRemainingLinesBefore) {
+          state2 = advanceColumn(state2);
+        } else {
+          state2 = advanceColumn(state2);
+          pendingPartialRow = continuationPartialRow;
+        }
+        isTableContinuation = true;
+        continue;
+      }
+      const bodyStartRow = currentRow;
+      const { endRow, partialRow } = findSplitPoint(block, measure, bodyStartRow, availableForBody, fullPageHeight);
+      if (endRow === bodyStartRow && partialRow === null && state2.page.fragments.length > 0) {
+        state2 = advanceColumn(state2);
+        continue;
+      }
+      if (endRow === bodyStartRow && partialRow === null) {
+        const forcedPartialRow = computePartialRow(bodyStartRow, block.rows[bodyStartRow], measure, availableForBody);
+        const forcedEndRow = bodyStartRow + 1;
+        const fragmentHeight2 = forcedPartialRow.partialHeight + (repeatHeaderCount > 0 ? headerHeight : 0);
+        const fragment2 = {
+          kind: "table",
+          blockId: block.id,
+          fromRow: bodyStartRow,
+          toRow: forcedEndRow,
+          x: columnX(state2.columnIndex),
+          y: state2.cursorY,
+          width: Math.min(columnWidth, measure.totalWidth || columnWidth),
+          height: fragmentHeight2,
+          continuesFromPrev: isTableContinuation,
+          continuesOnNext: !forcedPartialRow.isLastPart || forcedEndRow < block.rows.length,
+          repeatHeaderCount,
+          partialRow: forcedPartialRow,
+          metadata: generateFragmentMetadata(measure)
+        };
+        state2.page.fragments.push(fragment2);
+        state2.cursorY += fragmentHeight2;
+        pendingPartialRow = forcedPartialRow;
+        isTableContinuation = true;
+        continue;
+      }
+      let fragmentHeight;
+      if (partialRow) {
+        const fullRowsHeight = sumRowHeights(measure.rows, bodyStartRow, endRow - 1);
+        fragmentHeight = fullRowsHeight + partialRow.partialHeight + (repeatHeaderCount > 0 ? headerHeight : 0);
+      } else {
+        fragmentHeight = calculateFragmentHeight(
+          { fromRow: bodyStartRow, toRow: endRow, repeatHeaderCount },
+          measure
+        );
+      }
+      const fragment = {
+        kind: "table",
+        blockId: block.id,
+        fromRow: bodyStartRow,
+        toRow: endRow,
+        x: columnX(state2.columnIndex),
+        y: state2.cursorY,
+        width: Math.min(columnWidth, measure.totalWidth || columnWidth),
+        height: fragmentHeight,
+        continuesFromPrev: isTableContinuation,
+        continuesOnNext: endRow < block.rows.length || (partialRow ? !partialRow.isLastPart : false),
+        repeatHeaderCount,
+        partialRow: partialRow || void 0,
+        metadata: generateFragmentMetadata(measure)
+      };
+      state2.page.fragments.push(fragment);
+      state2.cursorY += fragmentHeight;
+      if (partialRow && !partialRow.isLastPart) {
+        pendingPartialRow = partialRow;
+        currentRow = partialRow.rowIndex;
+      } else {
+        currentRow = endRow;
+        pendingPartialRow = null;
+      }
+      isTableContinuation = true;
     }
-    state2 = ensurePage();
-    const height = Math.min(measure.totalHeight, state2.contentBottom - state2.cursorY);
+  }
+  function createAnchoredTableFragment(block, measure, x2, y2) {
     const metadata = {
       columnBoundaries: generateColumnBoundaries(measure),
       coordinateSystem: "fragment"
-      // rowBoundaries omitted - not needed for column resize, reduces DOM overhead
     };
-    const fragment = {
+    return {
       kind: "table",
       blockId: block.id,
       fromRow: 0,
       toRow: block.rows.length,
-      x: columnX(state2.columnIndex),
-      y: state2.cursorY,
-      width: Math.min(columnWidth, measure.totalWidth || columnWidth),
-      height,
+      x: x2,
+      y: y2,
+      width: measure.totalWidth ?? 0,
+      height: measure.totalHeight ?? 0,
       metadata
     };
-    state2.page.fragments.push(fragment);
-    state2.cursorY += height;
   }
   function isPageRelativeAnchor(block) {
     const vRelativeFrom = block.anchor?.vRelativeFrom;
@@ -70313,9 +71294,6 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   function collectAnchoredDrawings(blocks2, measures) {
     const map2 = /* @__PURE__ */ new Map();
     const len2 = Math.min(blocks2.length, measures.length);
-    for (let i2 = 0; i2 < len2; i2 += 1) {
-      if (blocks2[i2].kind === "paragraph") ;
-    }
     const nearestPrevParagraph = (fromIndex) => {
       for (let i2 = fromIndex - 1; i2 >= 0; i2 -= 1) {
         if (blocks2[i2].kind === "paragraph") return i2;
@@ -70351,6 +71329,36 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return map2;
   }
+  function collectAnchoredTables(blocks2, measures) {
+    const map2 = /* @__PURE__ */ new Map();
+    const nearestPrevParagraph = (fromIndex) => {
+      for (let i2 = fromIndex - 1; i2 >= 0; i2 -= 1) {
+        if (blocks2[i2].kind === "paragraph") return i2;
+      }
+      return null;
+    };
+    const nearestNextParagraph = (fromIndex) => {
+      for (let i2 = fromIndex + 1; i2 < blocks2.length; i2 += 1) {
+        if (blocks2[i2].kind === "paragraph") return i2;
+      }
+      return null;
+    };
+    for (let i2 = 0; i2 < blocks2.length; i2 += 1) {
+      const block = blocks2[i2];
+      const measure = measures[i2];
+      if (block.kind !== "table" || measure?.kind !== "table") continue;
+      const tableBlock = block;
+      const tableMeasure = measure;
+      if (!tableBlock.anchor?.isAnchored) continue;
+      let anchorParaIndex = nearestPrevParagraph(i2);
+      if (anchorParaIndex == null) anchorParaIndex = nearestNextParagraph(i2);
+      if (anchorParaIndex == null) continue;
+      const list2 = map2.get(anchorParaIndex) ?? [];
+      list2.push({ block: tableBlock, measure: tableMeasure });
+      map2.set(anchorParaIndex, list2);
+    }
+    return map2;
+  }
   function createPaginator(opts) {
     const states = [];
     const pages = [];
@@ -70936,7 +71944,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       cachedColumnsState.state = null;
     };
     const anchoredByParagraph = collectAnchoredDrawings(blocks2, measures);
+    const anchoredTablesByParagraph = collectAnchoredTables(blocks2, measures);
     const placedAnchoredIds = /* @__PURE__ */ new Set();
+    const placedAnchoredTableIds = /* @__PURE__ */ new Set();
     const preRegisteredAnchors = collectPreRegisteredAnchors(blocks2, measures);
     const preRegisteredPositions = /* @__PURE__ */ new Map();
     for (const entry of preRegisteredAnchors) {
@@ -71114,6 +72124,19 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           }
         }
         const anchorsForPara = anchoredByParagraph.get(index2);
+        const tablesForPara = anchoredTablesByParagraph.get(index2);
+        if (tablesForPara) {
+          const state2 = paginator.ensurePage();
+          for (const { block: tableBlock, measure: tableMeasure } of tablesForPara) {
+            if (placedAnchoredTableIds.has(tableBlock.id)) continue;
+            floatManager.registerTable(tableBlock, tableMeasure, state2.cursorY, state2.columnIndex, state2.page.number);
+            const anchorX = tableBlock.anchor?.offsetH ?? columnX(state2.columnIndex);
+            const anchorY = state2.cursorY + (tableBlock.anchor?.offsetV ?? 0);
+            const tableFragment = createAnchoredTableFragment(tableBlock, tableMeasure, anchorX, anchorY);
+            state2.page.fragments.push(tableFragment);
+            placedAnchoredTableIds.add(tableBlock.id);
+          }
+        }
         layoutParagraphBlock(
           {
             block,
@@ -71385,7 +72408,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const trackedMode = block.attrs && "trackedChangesMode" in block.attrs && block.attrs.trackedChangesMode || "review";
     const trackedEnabled = resolveTrackedChangesEnabled(block.attrs, true);
     const runsHash = block.runs.map((run2) => {
-      const text2 = normalizeText("src" in run2 || run2.kind === "lineBreak" ? "" : run2.text ?? "");
+      const text2 = normalizeText(
+        "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" ? "" : run2.text ?? ""
+      );
       const bold = "bold" in run2 ? run2.bold : false;
       const italic = "italic" in run2 ? run2.italic : false;
       const color2 = "color" in run2 ? run2.color : void 0;
@@ -71399,7 +72424,22 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       }
       return `${text2}:${marks}${trackedKey}`;
     }).join("|");
-    return `${trackedMode}:${trackedEnabled ? "on" : "off"}|${runsHash}`;
+    let numberingKey = "";
+    if (block.attrs) {
+      const attrs = block.attrs;
+      if (attrs.numberingProperties) {
+        const np = attrs.numberingProperties;
+        let markerTextKey;
+        if (!attrs.wordLayout?.marker) {
+          markerTextKey = "<NULL>";
+        } else {
+          const markerText = attrs.wordLayout.marker.markerText;
+          markerTextKey = markerText === "" ? "<EMPTY>" : markerText ?? "<NULL>";
+        }
+        numberingKey = `|num:${np.numId ?? ""}:${np.ilvl ?? 0}:${markerTextKey}`;
+      }
+    }
+    return `${trackedMode}:${trackedEnabled ? "on" : "off"}|${runsHash}${numberingKey}`;
   };
   const createStats = () => ({
     hits: 0,
@@ -72045,7 +73085,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     return `${italic}${bold}${size2}px ${family}`.trim();
   }
   function runText(run2) {
-    return "src" in run2 || run2.kind === "lineBreak" ? "" : run2.text ?? "";
+    return "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" ? "" : run2.text ?? "";
   }
   function measureRunSliceWidth(run2, fromChar, toChar) {
     const context = getCtx();
@@ -72207,7 +73247,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     for (let i2 = 0; i2 < a2.runs.length; i2 += 1) {
       const runA = a2.runs[i2];
       const runB = b2.runs[i2];
-      if (("src" in runA || runA.kind === "lineBreak" ? "" : runA.text) !== ("src" in runB || runB.kind === "lineBreak" ? "" : runB.text) || ("bold" in runA ? runA.bold : false) !== ("bold" in runB ? runB.bold : false) || ("italic" in runA ? runA.italic : false) !== ("italic" in runB ? runB.italic : false) || ("color" in runA ? runA.color : void 0) !== ("color" in runB ? runB.color : void 0) || getTrackedChangeKey(runA) !== getTrackedChangeKey(runB)) {
+      if (("src" in runA || runA.kind === "lineBreak" || runA.kind === "break" ? "" : runA.text) !== ("src" in runB || runB.kind === "lineBreak" || runB.kind === "break" ? "" : runB.text) || ("bold" in runA ? runA.bold : false) !== ("bold" in runB ? runB.bold : false) || ("italic" in runA ? runA.italic : false) !== ("italic" in runB ? runB.italic : false) || ("color" in runA ? runA.color : void 0) !== ("color" in runB ? runB.color : void 0) || getTrackedChangeKey(runA) !== getTrackedChangeKey(runB)) {
         return false;
       }
     }
@@ -72327,7 +73367,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       parts.push(block.id);
       if (block.kind === "paragraph") {
         for (const run2 of block.runs) {
-          if (!("src" in run2) && run2.kind !== "lineBreak") {
+          if (!("src" in run2) && run2.kind !== "lineBreak" && run2.kind !== "break") {
             parts.push(run2.text ?? "");
           }
           if ("bold" in run2 && run2.bold) parts.push("b");
@@ -73298,7 +74338,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     for (let runIndex = line.fromRun; runIndex <= line.toRun; runIndex += 1) {
       const run2 = block.runs[runIndex];
       if (!run2) continue;
-      const text2 = "src" in run2 || run2.kind === "lineBreak" ? "" : run2.text ?? "";
+      const text2 = "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" ? "" : run2.text ?? "";
       const runLength = text2.length;
       const runPmStart = run2.pmStart ?? null;
       const runPmEnd = run2.pmEnd ?? (runPmStart != null ? runPmStart + runLength : null);
@@ -75906,7 +76946,20 @@ ${l}
     };
   };
   const renderTableCell = (deps) => {
-    const { doc: doc2, x: x2, y: y2, rowHeight, cellMeasure, cell: cell2, borders, renderLine, context, applySdtDataset } = deps;
+    const {
+      doc: doc2,
+      x: x2,
+      y: y2,
+      rowHeight,
+      cellMeasure,
+      cell: cell2,
+      borders,
+      renderLine,
+      context,
+      applySdtDataset,
+      fromLine,
+      toLine
+    } = deps;
     const cellEl = doc2.createElement("div");
     cellEl.style.position = "absolute";
     cellEl.style.left = `${x2}px`;
@@ -75914,6 +76967,7 @@ ${l}
     cellEl.style.width = `${cellMeasure.width}px`;
     cellEl.style.height = `${rowHeight}px`;
     cellEl.style.boxSizing = "border-box";
+    cellEl.style.overflow = "hidden";
     if (borders) {
       applyCellBorders(cellEl, borders);
     }
@@ -75927,36 +76981,87 @@ ${l}
     }
     let contentElement;
     const attrs = cell2?.attrs;
-    const padding = attrs?.padding || { top: 2, left: 4, right: 4 };
+    const padding = attrs?.padding || { top: 2, left: 4, right: 4, bottom: 2 };
     const paddingLeft = padding.left ?? 4;
     const paddingTop = padding.top ?? 2;
     const paddingRight = padding.right ?? 4;
+    const paddingBottom = padding.bottom ?? 2;
     const cellBlocks = cell2?.blocks ?? (cell2?.paragraph ? [cell2.paragraph] : []);
-    const blockMeasures = cellMeasure.blocks ?? (cellMeasure.paragraph ? [cellMeasure.paragraph] : []);
+    const blockMeasures = cellMeasure?.blocks ?? (cellMeasure?.paragraph ? [cellMeasure.paragraph] : []);
     if (cellBlocks.length > 0 && blockMeasures.length > 0) {
       const content2 = doc2.createElement("div");
       content2.style.position = "absolute";
       content2.style.left = `${x2 + paddingLeft}px`;
       content2.style.top = `${y2 + paddingTop}px`;
-      content2.style.width = `${Math.max(0, cellMeasure.width - paddingLeft - paddingRight)}px`;
-      let blockY = 0;
+      const contentWidth = Math.max(0, cellMeasure.width - paddingLeft - paddingRight);
+      const contentHeight = Math.max(0, rowHeight - paddingTop - paddingBottom);
+      content2.style.width = `${contentWidth + 1}px`;
+      content2.style.height = `${contentHeight}px`;
+      content2.style.display = "flex";
+      content2.style.flexDirection = "column";
+      content2.style.overflowX = "visible";
+      content2.style.overflowY = "hidden";
+      if (cell2?.attrs?.verticalAlign === "center") {
+        content2.style.justifyContent = "center";
+      } else if (cell2?.attrs?.verticalAlign === "bottom") {
+        content2.style.justifyContent = "flex-end";
+      } else {
+        content2.style.justifyContent = "flex-start";
+      }
+      const blockLineCounts = [];
+      for (let i2 = 0; i2 < Math.min(blockMeasures.length, cellBlocks.length); i2++) {
+        const bm = blockMeasures[i2];
+        if (bm.kind === "paragraph") {
+          blockLineCounts.push(bm.lines?.length || 0);
+        } else {
+          blockLineCounts.push(0);
+        }
+      }
+      const totalLines = blockLineCounts.reduce((a2, b2) => a2 + b2, 0);
+      const globalFromLine = fromLine ?? 0;
+      const globalToLine = toLine === -1 || toLine === void 0 ? totalLines : toLine;
+      let cumulativeLineCount = 0;
       for (let i2 = 0; i2 < Math.min(blockMeasures.length, cellBlocks.length); i2++) {
         const blockMeasure = blockMeasures[i2];
         const block = cellBlocks[i2];
         if (blockMeasure.kind === "paragraph" && block?.kind === "paragraph") {
+          const lines = blockMeasure.lines;
+          const blockLineCount = lines?.length || 0;
+          const blockStartGlobal = cumulativeLineCount;
+          const blockEndGlobal = cumulativeLineCount + blockLineCount;
+          if (blockEndGlobal <= globalFromLine) {
+            cumulativeLineCount += blockLineCount;
+            continue;
+          }
+          if (blockStartGlobal >= globalToLine) {
+            cumulativeLineCount += blockLineCount;
+            continue;
+          }
+          const localStartLine = Math.max(0, globalFromLine - blockStartGlobal);
+          const localEndLine = Math.min(blockLineCount, globalToLine - blockStartGlobal);
           const paraWrapper = doc2.createElement("div");
-          paraWrapper.style.position = "absolute";
-          paraWrapper.style.top = `${blockY}px`;
+          paraWrapper.style.position = "relative";
           paraWrapper.style.left = "0";
           paraWrapper.style.width = "100%";
           applySdtDataset(paraWrapper, block.attrs?.sdt);
-          const lines = blockMeasure.lines;
-          lines.forEach((line) => {
+          let renderedHeight = 0;
+          for (let lineIdx = localStartLine; lineIdx < localEndLine && lineIdx < lines.length; lineIdx++) {
+            const line = lines[lineIdx];
             const lineEl = renderLine(block, line, { ...context, section: "body" });
             paraWrapper.appendChild(lineEl);
-          });
+            renderedHeight += line.lineHeight;
+          }
+          const renderedEntireBlock = localStartLine === 0 && localEndLine >= blockLineCount;
+          if (renderedEntireBlock && blockMeasure.totalHeight && blockMeasure.totalHeight > renderedHeight) {
+            renderedHeight = blockMeasure.totalHeight;
+          }
           content2.appendChild(paraWrapper);
-          blockY += blockMeasure.totalHeight;
+          if (renderedHeight > 0) {
+            paraWrapper.style.height = `${renderedHeight}px`;
+          }
+          cumulativeLineCount += blockLineCount;
+        } else {
+          cumulativeLineCount += 0;
         }
       }
       contentElement = content2;
@@ -75977,7 +77082,10 @@ ${l}
       allRowHeights,
       context,
       renderLine,
-      applySdtDataset
+      applySdtDataset,
+      continuesFromPrev,
+      continuesOnNext,
+      partialRow
     } = deps;
     const calculateXPosition = (gridColumnStart) => {
       let x2 = 0;
@@ -76010,25 +77118,57 @@ ${l}
         const isLastRow = rowIndex === totalRows - 1;
         const isFirstCol = gridColIndex === 0;
         const isLastCol = gridColIndex === totalCols - 1;
+        const treatAsFirstRow = isFirstRow || continuesFromPrev;
+        const treatAsLastRow = isLastRow || continuesOnNext;
         resolvedBorders = {
-          // For top: use cell's if defined, otherwise use table's top for first row
-          top: cellBordersAttr.top ?? borderValueToSpec(isFirstRow ? tableBorders.top : tableBorders.insideH),
-          // For bottom: use cell's if defined, otherwise use table's bottom for last row only
-          bottom: cellBordersAttr.bottom ?? borderValueToSpec(isLastRow ? tableBorders.bottom : void 0),
+          // For top: use cell's if defined, otherwise use table's top border for first row OR continuation
+          top: cellBordersAttr.top ?? borderValueToSpec(treatAsFirstRow ? tableBorders.top : tableBorders.insideH),
+          // For bottom: use cell's if defined, otherwise use table's bottom border for last row OR before continuation
+          bottom: cellBordersAttr.bottom ?? borderValueToSpec(treatAsLastRow ? tableBorders.bottom : void 0),
           // For left: use cell's if defined, otherwise use table's left for first col
           left: cellBordersAttr.left ?? borderValueToSpec(isFirstCol ? tableBorders.left : tableBorders.insideV),
           // For right: use cell's if defined, otherwise use table's right for last col only
           right: cellBordersAttr.right ?? borderValueToSpec(isLastCol ? tableBorders.right : void 0)
         };
       } else if (hasExplicitBorders) {
-        resolvedBorders = cellBordersAttr;
+        resolvedBorders = {
+          top: cellBordersAttr.top,
+          bottom: cellBordersAttr.bottom,
+          left: cellBordersAttr.left,
+          right: cellBordersAttr.right
+        };
       } else if (tableBorders) {
-        resolvedBorders = resolveTableCellBorders(tableBorders, rowIndex, gridColIndex, totalRows, totalCols);
+        const isFirstRow = rowIndex === 0;
+        const isLastRow = rowIndex === totalRows - 1;
+        const treatAsFirstRow = isFirstRow || continuesFromPrev;
+        const treatAsLastRow = isLastRow || continuesOnNext;
+        const baseBorders = resolveTableCellBorders(tableBorders, rowIndex, gridColIndex, totalRows, totalCols);
+        if (baseBorders) {
+          resolvedBorders = {
+            // If this is a continuation (continuesFromPrev), use table's top border
+            top: treatAsFirstRow ? borderValueToSpec(tableBorders.top) : baseBorders.top,
+            // If this continues on next (continuesOnNext), use table's bottom border
+            bottom: treatAsLastRow ? borderValueToSpec(tableBorders.bottom) : baseBorders.bottom,
+            left: baseBorders.left,
+            right: baseBorders.right
+          };
+        } else {
+          resolvedBorders = void 0;
+        }
       } else {
         resolvedBorders = void 0;
       }
       const rowSpan = cellMeasure.rowSpan ?? 1;
-      const cellHeight = rowSpan > 1 ? calculateRowspanHeight(rowIndex, rowSpan) : rowMeasure.height;
+      let cellHeight;
+      if (partialRow) {
+        cellHeight = partialRow.partialHeight;
+      } else if (rowSpan > 1) {
+        cellHeight = calculateRowspanHeight(rowIndex, rowSpan);
+      } else {
+        cellHeight = rowMeasure.height;
+      }
+      const fromLine = partialRow?.fromLineByCell?.[cellIndex];
+      const toLine = partialRow?.toLineByCell?.[cellIndex];
       const { cellElement, contentElement } = renderTableCell({
         doc: doc2,
         x: x2,
@@ -76039,7 +77179,9 @@ ${l}
         borders: resolvedBorders,
         renderLine,
         context,
-        applySdtDataset
+        applySdtDataset,
+        fromLine,
+        toLine
       });
       container.appendChild(cellElement);
       if (contentElement) {
@@ -76153,11 +77295,46 @@ ${l}
     if (borderCollapse === "separate" && block.attrs?.cellSpacing) {
       container.style.borderSpacing = `${block.attrs.cellSpacing}px`;
     }
-    const allRowHeights = measure.rows.map((r2) => r2.height);
+    const allRowHeights = measure.rows.map((r2, idx) => {
+      if (fragment.partialRow && fragment.partialRow.rowIndex === idx) {
+        return fragment.partialRow.partialHeight;
+      }
+      return r2?.height ?? 0;
+    });
     let y2 = 0;
+    if (fragment.repeatHeaderCount && fragment.repeatHeaderCount > 0) {
+      for (let r2 = 0; r2 < fragment.repeatHeaderCount; r2 += 1) {
+        const rowMeasure = measure.rows[r2];
+        if (!rowMeasure) break;
+        renderTableRow({
+          doc: doc2,
+          container,
+          rowIndex: r2,
+          y: y2,
+          rowMeasure,
+          row: block.rows[r2],
+          totalRows: block.rows.length,
+          tableBorders,
+          columnWidths: measure.columnWidths,
+          allRowHeights,
+          context,
+          renderLine,
+          applySdtDataset,
+          // Headers are always rendered as-is (no border suppression)
+          continuesFromPrev: false,
+          continuesOnNext: false
+        });
+        y2 += rowMeasure.height;
+      }
+    }
     for (let r2 = fragment.fromRow; r2 < fragment.toRow; r2 += 1) {
       const rowMeasure = measure.rows[r2];
       if (!rowMeasure) break;
+      const isFirstRenderedBodyRow = r2 === fragment.fromRow;
+      const isLastRenderedBodyRow = r2 === fragment.toRow - 1;
+      const isPartialRow = fragment.partialRow && fragment.partialRow.rowIndex === r2;
+      const partialRowData = isPartialRow ? fragment.partialRow : void 0;
+      const actualRowHeight = partialRowData ? partialRowData.partialHeight : rowMeasure.height;
       renderTableRow({
         doc: doc2,
         container,
@@ -76171,9 +77348,15 @@ ${l}
         allRowHeights,
         context,
         renderLine,
-        applySdtDataset
+        applySdtDataset,
+        // Draw top border if table continues from previous fragment (MS Word behavior)
+        continuesFromPrev: isFirstRenderedBodyRow && fragment.continuesFromPrev === true,
+        // Draw bottom border if table continues on next fragment (MS Word behavior)
+        continuesOnNext: isLastRenderedBodyRow && fragment.continuesOnNext === true,
+        // Pass partial row data for mid-row splits
+        partialRow: partialRowData
       });
-      y2 += rowMeasure.height;
+      y2 += actualRowHeight;
     }
     return container;
   };
@@ -76268,6 +77451,7 @@ ${l}
     }
   }
   const LIST_MARKER_GAP$1 = 8;
+  const DEFAULT_TAB_INTERVAL_PX$1 = 48;
   const COMMENT_EXTERNAL_COLOR = "#B1124B";
   const COMMENT_INTERNAL_COLOR = "#078383";
   const COMMENT_INACTIVE_ALPHA = "22";
@@ -77064,33 +78248,41 @@ ${l}
         const firstLineOffset = (paraIndent?.firstLine ?? 0) - (paraIndent?.hanging ?? 0);
         lines.forEach((line, index2) => {
           const lineEl = this.renderLine(block, line, context);
-          if (paraIndentLeft) {
+          const isListFirstLine = index2 === 0 && !fragment.continuesFromPrev && fragment.markerWidth && wordLayout?.marker;
+          if (paraIndentLeft && !isListFirstLine) {
             lineEl.style.paddingLeft = `${paraIndentLeft}px`;
           }
           if (paraIndentRight) {
             lineEl.style.paddingRight = `${paraIndentRight}px`;
           }
-          if (!fragment.continuesFromPrev && index2 === 0 && firstLineOffset) {
+          if (!fragment.continuesFromPrev && index2 === 0 && firstLineOffset && !isListFirstLine) {
             lineEl.style.textIndent = `${firstLineOffset}px`;
-          } else if (firstLineOffset) {
+          } else if (firstLineOffset && !isListFirstLine) {
             lineEl.style.textIndent = "0px";
           }
-          if (index2 === 0 && !fragment.continuesFromPrev && fragment.markerWidth && wordLayout?.marker) {
+          if (isListFirstLine && wordLayout?.marker && fragment.markerWidth) {
+            const markerStartPos = paraIndentLeft - (paraIndent?.hanging ?? 0);
+            lineEl.style.paddingLeft = `${markerStartPos}px`;
             const markerContainer = this.doc.createElement("span");
             markerContainer.style.display = "inline-block";
             const markerEl = this.doc.createElement("span");
             markerEl.classList.add("superdoc-paragraph-marker");
             markerEl.textContent = wordLayout.marker.markerText ?? "";
-            markerEl.style.width = `${fragment.markerWidth}px`;
-            markerEl.style.textAlign = wordLayout.marker.justification ?? "right";
-            markerEl.style.paddingRight = `${LIST_MARKER_GAP$1}px`;
             markerEl.style.pointerEvents = "none";
-            const indentLeft = paraIndentLeft;
-            const hanging = paraIndent?.hanging ?? 0;
-            const textStartX = indentLeft - hanging;
-            const markerLeftX = textStartX - fragment.markerWidth;
-            markerEl.style.position = "relative";
-            markerEl.style.left = `${markerLeftX}px`;
+            const markerJustification = wordLayout.marker.justification ?? "left";
+            if (markerJustification !== "left") {
+              markerEl.style.width = `${fragment.markerWidth}px`;
+              markerEl.style.textAlign = wordLayout.marker.justification ?? "right";
+              markerEl.style.paddingRight = `${LIST_MARKER_GAP$1}px`;
+            }
+            if (markerJustification === "left") {
+              markerContainer.style.position = "relative";
+            } else {
+              const markerLeftX = markerStartPos - fragment.markerWidth;
+              markerContainer.style.position = "absolute";
+              markerContainer.style.left = `${markerLeftX}px`;
+              markerContainer.style.top = "0";
+            }
             markerEl.style.fontFamily = wordLayout.marker.run.fontFamily;
             markerEl.style.fontSize = `${wordLayout.marker.run.fontSize}px`;
             markerEl.style.fontWeight = wordLayout.marker.run.bold ? "bold" : "";
@@ -77107,12 +78299,25 @@ ${l}
               const tabEl = this.doc.createElement("span");
               tabEl.className = "superdoc-tab";
               tabEl.innerHTML = "&nbsp;";
-              const gutterWidth = typeof wordLayout.marker.gutterWidthPx === "number" && isFinite(wordLayout.marker.gutterWidthPx) && wordLayout.marker.gutterWidthPx > 0 ? wordLayout.marker.gutterWidthPx : LIST_MARKER_GAP$1;
+              let tabWidth;
+              const markerBoxWidth = fragment.markerWidth;
+              const markerTextWidth = fragment.markerTextWidth != null && isFinite(fragment.markerTextWidth) && fragment.markerTextWidth >= 0 ? fragment.markerTextWidth : markerBoxWidth;
+              if ((wordLayout.marker.justification ?? "left") === "left") {
+                const currentPos = markerStartPos + markerTextWidth;
+                const implicitTabStop = paraIndentLeft;
+                tabWidth = implicitTabStop - currentPos;
+                if (tabWidth < 1) {
+                  tabWidth = DEFAULT_TAB_INTERVAL_PX$1 - currentPos % DEFAULT_TAB_INTERVAL_PX$1;
+                  if (tabWidth === 0) tabWidth = DEFAULT_TAB_INTERVAL_PX$1;
+                }
+              } else {
+                tabWidth = fragment.markerGutter != null && isFinite(fragment.markerGutter) ? fragment.markerGutter : typeof wordLayout.marker.gutterWidthPx === "number" && isFinite(wordLayout.marker.gutterWidthPx) && wordLayout.marker.gutterWidthPx > 0 ? wordLayout.marker.gutterWidthPx : LIST_MARKER_GAP$1;
+              }
               tabEl.style.display = "inline-block";
-              tabEl.style.width = `${gutterWidth}px`;
-              markerContainer.appendChild(tabEl);
+              tabEl.style.width = `${tabWidth}px`;
+              lineEl.prepend(tabEl);
             } else if (suffix2 === "space") {
-              markerContainer.appendChild(this.doc.createTextNode(" "));
+              lineEl.prepend(this.doc.createTextNode(" "));
             }
             lineEl.prepend(markerContainer);
           }
@@ -77961,6 +79166,12 @@ ${l}
     isLineBreakRun(run2) {
       return run2.kind === "lineBreak";
     }
+    /**
+     * Type guard to check if a run is a break run.
+     */
+    isBreakRun(run2) {
+      return run2.kind === "break";
+    }
     renderRun(run2, context, trackedConfig) {
       if (this.isImageRun(run2)) {
         return this.renderImageRun(run2);
@@ -77968,7 +79179,10 @@ ${l}
       if (this.isLineBreakRun(run2)) {
         return null;
       }
-      if (!run2.text || !this.doc) {
+      if (this.isBreakRun(run2)) {
+        return null;
+      }
+      if (!("text" in run2) || !run2.text || !this.doc) {
         return null;
       }
       const linkData = this.extractLinkData(run2);
@@ -78109,6 +79323,12 @@ ${l}
       if (styleId) {
         el.setAttribute("styleid", styleId);
       }
+      const alignment2 = block.attrs?.alignment;
+      if (alignment2 === "center" || alignment2 === "right" || alignment2 === "justify") {
+        el.style.textAlign = alignment2 === "justify" ? "justify" : alignment2;
+      } else {
+        el.style.textAlign = "left";
+      }
       const lineRange = computeLinePmRange(block, line);
       if (lineRange.pmStart != null) {
         el.dataset.pmStart = String(lineRange.pmStart);
@@ -78226,10 +79446,16 @@ ${l}
           if (this.isLineBreakRun(baseRun)) {
             continue;
           }
+          if (this.isBreakRun(baseRun)) {
+            continue;
+          }
           const runSegments = segmentsByRun.get(runIndex);
           if (!runSegments || runSegments.length === 0) {
             continue;
           }
+          if (!("text" in baseRun)) {
+            continue;
+          }
           const baseText = baseRun.text ?? "";
           const runPmStart = baseRun.pmStart ?? null;
           const fallbackPmEnd = runPmStart != null && baseRun.pmEnd == null ? runPmStart + baseText.length : baseRun.pmEnd ?? null;
@@ -78548,7 +79774,12 @@ ${l}
     if (fragment.kind === "drawing") {
       return `drawing:${fragment.blockId}:${fragment.x}:${fragment.y}`;
     }
-    return `${fragment.kind}:${fragment.blockId}`;
+    if (fragment.kind === "table") {
+      const partialKey = fragment.partialRow ? `:${fragment.partialRow.fromLineByCell.join(",")}-${fragment.partialRow.toLineByCell.join(",")}` : "";
+      return `table:${fragment.blockId}:${fragment.fromRow}:${fragment.toRow}${partialKey}`;
+    }
+    const _exhaustiveCheck = fragment;
+    return _exhaustiveCheck;
   };
   const fragmentSignature = (fragment, lookup2) => {
     const base2 = lookup2.get(fragment.blockId)?.version ?? "missing";
@@ -78560,7 +79791,9 @@ ${l}
         fragment.pmStart ?? "",
         fragment.pmEnd ?? "",
         fragment.continuesFromPrev ? 1 : 0,
-        fragment.continuesOnNext ? 1 : 0
+        fragment.continuesOnNext ? 1 : 0,
+        fragment.markerWidth ?? ""
+        // Include markerWidth to trigger re-render when list status changes
       ].join("|");
     }
     if (fragment.kind === "list-item") {
@@ -78590,6 +79823,20 @@ ${l}
         fragment.zIndex ?? ""
       ].join("|");
     }
+    if (fragment.kind === "table") {
+      const partialSig = fragment.partialRow ? `${fragment.partialRow.fromLineByCell.join(",")}-${fragment.partialRow.toLineByCell.join(",")}-${fragment.partialRow.partialHeight}` : "";
+      return [
+        base2,
+        fragment.fromRow,
+        fragment.toRow,
+        fragment.width,
+        fragment.height,
+        fragment.continuesFromPrev ? 1 : 0,
+        fragment.continuesOnNext ? 1 : 0,
+        fragment.repeatHeaderCount ?? 0,
+        partialSig
+      ].join("|");
+    }
     return base2;
   };
   const deriveBlockVersion = (block) => {
@@ -78735,7 +79982,7 @@ ${l}
     return block.id;
   };
   const applyRunStyles = (element2, run2, isLink = false) => {
-    if (run2.kind === "tab" || run2.kind === "image" || run2.kind === "lineBreak") {
+    if (run2.kind === "tab" || run2.kind === "image" || run2.kind === "lineBreak" || run2.kind === "break") {
       return;
     }
     element2.style.fontFamily = run2.fontFamily;
@@ -78869,6 +80116,17 @@ ${l}
         result.push(run2);
         continue;
       }
+      if (run2.kind === "break") {
+        result.push(run2);
+        continue;
+      }
+      if (run2.kind === "tab") {
+        result.push(run2);
+        continue;
+      }
+      if (!("text" in run2)) {
+        continue;
+      }
       const text2 = run2.text ?? "";
       const isFirstRun = runIndex === line.fromRun;
       const isLastRun = runIndex === line.toRun;
@@ -78882,20 +80140,14 @@ ${l}
         if (!slice2) continue;
         const pmSliceStart = runPmStart != null ? runPmStart + start2 : void 0;
         const pmSliceEnd = runPmStart != null ? runPmStart + end2 : fallbackPmEnd ?? void 0;
-        if (run2.kind === "tab") {
-          if (slice2.includes("	")) {
-            result.push(run2);
-          }
-        } else {
-          const sliced = {
-            ...run2,
-            text: slice2,
-            pmStart: pmSliceStart,
-            pmEnd: pmSliceEnd,
-            comments: run2.comments ? [...run2.comments] : void 0
-          };
-          result.push(sliced);
-        }
+        const sliced = {
+          ...run2,
+          text: slice2,
+          pmStart: pmSliceStart,
+          pmEnd: pmSliceEnd,
+          comments: run2.comments ? [...run2.comments] : void 0
+        };
+        result.push(sliced);
       } else {
         result.push(run2);
       }
@@ -78938,6 +80190,39 @@ ${l}
         }
         continue;
       }
+      if (run2.kind === "break") {
+        const runPmStart2 = run2.pmStart ?? null;
+        const runPmEnd = run2.pmEnd ?? null;
+        if (runPmStart2 == null || runPmEnd == null) {
+          continue;
+        }
+        if (pmStart == null) {
+          pmStart = runPmStart2;
+        }
+        pmEnd = runPmEnd;
+        if (runIndex === line.toRun) {
+          break;
+        }
+        continue;
+      }
+      if (run2.kind === "tab") {
+        const runPmStart2 = run2.pmStart ?? null;
+        const runPmEnd = run2.pmEnd ?? null;
+        if (runPmStart2 == null || runPmEnd == null) {
+          continue;
+        }
+        if (pmStart == null) {
+          pmStart = runPmStart2;
+        }
+        pmEnd = runPmEnd;
+        if (runIndex === line.toRun) {
+          break;
+        }
+        continue;
+      }
+      if (!("text" in run2)) {
+        continue;
+      }
       const text2 = run2.text ?? "";
       const runLength = text2.length;
       const runPmStart = run2.pmStart ?? null;
@@ -78979,6 +80264,12 @@ ${l}
     if (run2.kind === "lineBreak") {
       return "";
     }
+    if (run2.kind === "break") {
+      return "";
+    }
+    if (!("text" in run2)) {
+      return "";
+    }
     if (!runToken) {
       return run2.text ?? "";
     }
@@ -79176,6 +80467,7 @@ ${l}
   async function measureParagraphBlock(block, maxWidth) {
     const ctx2 = getCanvasContext();
     const wordLayout = block.attrs?.wordLayout;
+    const WIDTH_FUDGE_PX = 0.5;
     const lines = [];
     const indent2 = block.attrs?.indent;
     const spacing = block.attrs?.spacing;
@@ -79270,8 +80562,67 @@ ${l}
       lastAppliedTabAlign = { target, val };
       pendingTabAlignment = null;
     };
-    for (let runIndex = 0; runIndex < block.runs.length; runIndex++) {
-      const run2 = block.runs[runIndex];
+    const runsToProcess = [];
+    for (const run2 of block.runs) {
+      if (run2.text && typeof run2.text === "string" && run2.text.includes("\n")) {
+        const textRun = run2;
+        const segments = textRun.text.split("\n");
+        let cursor = textRun.pmStart ?? 0;
+        segments.forEach((seg, idx) => {
+          runsToProcess.push({
+            ...textRun,
+            text: seg,
+            pmStart: cursor,
+            pmEnd: cursor + seg.length
+          });
+          cursor += seg.length;
+          if (idx !== segments.length - 1) {
+            runsToProcess.push({
+              kind: "break",
+              breakType: "line",
+              pmStart: cursor,
+              pmEnd: cursor + 1,
+              sdt: run2.sdt
+            });
+            cursor += 1;
+          }
+        });
+      } else {
+        runsToProcess.push(run2);
+      }
+    }
+    for (let runIndex = 0; runIndex < runsToProcess.length; runIndex++) {
+      const run2 = runsToProcess[runIndex];
+      if (run2.kind === "break") {
+        if (currentLine) {
+          const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing);
+          const completedLine = { ...currentLine, ...metrics };
+          addBarTabsToLine(completedLine);
+          lines.push(completedLine);
+          currentLine = null;
+        } else {
+          const textRunWithSize = block.runs.find(
+            (r2) => r2.kind !== "tab" && r2.kind !== "lineBreak" && r2.kind !== "break" && !("src" in r2) && "fontSize" in r2
+          );
+          const fallbackSize = textRunWithSize?.fontSize ?? 12;
+          const metrics = calculateTypographyMetrics(fallbackSize, spacing);
+          const emptyLine = {
+            fromRun: runIndex,
+            fromChar: 0,
+            toRun: runIndex,
+            toChar: 0,
+            width: 0,
+            segments: [],
+            ...metrics
+          };
+          addBarTabsToLine(emptyLine);
+          lines.push(emptyLine);
+        }
+        tabStopCursor = 0;
+        pendingTabAlignment = null;
+        lastAppliedTabAlign = null;
+        continue;
+      }
       if (isLineBreakRun(run2)) {
         if (currentLine) {
           const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing);
@@ -79422,6 +80773,9 @@ ${l}
         }
         continue;
       }
+      if (!("text" in run2) || !("fontSize" in run2)) {
+        continue;
+      }
       lastFontSize = run2.fontSize;
       const { font } = buildFontString(run2);
       const tabSegments = run2.text.split("	");
@@ -79461,18 +80815,18 @@ ${l}
               segments: [{ runIndex, fromChar: wordStartChar, toChar: wordEndNoSpace, width: wordOnlyWidth }]
             };
             const ls = run2.letterSpacing ?? 0;
-            if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth) {
+            if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX) {
               currentLine.toChar = wordEndWithSpace;
               currentLine.width = roundValue(currentLine.width + spaceWidth + ls);
               charPosInRun = wordEndWithSpace;
             } else {
-              charPosInRun = wordEndNoSpace;
+              charPosInRun = wordEndWithSpace;
             }
             continue;
           }
           const isTocEntry = block.attrs?.isTocEntry;
           const boundarySpacing = currentLine.width > 0 ? run2.letterSpacing ?? 0 : 0;
-          if (currentLine.width + boundarySpacing + wordOnlyWidth > currentLine.maxWidth && currentLine.width > 0 && !isTocEntry) {
+          if (currentLine.width + boundarySpacing + wordOnlyWidth > currentLine.maxWidth - WIDTH_FUDGE_PX && currentLine.width > 0 && !isTocEntry) {
             const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing);
             const completedLine = {
               ...currentLine,
@@ -79492,16 +80846,16 @@ ${l}
               maxWidth: getEffectiveWidth(contentWidth),
               segments: [{ runIndex, fromChar: wordStartChar, toChar: wordEndNoSpace, width: wordOnlyWidth }]
             };
-            if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth) {
+            if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX) {
               currentLine.toChar = wordEndWithSpace;
               currentLine.width = roundValue(currentLine.width + spaceWidth + (run2.letterSpacing ?? 0));
               charPosInRun = wordEndWithSpace;
             } else {
-              charPosInRun = wordEndNoSpace;
+              charPosInRun = wordEndWithSpace;
             }
           } else {
             currentLine.toRun = runIndex;
-            if (!isLastWord && currentLine.width + boundarySpacing + wordOnlyWidth + spaceWidth > currentLine.maxWidth) {
+            if (!isLastWord && currentLine.width + boundarySpacing + wordOnlyWidth + spaceWidth > currentLine.maxWidth - WIDTH_FUDGE_PX) {
               currentLine.toChar = wordEndNoSpace;
               currentLine.width = roundValue(currentLine.width + boundarySpacing + wordOnlyWidth);
               currentLine.maxFontSize = Math.max(currentLine.maxFontSize, run2.fontSize);
@@ -79610,10 +80964,14 @@ ${l}
       const { font: markerFont } = buildFontString(markerRun);
       const markerText = wordLayout.marker.markerText ?? "";
       const glyphWidth = markerText ? measureText(markerText, markerFont, ctx2) : 0;
+      const gutter = typeof wordLayout.marker.gutterWidthPx === "number" && isFinite(wordLayout.marker.gutterWidthPx) && wordLayout.marker.gutterWidthPx >= 0 ? wordLayout.marker.gutterWidthPx : LIST_MARKER_GAP;
+      const markerBoxWidth = Math.max(wordLayout.marker.markerBoxWidthPx ?? 0, glyphWidth + LIST_MARKER_GAP);
       markerInfo = {
-        markerWidth: Math.max(wordLayout.marker.markerBoxWidthPx ?? 0, glyphWidth + LIST_MARKER_GAP),
+        markerWidth: markerBoxWidth,
         markerTextWidth: glyphWidth,
-        indentLeft: wordLayout.indentLeftPx ?? 0
+        indentLeft: wordLayout.indentLeftPx ?? 0,
+        // For tab sizing in the renderer: expose gutter for word-layout lists
+        gutterWidth: gutter
       };
     }
     return {
@@ -79627,6 +80985,34 @@ ${l}
   async function measureTableBlock(block, constraints) {
     const maxWidth = typeof constraints === "number" ? constraints : constraints.maxWidth;
     let columnWidths;
+    const scaleColumnWidths = (widths, targetWidth) => {
+      const totalWidth2 = widths.reduce((a2, b2) => a2 + b2, 0);
+      if (totalWidth2 <= targetWidth || widths.length === 0) return widths;
+      const scale = targetWidth / totalWidth2;
+      const scaled = widths.map((w2) => Math.max(1, Math.round(w2 * scale)));
+      const sum = scaled.reduce((a2, b2) => a2 + b2, 0);
+      if (sum !== targetWidth) {
+        const adjust = (delta) => {
+          let idx = 0;
+          const direction = delta > 0 ? 1 : -1;
+          delta = Math.abs(delta);
+          while (delta > 0 && scaled.length > 0) {
+            const i2 = idx % scaled.length;
+            if (direction > 0) {
+              scaled[i2] += 1;
+              delta -= 1;
+            } else if (scaled[i2] > 1) {
+              scaled[i2] -= 1;
+              delta -= 1;
+            }
+            idx += 1;
+            if (idx > scaled.length * 2 && delta > 0) break;
+          }
+        };
+        adjust(targetWidth - sum);
+      }
+      return scaled;
+    };
     const maxCellCount = Math.max(1, Math.max(...block.rows.map((r2) => r2.cells.length)));
     if (block.columnWidths && block.columnWidths.length > 0) {
       columnWidths = [...block.columnWidths];
@@ -79635,8 +81021,7 @@ ${l}
       if (hasExplicitWidth || hasFixedLayout) {
         const totalWidth2 = columnWidths.reduce((a2, b2) => a2 + b2, 0);
         if (totalWidth2 > maxWidth) {
-          const scale = maxWidth / totalWidth2;
-          columnWidths = columnWidths.map((w2) => Math.max(1, Math.floor(w2 * scale)));
+          columnWidths = scaleColumnWidths(columnWidths, maxWidth);
         }
       } else {
         if (columnWidths.length < maxCellCount) {
@@ -79650,8 +81035,7 @@ ${l}
         }
         const totalWidth2 = columnWidths.reduce((a2, b2) => a2 + b2, 0);
         if (totalWidth2 > maxWidth) {
-          const scale = maxWidth / totalWidth2;
-          columnWidths = columnWidths.map((w2) => Math.max(1, Math.floor(w2 * scale)));
+          columnWidths = scaleColumnWidths(columnWidths, maxWidth);
         }
       }
     } else {
@@ -79668,6 +81052,8 @@ ${l}
     };
     const rowspanTracker = new Array(gridColumnCount).fill(0);
     const rows = [];
+    const rowBaseHeights = new Array(block.rows.length).fill(0);
+    const spanConstraints = [];
     for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex++) {
       const row2 = block.rows[rowIndex];
       const cellMeasures = [];
@@ -79714,6 +81100,11 @@ ${l}
           colSpan: colspan,
           rowSpan: rowspan
         });
+        if (rowspan === 1) {
+          rowBaseHeights[rowIndex] = Math.max(rowBaseHeights[rowIndex], totalCellHeight);
+        } else {
+          spanConstraints.push({ startRow: rowIndex, rowSpan: rowspan, requiredHeight: totalCellHeight });
+        }
         gridColIndex += colspan;
       }
       for (let col = gridColIndex; col < gridColumnCount; col++) {
@@ -79721,10 +81112,39 @@ ${l}
           rowspanTracker[col]--;
         }
       }
-      const rowHeight = Math.max(0, ...cellMeasures.map((c2) => c2.height));
-      rows.push({ cells: cellMeasures, height: rowHeight });
+      rows.push({ cells: cellMeasures, height: 0 });
+    }
+    const rowHeights = [...rowBaseHeights];
+    for (const constraint of spanConstraints) {
+      const { startRow, rowSpan, requiredHeight } = constraint;
+      if (rowSpan <= 0) continue;
+      let currentHeight = 0;
+      for (let i2 = 0; i2 < rowSpan && startRow + i2 < rowHeights.length; i2++) {
+        currentHeight += rowHeights[startRow + i2];
+      }
+      if (currentHeight < requiredHeight) {
+        const spanLength = Math.min(rowSpan, rowHeights.length - startRow);
+        const increment2 = spanLength > 0 ? (requiredHeight - currentHeight) / spanLength : 0;
+        for (let i2 = 0; i2 < spanLength; i2++) {
+          rowHeights[startRow + i2] += increment2;
+        }
+      }
+    }
+    block.rows.forEach((row2, index2) => {
+      const spec = row2.attrs?.rowHeight;
+      if (spec?.value != null && Number.isFinite(spec.value)) {
+        const rule = spec.rule ?? "atLeast";
+        if (rule === "exact") {
+          rowHeights[index2] = spec.value;
+        } else {
+          rowHeights[index2] = Math.max(rowHeights[index2], spec.value);
+        }
+      }
+    });
+    for (let i2 = 0; i2 < rows.length; i2++) {
+      rows[i2].height = Math.max(0, rowHeights[i2]);
     }
-    const totalHeight = rows.reduce((sum, r2) => sum + r2.height, 0);
+    const totalHeight = rowHeights.reduce((sum, h2) => sum + h2, 0);
     const totalWidth = columnWidths.reduce((a2, b2) => a2 + b2, 0);
     return {
       kind: "table",
@@ -79930,7 +81350,7 @@ ${l}
     if (spacing.lineRule === "atLeast") {
       return Math.max(baseLineHeight, raw);
     }
-    return raw;
+    return Math.max(baseLineHeight, raw);
   };
   const sanitizePositive = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0;
   const sanitizeDecimalSeparator = (value) => {
@@ -85820,6 +87240,17 @@ ${l}
     parseTagObject
   }, Symbol.toStringTag, { value: "Module" }));
   const STRUCTURED_CONTENT_NAMES = ["structuredContent", "structuredContentBlock"];
+  const findFirstTextNode = (node2) => {
+    let firstTextNode = null;
+    node2.descendants((child) => {
+      if (child.isText) {
+        firstTextNode = child;
+        return false;
+      }
+      return true;
+    });
+    return firstTextNode;
+  };
   const StructuredContentCommands = Extension.create({
     name: "structuredContentCommands",
     addCommands() {
@@ -85960,7 +87391,7 @@ ${l}
          * @param {string} id - Unique identifier of the field
          * @param {StructuredContentUpdate} options
          * @example
-         * editor.commands.updateStructuredContentById('123', { text: 'Jane Doe' });
+         * editor.commands.updateStructuredContentById('123', { text: 'Jane Doe', keepTextNodeStyles: true });
          * editor.commands.updateStructuredContentById('123', {
          *  json: { type: 'text', text: 'Jane Doe' },
          * });
@@ -85981,7 +87412,9 @@ ${l}
             const posTo = pos + node2.nodeSize;
             let content2 = null;
             if (options.text) {
-              content2 = schema.text(options.text);
+              const firstTextNode = options.keepTextNodeStyles === true ? findFirstTextNode(node2) : null;
+              const textMarks = firstTextNode ? firstTextNode.marks : [];
+              content2 = schema.text(options.text, textMarks);
             }
             if (options.html) {
               const html2 = htmlHandler(options.html, editor);
@@ -85995,6 +87428,13 @@ ${l}
               content2 = node2.content;
             }
             const updatedNode = node2.type.create({ ...node2.attrs, ...options.attrs }, content2, node2.marks);
+            try {
+              const nodeForValidation = editor.validateJSON(updatedNode.toJSON());
+              nodeForValidation.check();
+            } catch (error) {
+              console.error("Invalid content.", "Passed value:", content2, "Error:", error);
+              return false;
+            }
             tr.replaceWith(posFrom, posTo, updatedNode);
           }
           return true;
@@ -86079,7 +87519,7 @@ ${l}
          * @param {StructuredContentUpdate} options
          * @example
          * // Update all fields in the customer-info group
-         * editor.commands.updateStructuredContentByGroup('customer-info', { text: 'Jane Doe' });
+         * editor.commands.updateStructuredContentByGroup('customer-info', { text: 'Jane Doe', keepTextNodeStyles: true });
          *
          * // Update block content in a group
          * editor.commands.updateStructuredContentByGroup('terms-section', {
@@ -86093,13 +87533,14 @@ ${l}
           }
           const { schema } = editor;
           if (dispatch) {
-            structuredContentTags.forEach((structuredContent) => {
+            const updates = [];
+            for (const structuredContent of structuredContentTags) {
               const { pos, node: node2 } = structuredContent;
-              const posFrom = tr.mapping.map(pos);
-              const posTo = tr.mapping.map(pos + node2.nodeSize);
               let content2 = null;
               if (options.text) {
-                content2 = schema.text(options.text);
+                const firstTextNode = options.keepTextNodeStyles === true ? findFirstTextNode(node2) : null;
+                const textMarks = firstTextNode ? firstTextNode.marks : [];
+                content2 = schema.text(options.text, textMarks);
               }
               if (options.html) {
                 const html2 = htmlHandler(options.html, editor);
@@ -86113,11 +87554,23 @@ ${l}
                 content2 = node2.content;
               }
               const updatedNode = node2.type.create({ ...node2.attrs, ...options.attrs }, content2, node2.marks);
+              try {
+                const nodeForValidation = editor.validateJSON(updatedNode.toJSON());
+                nodeForValidation.check();
+              } catch (error) {
+                console.error("Invalid content.", "Passed value:", content2, "Error:", error);
+                return false;
+              }
+              updates.push({ pos, node: node2, updatedNode });
+            }
+            for (const { pos, node: node2, updatedNode } of updates) {
+              const posFrom = tr.mapping.map(pos);
+              const posTo = tr.mapping.map(pos + node2.nodeSize);
               const currentNode = tr.doc.nodeAt(posFrom);
               if (currentNode && node2.eq(currentNode)) {
                 tr.replaceWith(posFrom, posTo, updatedNode);
               }
-            });
+            }
           }
           return true;
         },
@@ -86693,61 +88146,153 @@ ${l}
       return {};
     }
   });
-  const splitRun = () => (props) => {
-    const { state: state2, view, tr } = props;
-    const { $from, empty: empty2 } = state2.selection;
-    if (!empty2) return false;
-    if ($from.parent.type.name !== "run") return false;
-    const handled = splitBlockPatch(state2, (transaction) => {
-      view.dispatch(transaction);
-    });
-    if (handled) {
-      tr.setMeta("preventDispatch", true);
-    }
-    return handled;
-  };
-  function splitBlockPatch(state2, dispatch) {
-    let { $from } = state2.selection;
-    if (state2.selection instanceof NodeSelection && state2.selection.node.isBlock) {
-      if (!$from.parentOffset || !canSplit(state2.doc, $from.pos)) return false;
-      if (dispatch) dispatch(state2.tr.split($from.pos).scrollIntoView());
-      return true;
+  const cleanupEmptyRunsPlugin = new Plugin({
+    appendTransaction(trs, oldState, newState) {
+      if (!trs.some((tr2) => tr2.docChanged)) return null;
+      const { run: run2, paragraph: paragraph2 } = newState.schema.nodes;
+      if (!run2) return null;
+      const ranges = [];
+      trs.forEach((tr2) => {
+        tr2.mapping.maps.forEach((map2) => {
+          map2.forEach((oldStart, oldEnd, newStart, newEnd) => {
+            if (newStart !== oldStart || oldEnd !== newEnd) ranges.push({ from: newStart, to: newEnd });
+          });
+        });
+      });
+      if (!ranges.length) return null;
+      ranges.sort((a2, b2) => a2.from - b2.from);
+      const merged = [];
+      for (const r2 of ranges) {
+        const from2 = Math.max(0, r2.from - 1);
+        const to = Math.min(newState.doc.content.size, r2.to + 1);
+        const last = merged[merged.length - 1];
+        if (last && from2 <= last.to) last.to = Math.max(last.to, to);
+        else merged.push({ from: from2, to });
+      }
+      const toDelete = [];
+      merged.forEach(({ from: from2, to }) => {
+        newState.doc.nodesBetween(from2, to, (node2, pos, parent) => {
+          if (node2.type === run2 && node2.content.size === 0 && parent?.type === paragraph2) {
+            toDelete.push({ from: pos, to: pos + node2.nodeSize });
+          }
+        });
+      });
+      if (!toDelete.length) return null;
+      const tr = newState.tr;
+      toDelete.sort((a2, b2) => b2.from - a2.from).forEach(({ from: from2, to }) => tr.deleteRange(from2, to));
+      return tr.docChanged ? tr : null;
     }
-    if (!$from.depth) return false;
-    let types2 = [];
-    let splitDepth, deflt, atEnd = false, atStart = false;
-    for (let d2 = $from.depth; ; d2--) {
-      let node2 = $from.node(d2);
-      if (node2.isBlock) {
-        atEnd = $from.end(d2) == $from.pos + ($from.depth - d2);
-        atStart = $from.start(d2) == $from.pos - ($from.depth - d2);
-        deflt = defaultBlockAt$1($from.node(d2 - 1).contentMatchAt($from.indexAfter(d2 - 1)));
-        types2.unshift(null);
-        splitDepth = d2;
-        break;
+  });
+  const mergeRanges$1 = (ranges, docSize) => {
+    if (!ranges.length) return [];
+    const sorted = ranges.map(({ from: from2, to }) => ({
+      from: Math.max(0, from2),
+      to: Math.min(docSize, to)
+    })).filter(({ from: from2, to }) => from2 < to).sort((a2, b2) => a2.from - b2.from);
+    const merged = [];
+    for (const range2 of sorted) {
+      const last = merged[merged.length - 1];
+      if (last && range2.from <= last.to) {
+        last.to = Math.max(last.to, range2.to);
       } else {
-        if (d2 == 1) return false;
-        types2.unshift(null);
+        merged.push({ ...range2 });
       }
     }
-    let tr = state2.tr;
-    if (state2.selection instanceof TextSelection$1 || state2.selection instanceof AllSelection) tr.deleteSelection();
-    let splitPos = tr.mapping.map($from.pos);
-    let can = canSplit(tr.doc, splitPos, types2.length, types2);
-    if (!can) {
-      types2[0] = deflt ? { type: deflt } : null;
-      can = canSplit(tr.doc, splitPos, types2.length, types2);
-    }
-    if (!can) return false;
-    tr.split(splitPos, types2.length, types2);
-    if (!atEnd && atStart && $from.node(splitDepth).type != deflt) {
-      let first2 = tr.mapping.map($from.before(splitDepth)), $first = tr.doc.resolve(first2);
-      if (deflt && $from.node(splitDepth - 1).canReplaceWith($first.index(), $first.index() + 1, deflt))
-        tr.setNodeMarkup(tr.mapping.map($from.before(splitDepth)), deflt);
-    }
-    if (dispatch) dispatch(tr.scrollIntoView());
-    return true;
-  }
+    return merged;
+  };
+  const collectChangedRanges = (trs, docSize) => {
+    const ranges = [];
+    trs.forEach((tr) => {
+      if (!tr.docChanged) return;
+      tr.mapping.maps.forEach((map2) => {
+        map2.forEach((oldStart, oldEnd, newStart, newEnd) => {
+          if (newStart !== oldStart || oldEnd !== newEnd) {
+            ranges.push({ from: newStart, to: newEnd });
+          }
+        });
+      });
+    });
+    return mergeRanges$1(ranges, docSize);
+  };
+  const mapRangesThroughTransactions = (ranges, transactions, docSize) => {
+    let mapped = ranges;
+    transactions.forEach((tr) => {
+      mapped = mapped.map(({ from: from2, to }) => {
+        const mappedFrom = tr.mapping.map(from2, -1);
+        const mappedTo = tr.mapping.map(to, 1);
+        if (mappedFrom >= mappedTo) return null;
+        return { from: mappedFrom, to: mappedTo };
+      }).filter(Boolean);
+    });
+    return mergeRanges$1(mapped, docSize);
+  };
+  const buildWrapTransaction = (state2, ranges, runType) => {
+    if (!ranges.length) return null;
+    const replacements = [];
+    ranges.forEach(({ from: from2, to }) => {
+      state2.doc.nodesBetween(from2, to, (node2, pos, parent, index2) => {
+        if (!node2.isText || !parent || parent.type === runType) return;
+        const match = parent.contentMatchAt ? parent.contentMatchAt(index2) : null;
+        if (match && !match.matchType(runType)) return;
+        if (!match && !parent.type.contentMatch.matchType(runType)) return;
+        const runProperties = decodeRPrFromMarks(node2.marks);
+        const runNode = runType.create({ runProperties }, node2);
+        replacements.push({ from: pos, to: pos + node2.nodeSize, runNode });
+      });
+    });
+    if (!replacements.length) return null;
+    const tr = state2.tr;
+    replacements.sort((a2, b2) => b2.from - a2.from).forEach(({ from: from2, to, runNode }) => tr.replaceWith(from2, to, runNode));
+    return tr.docChanged ? tr : null;
+  };
+  const wrapTextInRunsPlugin = () => {
+    let view = null;
+    let pendingRanges = [];
+    const flush = () => {
+      if (!view) return;
+      const runType = view.state.schema.nodes.run;
+      if (!runType) {
+        pendingRanges = [];
+        return;
+      }
+      const tr = buildWrapTransaction(view.state, pendingRanges, runType);
+      pendingRanges = [];
+      if (tr) {
+        view.dispatch(tr);
+      }
+    };
+    const onCompositionEnd2 = () => {
+      if (typeof globalThis === "undefined") return;
+      globalThis.queueMicrotask(flush);
+    };
+    return new Plugin({
+      view(editorView) {
+        view = editorView;
+        editorView.dom.addEventListener("compositionend", onCompositionEnd2);
+        return {
+          destroy() {
+            editorView.dom.removeEventListener("compositionend", onCompositionEnd2);
+            view = null;
+            pendingRanges = [];
+          }
+        };
+      },
+      appendTransaction(transactions, _oldState, newState) {
+        const docSize = newState.doc.content.size;
+        const runType = newState.schema.nodes.run;
+        if (!runType) return null;
+        pendingRanges = mapRangesThroughTransactions(pendingRanges, transactions, docSize);
+        const changedRanges = collectChangedRanges(transactions, docSize);
+        pendingRanges = mergeRanges$1([...pendingRanges, ...changedRanges], docSize);
+        if (view?.composing) {
+          return null;
+        }
+        const tr = buildWrapTransaction(newState, pendingRanges, runType);
+        pendingRanges = [];
+        return tr;
+      }
+    });
+  };
   const Run = OxmlNode.create({
     name: "run",
     oXmlName: "w:r",
@@ -86790,7 +88335,8 @@ ${l}
     // @ts-expect-error - Command signatures will be fixed in TS migration
     addCommands() {
       return {
-        splitRun
+        splitRunToParagraph,
+        splitRunAtCursor
       };
     },
     parseDOM() {
@@ -86799,6 +88345,9 @@ ${l}
     renderDOM({ htmlAttributes }) {
       const base2 = Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
       return ["span", base2, 0];
+    },
+    addPmPlugins() {
+      return [wrapTextInRunsPlugin(), cleanupEmptyRunsPlugin];
     }
   });
   const restartNumbering = ({ editor, tr, state: state2, dispatch }) => {
@@ -87541,20 +89090,15 @@ ${l}
           } else {
             markerText = docxNumberingHelpers.normalizeLvlTextChar(lvlText);
           }
-          if (JSON.stringify(node2.attrs.listRendering) !== JSON.stringify({
+          const newListRendering = {
             markerText,
             suffix: suffix2,
             justification,
             path: path2,
             numberingType: listNumberingType
-          })) {
-            tr.setNodeAttribute(pos, "listRendering", {
-              markerText,
-              suffix: suffix2,
-              justification,
-              path: path2,
-              numberingType: listNumberingType
-            });
+          };
+          if (JSON.stringify(node2.attrs.listRendering) !== JSON.stringify(newListRendering)) {
+            tr.setNodeAttribute(pos, "listRendering", newListRendering);
           }
           return false;
         });
@@ -87855,7 +89399,7 @@ ${l}
               return null;
             }
             const { tr } = state2;
-            tr.delete(range2.from, range2.to);
+            tr.delete(range2.from, range2.to).setSelection(TextSelection$1.create(tr.doc, range2.from));
             ListHelpers.createNewList({
               listType: type2,
               tr,
@@ -91285,7 +92829,10 @@ ${l}
         insertTable: ({ rows = 3, cols = 3, withHeaderRow = false } = {}) => ({ tr, dispatch, editor }) => {
           const node2 = createTable(editor.schema, rows, cols, withHeaderRow);
           if (dispatch) {
-            const offset2 = tr.selection.from + 1;
+            let offset2 = tr.selection.$from.end() + 1;
+            if (tr.selection.$from.parent?.type?.name === "run") {
+              offset2 = tr.selection.$from.after(tr.selection.$from.depth - 1);
+            }
             tr.replaceSelectionWith(node2).scrollIntoView().setSelection(TextSelection$1.near(tr.doc.resolve(offset2)));
           }
           return true;
@@ -118596,6 +120143,12 @@ ${style2}
   };
   const GenericPopover = /* @__PURE__ */ _export_sfc$1(_sfc_main$4$1, [["__scopeId", "data-v-cbddcc0f"]]);
   const _hoisted_1$3$1 = ["data-boundary-index", "data-boundary-type", "onMousedown"];
+  const RESIZE_HANDLE_WIDTH_PX = 9;
+  const RESIZE_HANDLE_OFFSET_PX = 4;
+  const DRAG_OVERLAY_EXTENSION_PX = 1e3;
+  const MIN_DRAG_OVERLAY_WIDTH_PX = 2e3;
+  const THROTTLE_INTERVAL_MS = 16;
+  const MIN_RESIZE_DELTA_PX = 1;
   const _sfc_main$3$1 = {
     __name: "TableResizeOverlay",
     props: {
@@ -118619,26 +120172,73 @@ ${style2}
     setup(__props, { emit: __emit }) {
       const props = __props;
       const emit2 = __emit;
+      const overlayRect = ref(null);
       const tableMetadata = ref(null);
       const dragState = ref(null);
       const forcedCleanup = ref(false);
+      let rafId = null;
+      let isUnmounted = false;
+      function startOverlayTracking() {
+        if (rafId !== null) return;
+        const step = () => {
+          updateOverlayRect();
+          rafId = requestAnimationFrame(step);
+        };
+        rafId = requestAnimationFrame(step);
+      }
+      function stopOverlayTracking() {
+        if (rafId !== null) {
+          cancelAnimationFrame(rafId);
+          rafId = null;
+        }
+      }
       const overlayStyle = computed(() => {
-        if (!props.tableElement) return {};
-        const rect = props.tableElement.getBoundingClientRect();
+        if (!overlayRect.value || !props.tableElement) return {};
+        const rect = overlayRect.value;
         let overlayWidth = rect.width;
         if (dragState.value) {
-          overlayWidth = Math.max(rect.width + 1e3, 2e3);
+          overlayWidth = Math.max(rect.width + DRAG_OVERLAY_EXTENSION_PX, MIN_DRAG_OVERLAY_WIDTH_PX);
         }
         return {
           position: "absolute",
-          left: `${props.tableElement.offsetLeft}px`,
-          top: `${props.tableElement.offsetTop}px`,
+          left: `${rect.left}px`,
+          top: `${rect.top}px`,
           width: `${overlayWidth}px`,
           height: `${rect.height}px`,
           pointerEvents: dragState.value ? "auto" : "none",
           zIndex: 10
         };
       });
+      function updateOverlayRect() {
+        if (!props.tableElement) {
+          overlayRect.value = null;
+          return;
+        }
+        const parent = props.tableElement.offsetParent;
+        const tableRect = props.tableElement.getBoundingClientRect();
+        if (tableRect.width === 0 || tableRect.height === 0) {
+          overlayRect.value = null;
+          return;
+        }
+        if (parent) {
+          const parentRect = parent.getBoundingClientRect();
+          const left2 = tableRect.left - parentRect.left + (parent.scrollLeft || 0);
+          const top2 = tableRect.top - parentRect.top + (parent.scrollTop || 0);
+          overlayRect.value = {
+            left: left2,
+            top: top2,
+            width: tableRect.width,
+            height: tableRect.height
+          };
+        } else {
+          overlayRect.value = {
+            left: props.tableElement.offsetLeft,
+            top: props.tableElement.offsetTop,
+            width: tableRect.width,
+            height: tableRect.height
+          };
+        }
+      }
       const resizableBoundaries = computed(() => {
         if (!tableMetadata.value?.columns) {
           return [];
@@ -118677,9 +120277,9 @@ ${style2}
         if (!colSegments || colSegments.length === 0) {
           return [];
         }
-        return colSegments.map((seg) => ({
-          y: seg.y,
-          h: seg.h
+        return colSegments.filter((seg) => seg && typeof seg === "object").map((seg) => ({
+          y: typeof seg.y === "number" ? seg.y : 0,
+          h: seg.h !== null && typeof seg.h === "number" ? seg.h : null
         }));
       }
       function getSegmentHandleStyle(boundary, segment) {
@@ -118687,16 +120287,16 @@ ${style2}
           position: "absolute",
           left: `${boundary.x}px`,
           top: segment.y != null ? `${segment.y}px` : "0",
-          width: "9px",
+          width: `${RESIZE_HANDLE_WIDTH_PX}px`,
           height: segment.h != null ? `${segment.h}px` : "100%",
-          transform: "translateX(-4px)",
+          transform: `translateX(-${RESIZE_HANDLE_OFFSET_PX}px)`,
           cursor: "col-resize",
           pointerEvents: "auto"
         };
       }
       const guidelineStyle = computed(() => {
         if (!dragState.value || !tableMetadata.value) return { display: "none" };
-        const initialBoundary = resizableBoundaries.value[dragState.value.boundaryIndex];
+        const initialBoundary = resizableBoundaries.value[dragState.value.resizableBoundaryIndex];
         if (!initialBoundary) return { display: "none" };
         const newX = initialBoundary.x + dragState.value.constrainedDelta;
         return {
@@ -118753,11 +120353,11 @@ ${style2}
           });
         }
       }
-      function onHandleMouseDown(event, boundaryIndex) {
+      function onHandleMouseDown(event, resizableBoundaryIndex) {
         event.preventDefault();
         event.stopPropagation();
         if (!tableMetadata.value?.columns) return;
-        const boundary = resizableBoundaries.value[boundaryIndex];
+        const boundary = resizableBoundaries.value[resizableBoundaryIndex];
         if (!boundary) return;
         const columns = tableMetadata.value.columns;
         const isRightEdge = boundary.type === "right-edge";
@@ -118765,7 +120365,7 @@ ${style2}
         const rightColumn = isRightEdge ? null : columns[boundary.index + 1];
         dragState.value = {
           columnIndex: boundary.index,
-          boundaryIndex,
+          resizableBoundaryIndex,
           isRightEdge,
           initialX: event.clientX,
           initialWidths: columns.map((col) => col.w),
@@ -118779,15 +120379,28 @@ ${style2}
           } : null,
           constrainedDelta: 0
         };
+        if (!props.editor?.view?.dom) {
+          emit2("resize-error", { error: "Editor view not available" });
+          dragState.value = null;
+          return;
+        }
         const pmView = props.editor.view.dom;
         pmView.style.pointerEvents = "none";
-        document.addEventListener("mousemove", onDocumentMouseMove2);
-        document.addEventListener("mouseup", onDocumentMouseUp);
-        emit2("resize-start", {
-          columnIndex: boundary.index,
-          isRightEdge,
-          initialWidths: dragState.value.initialWidths
-        });
+        try {
+          document.addEventListener("mousemove", onDocumentMouseMove2);
+          document.addEventListener("mouseup", onDocumentMouseUp);
+          emit2("resize-start", {
+            columnIndex: boundary.index,
+            isRightEdge,
+            initialWidths: dragState.value.initialWidths
+          });
+        } catch (error) {
+          document.removeEventListener("mousemove", onDocumentMouseMove2);
+          document.removeEventListener("mouseup", onDocumentMouseUp);
+          pmView.style.pointerEvents = "auto";
+          dragState.value = null;
+          emit2("resize-error", { error: error instanceof Error ? error.message : String(error) });
+        }
       }
       function throttle2(func, limit) {
         let inThrottle;
@@ -118812,7 +120425,7 @@ ${style2}
         return { throttled, cancel };
       }
       const mouseMoveThrottle = throttle2((event) => {
-        if (!dragState.value) return;
+        if (isUnmounted || !dragState.value) return;
         const delta = event.clientX - dragState.value.initialX;
         const minDelta = -(dragState.value.leftColumn.width - dragState.value.leftColumn.minWidth);
         let maxDelta;
@@ -118838,7 +120451,7 @@ ${style2}
           columnIndex: dragState.value.columnIndex,
           delta: constrainedDelta
         });
-      }, 16);
+      }, THROTTLE_INTERVAL_MS);
       const onDocumentMouseMove2 = mouseMoveThrottle.throttled;
       function onDocumentMouseUp(event) {
         if (!dragState.value) return;
@@ -118853,13 +120466,11 @@ ${style2}
         }
         document.removeEventListener("mousemove", onDocumentMouseMove2);
         document.removeEventListener("mouseup", onDocumentMouseUp);
-        if (props.editor?.view) {
+        if (props.editor?.view?.dom) {
           const pmView = props.editor.view.dom;
-          if (pmView && pmView.style) {
-            pmView.style.pointerEvents = "auto";
-          }
+          pmView.style.pointerEvents = "auto";
         }
-        if (!forcedCleanup.value && Math.abs(finalDelta) > 1) {
+        if (!forcedCleanup.value && Math.abs(finalDelta) > MIN_RESIZE_DELTA_PX) {
           dispatchResizeTransaction(columnIndex, newWidths);
           emit2("resize-end", {
             columnIndex,
@@ -118922,7 +120533,14 @@ ${style2}
         if (!pmElement) {
           return null;
         }
-        const pmStart = parseInt(pmElement.getAttribute("data-pm-start"), 10);
+        const pmStartAttr = pmElement.getAttribute("data-pm-start");
+        if (!pmStartAttr) {
+          return null;
+        }
+        const pmStart = parseInt(pmStartAttr, 10);
+        if (!Number.isFinite(pmStart)) {
+          return null;
+        }
         let tablePos = null;
         state2.doc.descendants((node2, pos) => {
           if (node2.type.name === "table") {
@@ -118974,6 +120592,12 @@ ${style2}
         () => props.tableElement,
         () => {
           parseTableMetadata();
+          updateOverlayRect();
+          if (props.visible && props.tableElement) {
+            startOverlayTracking();
+          } else if (!props.tableElement) {
+            stopOverlayTracking();
+          }
         },
         { immediate: true }
       );
@@ -118982,7 +120606,10 @@ ${style2}
         (visible) => {
           if (visible) {
             parseTableMetadata();
+            updateOverlayRect();
+            startOverlayTracking();
           } else {
+            stopOverlayTracking();
             if (dragState.value) {
               forcedCleanup.value = true;
               onDocumentMouseUp(new MouseEvent("mouseup"));
@@ -118991,8 +120618,15 @@ ${style2}
           }
         }
       );
+      onMounted(() => {
+        window.addEventListener("scroll", updateOverlayRect, true);
+        window.addEventListener("resize", updateOverlayRect);
+        updateOverlayRect();
+      });
       onBeforeUnmount(() => {
+        isUnmounted = true;
         mouseMoveThrottle.cancel();
+        stopOverlayTracking();
         if (dragState.value) {
           document.removeEventListener("mousemove", onDocumentMouseMove2);
           document.removeEventListener("mouseup", onDocumentMouseUp);
@@ -119000,6 +120634,8 @@ ${style2}
             props.editor.view.dom.style.pointerEvents = "auto";
           }
         }
+        window.removeEventListener("scroll", updateOverlayRect, true);
+        window.removeEventListener("resize", updateOverlayRect);
       });
       return (_ctx, _cache) => {
         return __props.visible && tableMetadata.value ? (openBlock(), createElementBlock("div", {
@@ -119009,21 +120645,21 @@ ${style2}
           onMousedown: _cache[0] || (_cache[0] = withModifiers(() => {
           }, ["stop"]))
         }, [
-          (openBlock(true), createElementBlock(Fragment, null, renderList(resizableBoundaries.value, (boundary, boundaryIndex) => {
+          (openBlock(true), createElementBlock(Fragment, null, renderList(resizableBoundaries.value, (boundary, resizableBoundaryIndex) => {
             return openBlock(), createElementBlock(Fragment, {
-              key: `boundary-${boundaryIndex}`
+              key: `boundary-${resizableBoundaryIndex}`
             }, [
               (openBlock(true), createElementBlock(Fragment, null, renderList(getBoundarySegments(boundary), (segment, segmentIndex) => {
                 return openBlock(), createElementBlock("div", {
                   key: `handle-${boundary.type}-${boundary.index}-${segmentIndex}`,
                   class: normalizeClass(["resize-handle", {
-                    "resize-handle--active": dragState.value && dragState.value.boundaryIndex === boundaryIndex,
+                    "resize-handle--active": dragState.value && dragState.value.resizableBoundaryIndex === resizableBoundaryIndex,
                     "resize-handle--edge": boundary.type === "right-edge"
                   }]),
-                  "data-boundary-index": boundaryIndex,
+                  "data-boundary-index": resizableBoundaryIndex,
                   "data-boundary-type": boundary.type,
                   style: normalizeStyle(getSegmentHandleStyle(boundary, segment)),
-                  onMousedown: ($event) => onHandleMouseDown($event, boundaryIndex)
+                  onMousedown: ($event) => onHandleMouseDown($event, resizableBoundaryIndex)
                 }, null, 46, _hoisted_1$3$1);
               }), 128))
             ], 64);
@@ -119037,7 +120673,7 @@ ${style2}
       };
     }
   };
-  const TableResizeOverlay = /* @__PURE__ */ _export_sfc$1(_sfc_main$3$1, [["__scopeId", "data-v-3f4a506b"]]);
+  const TableResizeOverlay = /* @__PURE__ */ _export_sfc$1(_sfc_main$3$1, [["__scopeId", "data-v-2fdf7836"]]);
   const _hoisted_1$2$1 = ["data-handle-position", "onMousedown"];
   const OVERLAY_EXPANSION_PX = 2e3;
   const RESIZE_HANDLE_SIZE_PX = 12;
@@ -137036,7 +138672,7 @@ ${style2}
       this.config.colors = shuffleArray(this.config.colors);
       this.userColorMap = /* @__PURE__ */ new Map();
       this.colorIndex = 0;
-      this.version = "1.0.0-beta.15";
+      this.version = "1.0.0-beta.17";
       this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config2.superdocId || v4();
       this.colors = this.config.colors;
@@ -139479,7 +141115,7 @@ ${style2}
       value && typeof value === "object" && "byteLength" in value && "byteOffset" in value
     );
   }
-  const indexBds7gW4r = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  const indexVCeRjVPO = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     __proto__: null,
     unified
   }, Symbol.toStringTag, { value: "Module" }));