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

package/dist/super-editor/chunks/{editor-D8ZdjC2V.js → editor-D2k2BwSG.js}

@@ -12,8 +12,8 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 var _Attribute_static, getGlobalAttributes_fn, getNodeAndMarksAttributes_fn, _Schema_static, createNodesSchema_fn, createMarksSchema_fn, _events, _ExtensionService_instances, setupExtensions_fn, attachEditorEvents_fn, _editor, _stateValidators, _xmlValidators, _requiredNodeTypes, _requiredMarkTypes, _SuperValidator_instances, initializeValidators_fn, collectValidatorRequirements_fn, analyzeDocument_fn, dispatchWithFallback_fn, _commandService, _Editor_instances, initContainerElement_fn, init_fn, initRichText_fn, onFocus_fn, checkHeadless_fn, registerCopyHandler_fn, insertNewFileData_fn, getPluginKeyName_fn, createExtensionService_fn, createCommandService_fn, createConverter_fn, initMedia_fn, initFonts_fn, checkFonts_fn, determineUnsupportedFonts_fn, createSchema_fn, generatePmData_fn, createView_fn, onCollaborationReady_fn, initComments_fn, dispatchTransaction_fn, handleNodeSelection_fn, prepareDocumentForImport_fn, prepareDocumentForExport_fn, endCollaboration_fn, validateDocumentInit_fn, validateDocumentExport_fn, initDevTools_fn, _map, _editor2, _descriptors, _collections, _editorEntries, _maxCachedEditors, _editorAccessOrder, _pendingCreations, _cacheHits, _cacheMisses, _evictions, _HeaderFooterEditorManager_instances, hasConverter_fn, extractCollections_fn, collectDescriptors_fn, teardownMissingEditors_fn, teardownEditors_fn, createEditor_fn, createEditorContainer_fn, registerConverterEditor_fn, unregisterConverterEditor_fn, updateAccessOrder_fn, enforceCacheSizeLimit_fn, _manager, _mediaFiles, _blockCache, _HeaderFooterLayoutAdapter_instances, getBlocks_fn, getConverterContext_fn, _instances, _options, _editor3, _visibleHost, _viewportHost, _painterHost, _selectionOverlay, _hiddenHost, _layoutOptions, _layoutState, _domPainter, _layoutError, _layoutErrorState, _errorBanner, _errorBannerMessage, _telemetryEmitter, _renderScheduled, _pendingDocChange, _isRerendering, _selectionUpdateScheduled, _remoteCursorUpdateScheduled, _rafHandle, _editorListeners, _sectionMetadata, _documentMode, _inputBridge, _trackedChangesMode, _trackedChangesEnabled, _trackedChangesOverrides, _headerFooterManager, _headerFooterAdapter, _headerFooterIdentifier, _headerLayoutResults, _footerLayoutResults, _headerDecorationProvider, _footerDecorationProvider, _headerFooterManagerCleanups, _headerRegions, _footerRegions, _session, _activeHeaderFooterEditor, _hoverOverlay, _hoverTooltip, _modeBanner, _ariaLiveRegion, _hoverRegion, _clickCount, _lastClickTime, _lastClickPosition, _lastSelectedImageBlockId, _remoteCursorState, _remoteCursorDirty, _remoteCursorOverlay, _localSelectionLayer, _awarenessCleanup, _scrollCleanup, _remoteCursorRafHandle, _scrollTimeout, _PresentationEditor_instances, aggregateLayoutBounds_fn, safeCleanup_fn, setupEditorListeners_fn, setupCollaborationCursors_fn, normalizeAwarenessStates_fn, getFallbackColor_fn, getValidatedColor_fn, scheduleRemoteCursorUpdate_fn, scheduleRemoteCursorReRender_fn, updateRemoteCursors_fn, renderRemoteCursors_fn, renderRemoteCaret_fn, renderRemoteCursorLabel_fn, renderRemoteSelection_fn, setupPointerHandlers_fn, setupInputBridge_fn, initHeaderFooterRegistry_fn, _handlePointerDown, getFirstTextPosition_fn, registerPointerClick_fn, selectWordAt_fn, selectParagraphAt_fn, isWordCharacter_fn, _handlePointerMove, _handlePointerLeave, _handleDoubleClick, _handleKeyDown, focusHeaderFooterShortcut_fn, scheduleRerender_fn, flushRerenderQueue_fn, rerender_fn, ensurePainter_fn, scheduleSelectionUpdate_fn, updateSelection_fn, resolveLayoutOptions_fn, buildHeaderFooterInput_fn, computeHeaderFooterConstraints_fn, updateDecorationProviders_fn, createDecorationProvider_fn, findHeaderFooterPageForPageNumber_fn, computeDecorationBox_fn, rebuildHeaderFooterRegions_fn, hitTestHeaderFooterRegion_fn, pointInRegion_fn, activateHeaderFooterRegion_fn, enterHeaderFooterMode_fn, exitHeaderFooterMode_fn, getActiveDomTarget_fn, emitHeaderFooterModeChanged_fn, emitHeaderFooterEditingContext_fn, updateAwarenessSession_fn, updateModeBanner_fn, announce_fn, validateHeaderFooterEditPermission_fn, emitHeaderFooterEditBlocked_fn, resolveDescriptorForRegion_fn, getBodyPageHeight_fn, getHeaderFooterPageHeight_fn, renderSelectionRects_fn, renderHoverRegion_fn, clearHoverRegion_fn, renderCaretOverlay_fn, getHeaderFooterContext_fn, computeHeaderFooterSelectionRects_fn, computeHeaderFooterCaretRect_fn, syncTrackedChangesPreferences_fn, deriveTrackedChangesMode_fn, deriveTrackedChangesEnabled_fn, getTrackChangesPluginState_fn, computeDefaultLayoutDefaults_fn, parseColumns_fn, inchesToPx_fn, applyZoom_fn, createLayoutMetrics_fn, convertPageLocalToOverlayCoords_fn, normalizeClientPoint_fn, computeCaretLayoutRect_fn, computeCaretLayoutRectFromDOM_fn, computeTableCaretLayoutRect_fn, findLineContainingPos_fn, lineHeightBeforeIndex_fn, getCurrentPageIndex_fn, findRegionForPage_fn, handleLayoutError_fn, decorateError_fn, showLayoutErrorBanner_fn, dismissErrorBanner_fn, createHiddenHost_fn, _windowRoot, _layoutSurfaces, _getTargetDom, _onTargetChanged, _listeners, _currentTarget, _destroyed, _useWindowFallback, _PresentationInputBridge_instances, addListener_fn, dispatchToTarget_fn, forwardKeyboardEvent_fn, forwardTextEvent_fn, forwardCompositionEvent_fn, forwardContextMenu_fn, isEventOnActiveTarget_fn, shouldSkipSurface_fn, isInLayoutSurface_fn, getListenerTargets_fn, isPlainCharacterKey_fn, _DocumentSectionView_instances, init_fn2, addToolTip_fn, _ParagraphNodeView_instances, checkShouldUpdate_fn, updateHTMLAttributes_fn, updateDOMStyles_fn, resolveNeighborParagraphProperties_fn, updateListStyles_fn, initList_fn, checkIsList_fn, createMarker_fn, createSeparator_fn, calculateTabSeparatorStyle_fn, calculateMarkerStyle_fn, removeList_fn, getParagraphContext_fn, scheduleAnimation_fn, cancelScheduledAnimation_fn, _FieldAnnotationView_instances, createAnnotation_fn, _AutoPageNumberNodeView_instances, renderDom_fn, scheduleUpdateNodeStyle_fn, _VectorShapeView_instances, ensureParentPositioned_fn, _ShapeGroupView_instances, ensureParentPositioned_fn2;
 import * as Y from "yjs";
 import { UndoManager, Item as Item$1, ContentType, Text as Text$1, XmlElement, encodeStateAsUpdate } from "yjs";
-import { P as PluginKey, a as Plugin, M as Mapping, N as NodeSelection, S as Selection, T as TextSelection, b as Slice, D as DOMSerializer, F as Fragment, c as DOMParser$1, d as Mark$1, e as dropPoint, A as AllSelection, p as process$1, B as Buffer2, f as callOrGet, g as getExtensionConfigField, h as getMarkType, i as getMarksFromSelection, j as getNodeType, k as getSchemaTypeNameByName, l as Schema$1, m as cleanSchemaItem, n as canSplit, o as defaultBlockAt$1, q as liftTarget, r as canJoin, s as joinPoint, t as replaceStep$1, R as ReplaceAroundStep$1, u as isTextSelection, v as getMarkRange, w as isMarkActive, x as isNodeActive, y as deleteProps, z as processContent, C as htmlHandler, E as ReplaceStep, G as twipsToInches, H as inchesToTwips, I as ptToTwips, J as getResolvedParagraphProperties, K as linesToTwips, L as ListHelpers, O as updateNumberingProperties, Q as changeListLevel, U as findParentNode, V as isList, W as isMacOS, X as isIOS, Y as getSchemaTypeByName, Z as inputRulesPlugin, _ as TrackDeleteMarkName, $ as TrackInsertMarkName, a0 as v4, a1 as TrackFormatMarkName, a2 as comments_module_events, a3 as findMark, a4 as objectIncludes, a5 as AddMarkStep, a6 as RemoveMarkStep, a7 as twipsToLines, a8 as pixelsToTwips, a9 as helpers, aa as posToDOMRect, ab as CommandService, ac as SuperConverter, ad as createDocument, ae as createDocFromMarkdown, af as createDocFromHTML, ag as EditorState, ah as isActive, ai as unflattenListsInHtml, aj as resolveParagraphProperties, ak as _getReferencedTableStyles, al as parseSizeUnit, am as minMax, an as updateDOMAttributes, ao as findChildren$5, ap as generateRandomSigned32BitIntStrId, aq as calculateResolvedParagraphProperties, ar as encodeCSSFromPPr, as as twipsToPixels$2, at as resolveRunProperties, au as encodeCSSFromRPr, av as generateOrderedListIndex, aw as docxNumberingHelpers, ax as InputRule, ay as convertSizeToCSS, az as SelectionRange, aA as Transform, aB as findParentNodeClosestToPos, aC as isInTable$1, aD as generateDocxRandomId, aE as insertNewRelationship, aF as inchesToPixels, aG as kebabCase, aH as getUnderlineCssString } from "./converter-qMoZOGGn.js";
-import { D as DocxZipper } from "./docx-zipper-QKiyORxV.js";
+import { P as PluginKey, a as Plugin, M as Mapping, N as NodeSelection, S as Selection, T as TextSelection, b as Slice, D as DOMSerializer, F as Fragment, c as DOMParser$1, d as Mark$1, e as dropPoint, A as AllSelection, p as process$1, B as Buffer2, f as callOrGet, g as getExtensionConfigField, h as getMarkType, i as getMarksFromSelection, j as getNodeType, k as getSchemaTypeNameByName, l as Schema$1, m as cleanSchemaItem, n as canSplit, o as defaultBlockAt$1, q as liftTarget, r as canJoin, s as joinPoint, t as replaceStep$1, R as ReplaceAroundStep$1, u as isTextSelection, v as getMarkRange, w as isMarkActive, x as isNodeActive, y as deleteProps, z as processContent, C as htmlHandler, E as ReplaceStep, G as twipsToInches, H as inchesToTwips, I as ptToTwips, J as getResolvedParagraphProperties, K as linesToTwips, L as ListHelpers, O as updateNumberingProperties, Q as changeListLevel, U as findParentNode, V as isList, W as isMacOS, X as isIOS, Y as getSchemaTypeByName, Z as inputRulesPlugin, _ as TrackDeleteMarkName, $ as TrackInsertMarkName, a0 as v4, a1 as TrackFormatMarkName, a2 as comments_module_events, a3 as findMark, a4 as objectIncludes, a5 as AddMarkStep, a6 as RemoveMarkStep, a7 as twipsToLines, a8 as pixelsToTwips, a9 as helpers, aa as posToDOMRect, ab as CommandService, ac as SuperConverter, ad as createDocument, ae as createDocFromMarkdown, af as createDocFromHTML, ag as EditorState, ah as isActive, ai as unflattenListsInHtml, aj as resolveParagraphProperties, ak as _getReferencedTableStyles, al as parseSizeUnit, am as minMax, an as updateDOMAttributes, ao as findChildren$5, ap as generateRandomSigned32BitIntStrId, aq as decodeRPrFromMarks, ar as calculateResolvedParagraphProperties, as as encodeCSSFromPPr, at as twipsToPixels$2, au as resolveRunProperties, av as encodeCSSFromRPr, aw as generateOrderedListIndex, ax as docxNumberingHelpers, ay as InputRule, az as convertSizeToCSS, aA as SelectionRange, aB as Transform, aC as findParentNodeClosestToPos, aD as isInTable$1, aE as generateDocxRandomId, aF as insertNewRelationship, aG as inchesToPixels, aH as kebabCase, aI as getUnderlineCssString } from "./converter-B9zUZjYT.js";
+import { D as DocxZipper } from "./docx-zipper-r5KdE_SA.js";
 import { ref, computed, createElementBlock, openBlock, withModifiers, Fragment as Fragment$1, renderList, normalizeClass, createCommentVNode, toDisplayString, createElementVNode, createApp } from "vue";
 var GOOD_LEAF_SIZE = 200;
 var RopeSequence = function RopeSequence2() {
@@ -8225,6 +8225,83 @@ const insertTabChar = () => ({ tr }) => {
   tr.insertText("	", tr.selection.from, tr.selection.to);
   return true;
 };
+const splitRunToParagraph = () => (props) => {
+  const { state, view, tr } = props;
+  const { $from, empty: empty2 } = state.selection;
+  if (!empty2) return false;
+  if ($from.parent.type.name !== "run") return false;
+  const handled = splitBlockPatch(state, (transaction) => {
+    view.dispatch(transaction);
+  });
+  if (handled) {
+    tr.setMeta("preventDispatch", true);
+  }
+  return handled;
+};
+function splitBlockPatch(state, dispatch) {
+  let { $from } = state.selection;
+  if (state.selection instanceof NodeSelection && state.selection.node.isBlock) {
+    if (!$from.parentOffset || !canSplit(state.doc, $from.pos)) return false;
+    if (dispatch) dispatch(state.tr.split($from.pos).scrollIntoView());
+    return true;
+  }
+  if (!$from.depth) return false;
+  let types = [];
+  let splitDepth, deflt, atEnd = false, atStart = false;
+  for (let d2 = $from.depth; ; d2--) {
+    let node = $from.node(d2);
+    if (node.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)));
+      types.unshift(null);
+      splitDepth = d2;
+      break;
+    } else {
+      if (d2 == 1) return false;
+      types.unshift(null);
+    }
+  }
+  let tr = state.tr;
+  if (state.selection instanceof TextSelection || state.selection instanceof AllSelection) tr.deleteSelection();
+  let splitPos = tr.mapping.map($from.pos);
+  let can = canSplit(tr.doc, splitPos, types.length, types);
+  if (!can) {
+    types[0] = deflt ? { type: deflt } : null;
+    can = canSplit(tr.doc, splitPos, types.length, types);
+  }
+  if (!can) return false;
+  tr.split(splitPos, types.length, types);
+  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, dispatch, tr } = props;
+  const sel = state.selection;
+  if (!sel.empty) return false;
+  const $pos = sel.$from;
+  const runType = state.schema.nodes.run;
+  if ($pos.parent.type !== runType) return false;
+  const run = $pos.parent;
+  const offset2 = $pos.parentOffset;
+  const runStart = $pos.before();
+  const runEnd = runStart + run.nodeSize;
+  const leftFrag = run.content.cut(0, offset2);
+  const rightFrag = run.content.cut(offset2);
+  const leftRun = runType.create(run.attrs, leftFrag, run.marks);
+  const rightRun = runType.create(run.attrs, rightFrag, run.marks);
+  const gapPos = runStart + leftRun.nodeSize;
+  tr.replaceWith(runStart, runEnd, [leftRun, rightRun]).setSelection(TextSelection.create(tr.doc, gapPos));
+  if (dispatch) {
+    dispatch(tr);
+  }
+  return true;
+};
 const insertTabCharacter = ({ tr, state, dispatch }) => {
   const { from: from2 } = tr.selection;
   const tabText = state.schema.text("	");
@@ -8234,10 +8311,23 @@ const insertTabCharacter = ({ tr, state, dispatch }) => {
   return true;
 };
 const insertTabNode = () => ({ tr, state, dispatch }) => {
-  const newPos = tr.selection.from;
+  let newPos = tr.selection.from;
   const tabNode = state.schema?.nodes?.tab?.create();
   if (!tabNode) return insertTabCharacter({ tr, state, dispatch });
+  const { from: from2 } = tr.selection;
+  const $pos = tr.doc.resolve(from2);
+  if ($pos.parent.type === state.schema.nodes.run) {
+    if (from2 === $pos.end()) {
+      newPos = $pos.end() + 1;
+    } else if (from2 === $pos.start()) {
+      newPos = $pos.start() - 1;
+    } else {
+      splitRunAtCursor()({ tr, state });
+      newPos = tr.selection.from;
+    }
+  }
   tr.insert(newPos, tabNode);
+  tr = tr.setSelection(TextSelection.create(tr.doc, newPos + tabNode.nodeSize));
   if (dispatch) dispatch(tr);
   return true;
 };
@@ -9693,6 +9783,139 @@ const unsetLineHeight = () => ({ commands: commands2 }) => {
     "paragraphProperties.spacing.lineRule"
   );
 };
+const backspaceEmptyRunParagraph = () => ({ state, dispatch }) => {
+  const { $from } = state.selection;
+  if (!state.selection.empty) return false;
+  const paraType = state.schema.nodes.paragraph;
+  const runType = state.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 (state.doc.childCount === 1 && $from.depth === 1) return false;
+  if (dispatch) {
+    const paraPos = $from.before();
+    let tr = state.tr.deleteRange(paraPos, paraPos + para.nodeSize).scrollIntoView();
+    const targetPos = Math.max(1, Math.min(paraPos - 1, tr.doc.content.size));
+    tr = tr.setSelection(TextSelection.create(tr.doc, targetPos));
+    dispatch(tr);
+  }
+  return true;
+};
+const backspaceSkipEmptyRun = () => ({ state, dispatch }) => {
+  const sel = state.selection;
+  if (!sel.empty) return false;
+  const runType = state.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(state.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(state.tr.delete(pos - 1, pos).scrollIntoView());
+  }
+  return true;
+};
+const backspaceNextToRun = () => ({ state, tr, dispatch }) => {
+  const sel = state.selection;
+  if (!sel.empty) return false;
+  const runType = state.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 = state.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, dispatch }) => {
+  const sel = state.selection;
+  if (!sel.empty) return false;
+  const runType = state.schema.nodes.run;
+  const $pos = sel.$from;
+  const emptyRun = (n) => n && n.type === runType && n.content.size === 0;
+  if ($pos.parent.type === runType && emptyRun(state.doc.nodeAt($pos.end() + 1))) {
+    if ($pos.pos === $pos.end()) {
+      return deleteFromEndOfRun(state, dispatch, $pos);
+    } else if ($pos.pos === $pos.end() - 1) {
+      return deleteFromLastCharacter(state, dispatch, $pos);
+    }
+    return false;
+  }
+  return false;
+};
+function deleteFromEndOfRun(state, dispatch, $pos) {
+  const rightRun = state.doc.nodeAt($pos.pos + 1);
+  const $afterRightRunPos = state.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(state.tr.delete(pos, pos + 1).scrollIntoView());
+  }
+  return true;
+}
+function deleteFromLastCharacter(state, dispatch, $pos) {
+  if (dispatch) {
+    dispatch(state.tr.delete($pos.pos, $pos.pos + 1).scrollIntoView());
+  }
+  return true;
+}
+const deleteNextToRun = () => ({ state, tr, dispatch }) => {
+  const sel = state.selection;
+  if (!sel.empty) return false;
+  const runType = state.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 = state.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, dispatch }) => {
+    const tab = state.schema.nodes.tab;
+    const run = state.schema.nodes.run;
+    const sel = state.selection;
+    if (!tab || !sel.empty) return false;
+    const $pos = sel.$from;
+    if ($pos.parent.type !== run) 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 = state.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, state.doc.nodeSize) : Math.max(0, $nextPos.pos - nextNode.nodeSize - 1);
+    if (dispatch) {
+      dispatch(state.tr.setSelection(TextSelection.create(state.doc, nextPos)));
+    }
+    return true;
+  };
+}
 const toggleList = (listType) => ({ editor, state, tr, dispatch }) => {
   let predicate;
   if (listType === "orderedList") {
@@ -9768,6 +9991,13 @@ const toggleList = (listType) => ({ editor, state, tr, dispatch }) => {
     }
     updateNumberingProperties(sharedNumberingProperties, node, pos, editor, tr);
   }
+  const newTo = tr.mapping.map(to);
+  if (newTo >= 0 && newTo <= tr.doc.content.size) {
+    try {
+      tr.setSelection(state.selection.constructor.near(tr.doc.resolve(newTo)));
+    } catch {
+    }
+  }
   if (dispatch) dispatch(tr);
   return true;
 };
@@ -9886,6 +10116,9 @@ const getSelectionMarks = () => ({ state, tr }) => {
 };
 const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
+  backspaceEmptyRunParagraph,
+  backspaceNextToRun,
+  backspaceSkipEmptyRun,
   changeListLevel,
   clearNodes,
   command,
@@ -9893,7 +10126,9 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   decreaseListIndent,
   decreaseTextIndent,
   defaultStyleDetector,
+  deleteNextToRun,
   deleteSelection,
+  deleteSkipEmptyRun,
   exitCode,
   first,
   getEffectiveStyleId,
@@ -9931,6 +10166,7 @@ const commands$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   setSectionHeaderFooterAtSelection,
   setTextIndentation,
   setTextSelection,
+  skipTab,
   splitBlock: splitBlock$1,
   toggleList,
   toggleMark,
@@ -9952,7 +10188,7 @@ const Commands = Extension.create({
 });
 const handleEnter = (editor) => {
   return editor.commands.first(({ commands: commands2 }) => [
-    () => commands2.splitRun(),
+    () => commands2.splitRunToParagraph(),
     () => commands2.newlineInCode(),
     () => commands2.createParagraphNear(),
     () => commands2.liftEmptyBlock(),
@@ -9966,6 +10202,9 @@ const handleBackspace = (editor) => {
       tr.setMeta("inputType", "deleteContentBackward");
       return false;
     },
+    () => commands2.backspaceEmptyRunParagraph(),
+    () => commands2.backspaceSkipEmptyRun(),
+    () => commands2.backspaceNextToRun(),
     () => commands2.deleteSelection(),
     () => commands2.removeNumberingProperties(),
     () => commands2.joinBackward(),
@@ -9974,6 +10213,8 @@ const handleBackspace = (editor) => {
 };
 const handleDelete = (editor) => {
   return editor.commands.first(({ commands: commands2 }) => [
+    () => commands2.deleteSkipEmptyRun(),
+    () => commands2.deleteNextToRun(),
     () => commands2.deleteSelection(),
     () => commands2.joinForward(),
     () => commands2.selectNodeForward()
@@ -9992,7 +10233,9 @@ const Keymap = Extension.create({
       Delete: () => handleDelete(this.editor),
       "Mod-Delete": () => handleDelete(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
@@ -13574,7 +13817,7 @@ const isHeadless = (editor) => {
 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) {
@@ -14087,12 +14330,9 @@ const _Editor = class _Editor extends EventEmitter {
     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}`);
@@ -14356,7 +14596,7 @@ const _Editor = class _Editor extends EventEmitter {
       { default: remarkStringify },
       { default: remarkGfm }
     ] = await Promise.all([
-      import("./index-Bds7gW4r.js"),
+      import("./index-VCeRjVPO.js"),
       import("./index-DRCvimau.js"),
       import("./index-C_x_N6Uh.js"),
       import("./index-D_sWOSiG.js"),
@@ -14561,7 +14801,7 @@ const _Editor = class _Editor extends EventEmitter {
    * 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");
@@ -15724,7 +15964,7 @@ const pickLang = (value) => {
   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;
@@ -16364,14 +16604,14 @@ const resolveThemeColor = (attrs, themeColors) => {
 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;
 };
@@ -16806,13 +17046,8 @@ const MAX_BORDER_SIZE_PX = 100;
 const borderSizeToPx = (size) => {
   if (!isFiniteNumber(size)) return void 0;
   if (size <= 0) return 0;
-  let pixelValue;
-  if (size < EIGHTHS_PER_POINT) {
-    pixelValue = size;
-  } else {
-    const points = size / EIGHTHS_PER_POINT;
-    pixelValue = points * PX_PER_PT;
-  }
+  const points = size / 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 = (color) => {
@@ -16951,7 +17186,7 @@ const normalizeBorderSide = (value) => {
   if (style === "none") return void 0;
   const width = pickNumber(raw.size);
   const widthPx = borderSizeToPx(width);
-  const color = normalizeColor(raw.color);
+  const color = normalizeColor$1(raw.color);
   const space = pickNumber(raw.space);
   if (!style && widthPx == null && space == null && !color) {
     return void 0;
@@ -17007,7 +17242,7 @@ const normalizeParagraphShading = (value) => {
   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;
@@ -18170,11 +18405,11 @@ const buildMarkerLayout = ({
   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 = (suffix) => {
+const normalizeSuffix$1 = (suffix) => {
   if (suffix === "tab" || suffix === "space" || suffix === "nothing") {
     return suffix;
   }
@@ -18628,6 +18863,154 @@ const cloneIfObject = (value) => {
 };
 const { resolveSpacingIndent } = Engines;
 const DEFAULT_DECIMAL_SEPARATOR$2 = ".";
+const asOoxmlElement = (value) => {
+  if (!value || typeof value !== "object") return void 0;
+  const element = value;
+  if (element.name == null && element.attributes == null && element.elements == null) return void 0;
+  return element;
+};
+const findChild = (parent, name) => {
+  return parent?.elements?.find((child) => child?.name === name);
+};
+const getAttribute = (element, key2) => {
+  if (!element?.attributes) return void 0;
+  const attrs = element.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 indent = {};
+  if (left2 != null) indent.left = left2;
+  if (right2 != null) indent.right = right2;
+  if (firstLine != null) indent.firstLine = firstLine;
+  if (hanging != null) indent.hanging = hanging;
+  return Object.keys(indent).length ? indent : 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 run = {};
+  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()) {
+    run.fontFamily = font;
+  }
+  const sz = parseNumberAttr(getAttribute(findChild(rPr, "w:sz"), "w:val")) ?? parseNumberAttr(getAttribute(findChild(rPr, "w:szCs"), "w:val"));
+  if (sz != null) {
+    run.fontSize = sz / 2;
+  }
+  const color = normalizeColor(getAttribute(findChild(rPr, "w:color"), "w:val"));
+  if (color) run.color = color;
+  if (findChild(rPr, "w:b")) run.bold = true;
+  if (findChild(rPr, "w:i")) run.italic = true;
+  const spacingTwips = parseNumberAttr(getAttribute(findChild(rPr, "w:spacing"), "w:val"));
+  if (spacingTwips != null && Number.isFinite(spacingTwips)) {
+    run.letterSpacing = twipsToPx$1(spacingTwips);
+  }
+  return Object.keys(run).length ? run : 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 suffix = normalizeSuffix(getAttribute(findChild(levelDef, "w:suff"), "w:val"));
+  const lvlJc = normalizeJustification(getAttribute(findChild(levelDef, "w:lvlJc"), "w:val"));
+  const indent = extractIndentFromLevel(levelDef);
+  const markerRun = extractMarkerRun(levelDef);
+  const numFmt = normalizeNumFmt(getAttribute(numFmtEl, "w:val"));
+  return {
+    format: numFmt,
+    lvlText,
+    start: start2,
+    suffix,
+    lvlJc,
+    resolvedLevelIndent: indent,
+    resolvedMarkerRpr: markerRun
+  };
+};
 const isTruthy = (value) => {
   if (value === true || value === 1) return true;
   if (typeof value === "string") {
@@ -19260,6 +19643,30 @@ const computeParagraphAttrs = (para, styleContext, listCounterContext, converter
     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);
@@ -20485,41 +20892,45 @@ function paragraphToFlowBlocks$1(para, nextBlockId, positions, defaultFont, defa
       }
       return;
     }
-    if (node.type === "hardBreak") {
-      flushParagraph();
-      blocks.push({
-        kind: "pageBreak",
-        id: nextId(),
-        attrs: node.attrs || {}
-      });
-      return;
-    }
-    if (node.type === "lineBreak") {
+    if (node.type === "hardBreak" || node.type === "lineBreak") {
       const attrs = node.attrs ?? {};
-      if (attrs.lineBreakType === "column") {
+      const breakType = attrs.pageBreakType ?? attrs.lineBreakType ?? "line";
+      if (breakType === "page") {
+        flushParagraph();
+        blocks.push({
+          kind: "pageBreak",
+          id: nextId(),
+          attrs: node.attrs || {}
+        });
+        return;
+      }
+      if (breakType === "column") {
         flushParagraph();
         blocks.push({
           kind: "columnBreak",
           id: nextId(),
           attrs: node.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(node);
-        if (pos) {
-          lineBreakRun.pmStart = pos.start;
-          lineBreakRun.pmEnd = pos.end;
-        }
-        currentRuns.push(lineBreakRun);
+        delete lineBreakRun.attrs;
+      }
+      const pos = positions.get(node);
+      if (pos) {
+        lineBreakRun.pmStart = pos.start;
+        lineBreakRun.pmEnd = pos.end;
       }
+      if (activeSdt) {
+        lineBreakRun.sdt = activeSdt;
+      }
+      currentRuns.push(lineBreakRun);
       return;
     }
   };
@@ -21112,6 +21523,22 @@ const normalizeTableWidth = (value) => {
 };
 const isTableRowNode = (node) => node.type === "tableRow" || node.type === "table_row";
 const isTableCellNode = (node) => node.type === "tableCell" || node.type === "table_cell" || node.type === "tableHeader" || node.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)) {
@@ -21149,8 +21576,9 @@ const parseTableCell = (args) => {
   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") {
@@ -21193,15 +21621,89 @@ const parseTableRow = (args) => {
   });
   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(node) {
+  const tableProperties = node.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 wrap = {
+    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) {
+      wrap.distTop = twipsToPx$1(floatingProps.topFromText);
+    }
+    if (floatingProps.bottomFromText !== void 0) {
+      wrap.distBottom = twipsToPx$1(floatingProps.bottomFromText);
+    }
+    if (floatingProps.leftFromText !== void 0) {
+      wrap.distLeft = twipsToPx$1(floatingProps.leftFromText);
+    }
+    if (floatingProps.rightFromText !== void 0) {
+      wrap.distRight = twipsToPx$1(floatingProps.rightFromText);
+    }
+  }
+  return { anchor, wrap };
+}
 function tableNodeToBlock$1(node, nextBlockId, positions, defaultFont, defaultSize, _styleContext, trackedChanges, bookmarks, hyperlinkConfig, themeColors, paragraphToFlowBlocks2, converterContext) {
   if (!Array.isArray(node.content) || node.content.length === 0) return null;
   if (!paragraphToFlowBlocks2) return null;
@@ -21266,6 +21768,10 @@ function tableNodeToBlock$1(node, nextBlockId, positions, defaultFont, defaultSi
   if (tableLayout) {
     tableAttrs.tableLayout = tableLayout;
   }
+  const tableProperties = node.attrs?.tableProperties;
+  if (tableProperties && typeof tableProperties === "object") {
+    tableAttrs.tableProperties = tableProperties;
+  }
   let columnWidths = void 0;
   const twipsToPixels2 = (twips) => {
     const PIXELS_PER_INCH2 = 96;
@@ -21309,12 +21815,15 @@ function tableNodeToBlock$1(node, nextBlockId, positions, defaultFont, defaultSi
       columnWidths = void 0;
     }
   }
+  const { anchor, wrap } = extractFloatingTableAnchorWrap(node);
   const tableBlock = {
     kind: "table",
     id: nextBlockId("table"),
     rows,
     attrs: Object.keys(tableAttrs).length > 0 ? tableAttrs : void 0,
-    columnWidths
+    columnWidths,
+    ...anchor ? { anchor } : {},
+    ...wrap ? { wrap } : {}
   };
   return tableBlock;
 }
@@ -21650,7 +22159,7 @@ function getMeasurementContext() {
   return measurementCtx;
 }
 function getRunFontString(run) {
-  if (run.kind === "tab" || run.kind === "lineBreak" || "src" in run) {
+  if (run.kind === "tab" || run.kind === "lineBreak" || run.kind === "break" || "src" in run) {
     return "normal normal 16px Arial";
   }
   const style = run.italic ? "italic" : "normal";
@@ -21677,6 +22186,10 @@ function sliceRunsForLine$1(block, line) {
       result.push(run);
       continue;
     }
+    if (run.kind === "break") {
+      result.push(run);
+      continue;
+    }
     const text = run.text ?? "";
     const isFirstRun = runIndex === line.fromRun;
     const isLastRun = runIndex === line.toRun;
@@ -21710,7 +22223,7 @@ function measureCharacterX(block, line, charOffset) {
       1,
       runs2.reduce((sum, run) => {
         if (isTabRun$1(run)) return sum + TAB_CHAR_LENGTH;
-        if ("src" in run || run.kind === "lineBreak") return sum;
+        if ("src" in run || run.kind === "lineBreak" || run.kind === "break") return sum;
         return sum + (run.text ?? "").length;
       }, 0)
     );
@@ -21731,7 +22244,7 @@ function measureCharacterX(block, line, charOffset) {
       currentCharOffset += runLength2;
       continue;
     }
-    const text = "src" in run || run.kind === "lineBreak" ? "" : run.text ?? "";
+    const text = "src" in run || run.kind === "lineBreak" || run.kind === "break" ? "" : run.text ?? "";
     const runLength = text.length;
     if (currentCharOffset + runLength >= charOffset) {
       const offsetInRun = charOffset - currentCharOffset;
@@ -21774,7 +22287,7 @@ function measureCharacterXSegmentBased(block, line, charOffset, ctx2) {
       if (isTabRun$1(run)) {
         return segmentBaseX + (offsetInSegment > 0 ? segment.width ?? 0 : 0);
       }
-      if ("src" in run || run.kind === "lineBreak") {
+      if ("src" in run || run.kind === "lineBreak" || run.kind === "break") {
         return segmentBaseX + (offsetInSegment >= segmentChars ? segment.width ?? 0 : 0);
       }
       const text = run.text ?? "";
@@ -21797,7 +22310,7 @@ function findCharacterAtX(block, line, x, pmStart) {
       1,
       runs2.reduce((sum, run) => {
         if (isTabRun$1(run)) return sum + TAB_CHAR_LENGTH;
-        if ("src" in run || run.kind === "lineBreak") return sum;
+        if ("src" in run || run.kind === "lineBreak" || run.kind === "break") return sum;
         return sum + (run.text ?? "").length;
       }, 0)
     );
@@ -21832,7 +22345,7 @@ function findCharacterAtX(block, line, x, pmStart) {
       currentCharOffset += TAB_CHAR_LENGTH;
       continue;
     }
-    const text = "src" in run || run.kind === "lineBreak" ? "" : run.text ?? "";
+    const text = "src" in run || run.kind === "lineBreak" || run.kind === "break" ? "" : run.text ?? "";
     const runLength = text.length;
     if (runLength === 0) continue;
     ctx2.font = getRunFontString(run);
@@ -22265,6 +22778,40 @@ function createFloatingObjectManager(columns, margins, pageWidth) {
       };
       zones.push(zone);
     },
+    registerTable(tableBlock, measure, anchorY, columnIndex, pageNumber) {
+      if (!tableBlock.anchor?.isAnchored) {
+        return;
+      }
+      const { wrap, anchor } = tableBlock;
+      const wrapType = wrap?.type ?? "None";
+      if (wrapType === "None") {
+        return;
+      }
+      const tableWidth = measure.totalWidth ?? 0;
+      const tableHeight = measure.totalHeight ?? 0;
+      const x = computeTableAnchorX(anchor, columnIndex, columns, tableWidth, margins, pageWidth);
+      const y = anchorY + (anchor.offsetV ?? 0);
+      const zone = {
+        imageBlockId: tableBlock.id,
+        // Reusing imageBlockId field for table id
+        pageNumber,
+        columnIndex,
+        bounds: {
+          x,
+          y,
+          width: tableWidth,
+          height: tableHeight
+        },
+        distances: {
+          top: wrap?.distTop ?? 0,
+          bottom: wrap?.distBottom ?? 0,
+          left: wrap?.distLeft ?? 0,
+          right: wrap?.distRight ?? 0
+        },
+        wrapMode: computeTableWrapMode(wrap)
+      };
+      zones.push(zone);
+    },
     getExclusionsForLine(lineY, lineHeight, columnIndex, pageNumber) {
       const result = zones.filter((zone) => {
         if (zone.pageNumber !== pageNumber || zone.columnIndex !== columnIndex) {
@@ -22372,6 +22919,49 @@ function computeWrapMode(wrap, _anchor) {
   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(wrap) {
+  if (!wrap) return "none";
+  if (wrap.type === "None") {
+    return "none";
+  }
+  const wrapText = wrap.wrapText ?? "bothSides";
+  if (wrapText === "left") return "right";
+  if (wrapText === "right") return "left";
+  if (wrapText === "largest") return "largest";
+  return "both";
+}
 function computeNextSectionPropsAtBreak(blocks) {
   const nextSectionPropsAtBreak = /* @__PURE__ */ new Map();
   const docxBreakIndexes = [];
@@ -22790,6 +23380,9 @@ function layoutParagraphBlock(ctx2, anchors) {
     };
     if (measure.marker) {
       fragment.markerWidth = measure.marker.markerWidth;
+      if (measure.marker.markerTextWidth != null) {
+        fragment.markerTextWidth = measure.marker.markerTextWidth;
+      }
     }
     state.page.fragments.push(fragment);
     state.trailingSpacing = 0;
@@ -22891,6 +23484,12 @@ function layoutParagraphBlock(ctx2, anchors) {
     };
     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;
@@ -23068,6 +23667,206 @@ function generateColumnBoundaries(measure) {
   }
   return boundaries;
 }
+function countHeaderRows(block) {
+  let count = 0;
+  for (let i = 0; i < block.rows.length; i++) {
+    const row = block.rows[i];
+    const repeatHeader = row.attrs?.tableRowProperties?.repeatHeader;
+    if (repeatHeader === true) {
+      count++;
+    } else {
+      break;
+    }
+  }
+  return count;
+}
+function sumRowHeights(rows, fromRow, toRow) {
+  let total = 0;
+  for (let i = fromRow; i < toRow && i < rows.length; i++) {
+    total += rows[i].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(cell) {
+  if (cell.blocks && cell.blocks.length > 0) {
+    const allLines = [];
+    for (const block of cell.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 (cell.paragraph?.lines) {
+    return cell.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(cell) {
+  return getCellLines(cell).length;
+}
+function computePartialRow(rowIndex, blockRow, measure, availableHeight, fromLineByCell) {
+  const row = measure.rows[rowIndex];
+  if (!row) {
+    throw new Error(`Invalid rowIndex ${rowIndex}: measure.rows has ${measure.rows.length} rows`);
+  }
+  const cellCount = row.cells.length;
+  const startLines = fromLineByCell || new Array(cellCount).fill(0);
+  const toLineByCell = [];
+  const heightByCell = [];
+  const cellPaddings = row.cells.map((_, idx) => getCellPadding(idx, blockRow));
+  for (let cellIdx = 0; cellIdx < cellCount; cellIdx++) {
+    const cell = row.cells[cellIdx];
+    const startLine = startLines[cellIdx] || 0;
+    const cellPadding = cellPaddings[cellIdx];
+    const availableForLines = Math.max(0, availableHeight - (cellPadding.top + cellPadding.bottom));
+    const lines = getCellLines(cell);
+    let cumulativeHeight = 0;
+    let cutLine = startLine;
+    for (let i = startLine; i < lines.length; i++) {
+      const lineHeight = lines[i].lineHeight || 0;
+      if (cumulativeHeight + lineHeight > availableForLines) {
+        break;
+      }
+      cumulativeHeight += lineHeight;
+      cutLine = i + 1;
+    }
+    toLineByCell.push(cutLine);
+    heightByCell.push(cumulativeHeight);
+  }
+  const positiveHeights = heightByCell.filter((h) => h > 0);
+  const minHeight = positiveHeights.length > 0 ? Math.min(...positiveHeights) : 0;
+  let actualPartialHeight = 0;
+  let maxPaddingTotal = 0;
+  for (let cellIdx = 0; cellIdx < cellCount; cellIdx++) {
+    const cell = row.cells[cellIdx];
+    const startLine = startLines[cellIdx] || 0;
+    const lines = getCellLines(cell);
+    const cellPadding = cellPaddings[cellIdx];
+    const paddingTotal = cellPadding.top + cellPadding.bottom;
+    maxPaddingTotal = Math.max(maxPaddingTotal, paddingTotal);
+    let cumulativeHeight = 0;
+    let cutLine = startLine;
+    for (let i = startLine; i < lines.length; i++) {
+      const lineHeight = lines[i].lineHeight || 0;
+      if (cumulativeHeight + lineHeight > minHeight) {
+        break;
+      }
+      cumulativeHeight += lineHeight;
+      cutLine = i + 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(row.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 i = startRow; i < block.rows.length; i++) {
+    const row = block.rows[i];
+    const rowHeight = measure.rows[i]?.height || 0;
+    const cantSplit = row.attrs?.tableRowProperties?.cantSplit === true;
+    if (accumulatedHeight + rowHeight <= availableHeight) {
+      accumulatedHeight += rowHeight;
+      lastFitRow = i + 1;
+    } else {
+      const remainingHeight = availableHeight - accumulatedHeight;
+      if (fullPageHeight && rowHeight > fullPageHeight) {
+        const partialRow = computePartialRow(i, block.rows[i], measure, remainingHeight);
+        return { endRow: i + 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(i, block.rows[i], measure, remainingHeight);
+        const hasContent = partialRow.toLineByCell.some(
+          (cutLine, idx) => cutLine > (partialRow.fromLineByCell[idx] || 0)
+        );
+        if (hasContent) {
+          return { endRow: i + 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 state = context.ensurePage();
+  if (state.cursorY + context.measure.totalHeight > state.contentBottom && state.page.fragments.length > 0) {
+    state = context.advanceColumn(state);
+  }
+  state = context.ensurePage();
+  const height = Math.min(context.measure.totalHeight, state.contentBottom - state.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(state.columnIndex),
+    y: state.cursorY,
+    width: Math.min(context.columnWidth, context.measure.totalWidth || context.columnWidth),
+    height,
+    metadata
+  };
+  state.page.fragments.push(fragment);
+  state.cursorY += height;
+}
 function layoutTableBlock({
   block,
   measure,
@@ -23076,30 +23875,176 @@ function layoutTableBlock({
   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 state = ensurePage();
-  if (state.cursorY + measure.totalHeight > state.contentBottom && state.page.fragments.length > 0) {
-    state = advanceColumn(state);
+  let currentRow = 0;
+  let isTableContinuation = false;
+  let pendingPartialRow = null;
+  while (currentRow < block.rows.length || pendingPartialRow !== null) {
+    state = ensurePage();
+    const availableHeight = state.contentBottom - state.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 = state.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(state.columnIndex),
+          y: state.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)
+        };
+        state.page.fragments.push(fragment2);
+        state.cursorY += fragmentHeight2;
+      }
+      const rowComplete = !hasRemainingLinesAfterContinuation;
+      if (rowComplete) {
+        currentRow = rowIndex + 1;
+        pendingPartialRow = null;
+      } else if (!madeProgress && hadRemainingLinesBefore) {
+        state = advanceColumn(state);
+      } else {
+        state = advanceColumn(state);
+        pendingPartialRow = continuationPartialRow;
+      }
+      isTableContinuation = true;
+      continue;
+    }
+    const bodyStartRow = currentRow;
+    const { endRow, partialRow } = findSplitPoint(block, measure, bodyStartRow, availableForBody, fullPageHeight);
+    if (endRow === bodyStartRow && partialRow === null && state.page.fragments.length > 0) {
+      state = advanceColumn(state);
+      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(state.columnIndex),
+        y: state.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)
+      };
+      state.page.fragments.push(fragment2);
+      state.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(state.columnIndex),
+      y: state.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)
+    };
+    state.page.fragments.push(fragment);
+    state.cursorY += fragmentHeight;
+    if (partialRow && !partialRow.isLastPart) {
+      pendingPartialRow = partialRow;
+      currentRow = partialRow.rowIndex;
+    } else {
+      currentRow = endRow;
+      pendingPartialRow = null;
+    }
+    isTableContinuation = true;
   }
-  state = ensurePage();
-  const height = Math.min(measure.totalHeight, state.contentBottom - state.cursorY);
+}
+function createAnchoredTableFragment(block, measure, x, y) {
   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(state.columnIndex),
-    y: state.cursorY,
-    width: Math.min(columnWidth, measure.totalWidth || columnWidth),
-    height,
+    x,
+    y,
+    width: measure.totalWidth ?? 0,
+    height: measure.totalHeight ?? 0,
     metadata
   };
-  state.page.fragments.push(fragment);
-  state.cursorY += height;
 }
 function isPageRelativeAnchor(block) {
   const vRelativeFrom = block.anchor?.vRelativeFrom;
@@ -23126,9 +24071,6 @@ function collectPreRegisteredAnchors(blocks, measures) {
 function collectAnchoredDrawings(blocks, measures) {
   const map2 = /* @__PURE__ */ new Map();
   const len = Math.min(blocks.length, measures.length);
-  for (let i = 0; i < len; i += 1) {
-    if (blocks[i].kind === "paragraph") ;
-  }
   const nearestPrevParagraph = (fromIndex) => {
     for (let i = fromIndex - 1; i >= 0; i -= 1) {
       if (blocks[i].kind === "paragraph") return i;
@@ -23164,6 +24106,36 @@ function collectAnchoredDrawings(blocks, measures) {
   }
   return map2;
 }
+function collectAnchoredTables(blocks, measures) {
+  const map2 = /* @__PURE__ */ new Map();
+  const nearestPrevParagraph = (fromIndex) => {
+    for (let i = fromIndex - 1; i >= 0; i -= 1) {
+      if (blocks[i].kind === "paragraph") return i;
+    }
+    return null;
+  };
+  const nearestNextParagraph = (fromIndex) => {
+    for (let i = fromIndex + 1; i < blocks.length; i += 1) {
+      if (blocks[i].kind === "paragraph") return i;
+    }
+    return null;
+  };
+  for (let i = 0; i < blocks.length; i += 1) {
+    const block = blocks[i];
+    const measure = measures[i];
+    if (block.kind !== "table" || measure?.kind !== "table") continue;
+    const tableBlock = block;
+    const tableMeasure = measure;
+    if (!tableBlock.anchor?.isAnchored) continue;
+    let anchorParaIndex = nearestPrevParagraph(i);
+    if (anchorParaIndex == null) anchorParaIndex = nearestNextParagraph(i);
+    if (anchorParaIndex == null) continue;
+    const list = map2.get(anchorParaIndex) ?? [];
+    list.push({ block: tableBlock, measure: tableMeasure });
+    map2.set(anchorParaIndex, list);
+  }
+  return map2;
+}
 function createPaginator(opts) {
   const states = [];
   const pages = [];
@@ -23749,7 +24721,9 @@ function layoutDocument(blocks, measures, options = {}) {
     cachedColumnsState.state = null;
   };
   const anchoredByParagraph = collectAnchoredDrawings(blocks, measures);
+  const anchoredTablesByParagraph = collectAnchoredTables(blocks, measures);
   const placedAnchoredIds = /* @__PURE__ */ new Set();
+  const placedAnchoredTableIds = /* @__PURE__ */ new Set();
   const preRegisteredAnchors = collectPreRegisteredAnchors(blocks, measures);
   const preRegisteredPositions = /* @__PURE__ */ new Map();
   for (const entry of preRegisteredAnchors) {
@@ -23927,6 +24901,19 @@ function layoutDocument(blocks, measures, options = {}) {
         }
       }
       const anchorsForPara = anchoredByParagraph.get(index2);
+      const tablesForPara = anchoredTablesByParagraph.get(index2);
+      if (tablesForPara) {
+        const state = paginator.ensurePage();
+        for (const { block: tableBlock, measure: tableMeasure } of tablesForPara) {
+          if (placedAnchoredTableIds.has(tableBlock.id)) continue;
+          floatManager.registerTable(tableBlock, tableMeasure, state.cursorY, state.columnIndex, state.page.number);
+          const anchorX = tableBlock.anchor?.offsetH ?? columnX(state.columnIndex);
+          const anchorY = state.cursorY + (tableBlock.anchor?.offsetV ?? 0);
+          const tableFragment = createAnchoredTableFragment(tableBlock, tableMeasure, anchorX, anchorY);
+          state.page.fragments.push(tableFragment);
+          placedAnchoredTableIds.add(tableBlock.id);
+        }
+      }
       layoutParagraphBlock(
         {
           block,
@@ -24198,7 +25185,9 @@ const hashRuns = (block) => {
   const trackedMode = block.attrs && "trackedChangesMode" in block.attrs && block.attrs.trackedChangesMode || "review";
   const trackedEnabled = resolveTrackedChangesEnabled(block.attrs, true);
   const runsHash = block.runs.map((run) => {
-    const text = normalizeText("src" in run || run.kind === "lineBreak" ? "" : run.text ?? "");
+    const text = normalizeText(
+      "src" in run || run.kind === "lineBreak" || run.kind === "break" ? "" : run.text ?? ""
+    );
     const bold = "bold" in run ? run.bold : false;
     const italic = "italic" in run ? run.italic : false;
     const color = "color" in run ? run.color : void 0;
@@ -24212,7 +25201,22 @@ const hashRuns = (block) => {
     }
     return `${text}:${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,
@@ -24858,7 +25862,7 @@ function fontString(run) {
   return `${italic}${bold}${size}px ${family}`.trim();
 }
 function runText(run) {
-  return "src" in run || run.kind === "lineBreak" ? "" : run.text ?? "";
+  return "src" in run || run.kind === "lineBreak" || run.kind === "break" ? "" : run.text ?? "";
 }
 function measureRunSliceWidth(run, fromChar, toChar) {
   const context = getCtx();
@@ -25020,7 +26024,7 @@ const paragraphBlocksEqual = (a, b) => {
   for (let i = 0; i < a.runs.length; i += 1) {
     const runA = a.runs[i];
     const runB = b.runs[i];
-    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;
     }
   }
@@ -25140,7 +26144,7 @@ function computeHeaderFooterContentHash(blocks) {
     parts.push(block.id);
     if (block.kind === "paragraph") {
       for (const run of block.runs) {
-        if (!("src" in run) && run.kind !== "lineBreak") {
+        if (!("src" in run) && run.kind !== "lineBreak" && run.kind !== "break") {
           parts.push(run.text ?? "");
         }
         if ("bold" in run && run.bold) parts.push("b");
@@ -26111,7 +27115,7 @@ function computeLinePmRange$1(block, line) {
   for (let runIndex = line.fromRun; runIndex <= line.toRun; runIndex += 1) {
     const run = block.runs[runIndex];
     if (!run) continue;
-    const text = "src" in run || run.kind === "lineBreak" ? "" : run.text ?? "";
+    const text = "src" in run || run.kind === "lineBreak" || run.kind === "break" ? "" : run.text ?? "";
     const runLength = text.length;
     const runPmStart = run.pmStart ?? null;
     const runPmEnd = run.pmEnd ?? (runPmStart != null ? runPmStart + runLength : null);
@@ -28719,7 +29723,20 @@ const resolveTableCellBorders = (tableBorders, rowIndex, colIndex, totalRows, to
   };
 };
 const renderTableCell = (deps) => {
-  const { doc: doc2, x, y, rowHeight, cellMeasure, cell, borders, renderLine, context, applySdtDataset } = deps;
+  const {
+    doc: doc2,
+    x,
+    y,
+    rowHeight,
+    cellMeasure,
+    cell,
+    borders,
+    renderLine,
+    context,
+    applySdtDataset,
+    fromLine,
+    toLine
+  } = deps;
   const cellEl = doc2.createElement("div");
   cellEl.style.position = "absolute";
   cellEl.style.left = `${x}px`;
@@ -28727,6 +29744,7 @@ const renderTableCell = (deps) => {
   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);
   }
@@ -28740,36 +29758,87 @@ const renderTableCell = (deps) => {
   }
   let contentElement;
   const attrs = cell?.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 = cell?.blocks ?? (cell?.paragraph ? [cell.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 content = doc2.createElement("div");
     content.style.position = "absolute";
     content.style.left = `${x + paddingLeft}px`;
     content.style.top = `${y + paddingTop}px`;
-    content.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);
+    content.style.width = `${contentWidth + 1}px`;
+    content.style.height = `${contentHeight}px`;
+    content.style.display = "flex";
+    content.style.flexDirection = "column";
+    content.style.overflowX = "visible";
+    content.style.overflowY = "hidden";
+    if (cell?.attrs?.verticalAlign === "center") {
+      content.style.justifyContent = "center";
+    } else if (cell?.attrs?.verticalAlign === "bottom") {
+      content.style.justifyContent = "flex-end";
+    } else {
+      content.style.justifyContent = "flex-start";
+    }
+    const blockLineCounts = [];
+    for (let i = 0; i < Math.min(blockMeasures.length, cellBlocks.length); i++) {
+      const bm = blockMeasures[i];
+      if (bm.kind === "paragraph") {
+        blockLineCounts.push(bm.lines?.length || 0);
+      } else {
+        blockLineCounts.push(0);
+      }
+    }
+    const totalLines = blockLineCounts.reduce((a, b) => a + b, 0);
+    const globalFromLine = fromLine ?? 0;
+    const globalToLine = toLine === -1 || toLine === void 0 ? totalLines : toLine;
+    let cumulativeLineCount = 0;
     for (let i = 0; i < Math.min(blockMeasures.length, cellBlocks.length); i++) {
       const blockMeasure = blockMeasures[i];
       const block = cellBlocks[i];
       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;
+        }
         content.appendChild(paraWrapper);
-        blockY += blockMeasure.totalHeight;
+        if (renderedHeight > 0) {
+          paraWrapper.style.height = `${renderedHeight}px`;
+        }
+        cumulativeLineCount += blockLineCount;
+      } else {
+        cumulativeLineCount += 0;
       }
     }
     contentElement = content;
@@ -28790,7 +29859,10 @@ const renderTableRow = (deps) => {
     allRowHeights,
     context,
     renderLine,
-    applySdtDataset
+    applySdtDataset,
+    continuesFromPrev,
+    continuesOnNext,
+    partialRow
   } = deps;
   const calculateXPosition = (gridColumnStart) => {
     let x = 0;
@@ -28823,25 +29895,57 @@ const renderTableRow = (deps) => {
       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,
@@ -28852,7 +29956,9 @@ const renderTableRow = (deps) => {
       borders: resolvedBorders,
       renderLine,
       context,
-      applySdtDataset
+      applySdtDataset,
+      fromLine,
+      toLine
     });
     container.appendChild(cellElement);
     if (contentElement) {
@@ -28966,11 +30072,46 @@ const renderTableFragment = (deps) => {
   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 y = 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,
+        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
+      });
+      y += 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,
@@ -28984,9 +30125,15 @@ const renderTableFragment = (deps) => {
       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
     });
-    y += rowMeasure.height;
+    y += actualRowHeight;
   }
   return container;
 };
@@ -29081,6 +30228,7 @@ function assertFragmentPmPositions(fragment, context) {
   }
 }
 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";
@@ -29877,33 +31025,41 @@ const _DomPainter = class _DomPainter {
       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" : "";
@@ -29920,12 +31076,25 @@ const _DomPainter = class _DomPainter {
             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 (suffix === "space") {
-            markerContainer.appendChild(this.doc.createTextNode(" "));
+            lineEl.prepend(this.doc.createTextNode(" "));
           }
           lineEl.prepend(markerContainer);
         }
@@ -30774,6 +31943,12 @@ const _DomPainter = class _DomPainter {
   isLineBreakRun(run) {
     return run.kind === "lineBreak";
   }
+  /**
+   * Type guard to check if a run is a break run.
+   */
+  isBreakRun(run) {
+    return run.kind === "break";
+  }
   renderRun(run, context, trackedConfig) {
     if (this.isImageRun(run)) {
       return this.renderImageRun(run);
@@ -30781,7 +31956,10 @@ const _DomPainter = class _DomPainter {
     if (this.isLineBreakRun(run)) {
       return null;
     }
-    if (!run.text || !this.doc) {
+    if (this.isBreakRun(run)) {
+      return null;
+    }
+    if (!("text" in run) || !run.text || !this.doc) {
       return null;
     }
     const linkData = this.extractLinkData(run);
@@ -30922,6 +32100,12 @@ const _DomPainter = class _DomPainter {
     if (styleId) {
       el.setAttribute("styleid", styleId);
     }
+    const alignment = block.attrs?.alignment;
+    if (alignment === "center" || alignment === "right" || alignment === "justify") {
+      el.style.textAlign = alignment === "justify" ? "justify" : alignment;
+    } else {
+      el.style.textAlign = "left";
+    }
     const lineRange = computeLinePmRange(block, line);
     if (lineRange.pmStart != null) {
       el.dataset.pmStart = String(lineRange.pmStart);
@@ -31039,10 +32223,16 @@ const _DomPainter = class _DomPainter {
         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;
@@ -31361,7 +32551,12 @@ const fragmentKey = (fragment) => {
   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, lookup) => {
   const base2 = lookup.get(fragment.blockId)?.version ?? "missing";
@@ -31373,7 +32568,9 @@ const fragmentSignature = (fragment, lookup) => {
       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") {
@@ -31403,6 +32600,20 @@ const fragmentSignature = (fragment, lookup) => {
       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) => {
@@ -31548,7 +32759,7 @@ const deriveBlockVersion = (block) => {
   return block.id;
 };
 const applyRunStyles = (element, run, isLink = false) => {
-  if (run.kind === "tab" || run.kind === "image" || run.kind === "lineBreak") {
+  if (run.kind === "tab" || run.kind === "image" || run.kind === "lineBreak" || run.kind === "break") {
     return;
   }
   element.style.fontFamily = run.fontFamily;
@@ -31682,6 +32893,17 @@ const sliceRunsForLine = (block, line) => {
       result.push(run);
       continue;
     }
+    if (run.kind === "break") {
+      result.push(run);
+      continue;
+    }
+    if (run.kind === "tab") {
+      result.push(run);
+      continue;
+    }
+    if (!("text" in run)) {
+      continue;
+    }
     const text = run.text ?? "";
     const isFirstRun = runIndex === line.fromRun;
     const isLastRun = runIndex === line.toRun;
@@ -31695,20 +32917,14 @@ const sliceRunsForLine = (block, line) => {
       if (!slice2) continue;
       const pmSliceStart = runPmStart != null ? runPmStart + start2 : void 0;
       const pmSliceEnd = runPmStart != null ? runPmStart + end2 : fallbackPmEnd ?? void 0;
-      if (run.kind === "tab") {
-        if (slice2.includes("	")) {
-          result.push(run);
-        }
-      } else {
-        const sliced = {
-          ...run,
-          text: slice2,
-          pmStart: pmSliceStart,
-          pmEnd: pmSliceEnd,
-          comments: run.comments ? [...run.comments] : void 0
-        };
-        result.push(sliced);
-      }
+      const sliced = {
+        ...run,
+        text: slice2,
+        pmStart: pmSliceStart,
+        pmEnd: pmSliceEnd,
+        comments: run.comments ? [...run.comments] : void 0
+      };
+      result.push(sliced);
     } else {
       result.push(run);
     }
@@ -31751,6 +32967,39 @@ const computeLinePmRange = (block, line) => {
       }
       continue;
     }
+    if (run.kind === "break") {
+      const runPmStart2 = run.pmStart ?? null;
+      const runPmEnd = run.pmEnd ?? null;
+      if (runPmStart2 == null || runPmEnd == null) {
+        continue;
+      }
+      if (pmStart == null) {
+        pmStart = runPmStart2;
+      }
+      pmEnd = runPmEnd;
+      if (runIndex === line.toRun) {
+        break;
+      }
+      continue;
+    }
+    if (run.kind === "tab") {
+      const runPmStart2 = run.pmStart ?? null;
+      const runPmEnd = run.pmEnd ?? null;
+      if (runPmStart2 == null || runPmEnd == null) {
+        continue;
+      }
+      if (pmStart == null) {
+        pmStart = runPmStart2;
+      }
+      pmEnd = runPmEnd;
+      if (runIndex === line.toRun) {
+        break;
+      }
+      continue;
+    }
+    if (!("text" in run)) {
+      continue;
+    }
     const text = run.text ?? "";
     const runLength = text.length;
     const runPmStart = run.pmStart ?? null;
@@ -31792,6 +33041,12 @@ const resolveRunText = (run, context) => {
   if (run.kind === "lineBreak") {
     return "";
   }
+  if (run.kind === "break") {
+    return "";
+  }
+  if (!("text" in run)) {
+    return "";
+  }
   if (!runToken) {
     return run.text ?? "";
   }
@@ -31989,6 +33244,7 @@ async function measureBlock(block, constraints) {
 async function measureParagraphBlock(block, maxWidth) {
   const ctx2 = getCanvasContext();
   const wordLayout = block.attrs?.wordLayout;
+  const WIDTH_FUDGE_PX = 0.5;
   const lines = [];
   const indent = block.attrs?.indent;
   const spacing = block.attrs?.spacing;
@@ -32083,8 +33339,67 @@ async function measureParagraphBlock(block, maxWidth) {
     lastAppliedTabAlign = { target, val };
     pendingTabAlignment = null;
   };
-  for (let runIndex = 0; runIndex < block.runs.length; runIndex++) {
-    const run = block.runs[runIndex];
+  const runsToProcess = [];
+  for (const run of block.runs) {
+    if (run.text && typeof run.text === "string" && run.text.includes("\n")) {
+      const textRun = run;
+      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: run.sdt
+          });
+          cursor += 1;
+        }
+      });
+    } else {
+      runsToProcess.push(run);
+    }
+  }
+  for (let runIndex = 0; runIndex < runsToProcess.length; runIndex++) {
+    const run = runsToProcess[runIndex];
+    if (run.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(run)) {
       if (currentLine) {
         const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing);
@@ -32235,6 +33550,9 @@ async function measureParagraphBlock(block, maxWidth) {
       }
       continue;
     }
+    if (!("text" in run) || !("fontSize" in run)) {
+      continue;
+    }
     lastFontSize = run.fontSize;
     const { font } = buildFontString(run);
     const tabSegments = run.text.split("	");
@@ -32274,18 +33592,18 @@ async function measureParagraphBlock(block, maxWidth) {
             segments: [{ runIndex, fromChar: wordStartChar, toChar: wordEndNoSpace, width: wordOnlyWidth }]
           };
           const ls = run.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 ? run.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,
@@ -32305,16 +33623,16 @@ async function measureParagraphBlock(block, maxWidth) {
             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 + (run.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, run.fontSize);
@@ -32423,10 +33741,14 @@ async function measureParagraphBlock(block, maxWidth) {
     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 {
@@ -32440,6 +33762,34 @@ async function measureParagraphBlock(block, maxWidth) {
 async function measureTableBlock(block, constraints) {
   const maxWidth = typeof constraints === "number" ? constraints : constraints.maxWidth;
   let columnWidths;
+  const scaleColumnWidths = (widths, targetWidth) => {
+    const totalWidth2 = widths.reduce((a, b) => a + b, 0);
+    if (totalWidth2 <= targetWidth || widths.length === 0) return widths;
+    const scale = targetWidth / totalWidth2;
+    const scaled = widths.map((w) => Math.max(1, Math.round(w * scale)));
+    const sum = scaled.reduce((a, b) => a + b, 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 i = idx % scaled.length;
+          if (direction > 0) {
+            scaled[i] += 1;
+            delta -= 1;
+          } else if (scaled[i] > 1) {
+            scaled[i] -= 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];
@@ -32448,8 +33798,7 @@ async function measureTableBlock(block, constraints) {
     if (hasExplicitWidth || hasFixedLayout) {
       const totalWidth2 = columnWidths.reduce((a, b) => a + b, 0);
       if (totalWidth2 > maxWidth) {
-        const scale = maxWidth / totalWidth2;
-        columnWidths = columnWidths.map((w) => Math.max(1, Math.floor(w * scale)));
+        columnWidths = scaleColumnWidths(columnWidths, maxWidth);
       }
     } else {
       if (columnWidths.length < maxCellCount) {
@@ -32463,8 +33812,7 @@ async function measureTableBlock(block, constraints) {
       }
       const totalWidth2 = columnWidths.reduce((a, b) => a + b, 0);
       if (totalWidth2 > maxWidth) {
-        const scale = maxWidth / totalWidth2;
-        columnWidths = columnWidths.map((w) => Math.max(1, Math.floor(w * scale)));
+        columnWidths = scaleColumnWidths(columnWidths, maxWidth);
       }
     }
   } else {
@@ -32481,6 +33829,8 @@ async function measureTableBlock(block, constraints) {
   };
   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 row = block.rows[rowIndex];
     const cellMeasures = [];
@@ -32527,6 +33877,11 @@ async function measureTableBlock(block, constraints) {
         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++) {
@@ -32534,10 +33889,39 @@ async function measureTableBlock(block, constraints) {
         rowspanTracker[col]--;
       }
     }
-    const rowHeight = Math.max(0, ...cellMeasures.map((c) => c.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 i = 0; i < rowSpan && startRow + i < rowHeights.length; i++) {
+      currentHeight += rowHeights[startRow + i];
+    }
+    if (currentHeight < requiredHeight) {
+      const spanLength = Math.min(rowSpan, rowHeights.length - startRow);
+      const increment = spanLength > 0 ? (requiredHeight - currentHeight) / spanLength : 0;
+      for (let i = 0; i < spanLength; i++) {
+        rowHeights[startRow + i] += increment;
+      }
+    }
+  }
+  block.rows.forEach((row, index2) => {
+    const spec = row.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 i = 0; i < rows.length; i++) {
+    rows[i].height = Math.max(0, rowHeights[i]);
   }
-  const totalHeight = rows.reduce((sum, r2) => sum + r2.height, 0);
+  const totalHeight = rowHeights.reduce((sum, h) => sum + h, 0);
   const totalWidth = columnWidths.reduce((a, b) => a + b, 0);
   return {
     kind: "table",
@@ -32743,7 +34127,7 @@ const resolveLineHeight = (spacing, baseLineHeight) => {
   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) => {
@@ -38978,6 +40362,17 @@ const structuredContentHelpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ O
   parseTagObject
 }, Symbol.toStringTag, { value: "Module" }));
 const STRUCTURED_CONTENT_NAMES = ["structuredContent", "structuredContentBlock"];
+const findFirstTextNode = (node) => {
+  let firstTextNode = null;
+  node.descendants((child) => {
+    if (child.isText) {
+      firstTextNode = child;
+      return false;
+    }
+    return true;
+  });
+  return firstTextNode;
+};
 const StructuredContentCommands = Extension.create({
   name: "structuredContentCommands",
   addCommands() {
@@ -39118,7 +40513,7 @@ const StructuredContentCommands = Extension.create({
        * @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' },
        * });
@@ -39139,7 +40534,9 @@ const StructuredContentCommands = Extension.create({
           const posTo = pos + node.nodeSize;
           let content = null;
           if (options.text) {
-            content = schema.text(options.text);
+            const firstTextNode = options.keepTextNodeStyles === true ? findFirstTextNode(node) : null;
+            const textMarks = firstTextNode ? firstTextNode.marks : [];
+            content = schema.text(options.text, textMarks);
           }
           if (options.html) {
             const html = htmlHandler(options.html, editor);
@@ -39153,6 +40550,13 @@ const StructuredContentCommands = Extension.create({
             content = node.content;
           }
           const updatedNode = node.type.create({ ...node.attrs, ...options.attrs }, content, node.marks);
+          try {
+            const nodeForValidation = editor.validateJSON(updatedNode.toJSON());
+            nodeForValidation.check();
+          } catch (error) {
+            console.error("Invalid content.", "Passed value:", content, "Error:", error);
+            return false;
+          }
           tr.replaceWith(posFrom, posTo, updatedNode);
         }
         return true;
@@ -39237,7 +40641,7 @@ const StructuredContentCommands = Extension.create({
        * @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', {
@@ -39251,13 +40655,14 @@ const StructuredContentCommands = Extension.create({
         }
         const { schema } = editor;
         if (dispatch) {
-          structuredContentTags.forEach((structuredContent) => {
+          const updates = [];
+          for (const structuredContent of structuredContentTags) {
             const { pos, node } = structuredContent;
-            const posFrom = tr.mapping.map(pos);
-            const posTo = tr.mapping.map(pos + node.nodeSize);
             let content = null;
             if (options.text) {
-              content = schema.text(options.text);
+              const firstTextNode = options.keepTextNodeStyles === true ? findFirstTextNode(node) : null;
+              const textMarks = firstTextNode ? firstTextNode.marks : [];
+              content = schema.text(options.text, textMarks);
             }
             if (options.html) {
               const html = htmlHandler(options.html, editor);
@@ -39271,11 +40676,23 @@ const StructuredContentCommands = Extension.create({
               content = node.content;
             }
             const updatedNode = node.type.create({ ...node.attrs, ...options.attrs }, content, node.marks);
+            try {
+              const nodeForValidation = editor.validateJSON(updatedNode.toJSON());
+              nodeForValidation.check();
+            } catch (error) {
+              console.error("Invalid content.", "Passed value:", content, "Error:", error);
+              return false;
+            }
+            updates.push({ pos, node, updatedNode });
+          }
+          for (const { pos, node, updatedNode } of updates) {
+            const posFrom = tr.mapping.map(pos);
+            const posTo = tr.mapping.map(pos + node.nodeSize);
             const currentNode = tr.doc.nodeAt(posFrom);
             if (currentNode && node.eq(currentNode)) {
               tr.replaceWith(posFrom, posTo, updatedNode);
             }
-          });
+          }
         }
         return true;
       },
@@ -39851,61 +41268,153 @@ const Text = Node$1.create({
     return {};
   }
 });
-const splitRun = () => (props) => {
-  const { state, view, tr } = props;
-  const { $from, empty: empty2 } = state.selection;
-  if (!empty2) return false;
-  if ($from.parent.type.name !== "run") return false;
-  const handled = splitBlockPatch(state, (transaction) => {
-    view.dispatch(transaction);
-  });
-  if (handled) {
-    tr.setMeta("preventDispatch", true);
-  }
-  return handled;
-};
-function splitBlockPatch(state, dispatch) {
-  let { $from } = state.selection;
-  if (state.selection instanceof NodeSelection && state.selection.node.isBlock) {
-    if (!$from.parentOffset || !canSplit(state.doc, $from.pos)) return false;
-    if (dispatch) dispatch(state.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, paragraph } = newState.schema.nodes;
+    if (!run) 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((a, b) => a.from - b.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, (node, pos, parent) => {
+        if (node.type === run && node.content.size === 0 && parent?.type === paragraph) {
+          toDelete.push({ from: pos, to: pos + node.nodeSize });
+        }
+      });
+    });
+    if (!toDelete.length) return null;
+    const tr = newState.tr;
+    toDelete.sort((a, b) => b.from - a.from).forEach(({ from: from2, to }) => tr.deleteRange(from2, to));
+    return tr.docChanged ? tr : null;
   }
-  if (!$from.depth) return false;
-  let types = [];
-  let splitDepth, deflt, atEnd = false, atStart = false;
-  for (let d2 = $from.depth; ; d2--) {
-    let node = $from.node(d2);
-    if (node.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)));
-      types.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((a, b) => a.from - b.from);
+  const merged = [];
+  for (const range of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && range.from <= last.to) {
+      last.to = Math.max(last.to, range.to);
     } else {
-      if (d2 == 1) return false;
-      types.unshift(null);
+      merged.push({ ...range });
     }
   }
-  let tr = state.tr;
-  if (state.selection instanceof TextSelection || state.selection instanceof AllSelection) tr.deleteSelection();
-  let splitPos = tr.mapping.map($from.pos);
-  let can = canSplit(tr.doc, splitPos, types.length, types);
-  if (!can) {
-    types[0] = deflt ? { type: deflt } : null;
-    can = canSplit(tr.doc, splitPos, types.length, types);
-  }
-  if (!can) return false;
-  tr.split(splitPos, types.length, types);
-  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 = (state, ranges, runType) => {
+  if (!ranges.length) return null;
+  const replacements = [];
+  ranges.forEach(({ from: from2, to }) => {
+    state.doc.nodesBetween(from2, to, (node, pos, parent, index2) => {
+      if (!node.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(node.marks);
+      const runNode = runType.create({ runProperties }, node);
+      replacements.push({ from: pos, to: pos + node.nodeSize, runNode });
+    });
+  });
+  if (!replacements.length) return null;
+  const tr = state.tr;
+  replacements.sort((a, b) => b.from - a.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 onCompositionEnd = () => {
+    if (typeof globalThis === "undefined") return;
+    globalThis.queueMicrotask(flush);
+  };
+  return new Plugin({
+    view(editorView) {
+      view = editorView;
+      editorView.dom.addEventListener("compositionend", onCompositionEnd);
+      return {
+        destroy() {
+          editorView.dom.removeEventListener("compositionend", onCompositionEnd);
+          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",
@@ -39948,7 +41457,8 @@ const Run = OxmlNode.create({
   // @ts-expect-error - Command signatures will be fixed in TS migration
   addCommands() {
     return {
-      splitRun
+      splitRunToParagraph,
+      splitRunAtCursor
     };
   },
   parseDOM() {
@@ -39957,6 +41467,9 @@ const Run = OxmlNode.create({
   renderDOM({ htmlAttributes }) {
     const base2 = Attribute.mergeAttributes(this.options.htmlAttributes, htmlAttributes);
     return ["span", base2, 0];
+  },
+  addPmPlugins() {
+    return [wrapTextInRunsPlugin(), cleanupEmptyRunsPlugin];
   }
 });
 const restartNumbering = ({ editor, tr, state, dispatch }) => {
@@ -40768,20 +42281,15 @@ function createNumberingPlugin(editor) {
         } else {
           markerText = docxNumberingHelpers.normalizeLvlTextChar(lvlText);
         }
-        if (JSON.stringify(node.attrs.listRendering) !== JSON.stringify({
+        const newListRendering = {
           markerText,
           suffix,
           justification,
           path,
           numberingType: listNumberingType
-        })) {
-          tr.setNodeAttribute(pos, "listRendering", {
-            markerText,
-            suffix,
-            justification,
-            path,
-            numberingType: listNumberingType
-          });
+        };
+        if (JSON.stringify(node.attrs.listRendering) !== JSON.stringify(newListRendering)) {
+          tr.setNodeAttribute(pos, "listRendering", newListRendering);
         }
         return false;
       });
@@ -41082,7 +42590,7 @@ const Paragraph = OxmlNode.create({
             return null;
           }
           const { tr } = state;
-          tr.delete(range.from, range.to);
+          tr.delete(range.from, range.to).setSelection(TextSelection.create(tr.doc, range.from));
           ListHelpers.createNewList({
             listType: type,
             tr,
@@ -44512,7 +46020,10 @@ const Table = Node$1.create({
       insertTable: ({ rows = 3, cols = 3, withHeaderRow = false } = {}) => ({ tr, dispatch, editor }) => {
         const node = 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(node).scrollIntoView().setSelection(TextSelection.near(tr.doc.resolve(offset2)));
         }
         return true;