superdoc 1.0.0-beta.14 → 1.0.0-beta.16

package/dist/super-editor/chunks/{editor-wC_gs8Bl.js → editor-DFFvalb1.js}

@@ -9,11 +9,11 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-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, 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;
+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-CfmIU--8.js";
-import { D as DocxZipper } from "./docx-zipper-B-CXiNSb.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 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-C_R_BK8X.js";
+import { D as DocxZipper } from "./docx-zipper-BvQAYmi1.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() {
@@ -887,17 +887,20 @@ function findOffsetInNode(node, coords) {
 }
 function findOffsetInText(node, coords) {
   let len = node.nodeValue.length;
-  let range = document.createRange();
+  let range = document.createRange(), result;
   for (let i = 0; i < len; i++) {
     range.setEnd(node, i + 1);
     range.setStart(node, i);
     let rect = singleRect(range, 1);
     if (rect.top == rect.bottom)
       continue;
-    if (inRect(coords, rect))
-      return { node, offset: i + (coords.left >= (rect.left + rect.right) / 2 ? 1 : 0) };
+    if (inRect(coords, rect)) {
+      result = { node, offset: i + (coords.left >= (rect.left + rect.right) / 2 ? 1 : 0) };
+      break;
+    }
   }
-  return { node, offset: 0 };
+  range.detach();
+  return result || { node, offset: 0 };
 }
 function inRect(coords, rect) {
   return coords.left >= rect.left - 1 && coords.left <= rect.right + 1 && coords.top >= rect.top - 1 && coords.top <= rect.bottom + 1;
@@ -3644,7 +3647,7 @@ editHandlers.compositionstart = editHandlers.compositionupdate = (view) => {
   if (!view.composing) {
     view.domObserver.flush();
     let { state } = view, $pos = state.selection.$to;
-    if (state.selection instanceof TextSelection && (state.storedMarks || !$pos.textOffset && $pos.parentOffset && $pos.nodeBefore.marks.some((m) => m.type.spec.inclusive === false))) {
+    if (state.selection instanceof TextSelection && (state.storedMarks || !$pos.textOffset && $pos.parentOffset && $pos.nodeBefore.marks.some((m) => m.type.spec.inclusive === false) || chrome && windows$1 && selectionBeforeUneditable(view))) {
       view.markCursor = view.state.storedMarks || $pos.marks();
       endComposition(view, true);
       view.markCursor = null;
@@ -3672,6 +3675,13 @@ editHandlers.compositionstart = editHandlers.compositionupdate = (view) => {
   }
   scheduleComposeEnd(view, timeoutComposition);
 };
+function selectionBeforeUneditable(view) {
+  let { focusNode, focusOffset } = view.domSelectionRange();
+  if (!focusNode || focusNode.nodeType != 1 || focusOffset >= focusNode.childNodes.length)
+    return false;
+  let next = focusNode.childNodes[focusOffset];
+  return next.nodeType == 1 && next.contentEditable == "false";
+}
 editHandlers.compositionend = (view, event) => {
   if (view.composing) {
     view.input.composing = false;
@@ -3875,10 +3885,14 @@ handlers.dragend = (view) => {
   }, 50);
 };
 editHandlers.dragover = editHandlers.dragenter = (_, e) => e.preventDefault();
-editHandlers.drop = (view, _event) => {
-  let event = _event;
-  let dragging = view.dragging;
-  view.dragging = null;
+editHandlers.drop = (view, event) => {
+  try {
+    handleDrop(view, event, view.dragging);
+  } finally {
+    view.dragging = null;
+  }
+};
+function handleDrop(view, event, dragging) {
   if (!event.dataTransfer)
     return;
   let eventPos = view.posAtCoords(eventCoords(event));
@@ -3931,7 +3945,7 @@ editHandlers.drop = (view, _event) => {
   }
   view.focus();
   view.dispatch(tr.setMeta("uiEvent", "drop"));
-};
+}
 handlers.focus = (view) => {
   view.input.lastFocus = Date.now();
   if (!view.focused) {
@@ -4781,6 +4795,13 @@ class DOMObserver {
             br.remove();
         }
       }
+    } else if ((chrome || safari) && added.some((n) => n.nodeName == "BR") && (view.input.lastKeyCode == 8 || view.input.lastKeyCode == 46)) {
+      for (let node of added)
+        if (node.nodeName == "BR" && node.parentNode) {
+          let after = node.nextSibling;
+          if (after && after.nodeType == 1 && after.contentEditable == "false")
+            node.parentNode.removeChild(node);
+        }
     }
     let readSel = null;
     if (from2 < 0 && newSel && view.input.lastFocus > Date.now() - 200 && Math.max(view.input.lastTouch, view.input.lastClick.time) < Date.now() - 300 && selectionCollapsed(sel) && (readSel = selectionFromDOM(view)) && readSel.eq(Selection.near(view.state.doc.resolve(0), 1))) {
@@ -9964,7 +9985,7 @@ const Keymap = Extension.create({
     const baseKeymap = {
       Enter: () => handleEnter(this.editor),
       "Shift-Enter": () => this.editor.commands.insertLineBreak(),
-      "Mod-Enter": () => this.editor.commands.exitCode(),
+      "Mod-Enter": () => this.editor.commands.insertPageBreak(),
       Backspace: () => handleBackspace(this.editor),
       "Mod-Backspace": () => handleBackspace(this.editor),
       "Shift-Backspace": () => handleBackspace(this.editor),
@@ -13553,7 +13574,7 @@ const isHeadless = (editor) => {
 const shouldSkipNodeView = (editor) => {
   return isHeadless(editor);
 };
-const summaryVersion = "1.0.0-beta.14";
+const summaryVersion = "1.0.0-beta.16";
 const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
 const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
 function mapAttributes(attrs) {
@@ -14335,7 +14356,7 @@ const _Editor = class _Editor extends EventEmitter {
       { default: remarkStringify },
       { default: remarkGfm }
     ] = await Promise.all([
-      import("./index-I4Ew0HDV.js"),
+      import("./index-DexFffM7.js"),
       import("./index-DRCvimau.js"),
       import("./index-C_x_N6Uh.js"),
       import("./index-D_sWOSiG.js"),
@@ -14540,7 +14561,7 @@ const _Editor = class _Editor extends EventEmitter {
    * Process collaboration migrations
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.14");
+    console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.16");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -15703,7 +15724,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;
@@ -16343,20 +16364,37 @@ 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;
 };
 const MAX_DATA_ATTR_COUNT = 50;
 const MAX_DATA_ATTR_VALUE_LENGTH = 1e3;
 const MAX_DATA_ATTR_NAME_LENGTH = 100;
+const pushCommentAnnotation = (run, attrs) => {
+  const commentId = typeof attrs?.commentId === "string" ? attrs.commentId : void 0;
+  const importedId = typeof attrs?.importedId === "string" ? attrs.importedId : void 0;
+  const internal = attrs?.internal === true;
+  if (!commentId && !importedId) return;
+  const annotations = run.comments ? [...run.comments] : [];
+  const key2 = `${commentId ?? ""}::${importedId ?? ""}`;
+  const exists = annotations.some((c) => `${c.commentId ?? ""}::${c.importedId ?? ""}` === key2);
+  if (!exists) {
+    annotations.push({
+      commentId: commentId ?? importedId,
+      importedId,
+      internal
+    });
+  }
+  run.comments = annotations;
+};
 const extractDataAttributes = (attrs) => {
   if (!attrs) return void 0;
   const result = {};
@@ -16639,6 +16677,11 @@ const applyMarksToRun = (run, marks, hyperlinkConfig = DEFAULT_HYPERLINK_CONFIG,
         case "textStyle":
           applyTextStyleMark(run, mark.attrs ?? {}, themeColors);
           break;
+        case "commentMark":
+        case "comment": {
+          pushCommentAnnotation(run, mark.attrs ?? {});
+          break;
+        }
         case "underline": {
           const style = normalizeUnderlineStyle(mark.attrs?.underlineType);
           if (style) {
@@ -16763,13 +16806,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) => {
@@ -16908,7 +16946,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;
@@ -16964,7 +17002,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;
@@ -18127,11 +18165,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;
   }
@@ -18555,10 +18593,17 @@ const hydrateParagraphStyleAttrs = (para, context, preResolved) => {
   }
   const resolvedExtended = resolved;
   const resolvedAsRecord = resolved;
+  let resolvedIndent = cloneIfObject(resolvedAsRecord.indent);
+  const styleIdLower = typeof styleId === "string" ? styleId.toLowerCase() : "";
+  const isHeadingStyle = typeof resolvedExtended.outlineLvl === "number" || styleIdLower.startsWith("heading ") || styleIdLower.startsWith("heading");
+  const onlyFirstLineIndent = resolvedIndent && resolvedIndent.firstLine != null && resolvedIndent.hanging == null && resolvedIndent.left == null && resolvedIndent.right == null;
+  if (isHeadingStyle && (!resolvedIndent || Object.keys(resolvedIndent).length === 0 || onlyFirstLineIndent)) {
+    resolvedIndent = { firstLine: 0, hanging: 0, left: resolvedIndent?.left, right: resolvedIndent?.right };
+  }
   const hydrated = {
     resolved,
     spacing: cloneIfObject(resolvedAsRecord.spacing),
-    indent: cloneIfObject(resolvedAsRecord.indent),
+    indent: resolvedIndent,
     borders: cloneIfObject(resolvedExtended.borders),
     shading: cloneIfObject(resolvedExtended.shading),
     alignment: resolvedExtended.justification,
@@ -18578,6 +18623,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") {
@@ -18666,6 +18859,12 @@ const cloneParagraphAttrs = (attrs) => {
   }
   if (attrs.shading) clone.shading = { ...attrs.shading };
   if (attrs.tabs) clone.tabs = attrs.tabs.map((tab) => ({ ...tab }));
+  if (attrs.dropCapDescriptor) {
+    clone.dropCapDescriptor = {
+      ...attrs.dropCapDescriptor,
+      run: { ...attrs.dropCapDescriptor.run }
+    };
+  }
   return clone;
 };
 const buildStyleNodeFromAttrs = (attrs, spacing, indent) => {
@@ -18777,6 +18976,119 @@ const normalizeResolvedTabAlignment = (value) => {
       return void 0;
   }
 };
+const DEFAULT_DROP_CAP_FONT_SIZE_PX = 64;
+const DEFAULT_DROP_CAP_FONT_FAMILY = "Times New Roman";
+const extractDropCapRunFromParagraph = (para) => {
+  const content = para.content;
+  if (!Array.isArray(content) || content.length === 0) {
+    return null;
+  }
+  let text = "";
+  let runProperties = {};
+  let textStyleMarks = {};
+  const MAX_RECURSION_DEPTH = 50;
+  const extractTextAndStyle = (nodes, depth = 0) => {
+    if (depth > MAX_RECURSION_DEPTH) {
+      console.warn(`extractTextAndStyle exceeded max recursion depth (${MAX_RECURSION_DEPTH})`);
+      return false;
+    }
+    for (const node of nodes) {
+      if (!node) continue;
+      if (node.type === "text" && typeof node.text === "string" && node.text.length > 0) {
+        text = node.text;
+        if (Array.isArray(node.marks)) {
+          for (const mark of node.marks) {
+            if (mark?.type === "textStyle" && mark.attrs) {
+              textStyleMarks = { ...textStyleMarks, ...mark.attrs };
+            }
+          }
+        }
+        return true;
+      }
+      if (node.type === "run") {
+        if (node.attrs?.runProperties && typeof node.attrs.runProperties === "object") {
+          runProperties = { ...runProperties, ...node.attrs.runProperties };
+        }
+        if (Array.isArray(node.marks)) {
+          for (const mark of node.marks) {
+            if (mark?.type === "textStyle" && mark.attrs) {
+              textStyleMarks = { ...textStyleMarks, ...mark.attrs };
+            }
+          }
+        }
+        if (Array.isArray(node.content) && extractTextAndStyle(node.content, depth + 1)) {
+          return true;
+        }
+      }
+      if (Array.isArray(node.content) && extractTextAndStyle(node.content, depth + 1)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  extractTextAndStyle(content);
+  if (!text) {
+    return null;
+  }
+  const mergedStyle = { ...runProperties, ...textStyleMarks };
+  let fontSizePx = DEFAULT_DROP_CAP_FONT_SIZE_PX;
+  const rawFontSize = mergedStyle.fontSize ?? mergedStyle["w:sz"] ?? mergedStyle.sz;
+  if (rawFontSize != null) {
+    if (typeof rawFontSize === "number") {
+      const converted = rawFontSize > 100 ? ptToPx(rawFontSize / 2) : rawFontSize;
+      fontSizePx = converted ?? DEFAULT_DROP_CAP_FONT_SIZE_PX;
+    } else if (typeof rawFontSize === "string") {
+      const numericPart = parseFloat(rawFontSize);
+      if (Number.isFinite(numericPart)) {
+        if (rawFontSize.endsWith("pt")) {
+          const converted = ptToPx(numericPart);
+          fontSizePx = converted ?? DEFAULT_DROP_CAP_FONT_SIZE_PX;
+        } else if (rawFontSize.endsWith("px")) {
+          fontSizePx = numericPart;
+        } else {
+          const converted = numericPart > 100 ? ptToPx(numericPart / 2) : numericPart;
+          fontSizePx = converted ?? DEFAULT_DROP_CAP_FONT_SIZE_PX;
+        }
+      }
+    }
+  }
+  let fontFamily = DEFAULT_DROP_CAP_FONT_FAMILY;
+  const rawFontFamily = mergedStyle.fontFamily ?? mergedStyle["w:rFonts"] ?? mergedStyle.rFonts;
+  if (typeof rawFontFamily === "string") {
+    fontFamily = rawFontFamily;
+  } else if (rawFontFamily && typeof rawFontFamily === "object") {
+    const rFonts = rawFontFamily;
+    const ascii = rFonts["w:ascii"] ?? rFonts.ascii;
+    if (typeof ascii === "string") {
+      fontFamily = ascii;
+    }
+  }
+  const dropCapRun = {
+    text,
+    fontFamily,
+    fontSize: fontSizePx
+  };
+  const bold = mergedStyle.bold ?? mergedStyle["w:b"] ?? mergedStyle.b;
+  if (isTruthy(bold)) {
+    dropCapRun.bold = true;
+  }
+  const italic = mergedStyle.italic ?? mergedStyle["w:i"] ?? mergedStyle.i;
+  if (isTruthy(italic)) {
+    dropCapRun.italic = true;
+  }
+  const color = mergedStyle.color ?? mergedStyle["w:color"] ?? mergedStyle.val;
+  if (typeof color === "string" && color.length > 0 && color.toLowerCase() !== "auto") {
+    dropCapRun.color = color.startsWith("#") ? color : `#${color}`;
+  }
+  const position = mergedStyle.position ?? mergedStyle["w:position"];
+  if (position != null) {
+    const posNum = pickNumber(position);
+    if (posNum != null) {
+      dropCapRun.position = ptToPx(posNum / 2);
+    }
+  }
+  return dropCapRun;
+};
 const computeWordLayoutForParagraph = (paragraphAttrs, numberingProps, styleContext, _paragraphNode) => {
   if (numberingProps === null) {
     return null;
@@ -19042,6 +19354,24 @@ const computeParagraphAttrs = (para, styleContext, listCounterContext, converter
     const dropCap = framePr["w:dropCap"] ?? framePr.dropCap;
     if (dropCap != null && (typeof dropCap === "string" || typeof dropCap === "number" || typeof dropCap === "boolean")) {
       paragraphAttrs.dropCap = dropCap;
+      const dropCapMode = typeof dropCap === "string" ? dropCap.toLowerCase() : "drop";
+      const linesValue = pickNumber(framePr["w:lines"] ?? framePr.lines);
+      const wrapValue = asString(framePr["w:wrap"] ?? framePr.wrap);
+      const dropCapRunInfo = extractDropCapRunFromParagraph(para);
+      if (dropCapRunInfo) {
+        const descriptor = {
+          mode: dropCapMode === "margin" ? "margin" : "drop",
+          lines: linesValue != null && linesValue > 0 ? linesValue : 3,
+          run: dropCapRunInfo
+        };
+        if (wrapValue) {
+          const normalizedWrap = wrapValue.toLowerCase();
+          if (normalizedWrap === "around" || normalizedWrap === "notbeside" || normalizedWrap === "none" || normalizedWrap === "tight") {
+            descriptor.wrap = normalizedWrap === "notbeside" ? "notBeside" : normalizedWrap;
+          }
+        }
+        paragraphAttrs.dropCapDescriptor = descriptor;
+      }
     }
     const frame = {};
     const wrap = asString(framePr["w:wrap"] ?? framePr.wrap);
@@ -19073,6 +19403,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);
@@ -19815,13 +20169,26 @@ const dataAttrsCompatible = (a, b) => {
   }
   return true;
 };
+const commentsCompatible = (a, b) => {
+  const aComments = a.comments ?? [];
+  const bComments = b.comments ?? [];
+  if (aComments.length === 0 && bComments.length === 0) return true;
+  if (aComments.length !== bComments.length) return false;
+  const normalize2 = (c) => `${c.commentId ?? ""}::${c.importedId ?? ""}::${c.internal ? "1" : "0"}`;
+  const aKeys = aComments.map(normalize2).sort();
+  const bKeys = bComments.map(normalize2).sort();
+  for (let i = 0; i < aKeys.length; i++) {
+    if (aKeys[i] !== bKeys[i]) return false;
+  }
+  return true;
+};
 function mergeAdjacentRuns(runs) {
   if (runs.length <= 1) return runs;
   const merged = [];
   let current = runs[0];
   for (let i = 1; i < runs.length; i++) {
     const next = runs[i];
-    const canMerge = isTextRun$1(current) && isTextRun$1(next) && !current.token && !next.token && current.pmStart != null && current.pmEnd != null && next.pmStart != null && next.pmEnd != null && current.pmEnd === next.pmStart && current.fontFamily === next.fontFamily && current.fontSize === next.fontSize && current.bold === next.bold && current.italic === next.italic && current.underline === next.underline && current.strike === next.strike && current.color === next.color && current.highlight === next.highlight && (current.letterSpacing ?? 0) === (next.letterSpacing ?? 0) && trackedChangesCompatible(current, next) && dataAttrsCompatible(current, next);
+    const canMerge = isTextRun$1(current) && isTextRun$1(next) && !current.token && !next.token && current.pmStart != null && current.pmEnd != null && next.pmStart != null && next.pmEnd != null && current.pmEnd === next.pmStart && current.fontFamily === next.fontFamily && current.fontSize === next.fontSize && current.bold === next.bold && current.italic === next.italic && current.underline === next.underline && current.strike === next.strike && current.color === next.color && current.highlight === next.highlight && (current.letterSpacing ?? 0) === (next.letterSpacing ?? 0) && trackedChangesCompatible(current, next) && dataAttrsCompatible(current, next) && commentsCompatible(current, next);
     if (canMerge) {
       const currText = current.text ?? "";
       const nextText = next.text ?? "";
@@ -20285,25 +20652,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 {
+        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;
     }
   };
@@ -20896,6 +21283,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)) {
@@ -20933,8 +21336,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") {
@@ -20977,15 +21381,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;
@@ -21050,6 +21528,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;
@@ -21093,12 +21575,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;
 }
@@ -21327,7 +21812,39 @@ function toFlowBlocks(pmDoc, options) {
   }
   instrumentation?.log?.({ totalBlocks: blocks.length, blockCounts, bookmarks: bookmarks.size });
   const hydratedBlocks = hydrateImageBlocks(blocks, options?.mediaFiles);
-  return { blocks: hydratedBlocks, bookmarks };
+  const mergedBlocks = mergeDropCapParagraphs(hydratedBlocks);
+  return { blocks: mergedBlocks, bookmarks };
+}
+function mergeDropCapParagraphs(blocks) {
+  const result = [];
+  let i = 0;
+  while (i < blocks.length) {
+    const block = blocks[i];
+    if (block.kind === "paragraph" && block.attrs?.dropCapDescriptor && i + 1 < blocks.length) {
+      const dropCapBlock = block;
+      const nextBlock = blocks[i + 1];
+      if (nextBlock.kind === "paragraph") {
+        const textBlock = nextBlock;
+        const mergedBlock = {
+          kind: "paragraph",
+          id: textBlock.id,
+          runs: textBlock.runs,
+          attrs: {
+            ...textBlock.attrs,
+            dropCapDescriptor: dropCapBlock.attrs?.dropCapDescriptor,
+            // Clear the legacy dropCap flag on the merged block
+            dropCap: void 0
+          }
+        };
+        result.push(mergedBlock);
+        i += 2;
+        continue;
+      }
+    }
+    result.push(block);
+    i += 1;
+  }
+  return result;
 }
 function paragraphToFlowBlocks(para, nextBlockId, positions, defaultFont, defaultSize, styleContext, listCounterContext, trackedChanges, bookmarks, hyperlinkConfig = DEFAULT_HYPERLINK_CONFIG$1, themeColors, converterContext) {
   return paragraphToFlowBlocks$1(
@@ -21402,7 +21919,7 @@ function getMeasurementContext() {
   return measurementCtx;
 }
 function getRunFontString(run) {
-  if (run.kind === "tab" || run.kind === "image") {
+  if (run.kind === "tab" || run.kind === "lineBreak" || run.kind === "break" || "src" in run) {
     return "normal normal 16px Arial";
   }
   const style = run.italic ? "italic" : "normal";
@@ -21421,7 +21938,15 @@ function sliceRunsForLine$1(block, line) {
       result.push(run);
       continue;
     }
-    if (run.kind === "image") {
+    if ("src" in run) {
+      result.push(run);
+      continue;
+    }
+    if (run.kind === "lineBreak") {
+      result.push(run);
+      continue;
+    }
+    if (run.kind === "break") {
       result.push(run);
       continue;
     }
@@ -21448,13 +21973,17 @@ function sliceRunsForLine$1(block, line) {
 }
 function measureCharacterX(block, line, charOffset) {
   const ctx2 = getMeasurementContext();
+  const hasExplicitPositioning = line.segments?.some((seg) => seg.x !== void 0);
+  if (hasExplicitPositioning && line.segments && ctx2) {
+    return measureCharacterXSegmentBased(block, line, charOffset, ctx2);
+  }
   if (!ctx2) {
     const runs2 = sliceRunsForLine$1(block, line);
     const charsInLine = Math.max(
       1,
       runs2.reduce((sum, run) => {
         if (isTabRun$1(run)) return sum + TAB_CHAR_LENGTH;
-        if (run.kind === "image") return sum;
+        if ("src" in run || run.kind === "lineBreak" || run.kind === "break") return sum;
         return sum + (run.text ?? "").length;
       }, 0)
     );
@@ -21475,7 +22004,7 @@ function measureCharacterX(block, line, charOffset) {
       currentCharOffset += runLength2;
       continue;
     }
-    const text = run.kind === "image" ? "" : 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;
@@ -21492,6 +22021,47 @@ function measureCharacterX(block, line, charOffset) {
   }
   return currentX;
 }
+function measureCharacterXSegmentBased(block, line, charOffset, ctx2) {
+  if (block.kind !== "paragraph" || !line.segments) return 0;
+  let lineCharCount = 0;
+  for (const segment of line.segments) {
+    const run = block.runs[segment.runIndex];
+    if (!run) continue;
+    const segmentChars = segment.toChar - segment.fromChar;
+    if (lineCharCount + segmentChars >= charOffset) {
+      const offsetInSegment = charOffset - lineCharCount;
+      let segmentBaseX = segment.x;
+      if (segmentBaseX === void 0) {
+        segmentBaseX = 0;
+        for (const prevSeg of line.segments) {
+          if (prevSeg === segment) break;
+          const prevRun = block.runs[prevSeg.runIndex];
+          if (!prevRun) continue;
+          if (prevSeg.x !== void 0) {
+            segmentBaseX = prevSeg.x + (prevSeg.width ?? 0);
+          } else {
+            segmentBaseX += prevSeg.width ?? 0;
+          }
+        }
+      }
+      if (isTabRun$1(run)) {
+        return segmentBaseX + (offsetInSegment > 0 ? segment.width ?? 0 : 0);
+      }
+      if ("src" in run || run.kind === "lineBreak" || run.kind === "break") {
+        return segmentBaseX + (offsetInSegment >= segmentChars ? segment.width ?? 0 : 0);
+      }
+      const text = run.text ?? "";
+      const segmentText = text.slice(segment.fromChar, segment.toChar);
+      const textUpToTarget = segmentText.slice(0, offsetInSegment);
+      ctx2.font = getRunFontString(run);
+      const measured = ctx2.measureText(textUpToTarget);
+      const spacingWidth = computeLetterSpacingWidth(run, offsetInSegment, segmentChars);
+      return segmentBaseX + measured.width + spacingWidth;
+    }
+    lineCharCount += segmentChars;
+  }
+  return line.width;
+}
 function findCharacterAtX(block, line, x, pmStart) {
   const ctx2 = getMeasurementContext();
   if (!ctx2) {
@@ -21500,7 +22070,7 @@ function findCharacterAtX(block, line, x, pmStart) {
       1,
       runs2.reduce((sum, run) => {
         if (isTabRun$1(run)) return sum + TAB_CHAR_LENGTH;
-        if (run.kind === "image") return sum;
+        if ("src" in run || run.kind === "lineBreak" || run.kind === "break") return sum;
         return sum + (run.text ?? "").length;
       }, 0)
     );
@@ -21535,7 +22105,7 @@ function findCharacterAtX(block, line, x, pmStart) {
       currentCharOffset += TAB_CHAR_LENGTH;
       continue;
     }
-    const text = run.kind === "image" ? "" : 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);
@@ -21572,7 +22142,7 @@ function findCharacterAtX(block, line, x, pmStart) {
   };
 }
 const computeLetterSpacingWidth = (run, precedingChars, runLength) => {
-  if (isTabRun$1(run) || run.kind === "image" || !run.letterSpacing) {
+  if (isTabRun$1(run) || "src" in run || !("letterSpacing" in run) || !run.letterSpacing) {
     return 0;
   }
   const maxGaps = Math.max(runLength - 1, 0);
@@ -21582,6 +22152,8 @@ const computeLetterSpacingWidth = (run, precedingChars, runLength) => {
   const clamped = Math.min(Math.max(precedingChars, 0), maxGaps);
   return clamped * run.letterSpacing;
 };
+const log = (...args) => {
+};
 const CLASS_NAMES$1 = {
   page: "superdoc-page",
   fragment: "superdoc-fragment",
@@ -21597,6 +22169,11 @@ function clickToPositionDom(domContainer, clientX, clientY) {
   const pageLocalY = clientY - pageRect.top;
   const viewX = pageRect.left + pageLocalX;
   const viewY = pageRect.top + pageLocalY;
+  log("Page found:", {
+    pageIndex: pageEl.dataset.pageIndex,
+    pageRect: { left: pageRect.left, top: pageRect.top, width: pageRect.width, height: pageRect.height },
+    viewCoords: { viewX, viewY }
+  });
   let hitChain = [];
   const doc2 = document;
   if (typeof doc2.elementsFromPoint === "function") {
@@ -21608,15 +22185,62 @@ function clickToPositionDom(domContainer, clientX, clientY) {
   if (!Array.isArray(hitChain)) {
     return null;
   }
+  const hitChainData = hitChain.map((el) => {
+    const rect = el.getBoundingClientRect();
+    return {
+      tag: el.tagName,
+      classes: el.className,
+      blockId: el.dataset?.blockId,
+      pmStart: el.dataset?.pmStart,
+      pmEnd: el.dataset?.pmEnd,
+      rect: {
+        top: Math.round(rect.top),
+        bottom: Math.round(rect.bottom),
+        left: Math.round(rect.left),
+        right: Math.round(rect.right),
+        height: Math.round(rect.height)
+      }
+    };
+  });
+  log("Hit chain elements:", JSON.stringify(hitChainData, null, 2));
+  const allFragments = Array.from(pageEl.querySelectorAll(`.${CLASS_NAMES$1.fragment}`));
+  const fragmentData = allFragments.map((el) => {
+    const rect = el.getBoundingClientRect();
+    return {
+      blockId: el.dataset.blockId,
+      pmStart: el.dataset.pmStart,
+      pmEnd: el.dataset.pmEnd,
+      rect: {
+        top: Math.round(rect.top),
+        bottom: Math.round(rect.bottom),
+        left: Math.round(rect.left),
+        right: Math.round(rect.right),
+        height: Math.round(rect.height)
+      }
+    };
+  });
+  log("All fragments on page:", JSON.stringify(fragmentData, null, 2));
   const fragmentEl = hitChain.find((el) => el.classList?.contains?.(CLASS_NAMES$1.fragment));
   if (!fragmentEl) {
     const fallbackFragment = pageEl.querySelector(`.${CLASS_NAMES$1.fragment}`);
     if (!fallbackFragment) {
       return null;
     }
-    return processFragment(fallbackFragment, viewX, viewY);
+    log("Using fallback fragment:", {
+      blockId: fallbackFragment.dataset.blockId,
+      pmStart: fallbackFragment.dataset.pmStart,
+      pmEnd: fallbackFragment.dataset.pmEnd
+    });
+    const result2 = processFragment(fallbackFragment, viewX, viewY);
+    return result2;
   }
-  return processFragment(fragmentEl, viewX, viewY);
+  log("Fragment found:", {
+    blockId: fragmentEl.dataset.blockId,
+    pmStart: fragmentEl.dataset.pmStart,
+    pmEnd: fragmentEl.dataset.pmEnd
+  });
+  const result = processFragment(fragmentEl, viewX, viewY);
+  return result;
 }
 function findPageElement(domContainer, clientX, clientY) {
   if (domContainer.classList?.contains?.(CLASS_NAMES$1.page)) {
@@ -21648,7 +22272,20 @@ function findPageElement(domContainer, clientX, clientY) {
   return null;
 }
 function processFragment(fragmentEl, viewX, viewY) {
+  log("processFragment:", { viewX, viewY, blockId: fragmentEl.dataset.blockId });
   const lineEls = Array.from(fragmentEl.querySelectorAll(`.${CLASS_NAMES$1.line}`));
+  log(
+    "Lines in fragment:",
+    lineEls.map((el, i) => {
+      const rect = el.getBoundingClientRect();
+      return {
+        index: i,
+        pmStart: el.dataset.pmStart,
+        pmEnd: el.dataset.pmEnd,
+        rect: { top: rect.top, bottom: rect.bottom, left: rect.left, right: rect.right }
+      };
+    })
+  );
   if (lineEls.length === 0) {
     return null;
   }
@@ -21658,10 +22295,30 @@ function processFragment(fragmentEl, viewX, viewY) {
   }
   const lineStart = Number(lineEl.dataset.pmStart ?? "NaN");
   const lineEnd = Number(lineEl.dataset.pmEnd ?? "NaN");
+  const lineRect = lineEl.getBoundingClientRect();
+  log("Selected line:", {
+    pmStart: lineStart,
+    pmEnd: lineEnd,
+    rect: { top: lineRect.top, bottom: lineRect.bottom, left: lineRect.left, right: lineRect.right }
+  });
   if (!Number.isFinite(lineStart) || !Number.isFinite(lineEnd)) {
     return null;
   }
   const spanEls = Array.from(lineEl.querySelectorAll("span"));
+  log(
+    "Spans in line:",
+    spanEls.map((el, i) => {
+      const rect = el.getBoundingClientRect();
+      return {
+        index: i,
+        pmStart: el.dataset.pmStart,
+        pmEnd: el.dataset.pmEnd,
+        text: el.textContent?.substring(0, 20) + (el.textContent && el.textContent.length > 20 ? "..." : ""),
+        visibility: el.style.visibility,
+        rect: { left: rect.left, right: rect.right, width: rect.width }
+      };
+    })
+  );
   if (spanEls.length === 0) {
     return lineStart;
   }
@@ -21679,6 +22336,14 @@ function processFragment(fragmentEl, viewX, viewY) {
   }
   const spanStart = Number(targetSpan.dataset.pmStart ?? "NaN");
   const spanEnd = Number(targetSpan.dataset.pmEnd ?? "NaN");
+  const targetRect = targetSpan.getBoundingClientRect();
+  log("Target span:", {
+    pmStart: spanStart,
+    pmEnd: spanEnd,
+    text: targetSpan.textContent?.substring(0, 30),
+    visibility: targetSpan.style.visibility,
+    rect: { left: targetRect.left, right: targetRect.right, width: targetRect.width }
+  });
   if (!Number.isFinite(spanStart) || !Number.isFinite(spanEnd)) {
     return null;
   }
@@ -21698,28 +22363,53 @@ function findLineAtY(lineEls, viewY) {
   if (lineEls.length === 0) {
     return null;
   }
-  for (const lineEl of lineEls) {
+  for (let i = 0; i < lineEls.length; i++) {
+    const lineEl = lineEls[i];
     const rect = lineEl.getBoundingClientRect();
     if (viewY >= rect.top && viewY <= rect.bottom) {
+      log("findLineAtY: Found line at index", i, {
+        pmStart: lineEl.dataset.pmStart,
+        pmEnd: lineEl.dataset.pmEnd,
+        rect: { top: rect.top, bottom: rect.bottom },
+        viewY
+      });
       return lineEl;
     }
   }
-  return lineEls[lineEls.length - 1];
+  const lastLine = lineEls[lineEls.length - 1];
+  log("findLineAtY: Y beyond all lines, using last line:", {
+    pmStart: lastLine.dataset.pmStart,
+    pmEnd: lastLine.dataset.pmEnd,
+    viewY
+  });
+  return lastLine;
 }
 function findSpanAtX(spanEls, viewX) {
   if (spanEls.length === 0) {
     return null;
   }
   let targetSpan = spanEls[0];
-  for (const span of spanEls) {
+  for (let i = 0; i < spanEls.length; i++) {
+    const span = spanEls[i];
     const rect = span.getBoundingClientRect();
     if (viewX >= rect.left && viewX <= rect.right) {
+      log("findSpanAtX: Found containing span at index", i, {
+        pmStart: span.dataset.pmStart,
+        pmEnd: span.dataset.pmEnd,
+        rect: { left: rect.left, right: rect.right },
+        viewX
+      });
       return span;
     }
     if (viewX > rect.right) {
       targetSpan = span;
     }
   }
+  log("findSpanAtX: No containing span, using nearest:", {
+    pmStart: targetSpan.dataset.pmStart,
+    pmEnd: targetSpan.dataset.pmEnd,
+    viewX
+  });
   return targetSpan;
 }
 function findCharIndexAtX(textNode, span, targetX) {
@@ -21848,8 +22538,42 @@ 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) {
-      return zones.filter((zone) => {
+      const result = zones.filter((zone) => {
         if (zone.pageNumber !== pageNumber || zone.columnIndex !== columnIndex) {
           return false;
         }
@@ -21857,8 +22581,10 @@ function createFloatingObjectManager(columns, margins, pageWidth) {
         const lineBottom = lineY + lineHeight;
         const zoneTop = zone.bounds.y - zone.distances.top;
         const zoneBottom = zone.bounds.y + zone.bounds.height + zone.distances.bottom;
-        return lineBottom > zoneTop && lineTop < zoneBottom;
+        const overlaps = lineBottom > zoneTop && lineTop < zoneBottom;
+        return overlaps;
       });
+      return result;
     },
     computeAvailableWidth(lineY, lineHeight, baseWidth, columnIndex, pageNumber) {
       const exclusions = this.getExclusionsForLine(lineY, lineHeight, columnIndex, pageNumber);
@@ -21871,6 +22597,8 @@ function createFloatingObjectManager(columns, margins, pageWidth) {
       }
       const leftFloats = [];
       const rightFloats = [];
+      const columnOrigin = marginLeft + columnIndex * (columns.width + columns.gap);
+      const columnCenter = columnOrigin + baseWidth / 2;
       for (const zone of wrappingZones) {
         if (zone.wrapMode === "left") {
           leftFloats.push(zone);
@@ -21878,7 +22606,7 @@ function createFloatingObjectManager(columns, margins, pageWidth) {
           rightFloats.push(zone);
         } else if (zone.wrapMode === "both" || zone.wrapMode === "largest") {
           const zoneCenter = zone.bounds.x + zone.bounds.width / 2;
-          if (zoneCenter < baseWidth / 2) {
+          if (zoneCenter < columnCenter) {
             leftFloats.push(zone);
           } else {
             rightFloats.push(zone);
@@ -21890,7 +22618,6 @@ function createFloatingObjectManager(columns, margins, pageWidth) {
         const boundary = zone.bounds.x + zone.bounds.width + zone.distances.left + zone.distances.right;
         leftBoundary = Math.max(leftBoundary, boundary);
       }
-      const columnOrigin = marginLeft + columnIndex * (columns.width + columns.gap);
       const columnRightEdge = columnOrigin + baseWidth;
       let rightBoundary = columnRightEdge;
       for (const zone of rightFloats) {
@@ -21952,6 +22679,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 = [];
@@ -22213,9 +22983,6 @@ const extractBlockPmRange = (block) => {
     pmEnd: end2 ?? (start2 != null ? start2 + 1 : void 0)
   };
 };
-const anchorDebugLog = (...args) => {
-  return;
-};
 function layoutParagraphBlock(ctx2, anchors) {
   const { block, measure, columnWidth, ensurePage, advanceColumn, columnX, floatManager } = ctx2;
   const remeasureParagraph2 = ctx2.remeasureParagraph;
@@ -22224,23 +22991,45 @@ function layoutParagraphBlock(ctx2, anchors) {
     for (const entry of anchors.anchoredDrawings) {
       if (anchors.placedAnchoredIds.has(entry.block.id)) continue;
       const state = ensurePage();
-      const baseAnchorY = state.cursorY;
-      const firstLineHeight = measure.lines?.[0]?.lineHeight ?? 0;
       const vRelativeFrom = entry.block.anchor?.vRelativeFrom;
-      const paragraphAdjustment = vRelativeFrom === "paragraph" ? firstLineHeight / 2 : 0;
-      const anchorY = baseAnchorY + paragraphAdjustment;
-      anchorDebugLog("Positioning anchored image:", {
-        blockId: entry.block.id,
-        baseAnchorY,
-        paragraphAdjustment,
-        anchorY,
-        offsetV: entry.block.anchor?.offsetV,
-        finalY: anchorY + (entry.block.anchor?.offsetV ?? 0),
-        measureHeight: entry.measure.height,
-        measureWidth: entry.measure.width,
-        pageNumber: state.page.number,
-        vRelativeFrom
-      });
+      const alignV = entry.block.anchor?.alignV;
+      const offsetV = entry.block.anchor?.offsetV ?? 0;
+      const imageHeight = entry.measure.height;
+      const contentTop = state.topMargin;
+      const contentBottom = state.contentBottom;
+      const contentHeight = Math.max(0, contentBottom - contentTop);
+      let anchorY;
+      if (vRelativeFrom === "margin") {
+        if (alignV === "top") {
+          anchorY = contentTop + offsetV;
+        } else if (alignV === "bottom") {
+          anchorY = contentBottom - imageHeight + offsetV;
+        } else if (alignV === "center") {
+          anchorY = contentTop + (contentHeight - imageHeight) / 2 + offsetV;
+        } else {
+          anchorY = contentTop + offsetV;
+        }
+      } else if (vRelativeFrom === "page") {
+        if (alignV === "top") {
+          anchorY = offsetV;
+        } else if (alignV === "bottom") {
+          const pageHeight = contentBottom + (anchors.pageMargins.bottom ?? 0);
+          anchorY = pageHeight - imageHeight + offsetV;
+        } else if (alignV === "center") {
+          const pageHeight = contentBottom + (anchors.pageMargins.bottom ?? 0);
+          anchorY = (pageHeight - imageHeight) / 2 + offsetV;
+        } else {
+          anchorY = offsetV;
+        }
+      } else if (vRelativeFrom === "paragraph") {
+        const baseAnchorY = state.cursorY;
+        const firstLineHeight = measure.lines?.[0]?.lineHeight ?? 0;
+        const paragraphAdjustment = firstLineHeight / 2;
+        anchorY = baseAnchorY + paragraphAdjustment + offsetV;
+      } else {
+        const baseAnchorY = state.cursorY;
+        anchorY = baseAnchorY + offsetV;
+      }
       floatManager.registerDrawing(entry.block, entry.measure, anchorY, state.columnIndex, state.page.number);
       const anchorX = entry.block.anchor ? computeAnchorX(
         entry.block.anchor,
@@ -22280,7 +23069,7 @@ function layoutParagraphBlock(ctx2, anchors) {
           kind: "image",
           blockId: entry.block.id,
           x: anchorX,
-          y: anchorY + (entry.block.anchor?.offsetV ?? 0),
+          y: anchorY,
           width: entry.measure.width,
           height: entry.measure.height,
           isAnchored: true,
@@ -22296,7 +23085,7 @@ function layoutParagraphBlock(ctx2, anchors) {
           blockId: entry.block.id,
           drawingKind: entry.block.drawingKind,
           x: anchorX,
-          y: anchorY + (entry.block.anchor?.offsetV ?? 0),
+          y: anchorY,
           width: entry.measure.width,
           height: entry.measure.height,
           geometry: entry.measure.geometry,
@@ -22357,7 +23146,39 @@ function layoutParagraphBlock(ctx2, anchors) {
     state.lastParagraphStyleId = styleId;
     return;
   }
+  let narrowestWidth = columnWidth;
+  let narrowestOffsetX = 0;
   let didRemeasureForFloats = false;
+  if (typeof remeasureParagraph2 === "function") {
+    const tempState = ensurePage();
+    let tempY = tempState.cursorY;
+    if (!appliedSpacingBefore && spacingBefore > 0) {
+      const prevTrailing = tempState.trailingSpacing ?? 0;
+      const neededSpacingBefore = Math.max(spacingBefore - prevTrailing, 0);
+      tempY += neededSpacingBefore;
+    }
+    for (let i = 0; i < lines.length; i++) {
+      const lineY = tempY;
+      const lineHeight = lines[i]?.lineHeight || 0;
+      const { width: availableWidth, offsetX: computedOffset } = floatManager.computeAvailableWidth(
+        lineY,
+        lineHeight,
+        columnWidth,
+        tempState.columnIndex,
+        tempState.page.number
+      );
+      if (availableWidth < narrowestWidth) {
+        narrowestWidth = availableWidth;
+        narrowestOffsetX = computedOffset;
+      }
+      tempY += lineHeight;
+    }
+    if (narrowestWidth < columnWidth) {
+      const newMeasure = remeasureParagraph2(block, narrowestWidth);
+      lines = normalizeLines(newMeasure);
+      didRemeasureForFloats = true;
+    }
+  }
   while (fromLine < lines.length) {
     let state = ensurePage();
     if (state.trailingSpacing == null) state.trailingSpacing = 0;
@@ -22402,23 +23223,9 @@ function layoutParagraphBlock(ctx2, anchors) {
     }
     let effectiveColumnWidth = columnWidth;
     let offsetX = 0;
-    if (!didRemeasureForFloats && typeof remeasureParagraph2 === "function") {
-      const firstLineY = state.cursorY;
-      const firstLineHeight = lines[fromLine]?.lineHeight || 0;
-      const { width: adjustedWidth, offsetX: computedOffset } = floatManager.computeAvailableWidth(
-        firstLineY,
-        firstLineHeight,
-        columnWidth,
-        state.columnIndex,
-        state.page.number
-      );
-      if (adjustedWidth < columnWidth) {
-        const newMeasure = remeasureParagraph2(block, adjustedWidth);
-        lines = normalizeLines(newMeasure);
-        didRemeasureForFloats = true;
-        effectiveColumnWidth = adjustedWidth;
-        offsetX = computedOffset;
-      }
+    if (didRemeasureForFloats) {
+      effectiveColumnWidth = narrowestWidth;
+      offsetX = narrowestOffsetX;
     }
     const slice2 = sliceLines(lines, fromLine, state.contentBottom - state.cursorY);
     const fragmentHeight = slice2.height;
@@ -22432,15 +23239,6 @@ function layoutParagraphBlock(ctx2, anchors) {
       width: effectiveColumnWidth,
       ...computeFragmentPmRange(block, lines, fromLine, slice2.toLine)
     };
-    anchorDebugLog("Positioning paragraph fragment:", {
-      blockId: block.id,
-      fragmentY: state.cursorY,
-      fragmentHeight,
-      firstLineHeight: lines[fromLine]?.lineHeight,
-      firstLineAscent: lines[fromLine]?.ascent,
-      firstLineDescent: lines[fromLine]?.descent,
-      pageNumber: state.page.number
-    });
     if (measure.marker && fromLine === 0) {
       fragment.markerWidth = measure.marker.markerWidth;
     }
@@ -22620,6 +23418,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,
@@ -22628,36 +23626,202 @@ 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;
+  return vRelativeFrom === "margin" || vRelativeFrom === "page";
+}
+function collectPreRegisteredAnchors(blocks, measures) {
+  const result = [];
+  const len = Math.min(blocks.length, measures.length);
+  for (let i = 0; i < len; i += 1) {
+    const block = blocks[i];
+    const measure = measures[i];
+    const isImage = block.kind === "image" && measure?.kind === "image";
+    const isDrawing = block.kind === "drawing" && measure?.kind === "drawing";
+    if (!isImage && !isDrawing) continue;
+    const drawingBlock = block;
+    const drawingMeasure = measure;
+    if (!drawingBlock.anchor?.isAnchored) continue;
+    if (isPageRelativeAnchor(drawingBlock)) {
+      result.push({ block: drawingBlock, measure: drawingMeasure });
+    }
+  }
+  return result;
 }
 function collectAnchoredDrawings(blocks, measures) {
   const map2 = /* @__PURE__ */ new Map();
-  for (let i = 0; i < blocks.length; i += 1) {
-    if (blocks[i].kind === "paragraph") ;
-  }
+  const len = Math.min(blocks.length, measures.length);
   const nearestPrevParagraph = (fromIndex) => {
     for (let i = fromIndex - 1; i >= 0; i -= 1) {
       if (blocks[i].kind === "paragraph") return i;
@@ -22665,12 +23829,12 @@ function collectAnchoredDrawings(blocks, measures) {
     return null;
   };
   const nearestNextParagraph = (fromIndex) => {
-    for (let i = fromIndex + 1; i < blocks.length; i += 1) {
+    for (let i = fromIndex + 1; i < len; i += 1) {
       if (blocks[i].kind === "paragraph") return i;
     }
     return null;
   };
-  for (let i = 0; i < blocks.length; i += 1) {
+  for (let i = 0; i < len; i += 1) {
     const block = blocks[i];
     const measure = measures[i];
     const isImage = block.kind === "image" && measure?.kind === "image";
@@ -22678,7 +23842,12 @@ function collectAnchoredDrawings(blocks, measures) {
     if (!isImage && !isDrawing) continue;
     const drawingBlock = block;
     const drawingMeasure = measure;
-    if (!drawingBlock.anchor?.isAnchored) continue;
+    if (!drawingBlock.anchor?.isAnchored) {
+      continue;
+    }
+    if (isPageRelativeAnchor(drawingBlock)) {
+      continue;
+    }
     let anchorParaIndex = nearestPrevParagraph(i);
     if (anchorParaIndex == null) anchorParaIndex = nearestNextParagraph(i);
     if (anchorParaIndex == null) continue;
@@ -22688,6 +23857,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 = [];
@@ -23273,7 +24472,57 @@ 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) {
+    const state = paginator.ensurePage();
+    const vRelativeFrom = entry.block.anchor?.vRelativeFrom ?? "paragraph";
+    const alignV = entry.block.anchor?.alignV ?? "top";
+    const offsetV = entry.block.anchor?.offsetV ?? 0;
+    const imageHeight = entry.measure.height ?? 0;
+    const contentTop = state.topMargin;
+    const contentBottom = state.contentBottom;
+    const contentHeight = Math.max(0, contentBottom - contentTop);
+    let anchorY;
+    if (vRelativeFrom === "margin") {
+      if (alignV === "top") {
+        anchorY = contentTop + offsetV;
+      } else if (alignV === "bottom") {
+        anchorY = contentBottom - imageHeight + offsetV;
+      } else if (alignV === "center") {
+        anchorY = contentTop + (contentHeight - imageHeight) / 2 + offsetV;
+      } else {
+        anchorY = contentTop + offsetV;
+      }
+    } else if (vRelativeFrom === "page") {
+      if (alignV === "top") {
+        anchorY = offsetV;
+      } else if (alignV === "bottom") {
+        const pageHeight = contentBottom + margins.bottom;
+        anchorY = pageHeight - imageHeight + offsetV;
+      } else if (alignV === "center") {
+        const pageHeight = contentBottom + margins.bottom;
+        anchorY = (pageHeight - imageHeight) / 2 + offsetV;
+      } else {
+        anchorY = offsetV;
+      }
+    } else {
+      anchorY = contentTop + offsetV;
+    }
+    const anchorX = entry.block.anchor ? computeAnchorX(
+      entry.block.anchor,
+      state.columnIndex,
+      normalizeColumns(activeColumns, contentWidth),
+      entry.measure.width,
+      { left: margins.left, right: margins.right },
+      activePageSize.w
+    ) : margins.left;
+    floatManager.registerDrawing(entry.block, entry.measure, anchorY, state.columnIndex, state.page.number);
+    preRegisteredPositions.set(entry.block.id, { anchorX, anchorY, pageNumber: state.page.number });
+  }
   for (let index2 = 0; index2 < blocks.length; index2 += 1) {
     const block = blocks[index2];
     const measure = measures[index2];
@@ -23403,6 +24652,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,
@@ -23433,6 +24695,52 @@ function layoutDocument(blocks, measures, options = {}) {
       if (measure.kind !== "image") {
         throw new Error(`layoutDocument: expected image measure for block ${block.id}`);
       }
+      const preRegPos = preRegisteredPositions.get(block.id);
+      if (preRegPos && Number.isFinite(preRegPos.anchorX) && Number.isFinite(preRegPos.anchorY) && Number.isFinite(preRegPos.pageNumber)) {
+        const state = paginator.ensurePage();
+        const imgBlock = block;
+        const imgMeasure = measure;
+        const pageContentHeight = Math.max(0, state.contentBottom - state.topMargin);
+        const relativeFrom = imgBlock.anchor?.hRelativeFrom ?? "column";
+        const cols = getCurrentColumns();
+        let maxWidth;
+        if (relativeFrom === "page") {
+          maxWidth = cols.count === 1 ? activePageSize.w - margins.left - margins.right : activePageSize.w;
+        } else if (relativeFrom === "margin") {
+          maxWidth = activePageSize.w - margins.left - margins.right;
+        } else {
+          maxWidth = cols.width;
+        }
+        const aspectRatio = imgMeasure.width > 0 && imgMeasure.height > 0 ? imgMeasure.width / imgMeasure.height : 1;
+        const minWidth = 20;
+        const minHeight = minWidth / aspectRatio;
+        const metadata = {
+          originalWidth: imgMeasure.width,
+          originalHeight: imgMeasure.height,
+          maxWidth,
+          maxHeight: pageContentHeight,
+          aspectRatio,
+          minWidth,
+          minHeight
+        };
+        const fragment = {
+          kind: "image",
+          blockId: imgBlock.id,
+          x: preRegPos.anchorX,
+          y: preRegPos.anchorY,
+          width: imgMeasure.width,
+          height: imgMeasure.height,
+          isAnchored: true,
+          zIndex: imgBlock.anchor?.behindDoc ? 0 : 1,
+          metadata
+        };
+        const attrs = imgBlock.attrs;
+        if (attrs?.pmStart != null) fragment.pmStart = attrs.pmStart;
+        if (attrs?.pmEnd != null) fragment.pmEnd = attrs.pmEnd;
+        state.page.fragments.push(fragment);
+        placedAnchoredIds.add(imgBlock.id);
+        continue;
+      }
       layoutImageBlock({
         block,
         measure,
@@ -23628,7 +24936,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(run.kind === "image" ? "" : 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;
@@ -23897,7 +25207,13 @@ const FeatureFlags = {
    * Logs cache hits, misses, invalidations, and bucket selection.
    * Should be disabled in production (only enabled for debugging).
    */
-  DEBUG_HF_CACHE: isEnabled("SD_DEBUG_HF_CACHE", false)
+  DEBUG_HF_CACHE: isEnabled("SD_DEBUG_HF_CACHE", false),
+  /**
+   * Enable debug logging for layout version tracking.
+   * Logs stale layout reads, geometry fallbacks, PM transactions, and layout completions.
+   * Should be disabled in production (only enabled for debugging).
+   */
+  DEBUG_LAYOUT_VERSION: isEnabled("SD_DEBUG_LAYOUT_VERSION", false)
 };
 const PageTokenLogger = {
   /**
@@ -24282,7 +25598,7 @@ function fontString(run) {
   return `${italic}${bold}${size}px ${family}`.trim();
 }
 function runText(run) {
-  return run.kind === "image" ? "" : run.text ?? "";
+  return "src" in run || run.kind === "lineBreak" || run.kind === "break" ? "" : run.text ?? "";
 }
 function measureRunSliceWidth(run, fromChar, toChar) {
   const context = getCtx();
@@ -24444,7 +25760,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 ((runA.kind === "image" ? "" : runA.text) !== (runB.kind === "image" ? "" : 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;
     }
   }
@@ -24564,7 +25880,7 @@ function computeHeaderFooterContentHash(blocks) {
     parts.push(block.id);
     if (block.kind === "paragraph") {
       for (const run of block.runs) {
-        if (run.kind !== "image") {
+        if (!("src" in run) && run.kind !== "lineBreak" && run.kind !== "break") {
           parts.push(run.text ?? "");
         }
         if ("bold" in run && run.bold) parts.push("b");
@@ -24993,6 +26309,23 @@ async function remeasureAffectedBlocks(blocks, measures, affectedBlockIds, const
   }
   return updatedMeasures;
 }
+var Priority = /* @__PURE__ */ ((Priority2) => {
+  Priority2[Priority2["P0"] = 0] = "P0";
+  Priority2[Priority2["P1"] = 1] = "P1";
+  Priority2[Priority2["P2"] = 2] = "P2";
+  Priority2[Priority2["P3"] = 3] = "P3";
+  return Priority2;
+})(Priority || {});
+({
+  /** P0: No debounce for synchronous cursor positioning */
+  [Priority.P0]: 0,
+  /** P1: One animation frame (~60fps) for viewport layout */
+  [Priority.P1]: 16,
+  /** P2: Typing burst threshold for adjacent pages layout */
+  [Priority.P2]: 50,
+  /** P3: Heavy debounce for full document layout */
+  [Priority.P3]: 150
+});
 const isAtomicFragment = (fragment) => {
   return fragment.kind === "drawing" || fragment.kind === "image";
 };
@@ -25080,6 +26413,111 @@ const hitTestAtomicFragment = (pageHit, blocks, measures, point) => {
   }
   return null;
 };
+const hitTestTableFragment = (pageHit, blocks, measures, point) => {
+  for (const fragment of pageHit.page.fragments) {
+    if (fragment.kind !== "table") continue;
+    const tableFragment = fragment;
+    const withinX = point.x >= tableFragment.x && point.x <= tableFragment.x + tableFragment.width;
+    const withinY = point.y >= tableFragment.y && point.y <= tableFragment.y + tableFragment.height;
+    if (!withinX || !withinY) continue;
+    const blockIndex = blocks.findIndex((block2) => block2.id === tableFragment.blockId);
+    if (blockIndex === -1) continue;
+    const block = blocks[blockIndex];
+    const measure = measures[blockIndex];
+    if (!block || block.kind !== "table" || !measure || measure.kind !== "table") continue;
+    const tableBlock = block;
+    const tableMeasure = measure;
+    const localX = point.x - tableFragment.x;
+    const localY = point.y - tableFragment.y;
+    let rowY = 0;
+    let rowIndex = -1;
+    if (tableMeasure.rows.length === 0 || tableBlock.rows.length === 0) continue;
+    for (let r2 = tableFragment.fromRow; r2 < tableFragment.toRow && r2 < tableMeasure.rows.length; r2++) {
+      const rowMeasure2 = tableMeasure.rows[r2];
+      if (localY >= rowY && localY < rowY + rowMeasure2.height) {
+        rowIndex = r2;
+        break;
+      }
+      rowY += rowMeasure2.height;
+    }
+    if (rowIndex === -1) {
+      rowIndex = Math.min(tableFragment.toRow - 1, tableMeasure.rows.length - 1);
+      if (rowIndex < tableFragment.fromRow) continue;
+    }
+    const rowMeasure = tableMeasure.rows[rowIndex];
+    const row = tableBlock.rows[rowIndex];
+    if (!rowMeasure || !row) continue;
+    let colX = 0;
+    let colIndex = -1;
+    if (rowMeasure.cells.length === 0 || row.cells.length === 0) continue;
+    for (let c = 0; c < rowMeasure.cells.length; c++) {
+      const cellMeasure2 = rowMeasure.cells[c];
+      if (localX >= colX && localX < colX + cellMeasure2.width) {
+        colIndex = c;
+        break;
+      }
+      colX += cellMeasure2.width;
+    }
+    if (colIndex === -1) {
+      colIndex = rowMeasure.cells.length - 1;
+      if (colIndex < 0) continue;
+    }
+    const cellMeasure = rowMeasure.cells[colIndex];
+    const cell = row.cells[colIndex];
+    if (!cellMeasure || !cell) continue;
+    const cellBlocks = cell.blocks ?? (cell.paragraph ? [cell.paragraph] : []);
+    const rawMeasures = cellMeasure.blocks ?? (cellMeasure.paragraph ? [cellMeasure.paragraph] : []);
+    const cellBlockMeasures = (Array.isArray(rawMeasures) ? rawMeasures : []).filter(
+      (m) => m != null && typeof m === "object" && "kind" in m
+    );
+    let blockStartY = 0;
+    const getBlockHeight = (m) => {
+      if (!m) return 0;
+      if ("totalHeight" in m && typeof m.totalHeight === "number") {
+        return m.totalHeight;
+      }
+      if ("height" in m && typeof m.height === "number") {
+        return m.height;
+      }
+      return 0;
+    };
+    for (let i = 0; i < cellBlocks.length && i < cellBlockMeasures.length; i++) {
+      const cellBlock = cellBlocks[i];
+      const cellBlockMeasure = cellBlockMeasures[i];
+      if (cellBlock?.kind !== "paragraph" || cellBlockMeasure?.kind !== "paragraph") {
+        blockStartY += getBlockHeight(cellBlockMeasure);
+        continue;
+      }
+      const blockHeight = getBlockHeight(cellBlockMeasure);
+      const blockEndY = blockStartY + blockHeight;
+      const padding = cell.attrs?.padding ?? { top: 2, left: 4 };
+      const cellLocalX = localX - colX - (padding.left ?? 4);
+      const cellLocalY = localY - rowY - (padding.top ?? 2);
+      const paragraphBlock = cellBlock;
+      const paragraphMeasure = cellBlockMeasure;
+      const isWithinBlock = cellLocalY >= blockStartY && cellLocalY < blockEndY;
+      const isLastParagraph = i === Math.min(cellBlocks.length, cellBlockMeasures.length) - 1;
+      if (isWithinBlock || isLastParagraph) {
+        const unclampedLocalY = cellLocalY - blockStartY;
+        const localYWithinBlock = Math.max(0, Math.min(unclampedLocalY, Math.max(blockHeight, 0)));
+        return {
+          fragment: tableFragment,
+          block: tableBlock,
+          measure: tableMeasure,
+          pageIndex: pageHit.pageIndex,
+          cellRowIndex: rowIndex,
+          cellColIndex: colIndex,
+          cellBlock: paragraphBlock,
+          cellMeasure: paragraphMeasure,
+          localX: Math.max(0, cellLocalX),
+          localY: Math.max(0, localYWithinBlock)
+        };
+      }
+      blockStartY = blockEndY;
+    }
+  }
+  return null;
+};
 function clickToPosition(layout, blocks, measures, containerPoint, domContainer, clientX, clientY) {
   logClickStage("log", "entry", {
     pages: layout.pages.length
@@ -25174,6 +26612,49 @@ function clickToPosition(layout, blocks, measures, containerPoint, domContainer,
       // lineIndex is now already absolute (within measure.lines), no need to add fragment.fromLine
     };
   }
+  const tableHit = hitTestTableFragment(pageHit, blocks, measures, pageRelativePoint);
+  if (tableHit) {
+    const { cellBlock, cellMeasure, localX, localY, pageIndex } = tableHit;
+    const lineIndex = findLineIndexAtY(cellMeasure, localY, 0, cellMeasure.lines.length);
+    if (lineIndex != null) {
+      const line = cellMeasure.lines[lineIndex];
+      const isRTL = isRtlBlock(cellBlock);
+      const pos = mapPointToPm(cellBlock, line, localX, isRTL);
+      if (pos != null) {
+        logClickStage("log", "success", {
+          blockId: tableHit.fragment.blockId,
+          column: determineColumn(layout, tableHit.fragment.x)
+        });
+        return {
+          pos,
+          blockId: tableHit.fragment.blockId,
+          pageIndex,
+          column: determineColumn(layout, tableHit.fragment.x),
+          lineIndex
+        };
+      }
+    }
+    const firstRun = cellBlock.runs?.[0];
+    if (firstRun && firstRun.pmStart != null) {
+      logClickStage("log", "success", {
+        blockId: tableHit.fragment.blockId,
+        pos: firstRun.pmStart,
+        column: determineColumn(layout, tableHit.fragment.x)
+      });
+      return {
+        pos: firstRun.pmStart,
+        blockId: tableHit.fragment.blockId,
+        pageIndex,
+        column: determineColumn(layout, tableHit.fragment.x),
+        lineIndex: 0
+      };
+    }
+    logClickStage("warn", "table-cell-no-position", {
+      blockId: tableHit.fragment.blockId,
+      cellRow: tableHit.cellRowIndex,
+      cellCol: tableHit.cellColIndex
+    });
+  }
   const atomicHit = hitTestAtomicFragment(pageHit, blocks, measures, pageRelativePoint);
   if (atomicHit && isAtomicFragment(atomicHit.fragment)) {
     const { fragment, block, pageIndex } = atomicHit;
@@ -25285,6 +26766,44 @@ function getFragmentAtPosition(layout, blocks, measures, pos) {
         }
         continue;
       }
+      if (fragment.kind === "table") {
+        if (block.kind !== "table" || measure.kind !== "table") continue;
+        const tableBlock = block;
+        const tableFragment = fragment;
+        let tableMinPos = null;
+        let tableMaxPos = null;
+        for (let r2 = tableFragment.fromRow; r2 < tableFragment.toRow && r2 < tableBlock.rows.length; r2++) {
+          const row = tableBlock.rows[r2];
+          for (const cell of row.cells) {
+            const cellBlocks = cell.blocks ?? (cell.paragraph ? [cell.paragraph] : []);
+            for (const cellBlock of cellBlocks) {
+              if (cellBlock?.kind === "paragraph") {
+                const paraBlock = cellBlock;
+                for (const run of paraBlock.runs ?? []) {
+                  if (run.pmStart != null) {
+                    if (tableMinPos === null || run.pmStart < tableMinPos) tableMinPos = run.pmStart;
+                    if (tableMaxPos === null || run.pmStart > tableMaxPos) tableMaxPos = run.pmStart;
+                  }
+                  if (run.pmEnd != null) {
+                    if (tableMinPos === null || run.pmEnd < tableMinPos) tableMinPos = run.pmEnd;
+                    if (tableMaxPos === null || run.pmEnd > tableMaxPos) tableMaxPos = run.pmEnd;
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (tableMinPos != null && tableMaxPos != null && pos >= tableMinPos && pos <= tableMaxPos) {
+          return {
+            fragment,
+            block,
+            measure,
+            pageIndex,
+            pageY: 0
+          };
+        }
+        continue;
+      }
       if (isAtomicFragment(fragment)) {
         const { pmStart, pmEnd } = getAtomicPmRange(fragment, block);
         const start2 = pmStart ?? pmEnd;
@@ -25332,7 +26851,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 = run.kind === "image" ? "" : 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);
@@ -27728,16 +29247,6 @@ const LINK_AND_TOC_STYLES = `
   opacity: 0.8;
 }
 
-/* External link indicator (WCAG 2.4.4 Link Purpose) */
-.superdoc-link[target="_blank"]::after {
-  content: "↗";
-  display: inline-block;
-  margin-left: 0.25em;
-  font-size: 0.85em;
-  text-decoration: none;
-  speak: literal-punctuation; /* Screen readers read the arrow */
-}
-
 /* Print mode: show URLs after links */
 @media print {
   .superdoc-link::after {
@@ -27750,11 +29259,6 @@ const LINK_AND_TOC_STYLES = `
   .superdoc-link[href^="#"]::after {
     content: "";
   }
-
-  /* Don't show URL for external link indicator */
-  .superdoc-link[target="_blank"]::after {
-    content: " (" attr(href) ")";
-  }
 }
 
 /* High contrast mode support */
@@ -27772,13 +29276,6 @@ const LINK_AND_TOC_STYLES = `
   }
 }
 
-/* RTL layout support */
-.superdoc-layout[dir="rtl"] .superdoc-link[target="_blank"]::after {
-  margin-left: 0;
-  margin-right: 0.25em;
-  content: "↖"; /* Mirror the arrow for RTL */
-}
-
 /* Screen reader only content (WCAG SC 1.3.1) */
 .sr-only {
   position: absolute;
@@ -27962,7 +29459,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`;
@@ -27970,6 +29480,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);
   }
@@ -27983,36 +29494,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;
@@ -28033,7 +29595,10 @@ const renderTableRow = (deps) => {
     allRowHeights,
     context,
     renderLine,
-    applySdtDataset
+    applySdtDataset,
+    continuesFromPrev,
+    continuesOnNext,
+    partialRow
   } = deps;
   const calculateXPosition = (gridColumnStart) => {
     let x = 0;
@@ -28066,25 +29631,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,
@@ -28095,7 +29692,9 @@ const renderTableRow = (deps) => {
       borders: resolvedBorders,
       renderLine,
       context,
-      applySdtDataset
+      applySdtDataset,
+      fromLine,
+      toLine
     });
     container.appendChild(cellElement);
     if (contentElement) {
@@ -28209,11 +29808,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,
@@ -28227,13 +29861,112 @@ 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;
 };
+const isDevelopment = () => {
+  if (typeof process$1 !== "undefined" && typeof process$1.env !== "undefined") {
+    return process$1.env.NODE_ENV === "development";
+  }
+  return false;
+};
+class ValidationStatsCollector {
+  constructor() {
+    this.stats = {
+      totalSpans: 0,
+      validSpans: 0,
+      missingPmStart: 0,
+      missingPmEnd: 0,
+      missingBoth: 0
+    };
+  }
+  record(hasPmStart, hasPmEnd) {
+    this.stats.totalSpans++;
+    if (hasPmStart && hasPmEnd) {
+      this.stats.validSpans++;
+    } else if (!hasPmStart && !hasPmEnd) {
+      this.stats.missingBoth++;
+    } else if (!hasPmStart) {
+      this.stats.missingPmStart++;
+    } else {
+      this.stats.missingPmEnd++;
+    }
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  reset() {
+    this.stats = {
+      totalSpans: 0,
+      validSpans: 0,
+      missingPmStart: 0,
+      missingPmEnd: 0,
+      missingBoth: 0
+    };
+  }
+  getCoveragePercent() {
+    if (this.stats.totalSpans === 0) return 100;
+    return this.stats.validSpans / this.stats.totalSpans * 100;
+  }
+  logSummary() {
+    if (!isDevelopment()) return;
+    const coverage = this.getCoveragePercent();
+    const s2 = this.stats;
+    if (coverage < 100) {
+      console.warn("[PmPositionValidation] PM position coverage:", {
+        coverage: `${coverage.toFixed(1)}%`,
+        totalSpans: s2.totalSpans,
+        validSpans: s2.validSpans,
+        missingPmStart: s2.missingPmStart,
+        missingPmEnd: s2.missingPmEnd,
+        missingBoth: s2.missingBoth
+      });
+    }
+  }
+}
+const globalValidationStats = new ValidationStatsCollector();
+function assertPmPositions(run, context) {
+  const hasPmStart = run.pmStart != null;
+  const hasPmEnd = run.pmEnd != null;
+  globalValidationStats.record(hasPmStart, hasPmEnd);
+  if (!isDevelopment()) return;
+  if (!hasPmStart || !hasPmEnd) {
+    const textPreview = run.text ? run.text.substring(0, 20) + (run.text.length > 20 ? "..." : "") : "(no text)";
+    console.warn(`[PmPositionValidation] Missing PM positions in ${context}:`, {
+      hasPmStart,
+      hasPmEnd,
+      textPreview,
+      fallback: "Will use PM DOM coordinates for cursor positioning"
+    });
+  }
+}
+function assertFragmentPmPositions(fragment, context) {
+  const hasPmStart = fragment.pmStart != null;
+  const hasPmEnd = fragment.pmEnd != null;
+  globalValidationStats.record(hasPmStart, hasPmEnd);
+  if (!isDevelopment()) return;
+  if (!hasPmStart || !hasPmEnd) {
+    console.warn(`[PmPositionValidation] Missing PM positions in ${context}:`, {
+      fragmentKind: fragment.kind ?? "unknown",
+      hasPmStart,
+      hasPmEnd,
+      fallback: "Will use PM DOM coordinates for cursor positioning"
+    });
+  }
+}
 const LIST_MARKER_GAP$1 = 8;
+const COMMENT_EXTERNAL_COLOR = "#B1124B";
+const COMMENT_INTERNAL_COLOR = "#078383";
+const COMMENT_INACTIVE_ALPHA = "22";
 const LINK_DATASET_KEYS = {
   blocked: "linkBlocked",
   docLocation: "linkDocLocation",
@@ -28890,7 +30623,7 @@ const _DomPainter = class _DomPainter {
           current.element = replacement;
           current.signature = fragmentSignature(fragment, this.blockLookup);
         }
-        this.updateFragmentElement(current.element, fragment);
+        this.updateFragmentElement(current.element, fragment, contextBase.section);
         current.fragment = fragment;
         current.key = key2;
         current.context = contextBase;
@@ -28958,10 +30691,10 @@ const _DomPainter = class _DomPainter {
       return this.renderListItemFragment(fragment, context);
     }
     if (fragment.kind === "image") {
-      return this.renderImageFragment(fragment);
+      return this.renderImageFragment(fragment, context);
     }
     if (fragment.kind === "drawing") {
-      return this.renderDrawingFragment(fragment);
+      return this.renderDrawingFragment(fragment, context);
     }
     if (fragment.kind === "table") {
       return this.renderTableFragment(fragment, context);
@@ -28994,7 +30727,7 @@ const _DomPainter = class _DomPainter {
       const hasMarker = !fragment.continuesFromPrev && fragment.markerWidth && wordLayout?.marker;
       const styles = isTocEntry ? { ...fragmentStyles, whiteSpace: "nowrap" } : hasMarker ? { ...fragmentStyles, overflow: "visible" } : fragmentStyles;
       applyStyles$2(fragmentEl, styles);
-      this.applyFragmentFrame(fragmentEl, fragment);
+      this.applyFragmentFrame(fragmentEl, fragment, context.section);
       if (isTocEntry) {
         fragmentEl.classList.add("superdoc-toc-entry");
       }
@@ -29012,8 +30745,32 @@ const _DomPainter = class _DomPainter {
       }
       this.applySdtDataset(fragmentEl, block.attrs?.sdt);
       this.applyContainerSdtDataset(fragmentEl, block.attrs?.containerSdt);
+      const dropCapDescriptor = block.attrs?.dropCapDescriptor;
+      const dropCapMeasure = measure.dropCap;
+      if (dropCapDescriptor && dropCapMeasure && !fragment.continuesFromPrev) {
+        const dropCapEl = this.renderDropCap(dropCapDescriptor, dropCapMeasure);
+        fragmentEl.appendChild(dropCapEl);
+      }
+      if (fragmentEl.style.paddingLeft) fragmentEl.style.removeProperty("padding-left");
+      if (fragmentEl.style.paddingRight) fragmentEl.style.removeProperty("padding-right");
+      if (fragmentEl.style.textIndent) fragmentEl.style.removeProperty("text-indent");
+      const paraIndent = block.attrs?.indent;
+      const paraIndentLeft = paraIndent?.left ?? 0;
+      const paraIndentRight = paraIndent?.right ?? 0;
+      const firstLineOffset = (paraIndent?.firstLine ?? 0) - (paraIndent?.hanging ?? 0);
       lines.forEach((line, index2) => {
         const lineEl = this.renderLine(block, line, context);
+        if (paraIndentLeft) {
+          lineEl.style.paddingLeft = `${paraIndentLeft}px`;
+        }
+        if (paraIndentRight) {
+          lineEl.style.paddingRight = `${paraIndentRight}px`;
+        }
+        if (!fragment.continuesFromPrev && index2 === 0 && firstLineOffset) {
+          lineEl.style.textIndent = `${firstLineOffset}px`;
+        } else if (firstLineOffset) {
+          lineEl.style.textIndent = "0px";
+        }
         if (index2 === 0 && !fragment.continuesFromPrev && fragment.markerWidth && wordLayout?.marker) {
           const markerContainer = this.doc.createElement("span");
           markerContainer.style.display = "inline-block";
@@ -29024,6 +30781,12 @@ const _DomPainter = class _DomPainter {
           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`;
           markerEl.style.fontFamily = wordLayout.marker.run.fontFamily;
           markerEl.style.fontSize = `${wordLayout.marker.run.fontSize}px`;
           markerEl.style.fontWeight = wordLayout.marker.run.bold ? "bold" : "";
@@ -29082,6 +30845,53 @@ const _DomPainter = class _DomPainter {
     }
     return el;
   }
+  /**
+   * Renders a drop cap element as a floated span at the start of a paragraph.
+   *
+   * Drop caps are large initial letters that span multiple lines of text.
+   * This method creates a floated element with the drop cap letter styled
+   * according to the descriptor's run properties.
+   *
+   * @param descriptor - The drop cap descriptor with text and styling info
+   * @param measure - The measured dimensions of the drop cap
+   * @returns HTMLElement containing the rendered drop cap
+   */
+  renderDropCap(descriptor, measure) {
+    const doc2 = this.doc;
+    const { run, mode } = descriptor;
+    const dropCapEl = doc2.createElement("span");
+    dropCapEl.classList.add("superdoc-drop-cap");
+    dropCapEl.textContent = run.text;
+    dropCapEl.style.fontFamily = run.fontFamily;
+    dropCapEl.style.fontSize = `${run.fontSize}px`;
+    if (run.bold) {
+      dropCapEl.style.fontWeight = "bold";
+    }
+    if (run.italic) {
+      dropCapEl.style.fontStyle = "italic";
+    }
+    if (run.color) {
+      dropCapEl.style.color = run.color;
+    }
+    if (mode === "drop") {
+      dropCapEl.style.float = "left";
+      dropCapEl.style.marginRight = "4px";
+      dropCapEl.style.lineHeight = "1";
+    } else if (mode === "margin") {
+      dropCapEl.style.position = "absolute";
+      dropCapEl.style.left = "0";
+      dropCapEl.style.lineHeight = "1";
+    }
+    if (run.position && run.position !== 0) {
+      dropCapEl.style.position = dropCapEl.style.position || "relative";
+      dropCapEl.style.top = `${run.position}px`;
+    }
+    if (measure) {
+      dropCapEl.style.width = `${measure.width}px`;
+      dropCapEl.style.height = `${measure.height}px`;
+    }
+    return dropCapEl;
+  }
   renderListItemFragment(fragment, context) {
     try {
       const lookup = this.blockLookup.get(fragment.blockId);
@@ -29159,7 +30969,7 @@ const _DomPainter = class _DomPainter {
       return this.createErrorPlaceholder(fragment.blockId, error);
     }
   }
-  renderImageFragment(fragment) {
+  renderImageFragment(fragment, context) {
     try {
       const lookup = this.blockLookup.get(fragment.blockId);
       if (!lookup || lookup.block.kind !== "image" || lookup.measure.kind !== "image") {
@@ -29172,7 +30982,7 @@ const _DomPainter = class _DomPainter {
       const fragmentEl = this.doc.createElement("div");
       fragmentEl.classList.add(CLASS_NAMES.fragment, "superdoc-image-fragment");
       applyStyles$2(fragmentEl, fragmentStyles);
-      this.applyFragmentFrame(fragmentEl, fragment);
+      this.applyFragmentFrame(fragmentEl, fragment, context.section);
       fragmentEl.style.height = `${fragment.height}px`;
       this.applySdtDataset(fragmentEl, block.attrs?.sdt);
       this.applyContainerSdtDataset(fragmentEl, block.attrs?.containerSdt);
@@ -29207,7 +31017,7 @@ const _DomPainter = class _DomPainter {
       return this.createErrorPlaceholder(fragment.blockId, error);
     }
   }
-  renderDrawingFragment(fragment) {
+  renderDrawingFragment(fragment, context) {
     try {
       const lookup = this.blockLookup.get(fragment.blockId);
       if (!lookup || lookup.block.kind !== "drawing" || lookup.measure.kind !== "drawing") {
@@ -29221,7 +31031,7 @@ const _DomPainter = class _DomPainter {
       const fragmentEl = this.doc.createElement("div");
       fragmentEl.classList.add(CLASS_NAMES.fragment, "superdoc-drawing-fragment");
       applyStyles$2(fragmentEl, fragmentStyles);
-      this.applyFragmentFrame(fragmentEl, fragment);
+      this.applyFragmentFrame(fragmentEl, fragment, context.section);
       fragmentEl.style.height = `${fragment.height}px`;
       fragmentEl.style.position = "absolute";
       fragmentEl.style.overflow = "hidden";
@@ -29668,13 +31478,16 @@ const _DomPainter = class _DomPainter {
     if (!this.doc) {
       throw new Error("DomPainter: document is not available");
     }
+    const applyFragmentFrameWithSection = (el, frag) => {
+      this.applyFragmentFrame(el, frag, context.section);
+    };
     return renderTableFragment({
       doc: this.doc,
       fragment,
       context,
       blockLookup: this.blockLookup,
       renderLine: this.renderLine.bind(this),
-      applyFragmentFrame: this.applyFragmentFrame.bind(this),
+      applyFragmentFrame: applyFragmentFrameWithSection,
       applySdtDataset: this.applySdtDataset.bind(this),
       applyStyles: applyStyles$2
     });
@@ -29684,7 +31497,7 @@ const _DomPainter = class _DomPainter {
    * @returns Sanitized link data or null if invalid/missing
    */
   extractLinkData(run) {
-    if (run.kind === "tab") {
+    if (run.kind === "tab" || run.kind === "image" || run.kind === "lineBreak") {
       return null;
     }
     const link = run.link;
@@ -29838,11 +31651,29 @@ const _DomPainter = class _DomPainter {
   isImageRun(run) {
     return run.kind === "image";
   }
+  /**
+   * Type guard to check if a run is a line break run.
+   */
+  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);
     }
-    if (!run.text || !this.doc) {
+    if (this.isLineBreakRun(run)) {
+      return null;
+    }
+    if (this.isBreakRun(run)) {
+      return null;
+    }
+    if (!("text" in run) || !run.text || !this.doc) {
       return null;
     }
     const linkData = this.extractLinkData(run);
@@ -29866,8 +31697,21 @@ const _DomPainter = class _DomPainter {
       }
     }
     applyRunStyles(elem, run, isActiveLink);
+    const commentColor = getCommentHighlight(run);
+    if (commentColor && !run.highlight) {
+      elem.style.backgroundColor = commentColor;
+    }
+    const commentAnnotations = run.comments;
+    if (commentAnnotations?.length) {
+      elem.dataset.commentIds = commentAnnotations.map((c) => c.commentId).join(",");
+      if (commentAnnotations.some((c) => c.internal)) {
+        elem.dataset.commentInternal = "true";
+      }
+      elem.classList.add("superdoc-comment-highlight");
+    }
     elem.style.zIndex = "1";
     applyRunDataAttributes(elem, run.dataAttrs);
+    assertPmPositions(run, "paragraph text run");
     if (run.pmStart != null) elem.dataset.pmStart = String(run.pmStart);
     if (run.pmEnd != null) elem.dataset.pmEnd = String(run.pmEnd);
     if (trackedConfig) {
@@ -29946,6 +31790,7 @@ const _DomPainter = class _DomPainter {
       img.style.marginRight = `${run.distRight}px`;
     }
     img.style.zIndex = "1";
+    assertPmPositions(run, "inline image run");
     if (run.pmStart != null) {
       img.dataset.pmStart = String(run.pmStart);
     }
@@ -29969,6 +31814,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);
@@ -29976,9 +31827,9 @@ const _DomPainter = class _DomPainter {
     if (lineRange.pmEnd != null) {
       el.dataset.pmEnd = String(lineRange.pmEnd);
     }
-    const runs = sliceRunsForLine(block, line);
+    const runsForLine = sliceRunsForLine(block, line);
     const trackedConfig = this.resolveTrackedChangesConfig(block);
-    if (runs.length === 0) {
+    if (runsForLine.length === 0) {
       const span = this.doc.createElement("span");
       span.innerHTML = "&nbsp;";
       el.appendChild(span);
@@ -30026,49 +31877,115 @@ const _DomPainter = class _DomPainter {
     const hasExplicitPositioning = line.segments?.some((seg) => seg.x !== void 0);
     if (hasExplicitPositioning && line.segments) {
       let cumulativeX = 0;
-      line.segments.forEach((segment, _segIdx) => {
-        const baseRun = runs[segment.runIndex];
-        if (!baseRun || baseRun.kind === "tab") return;
-        if (this.isImageRun(baseRun)) {
-          const elem2 = this.renderRun(baseRun, context, trackedConfig);
-          if (elem2) {
-            if (styleId) {
-              elem2.setAttribute("styleid", styleId);
-            }
-            el.appendChild(elem2);
+      const segmentsByRun = /* @__PURE__ */ new Map();
+      line.segments.forEach((segment) => {
+        const list = segmentsByRun.get(segment.runIndex);
+        if (list) {
+          list.push(segment);
+        } else {
+          segmentsByRun.set(segment.runIndex, [segment]);
+        }
+      });
+      const findImmediateNextSegmentX = (fromRunIndex) => {
+        const nextRunIdx = fromRunIndex + 1;
+        if (nextRunIdx <= line.toRun) {
+          const nextSegments = segmentsByRun.get(nextRunIdx);
+          if (nextSegments && nextSegments.length > 0) {
+            const firstSegment = nextSegments[0];
+            return firstSegment.x;
           }
-          return;
         }
-        const segmentText = baseRun.text.slice(segment.fromChar, segment.toChar);
-        const segmentRun = { ...baseRun, text: segmentText };
-        const elem = this.renderRun(segmentRun, context, trackedConfig);
-        if (elem) {
+        return void 0;
+      };
+      for (let runIndex = line.fromRun; runIndex <= line.toRun; runIndex += 1) {
+        const baseRun = block.runs[runIndex];
+        if (!baseRun) continue;
+        if (baseRun.kind === "tab") {
+          const immediateNextX = findImmediateNextSegmentX(runIndex);
+          const tabStartX = cumulativeX;
+          const tabEndX = immediateNextX !== void 0 ? immediateNextX : tabStartX + (baseRun.width ?? 0);
+          const actualTabWidth = tabEndX - tabStartX;
+          const tabEl = this.doc.createElement("span");
+          tabEl.style.position = "absolute";
+          tabEl.style.left = `${tabStartX}px`;
+          tabEl.style.top = "0px";
+          tabEl.style.width = `${actualTabWidth}px`;
+          tabEl.style.height = `${line.lineHeight}px`;
+          tabEl.style.display = "inline-block";
+          tabEl.style.visibility = "hidden";
+          tabEl.style.pointerEvents = "none";
+          tabEl.style.zIndex = "1";
           if (styleId) {
-            elem.setAttribute("styleid", styleId);
+            tabEl.setAttribute("styleid", styleId);
           }
-          let xPos;
-          if (segment.x !== void 0) {
-            xPos = segment.x;
-          } else {
-            xPos = cumulativeX;
+          if (baseRun.pmStart != null) tabEl.dataset.pmStart = String(baseRun.pmStart);
+          if (baseRun.pmEnd != null) tabEl.dataset.pmEnd = String(baseRun.pmEnd);
+          el.appendChild(tabEl);
+          cumulativeX = tabEndX;
+          continue;
+        }
+        if (this.isImageRun(baseRun)) {
+          const elem = this.renderRun(baseRun, context, trackedConfig);
+          if (elem) {
+            if (styleId) {
+              elem.setAttribute("styleid", styleId);
+            }
+            el.appendChild(elem);
           }
-          elem.style.position = "absolute";
-          elem.style.left = `${xPos}px`;
-          el.appendChild(elem);
-          if (this.doc) {
-            const measureEl = elem.cloneNode(true);
-            measureEl.style.position = "absolute";
-            measureEl.style.visibility = "hidden";
-            measureEl.style.left = "-9999px";
-            this.doc.body.appendChild(measureEl);
-            const width = measureEl.offsetWidth;
-            this.doc.body.removeChild(measureEl);
+          continue;
+        }
+        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;
+        runSegments.forEach((segment) => {
+          const segmentText = baseText.slice(segment.fromChar, segment.toChar);
+          if (!segmentText) return;
+          const pmSliceStart = runPmStart != null ? runPmStart + segment.fromChar : void 0;
+          const pmSliceEnd = runPmStart != null ? runPmStart + segment.toChar : fallbackPmEnd ?? void 0;
+          const segmentRun = {
+            ...baseRun,
+            text: segmentText,
+            pmStart: pmSliceStart,
+            pmEnd: pmSliceEnd
+          };
+          const elem = this.renderRun(segmentRun, context, trackedConfig);
+          if (elem) {
+            if (styleId) {
+              elem.setAttribute("styleid", styleId);
+            }
+            const xPos = segment.x !== void 0 ? segment.x : cumulativeX;
+            elem.style.position = "absolute";
+            elem.style.left = `${xPos}px`;
+            el.appendChild(elem);
+            let width = segment.width ?? 0;
+            if (width <= 0 && this.doc) {
+              const measureEl = elem.cloneNode(true);
+              measureEl.style.position = "absolute";
+              measureEl.style.visibility = "hidden";
+              measureEl.style.left = "-9999px";
+              this.doc.body.appendChild(measureEl);
+              width = measureEl.offsetWidth;
+              this.doc.body.removeChild(measureEl);
+            }
             cumulativeX = xPos + width;
           }
-        }
-      });
+        });
+      }
     } else {
-      runs.forEach((run) => {
+      runsForLine.forEach((run) => {
         const elem = this.renderRun(run, context, trackedConfig);
         if (elem) {
           if (styleId) {
@@ -30126,8 +32043,18 @@ const _DomPainter = class _DomPainter {
       elem.dataset.trackChangeDate = meta.date;
     }
   }
-  updateFragmentElement(el, fragment) {
-    this.applyFragmentFrame(el, fragment);
+  /**
+   * Updates an existing fragment element's position and dimensions in place.
+   * Used during incremental updates to efficiently reposition fragments without full re-render.
+   *
+   * @param el - The HTMLElement representing the fragment to update
+   * @param fragment - The fragment data containing updated position and dimensions
+   * @param section - The document section ('body', 'header', 'footer') containing this fragment.
+   *                  Affects PM position validation - only body sections validate PM positions.
+   *                  If undefined, defaults to 'body' section behavior.
+   */
+  updateFragmentElement(el, fragment, section) {
+    this.applyFragmentFrame(el, fragment, section);
     if (fragment.kind === "image") {
       el.style.height = `${fragment.height}px`;
     }
@@ -30135,12 +32062,27 @@ const _DomPainter = class _DomPainter {
       el.style.height = `${fragment.height}px`;
     }
   }
-  applyFragmentFrame(el, fragment) {
+  /**
+   * Applies fragment positioning, dimensions, and metadata to an HTML element.
+   * Sets CSS positioning, block ID, and PM position data attributes for paragraph fragments.
+   *
+   * @param el - The HTMLElement to apply fragment properties to
+   * @param fragment - The fragment data containing position, dimensions, and PM position information
+   * @param section - The document section ('body', 'header', 'footer') containing this fragment.
+   *                  Controls PM position validation behavior:
+   *                  - 'body' or undefined: PM positions are validated and required for paragraph fragments
+   *                  - 'header' or 'footer': PM position validation is skipped (these sections have separate PM coordinate spaces)
+   *                  When undefined, defaults to 'body' section behavior (validation enabled).
+   */
+  applyFragmentFrame(el, fragment, section) {
     el.style.left = `${fragment.x}px`;
     el.style.top = `${fragment.y}px`;
     el.style.width = `${fragment.width}px`;
     el.dataset.blockId = fragment.blockId;
     if (fragment.kind === "para") {
+      if (section === "body" || section === void 0) {
+        assertFragmentPmPositions(fragment, "paragraph fragment");
+      }
       if (fragment.pmStart != null) {
         el.dataset.pmStart = String(fragment.pmStart);
       } else {
@@ -30323,7 +32265,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";
@@ -30365,6 +32312,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) => {
@@ -30387,22 +32348,29 @@ const deriveBlockVersion = (block) => {
           imgRun.pmEnd ?? ""
         ].join(",");
       }
+      if (run.kind === "lineBreak") {
+        return ["linebreak", run.pmStart ?? "", run.pmEnd ?? ""].join(",");
+      }
+      if (run.kind === "tab") {
+        return [run.text ?? "", "tab", run.pmStart ?? "", run.pmEnd ?? ""].join(",");
+      }
+      const textRun = run;
       return [
-        run.text ?? "",
-        run.kind !== "tab" ? run.fontFamily : "",
-        run.kind !== "tab" ? run.fontSize : "",
-        run.kind !== "tab" && run.bold ? 1 : 0,
-        run.kind !== "tab" && run.italic ? 1 : 0,
-        run.kind !== "tab" ? run.color ?? "" : "",
+        textRun.text ?? "",
+        textRun.fontFamily,
+        textRun.fontSize,
+        textRun.bold ? 1 : 0,
+        textRun.italic ? 1 : 0,
+        textRun.color ?? "",
         // Text decorations - ensures DOM updates when decoration properties change.
-        run.kind !== "tab" ? run.underline?.style ?? "" : "",
-        run.kind !== "tab" ? run.underline?.color ?? "" : "",
-        run.kind !== "tab" && run.strike ? 1 : 0,
-        run.kind !== "tab" ? run.highlight ?? "" : "",
-        run.kind !== "tab" && run.letterSpacing != null ? run.letterSpacing : "",
-        run.pmStart ?? "",
-        run.pmEnd ?? "",
-        run.kind !== "tab" ? run.token ?? "" : ""
+        textRun.underline?.style ?? "",
+        textRun.underline?.color ?? "",
+        textRun.strike ? 1 : 0,
+        textRun.highlight ?? "",
+        textRun.letterSpacing != null ? textRun.letterSpacing : "",
+        textRun.pmStart ?? "",
+        textRun.pmEnd ?? "",
+        textRun.token ?? ""
       ].join(",");
     }).join("|");
   }
@@ -30453,16 +32421,57 @@ const deriveBlockVersion = (block) => {
   }
   if (block.kind === "table") {
     const tableBlock = block;
-    return [
-      block.id,
-      tableBlock.columnWidths ? JSON.stringify(tableBlock.columnWidths) : "",
-      tableBlock.rows.length
-    ].join("|");
+    const hashString = (seed, value) => {
+      let hash22 = seed >>> 0;
+      for (let i = 0; i < value.length; i++) {
+        hash22 ^= value.charCodeAt(i);
+        hash22 = Math.imul(hash22, 16777619);
+      }
+      return hash22 >>> 0;
+    };
+    const hashNumber = (seed, value) => {
+      const n = Number.isFinite(value) ? value : 0;
+      let hash22 = seed ^ n;
+      hash22 = Math.imul(hash22, 16777619);
+      hash22 ^= hash22 >>> 13;
+      return hash22 >>> 0;
+    };
+    let hash2 = 2166136261;
+    hash2 = hashString(hash2, block.id);
+    hash2 = hashNumber(hash2, tableBlock.rows.length);
+    hash2 = (tableBlock.columnWidths ?? []).reduce((acc, width) => hashNumber(acc, Math.round(width * 1e3)), hash2);
+    const rows = tableBlock.rows ?? [];
+    for (const row of rows) {
+      if (!row || !Array.isArray(row.cells)) continue;
+      hash2 = hashNumber(hash2, row.cells.length);
+      for (const cell of row.cells) {
+        if (!cell) continue;
+        const cellBlocks = cell.blocks ?? (cell.paragraph ? [cell.paragraph] : []);
+        hash2 = hashNumber(hash2, cellBlocks.length);
+        hash2 = hashNumber(hash2, cell.rowSpan ?? 1);
+        hash2 = hashNumber(hash2, cell.colSpan ?? 1);
+        for (const cellBlock of cellBlocks) {
+          hash2 = hashString(hash2, cellBlock?.kind ?? "unknown");
+          if (cellBlock?.kind === "paragraph") {
+            const runs = cellBlock.runs ?? [];
+            hash2 = hashNumber(hash2, runs.length);
+            for (const run of runs) {
+              if ("text" in run && typeof run.text === "string") {
+                hash2 = hashString(hash2, run.text);
+              }
+              hash2 = hashNumber(hash2, run.pmStart ?? -1);
+              hash2 = hashNumber(hash2, run.pmEnd ?? -1);
+            }
+          }
+        }
+      }
+    }
+    return [block.id, tableBlock.rows.length, hash2.toString(16)].join("|");
   }
   return block.id;
 };
 const applyRunStyles = (element, run, isLink = false) => {
-  if (run.kind === "tab" || run.kind === "image") {
+  if (run.kind === "tab" || run.kind === "image" || run.kind === "lineBreak" || run.kind === "break") {
     return;
   }
   element.style.fontFamily = run.fontFamily;
@@ -30494,6 +32503,13 @@ const applyRunStyles = (element, run, isLink = false) => {
     element.style.textDecorationLine = decorations.join(" ");
   }
 };
+const getCommentHighlight = (run) => {
+  const comments = run.comments;
+  if (!comments || comments.length === 0) return void 0;
+  const primary = comments[0];
+  const base2 = primary.internal ? COMMENT_INTERNAL_COLOR : COMMENT_EXTERNAL_COLOR;
+  return `${base2}${COMMENT_INACTIVE_ALPHA}`;
+};
 const applyRunDataAttributes = (element, dataAttrs) => {
   if (!dataAttrs) return;
   Object.entries(dataAttrs).forEach(([key2, value]) => {
@@ -30585,6 +32601,21 @@ const sliceRunsForLine = (block, line) => {
       result.push(run);
       continue;
     }
+    if (run.kind === "lineBreak") {
+      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;
@@ -30598,19 +32629,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
-        };
-        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);
     }
@@ -30638,6 +32664,54 @@ const computeLinePmRange = (block, line) => {
       }
       continue;
     }
+    if (run.kind === "lineBreak") {
+      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 === "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;
@@ -30676,6 +32750,15 @@ const resolveRunText = (run, context) => {
   if (run.kind === "image") {
     return "";
   }
+  if (run.kind === "lineBreak") {
+    return "";
+  }
+  if (run.kind === "break") {
+    return "";
+  }
+  if (!("text" in run)) {
+    return "";
+  }
   if (!runToken) {
     return run.text ?? "";
   }
@@ -30842,6 +32925,9 @@ function isTabRun(run) {
 function isImageRun(run) {
   return run.kind === "image";
 }
+function isLineBreakRun(run) {
+  return run.kind === "lineBreak";
+}
 async function measureBlock(block, constraints) {
   const normalized = normalizeConstraints(constraints);
   if (block.kind === "drawing") {
@@ -30870,6 +32956,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;
@@ -30879,7 +32966,7 @@ async function measureParagraphBlock(block, maxWidth) {
   const hanging = indent?.hanging ?? 0;
   const firstLineOffset = firstLine - hanging;
   const contentWidth = Math.max(1, maxWidth - indentLeft - indentRight);
-  let availableWidth = Math.max(1, contentWidth - firstLineOffset);
+  const initialAvailableWidth = Math.max(1, contentWidth - firstLineOffset);
   const tabStops = buildTabStopsPx(
     indent,
     block.attrs?.tabs,
@@ -30892,6 +32979,18 @@ async function measureParagraphBlock(block, maxWidth) {
       line.bars = barTabStops.map((stop) => ({ x: stop.pos }));
     }
   };
+  const dropCapDescriptor = block.attrs?.dropCapDescriptor;
+  let dropCapMeasure = null;
+  if (dropCapDescriptor) {
+    if (!dropCapDescriptor.run || !dropCapDescriptor.run.text || !dropCapDescriptor.lines) {
+      console.warn("Invalid drop cap descriptor - missing required fields:", dropCapDescriptor);
+    } else {
+      const dropCapMeasured = measureDropCap(ctx2, dropCapDescriptor, spacing);
+      dropCapMeasure = dropCapMeasured;
+      dropCapDescriptor.measuredWidth = dropCapMeasured.width;
+      dropCapDescriptor.measuredHeight = dropCapMeasured.height;
+    }
+  }
   if (block.runs.length === 0) {
     const metrics = calculateTypographyMetrics(12, spacing);
     const emptyLine = {
@@ -30911,6 +33010,13 @@ async function measureParagraphBlock(block, maxWidth) {
     };
   }
   let currentLine = null;
+  const getEffectiveWidth = (baseWidth) => {
+    if (dropCapMeasure && lines.length < dropCapMeasure.lines && dropCapMeasure.mode === "drop") {
+      return Math.max(1, baseWidth - dropCapMeasure.width);
+    }
+    return baseWidth;
+  };
+  let lastFontSize = 12;
   let tabStopCursor = 0;
   let pendingTabAlignment = null;
   let lastAppliedTabAlign = null;
@@ -30945,8 +33051,108 @@ 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);
+        const completedLine = {
+          ...currentLine,
+          ...metrics
+        };
+        addBarTabsToLine(completedLine);
+        lines.push(completedLine);
+      } else {
+        const metrics = calculateTypographyMetrics(lastFontSize, spacing);
+        const emptyLine = {
+          fromRun: runIndex,
+          fromChar: 0,
+          toRun: runIndex,
+          toChar: 0,
+          width: 0,
+          maxWidth: getEffectiveWidth(initialAvailableWidth),
+          segments: [],
+          ...metrics
+        };
+        addBarTabsToLine(emptyLine);
+        lines.push(emptyLine);
+      }
+      const hadPreviousLine = lines.length > 0;
+      const nextLineMaxWidth = hadPreviousLine ? getEffectiveWidth(contentWidth) : getEffectiveWidth(initialAvailableWidth);
+      currentLine = {
+        fromRun: runIndex,
+        fromChar: 0,
+        toRun: runIndex,
+        toChar: 0,
+        width: 0,
+        maxFontSize: lastFontSize,
+        maxWidth: nextLineMaxWidth,
+        segments: []
+      };
+      tabStopCursor = 0;
+      pendingTabAlignment = null;
+      lastAppliedTabAlign = null;
+      continue;
+    }
     if (isTabRun(run)) {
       if (!currentLine) {
         currentLine = {
@@ -30957,7 +33163,7 @@ async function measureParagraphBlock(block, maxWidth) {
           width: 0,
           maxFontSize: 12,
           // Default font size for tabs
-          maxWidth: availableWidth,
+          maxWidth: getEffectiveWidth(initialAvailableWidth),
           segments: []
         };
       }
@@ -31002,7 +33208,7 @@ async function measureParagraphBlock(block, maxWidth) {
           width: imageWidth,
           maxFontSize: imageHeight,
           // Use image height for line height calculation
-          maxWidth: availableWidth,
+          maxWidth: getEffectiveWidth(initialAvailableWidth),
           segments: [
             {
               runIndex,
@@ -31012,7 +33218,6 @@ async function measureParagraphBlock(block, maxWidth) {
             }
           ]
         };
-        availableWidth = contentWidth;
         continue;
       }
       if (currentLine.width + imageWidth > currentLine.maxWidth && currentLine.width > 0) {
@@ -31032,7 +33237,7 @@ async function measureParagraphBlock(block, maxWidth) {
           toChar: 1,
           width: imageWidth,
           maxFontSize: imageHeight,
-          maxWidth: contentWidth,
+          maxWidth: getEffectiveWidth(contentWidth),
           segments: [
             {
               runIndex,
@@ -31042,7 +33247,6 @@ async function measureParagraphBlock(block, maxWidth) {
             }
           ]
         };
-        availableWidth = contentWidth;
       } else {
         currentLine.toRun = runIndex;
         currentLine.toChar = 1;
@@ -31058,6 +33262,10 @@ 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("	");
     let charPosInRun = 0;
@@ -31092,23 +33300,22 @@ async function measureParagraphBlock(block, maxWidth) {
             toChar: wordEndNoSpace,
             width: wordOnlyWidth,
             maxFontSize: run.fontSize,
-            maxWidth: availableWidth,
+            maxWidth: getEffectiveWidth(initialAvailableWidth),
             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;
           }
-          availableWidth = contentWidth;
           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,
@@ -31125,19 +33332,19 @@ async function measureParagraphBlock(block, maxWidth) {
             toChar: wordEndNoSpace,
             width: wordOnlyWidth,
             maxFontSize: run.fontSize,
-            maxWidth: contentWidth,
+            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);
@@ -31181,10 +33388,9 @@ async function measureParagraphBlock(block, maxWidth) {
             toChar: charPosInRun,
             width: 0,
             maxFontSize: run.fontSize,
-            maxWidth: availableWidth,
+            maxWidth: getEffectiveWidth(initialAvailableWidth),
             segments: []
           };
-          availableWidth = contentWidth;
         }
         const originX = currentLine.width;
         const { target, nextIndex, stop } = getNextTabStopPx(currentLine.width, tabStops, tabStopCursor);
@@ -31257,12 +33463,41 @@ async function measureParagraphBlock(block, maxWidth) {
     kind: "paragraph",
     lines,
     totalHeight,
-    ...markerInfo ? { marker: markerInfo } : {}
+    ...markerInfo ? { marker: markerInfo } : {},
+    ...dropCapMeasure ? { dropCap: dropCapMeasure } : {}
   };
 }
 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];
@@ -31271,8 +33506,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) {
@@ -31286,8 +33520,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 {
@@ -31304,6 +33537,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 = [];
@@ -31350,6 +33585,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++) {
@@ -31357,10 +33597,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;
+      }
+    }
   }
-  const totalHeight = rows.reduce((sum, r2) => sum + r2.height, 0);
+  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 = rowHeights.reduce((sum, h) => sum + h, 0);
   const totalWidth = columnWidths.reduce((a, b) => a + b, 0);
   return {
     kind: "table",
@@ -31537,7 +33806,7 @@ const getPrimaryRun = (paragraph) => {
   };
 };
 const measureRunWidth = (text, font, ctx2, run) => {
-  const letterSpacing = run.kind === "text" ? run.letterSpacing || 0 : 0;
+  const letterSpacing = run.kind === "text" || run.kind === void 0 ? run.letterSpacing || 0 : 0;
   const width = getMeasuredTextWidth(text, font, letterSpacing, ctx2);
   return roundValue(width);
 };
@@ -31566,13 +33835,37 @@ 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) => {
   if (value === ",") return ",";
   return DEFAULT_DECIMAL_SEPARATOR;
 };
+const DROP_CAP_PADDING_PX = 4;
+const measureDropCap = (ctx2, descriptor, spacing) => {
+  const { run, lines, mode } = descriptor;
+  const { font } = buildFontString({
+    fontFamily: run.fontFamily,
+    fontSize: run.fontSize,
+    bold: run.bold,
+    italic: run.italic
+  });
+  ctx2.font = font;
+  const metrics = ctx2.measureText(run.text);
+  const advanceWidth = metrics.width;
+  const paintedWidth = (metrics.actualBoundingBoxLeft || 0) + (metrics.actualBoundingBoxRight || 0);
+  const textWidth = Math.max(advanceWidth, paintedWidth);
+  const width = roundValue(textWidth + DROP_CAP_PADDING_PX);
+  const baseLineHeight = resolveLineHeight(spacing, run.fontSize * 1.2);
+  const height = roundValue(baseLineHeight * lines);
+  return {
+    width,
+    height,
+    lines,
+    mode
+  };
+};
 const resolveIndentLeft = (item) => {
   const indentLeft = sanitizePositive(item.paragraph.attrs?.indent?.left);
   if (indentLeft > 0) {
@@ -32711,10 +35004,7 @@ const _PresentationEditor = class _PresentationEditor extends EventEmitter {
         const tr = __privateGet(this, _editor3).state.tr.setSelection(TextSelection.create(__privateGet(this, _editor3).state.doc, hit.pos));
         try {
           __privateGet(this, _editor3).view?.dispatch(tr);
-        } catch (error) {
-          if (process$1.env.NODE_ENV === "development") {
-            console.warn("[PresentationEditor] Failed to dispatch selection at position:", hit.pos, error);
-          }
+        } catch {
         }
       }
       __privateMethod(this, _PresentationEditor_instances, scheduleSelectionUpdate_fn).call(this);
@@ -35247,10 +37537,10 @@ computeHeaderFooterCaretRect_fn = function(pos) {
   if (!lineInfo) return null;
   const { line, index: index2 } = lineInfo;
   const range = computeLinePmRange$1(block, line);
-  if (range.pmStart == null) return null;
-  const charsInLine = Math.max(0, line.toChar - line.fromChar);
-  const offsetChars = Math.max(0, Math.min(charsInLine, pos - range.pmStart));
-  const localX = hit.fragment.x + measureCharacterX(block, line, offsetChars);
+  if (range.pmStart == null || range.pmEnd == null) return null;
+  const pmCharsInLine = Math.max(1, range.pmEnd - range.pmStart);
+  const pmOffset = Math.max(0, Math.min(pmCharsInLine, pos - range.pmStart));
+  const localX = hit.fragment.x + measureCharacterX(block, line, pmOffset);
   const lineOffset = __privateMethod(this, _PresentationEditor_instances, lineHeightBeforeIndex_fn).call(this, measure.lines, hit.fragment.fromLine, index2);
   const headerPageHeight = context.layout.pageSize?.h ?? context.region.height ?? 1;
   const headerLocalY = hit.pageIndex * headerPageHeight + (hit.fragment.y + lineOffset);
@@ -35390,23 +37680,34 @@ normalizeClientPoint_fn = function(clientX, clientY) {
 computeCaretLayoutRect_fn = function(pos) {
   const layout = __privateGet(this, _layoutState).layout;
   if (!layout) return null;
+  const domResult = __privateMethod(this, _PresentationEditor_instances, computeCaretLayoutRectFromDOM_fn).call(this, pos);
+  if (domResult) {
+    return domResult;
+  }
   const hit = getFragmentAtPosition(layout, __privateGet(this, _layoutState).blocks, __privateGet(this, _layoutState).measures, pos);
-  if (!hit) return null;
+  if (!hit) {
+    return null;
+  }
   const block = hit.block;
   const measure = hit.measure;
+  if (hit.fragment.kind === "table" && block?.kind === "table" && measure?.kind === "table") {
+    return __privateMethod(this, _PresentationEditor_instances, computeTableCaretLayoutRect_fn).call(this, pos, hit.fragment, block, measure, hit.pageIndex);
+  }
   if (!block || block.kind !== "paragraph" || measure?.kind !== "paragraph") return null;
   if (hit.fragment.kind !== "para") {
     return null;
   }
   const fragment = hit.fragment;
   const lineInfo = __privateMethod(this, _PresentationEditor_instances, findLineContainingPos_fn).call(this, block, measure, fragment.fromLine, fragment.toLine, pos);
-  if (!lineInfo) return null;
+  if (!lineInfo) {
+    return null;
+  }
   const { line, index: index2 } = lineInfo;
   const range = computeLinePmRange$1(block, line);
-  if (range.pmStart == null) return null;
-  const charsInLine = Math.max(0, line.toChar - line.fromChar);
-  const offsetChars = Math.max(0, Math.min(charsInLine, pos - range.pmStart));
-  const localX = fragment.x + measureCharacterX(block, line, offsetChars);
+  if (range.pmStart == null || range.pmEnd == null) return null;
+  const pmCharsInLine = Math.max(1, range.pmEnd - range.pmStart);
+  const pmOffset = Math.max(0, Math.min(pmCharsInLine, pos - range.pmStart));
+  const localX = fragment.x + measureCharacterX(block, line, pmOffset);
   const lineOffset = __privateMethod(this, _PresentationEditor_instances, lineHeightBeforeIndex_fn).call(this, measure.lines, fragment.fromLine, index2);
   const localY = fragment.y + lineOffset;
   return {
@@ -35416,17 +37717,179 @@ computeCaretLayoutRect_fn = function(pos) {
     height: line.lineHeight
   };
 };
+/**
+ * Computes caret position using DOM-based positioning.
+ * This matches how click-to-position mapping works and correctly handles
+ * segment-based rendering with tab stops.
+ *
+ * Returns page-local coordinates (x, y relative to the page element).
+ */
+computeCaretLayoutRectFromDOM_fn = function(pos) {
+  const zoom = __privateGet(this, _layoutOptions).zoom ?? 1;
+  let targetPageEl = null;
+  if (__privateGet(this, _layoutState).layout && __privateGet(this, _layoutState).blocks && __privateGet(this, _layoutState).measures) {
+    const fragmentHit = getFragmentAtPosition(
+      __privateGet(this, _layoutState).layout,
+      __privateGet(this, _layoutState).blocks,
+      __privateGet(this, _layoutState).measures,
+      pos
+    );
+    if (fragmentHit) {
+      const pageEl = __privateGet(this, _viewportHost).querySelector(
+        `.superdoc-page[data-page-index="${fragmentHit.pageIndex}"]`
+      );
+      if (pageEl) {
+        targetPageEl = pageEl;
+      }
+    }
+  }
+  const spanEls = Array.from(
+    targetPageEl ? targetPageEl.querySelectorAll("span[data-pm-start][data-pm-end]") : __privateGet(this, _viewportHost).querySelectorAll("span[data-pm-start][data-pm-end]")
+  );
+  for (const spanEl of spanEls) {
+    const pmStart = Number(spanEl.dataset.pmStart ?? "NaN");
+    const pmEnd = Number(spanEl.dataset.pmEnd ?? "NaN");
+    if (!Number.isFinite(pmStart) || !Number.isFinite(pmEnd)) continue;
+    if (pos < pmStart || pos > pmEnd) continue;
+    const pageEl = spanEl.closest(".superdoc-page");
+    if (!pageEl) continue;
+    const pageIndex = Number(pageEl.dataset.pageIndex ?? "0");
+    const pageRect = pageEl.getBoundingClientRect();
+    const textNode = spanEl.firstChild;
+    if (!textNode || textNode.nodeType !== Node.TEXT_NODE) {
+      const spanRect2 = spanEl.getBoundingClientRect();
+      return {
+        pageIndex,
+        x: (spanRect2.left - pageRect.left) / zoom,
+        y: (spanRect2.top - pageRect.top) / zoom,
+        height: spanRect2.height / zoom
+      };
+    }
+    const text = textNode.textContent ?? "";
+    const charOffset = Math.max(0, Math.min(text.length, pos - pmStart));
+    const range = document.createRange();
+    try {
+      range.setStart(textNode, charOffset);
+      range.setEnd(textNode, charOffset);
+    } catch (error) {
+      if (process$1.env.NODE_ENV === "development") {
+        console.warn("[PresentationEditor] Range.setStart/setEnd failed:", {
+          error: error instanceof Error ? error.message : String(error),
+          charOffset,
+          textLength: text.length,
+          pos,
+          pmStart,
+          pmEnd
+        });
+      }
+      const spanRect2 = spanEl.getBoundingClientRect();
+      return {
+        pageIndex,
+        x: (spanRect2.left - pageRect.left) / zoom,
+        y: (spanRect2.top - pageRect.top) / zoom,
+        height: spanRect2.height / zoom
+      };
+    }
+    const rangeRect = range.getBoundingClientRect();
+    const spanRect = spanEl.getBoundingClientRect();
+    const lineEl = spanEl.closest(".superdoc-line");
+    const lineRect = lineEl ? lineEl.getBoundingClientRect() : spanRect;
+    const caretHeight = spanRect.height;
+    const verticalOffset = (lineRect.height - caretHeight) / 2;
+    const caretY = lineRect.top + verticalOffset;
+    return {
+      pageIndex,
+      x: (rangeRect.left - pageRect.left) / zoom,
+      y: (caretY - pageRect.top) / zoom,
+      height: caretHeight / zoom
+    };
+  }
+  return null;
+};
+/**
+ * Computes caret position within a table cell using DOM-based positioning.
+ * This uses the actual rendered DOM elements to get accurate positions,
+ * matching how click-to-position mapping works.
+ */
+computeTableCaretLayoutRect_fn = function(pos, _fragment, _tableBlock, _tableMeasure, pageIndex) {
+  const lineEls = Array.from(__privateGet(this, _viewportHost).querySelectorAll(".superdoc-line"));
+  if (lineEls.length === 0) return null;
+  for (const lineEl of lineEls) {
+    const pmStart = Number(lineEl.dataset.pmStart ?? "NaN");
+    const pmEnd = Number(lineEl.dataset.pmEnd ?? "NaN");
+    if (!Number.isFinite(pmStart) || !Number.isFinite(pmEnd)) continue;
+    if (pos < pmStart || pos > pmEnd) continue;
+    const spanEls = Array.from(lineEl.querySelectorAll("span[data-pm-start]"));
+    for (const spanEl of spanEls) {
+      const spanStart = Number(spanEl.dataset.pmStart ?? "NaN");
+      const spanEnd = Number(spanEl.dataset.pmEnd ?? "NaN");
+      if (!Number.isFinite(spanStart) || !Number.isFinite(spanEnd)) continue;
+      if (pos < spanStart || pos > spanEnd) continue;
+      const textNode = spanEl.firstChild;
+      if (!textNode || textNode.nodeType !== Node.TEXT_NODE) {
+        const spanRect = spanEl.getBoundingClientRect();
+        const viewportRect3 = __privateGet(this, _viewportHost).getBoundingClientRect();
+        const zoom3 = __privateGet(this, _layoutOptions).zoom ?? 1;
+        return {
+          pageIndex,
+          x: (spanRect.left - viewportRect3.left + __privateGet(this, _visibleHost).scrollLeft) / zoom3,
+          y: (spanRect.top - viewportRect3.top + __privateGet(this, _visibleHost).scrollTop) / zoom3,
+          height: spanRect.height / zoom3
+        };
+      }
+      const text = textNode.textContent ?? "";
+      const charOffset = Math.max(0, Math.min(text.length, pos - spanStart));
+      const range = document.createRange();
+      range.setStart(textNode, charOffset);
+      range.setEnd(textNode, charOffset);
+      const rangeRect = range.getBoundingClientRect();
+      const viewportRect2 = __privateGet(this, _viewportHost).getBoundingClientRect();
+      const zoom2 = __privateGet(this, _layoutOptions).zoom ?? 1;
+      const lineRect2 = lineEl.getBoundingClientRect();
+      return {
+        pageIndex,
+        x: (rangeRect.left - viewportRect2.left + __privateGet(this, _visibleHost).scrollLeft) / zoom2,
+        y: (lineRect2.top - viewportRect2.top + __privateGet(this, _visibleHost).scrollTop) / zoom2,
+        height: lineRect2.height / zoom2
+      };
+    }
+    const lineRect = lineEl.getBoundingClientRect();
+    const viewportRect = __privateGet(this, _viewportHost).getBoundingClientRect();
+    const zoom = __privateGet(this, _layoutOptions).zoom ?? 1;
+    return {
+      pageIndex,
+      x: (lineRect.left - viewportRect.left + __privateGet(this, _visibleHost).scrollLeft) / zoom,
+      y: (lineRect.top - viewportRect.top + __privateGet(this, _visibleHost).scrollTop) / zoom,
+      height: lineRect.height / zoom
+    };
+  }
+  return null;
+};
 findLineContainingPos_fn = function(block, measure, fromLine, toLine, pos) {
+  const log2 = (...args) => {
+    console.log("[LINE-SEARCH]", ...args);
+  };
+  log2("Searching for pos:", pos, "in lines", fromLine, "to", toLine);
   if (measure.kind !== "paragraph" || block.kind !== "paragraph") return null;
   for (let lineIndex = fromLine; lineIndex < toLine; lineIndex += 1) {
     const line = measure.lines[lineIndex];
     if (!line) continue;
     const range = computeLinePmRange$1(block, line);
+    log2("Line", lineIndex, ":", {
+      pmStart: range.pmStart,
+      pmEnd: range.pmEnd,
+      fromRun: line.fromRun,
+      toRun: line.toRun,
+      fromChar: line.fromChar,
+      toChar: line.toChar
+    });
     if (range.pmStart == null || range.pmEnd == null) continue;
     if (pos >= range.pmStart && pos <= range.pmEnd) {
+      log2("Found line", lineIndex, "for pos", pos);
       return { line, index: lineIndex };
     }
   }
+  log2("No line found for pos", pos);
   return null;
 };
 lineHeightBeforeIndex_fn = function(lines, fromLine, targetIndex) {
@@ -48995,6 +51458,49 @@ const ShapeGroup = Node$1.create({
     };
   }
 });
+const sharedAttributes = () => ({
+  originalName: {
+    default: null
+  },
+  originalXml: {
+    default: null
+  }
+});
+const hiddenRender = (type) => ["sd-passthrough", { "data-sd-passthrough": type, style: "display: none;" }];
+const PassthroughBlock = Node$1.create({
+  name: "passthroughBlock",
+  group: "block",
+  atom: true,
+  draggable: false,
+  selectable: false,
+  defining: true,
+  parseDOM() {
+    return [{ tag: 'sd-passthrough[data-sd-passthrough="block"]' }];
+  },
+  renderDOM() {
+    return hiddenRender("block");
+  },
+  addAttributes() {
+    return sharedAttributes();
+  }
+});
+const PassthroughInline = Node$1.create({
+  name: "passthroughInline",
+  group: "inline",
+  inline: true,
+  atom: true,
+  draggable: false,
+  selectable: false,
+  parseDOM() {
+    return [{ tag: 'sd-passthrough[data-sd-passthrough="inline"]' }];
+  },
+  renderDOM() {
+    return hiddenRender("inline");
+  },
+  addAttributes() {
+    return sharedAttributes();
+  }
+});
 const TextStyle = Mark.create({
   name: "textStyle",
   addOptions() {
@@ -54905,7 +57411,9 @@ const getRichTextExtensions = () => {
     AiPlugin,
     Image,
     NodeResizer,
-    CustomSelection
+    CustomSelection,
+    PassthroughInline,
+    PassthroughBlock
   ];
 };
 const getStarterExtensions = () => {
@@ -54977,7 +57485,9 @@ const getStarterExtensions = () => {
     CustomSelection,
     TextTransform,
     VectorShape,
-    ShapeGroup
+    ShapeGroup,
+    PassthroughInline,
+    PassthroughBlock
   ];
 };
 export {