npm - superdoc - Versions diffs - 1.0.1 → 1.0.3 - Mend

superdoc 1.0.1 → 1.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (32) hide show

package/dist/chunks/{super-editor.es-DfwLAyUW.es.js → super-editor.es-DWpzsMUa.es.js} RENAMED Viewed

@@ -42410,7 +42410,7 @@ const _SuperConverter = class _SuperConverter2 {
   static getStoredSuperdocVersion(docx) {
     return _SuperConverter2.getStoredCustomProperty(docx, "SuperdocVersion");
   }
-  static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.1") {
+  static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.3") {
     return _SuperConverter2.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
   }
   /**
@@ -60491,7 +60491,7 @@ const isHeadless = (editor) => {
 const shouldSkipNodeView = (editor) => {
   return isHeadless(editor);
 };
-const summaryVersion = "1.0.1";
+const summaryVersion = "1.0.3";
 const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
 const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
 function mapAttributes(attrs) {
@@ -61280,7 +61280,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
       { default: remarkStringify },
       { default: remarkGfm }
     ] = await Promise.all([
-      import("./index-BvhLTOBv-BqXHHksu.es.js"),
+      import("./index-BFesQTtm-DNeH374x.es.js"),
       import("./index-DRCvimau-Cw339678.es.js"),
       import("./index-C_x_N6Uh-DJn8hIEt.es.js"),
       import("./index-D_sWOSiG-DE96TaT5.es.js"),
@@ -61485,7 +61485,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
    * Process collaboration migrations
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "1.0.1");
+    console.debug("[checkVersionMigrations] Current editor version", "1.0.3");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -68737,7 +68737,7 @@ function isMinimalWordLayout(value) {
   return true;
 }
 const LIST_MARKER_GAP$2 = 8;
-const DEFAULT_TAB_INTERVAL_PX$1 = 48;
+const DEFAULT_TAB_INTERVAL_PX$2 = 48;
 const DEFAULT_PAGE_HEIGHT_PX = 1056;
 const DEFAULT_VIRTUALIZED_PAGE_GAP$1 = 72;
 const COMMENT_EXTERNAL_COLOR = "#B1124B";
@@ -69664,6 +69664,7 @@ const _DomPainter = class _DomPainter2 {
       const block = lookup2.block;
       const measure = lookup2.measure;
       const wordLayout = isMinimalWordLayout(block.attrs?.wordLayout) ? block.attrs.wordLayout : void 0;
+      const alignment2 = block.attrs?.alignment;
       const fragmentEl = this.doc.createElement("div");
       fragmentEl.classList.add(CLASS_NAMES$1.fragment);
       const isTocEntry = block.attrs?.isTocEntry;
@@ -69742,7 +69743,7 @@ const _DomPainter = class _DomPainter2 {
               const textStart = paraIndentLeft + firstLine;
               tabWidth = textStart - currentPos;
               if (tabWidth <= 0) {
-                tabWidth = DEFAULT_TAB_INTERVAL_PX$1 - currentPos % DEFAULT_TAB_INTERVAL_PX$1;
+                tabWidth = DEFAULT_TAB_INTERVAL_PX$2 - currentPos % DEFAULT_TAB_INTERVAL_PX$2;
               } else if (tabWidth < LIST_MARKER_GAP$2) {
                 tabWidth = LIST_MARKER_GAP$2;
               }
@@ -69769,6 +69770,21 @@ const _DomPainter = class _DomPainter2 {
         let availableWidthOverride = line.maxWidth != null ? Math.min(line.maxWidth, fallbackAvailableWidth) : fallbackAvailableWidth;
         if (index2 === 0 && listFirstLineMarkerTabWidth != null) {
           availableWidthOverride = fragment.width - listFirstLineMarkerTabWidth - Math.max(0, paraIndentRight);
+          if (alignment2 === "justify" || alignment2 === "both") {
+            console.log(
+              "[justify-debug][painter-firstline-available]",
+              JSON.stringify({
+                blockId: block.id,
+                fragmentWidth: fragment.width,
+                markerTabWidth: listFirstLineMarkerTabWidth,
+                paraIndentRight,
+                availableWidthOverride,
+                lineMaxWidth: line.maxWidth ?? null,
+                lineWidth: line.width,
+                lineNaturalWidth: line.naturalWidth ?? null
+              })
+            );
+          }
         }
         const isLastLineOfFragment = index2 === lines.length - 1;
         const isLastLineOfParagraph = isLastLineOfFragment && !fragment.continuesOnNext;
@@ -69894,7 +69910,7 @@ const _DomPainter = class _DomPainter2 {
                 const textStart = paraIndentLeft + firstLine;
                 tabWidth = textStart - currentPos;
                 if (tabWidth <= 0) {
-                  tabWidth = DEFAULT_TAB_INTERVAL_PX$1 - currentPos % DEFAULT_TAB_INTERVAL_PX$1;
+                  tabWidth = DEFAULT_TAB_INTERVAL_PX$2 - currentPos % DEFAULT_TAB_INTERVAL_PX$2;
                 } else if (tabWidth < LIST_MARKER_GAP$2) {
                   tabWidth = LIST_MARKER_GAP$2;
                 }
@@ -71428,6 +71444,23 @@ const _DomPainter = class _DomPainter2 {
     if (spacingPerSpace !== 0) {
       el.style.wordSpacing = `${spacingPerSpace}px`;
     }
+    if (justifyShouldApply && spacingPerSpace < 0) {
+      console.log(
+        "[justify-debug][painter-wordspacing-negative]",
+        JSON.stringify({
+          blockId: block.id,
+          lineIndex: lineIndex ?? null,
+          alignment: alignment2 ?? null,
+          availableWidth,
+          lineWidth,
+          lineMaxWidth: line.maxWidth ?? null,
+          lineNaturalWidth: line.naturalWidth ?? null,
+          spaceCount,
+          hasExplicitPositioning: Boolean(hasExplicitPositioning),
+          skipJustify: Boolean(skipJustify)
+        })
+      );
+    }
     if (hasExplicitPositioning && line.segments) {
       const paraIndent = block.attrs?.indent;
       const indentLeft = paraIndent?.left ?? 0;
@@ -73621,6 +73654,28 @@ let measurementCtx = null;
 const TAB_CHAR_LENGTH = 1;
 const SPACE_CHARS = SPACE_CHARS$1;
 const isTabRun$1 = (run2) => run2?.kind === "tab";
+const isWordChar$3 = (char) => {
+  if (!char) return false;
+  const code = char.charCodeAt(0);
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || char === "'";
+};
+const capitalizeText$2 = (text) => {
+  if (!text) return text;
+  let result = "";
+  for (let i = 0; i < text.length; i += 1) {
+    const prevChar = i > 0 ? text[i - 1] : "";
+    const ch = text[i];
+    result += isWordChar$3(ch) && !isWordChar$3(prevChar) ? ch.toUpperCase() : ch;
+  }
+  return result;
+};
+const applyTextTransform$2 = (text, transform) => {
+  if (!text || !transform || transform === "none") return text;
+  if (transform === "uppercase") return text.toUpperCase();
+  if (transform === "lowercase") return text.toLowerCase();
+  if (transform === "capitalize") return capitalizeText$2(text);
+  return text;
+};
 function getMeasurementContext() {
   if (measurementCtx) return measurementCtx;
   if (typeof document === "undefined") {
@@ -73796,17 +73851,18 @@ function measureCharacterX(block, line, charOffset, availableWidthOverride, alig
     }
     const text = "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" ? "" : run2.text ?? "";
     const runLength = text.length;
+    const displayText = applyTextTransform$2(text, run2.textTransform);
     if (currentCharOffset + runLength >= charOffset) {
       const offsetInRun = charOffset - currentCharOffset;
       ctx2.font = getRunFontString(run2);
-      const textUpToTarget = text.slice(0, offsetInRun);
+      const textUpToTarget = displayText.slice(0, offsetInRun);
       const measured2 = ctx2.measureText(textUpToTarget);
       const spacingWidth = computeLetterSpacingWidth(run2, offsetInRun, runLength);
-      const spacesInPortion = justify.extraPerSpace !== 0 ? countSpaces(textUpToTarget) : 0;
+      const spacesInPortion = justify.extraPerSpace !== 0 ? countSpaces(text.slice(0, offsetInRun)) : 0;
       return alignmentOffset + currentX + measured2.width + spacingWidth + justify.extraPerSpace * (spaceTally + spacesInPortion);
     }
     ctx2.font = getRunFontString(run2);
-    const measured = ctx2.measureText(text);
+    const measured = ctx2.measureText(displayText);
     const runLetterSpacing = computeLetterSpacingWidth(run2, runLength, runLength);
     const spacesInRun = justify.extraPerSpace !== 0 ? countSpaces(text) : 0;
     currentX += measured.width + runLetterSpacing + justify.extraPerSpace * spacesInRun;
@@ -73845,8 +73901,9 @@ function measureCharacterXSegmentBased(block, line, charOffset, ctx2) {
         return segmentBaseX + (offsetInSegment >= segmentChars ? segment.width ?? 0 : 0);
       }
       const text = run2.text ?? "";
-      const segmentText = text.slice(segment.fromChar, segment.toChar);
-      const textUpToTarget = segmentText.slice(0, offsetInSegment);
+      const displayText = applyTextTransform$2(text, run2.textTransform);
+      const displaySegmentText = displayText.slice(segment.fromChar, segment.toChar);
+      const textUpToTarget = displaySegmentText.slice(0, offsetInSegment);
       ctx2.font = getRunFontString(run2);
       const measured = ctx2.measureText(textUpToTarget);
       const spacingWidth = computeLetterSpacingWidth(run2, offsetInSegment, segmentChars);
@@ -73942,12 +73999,13 @@ function findCharacterAtX(block, line, x2, pmStart, availableWidthOverride, alig
     }
     const text = "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" ? "" : run2.text ?? "";
     const runLength = text.length;
+    const displayText = applyTextTransform$2(text, run2.textTransform);
     if (runLength === 0) continue;
     ctx2.font = getRunFontString(run2);
     for (let i = 0; i <= runLength; i++) {
-      const textUpToChar = text.slice(0, i);
+      const textUpToChar = displayText.slice(0, i);
       const measured2 = ctx2.measureText(textUpToChar);
-      const spacesInPortion = justify.extraPerSpace > 0 ? countSpaces(textUpToChar) : 0;
+      const spacesInPortion = justify.extraPerSpace > 0 ? countSpaces(text.slice(0, i)) : 0;
       const charX = currentX + measured2.width + computeLetterSpacingWidth(run2, i, runLength) + justify.extraPerSpace * (spaceTally + spacesInPortion);
       if (charX >= safeX) {
         if (i === 0) {
@@ -73957,7 +74015,7 @@ function findCharacterAtX(block, line, x2, pmStart, availableWidthOverride, alig
             pmPosition: pmPosition3
           };
         }
-        const prevText = text.slice(0, i - 1);
+        const prevText = displayText.slice(0, i - 1);
         const prevMeasured = ctx2.measureText(prevText);
         const prevX = currentX + prevMeasured.width + computeLetterSpacingWidth(run2, i - 1, runLength);
         const distToPrev = Math.abs(safeX - prevX);
@@ -73970,7 +74028,7 @@ function findCharacterAtX(block, line, x2, pmStart, availableWidthOverride, alig
         };
       }
     }
-    const measured = ctx2.measureText(text);
+    const measured = ctx2.measureText(displayText);
     const runLetterSpacing = computeLetterSpacingWidth(run2, runLength, runLength);
     const spacesInRun = justify.extraPerSpace > 0 ? countSpaces(text) : 0;
     currentX += measured.width + runLetterSpacing + justify.extraPerSpace * spacesInRun;
@@ -74401,6 +74459,83 @@ function findCharIndexAtX(textNode, container, targetX) {
   }
   return index2;
 }
+const LIST_MARKER_GAP$1 = 8;
+const MIN_MARKER_GUTTER = 24;
+const DEFAULT_LIST_INDENT_BASE_PX = 24;
+const DEFAULT_LIST_INDENT_STEP_PX = 24;
+const DEFAULT_LIST_HANGING_PX$1 = 18;
+const SPACE_SUFFIX_GAP_PX = 4;
+const DEFAULT_TAB_INTERVAL_PX$1 = 48;
+function resolveListTextStartPx(wordLayout, indentLeft, firstLine, hanging, measureMarkerText) {
+  const marker = wordLayout?.marker;
+  if (!marker) {
+    const textStartPx = wordLayout?.firstLineIndentMode === true && typeof wordLayout.textStartPx === "number" && Number.isFinite(wordLayout.textStartPx) ? wordLayout.textStartPx : void 0;
+    return textStartPx;
+  }
+  const markerBoxWidth = typeof marker.markerBoxWidthPx === "number" && Number.isFinite(marker.markerBoxWidthPx) ? marker.markerBoxWidthPx : 0;
+  let markerTextWidth = typeof marker.glyphWidthPx === "number" && Number.isFinite(marker.glyphWidthPx) ? marker.glyphWidthPx : void 0;
+  if (markerTextWidth == null && marker.markerText) {
+    markerTextWidth = measureMarkerText(marker.markerText, marker);
+  }
+  if (!Number.isFinite(markerTextWidth) || markerTextWidth < 0) {
+    markerTextWidth = markerBoxWidth;
+  }
+  markerTextWidth = Math.max(0, markerTextWidth);
+  let markerStartPos;
+  if (wordLayout?.firstLineIndentMode === true && Number.isFinite(marker.markerX)) {
+    markerStartPos = marker.markerX;
+  } else {
+    markerStartPos = indentLeft - hanging + firstLine;
+  }
+  if (!Number.isFinite(markerStartPos)) {
+    markerStartPos = 0;
+  }
+  const currentPos = markerStartPos + markerTextWidth;
+  const suffix2 = marker.suffix ?? "tab";
+  if (suffix2 === "space") {
+    return markerStartPos + markerTextWidth + SPACE_SUFFIX_GAP_PX;
+  }
+  if (suffix2 === "nothing") {
+    return markerStartPos + markerTextWidth;
+  }
+  const markerJustification = marker.justification ?? "left";
+  if (markerJustification !== "left") {
+    const gutterWidth = typeof marker.gutterWidthPx === "number" && Number.isFinite(marker.gutterWidthPx) && marker.gutterWidthPx > 0 ? marker.gutterWidthPx : LIST_MARKER_GAP$1;
+    return markerStartPos + markerTextWidth + Math.max(gutterWidth, LIST_MARKER_GAP$1);
+  }
+  if (wordLayout?.firstLineIndentMode === true) {
+    let targetTabStop;
+    if (Array.isArray(wordLayout.tabsPx)) {
+      for (const tab of wordLayout.tabsPx) {
+        if (typeof tab === "number" && tab > currentPos) {
+          targetTabStop = tab;
+          break;
+        }
+      }
+    }
+    const textStartTarget = typeof marker.textStartX === "number" && Number.isFinite(marker.textStartX) ? marker.textStartX : wordLayout.textStartPx;
+    let tabWidth2;
+    if (targetTabStop !== void 0) {
+      tabWidth2 = targetTabStop - currentPos;
+    } else if (textStartTarget !== void 0 && Number.isFinite(textStartTarget) && textStartTarget > currentPos) {
+      tabWidth2 = textStartTarget - currentPos;
+    } else {
+      tabWidth2 = LIST_MARKER_GAP$1;
+    }
+    if (tabWidth2 < LIST_MARKER_GAP$1) {
+      tabWidth2 = LIST_MARKER_GAP$1;
+    }
+    return markerStartPos + markerTextWidth + tabWidth2;
+  }
+  const textStart = indentLeft + firstLine;
+  let tabWidth = textStart - currentPos;
+  if (tabWidth <= 0) {
+    tabWidth = DEFAULT_TAB_INTERVAL_PX$1 - currentPos % DEFAULT_TAB_INTERVAL_PX$1;
+  } else if (tabWidth < LIST_MARKER_GAP$1) {
+    tabWidth = LIST_MARKER_GAP$1;
+  }
+  return markerStartPos + markerTextWidth + tabWidth;
+}
 function getWordLayoutConfig(block) {
   if (!block || block.kind !== "paragraph") {
     return void 0;
@@ -74433,9 +74568,16 @@ function calculateTextStartIndent(params2) {
   const isFirstLineIndentMode = wordLayout?.firstLineIndentMode === true;
   let indentAdjust = paraIndentLeft;
   if (isListItem2 && isFirstLine && isFirstLineIndentMode) {
+    const resolvedTextStart = resolveListTextStartPx(
+      wordLayout,
+      paraIndentLeft,
+      Math.max(firstLineIndent, 0),
+      Math.max(hangingIndent, 0),
+      () => markerWidth
+      // Use provided markerWidth since we don't have canvas access here
+    );
     const textStartFallback = paraIndentLeft + Math.max(firstLineIndent, 0) + markerWidth;
-    const markerTextStartX = wordLayout?.marker?.textStartX;
-    indentAdjust = typeof markerTextStartX === "number" && Number.isFinite(markerTextStartX) ? markerTextStartX : typeof wordLayout?.textStartPx === "number" && Number.isFinite(wordLayout.textStartPx) ? wordLayout.textStartPx : textStartFallback;
+    indentAdjust = typeof resolvedTextStart === "number" && Number.isFinite(resolvedTextStart) ? resolvedTextStart : textStartFallback;
   } else if (isFirstLine && !isListItem2) {
     indentAdjust += firstLineOffset;
   }
@@ -74591,7 +74733,10 @@ function getHeaderFooterTypeForSection(pageNumber, sectionIndex, identifier, opt
 }
 function createFloatingObjectManager(columns, margins, pageWidth) {
   const zones = [];
-  const marginLeft = Math.max(0, margins?.left ?? 0);
+  let currentColumns = columns;
+  let currentMargins = margins;
+  let currentPageWidth = pageWidth;
+  let marginLeft = Math.max(0, currentMargins?.left ?? 0);
   return {
     registerDrawing(drawingBlock, measure, anchorY, columnIndex, pageNumber) {
       if (!drawingBlock.anchor?.isAnchored) {
@@ -74604,7 +74749,7 @@ function createFloatingObjectManager(columns, margins, pageWidth) {
       }
       const objectWidth = measure.width ?? 0;
       const objectHeight = measure.height ?? 0;
-      const x2 = computeAnchorX(anchor, columnIndex, columns, objectWidth, margins, pageWidth);
+      const x2 = computeAnchorX(anchor, columnIndex, currentColumns, objectWidth, currentMargins, currentPageWidth);
       const y2 = anchorY + (anchor.offsetV ?? 0);
       const zone = {
         imageBlockId: drawingBlock.id,
@@ -74638,7 +74783,7 @@ function createFloatingObjectManager(columns, margins, pageWidth) {
       }
       const tableWidth = measure.totalWidth ?? 0;
       const tableHeight = measure.totalHeight ?? 0;
-      const x2 = computeTableAnchorX(anchor, columnIndex, columns, tableWidth, margins, pageWidth);
+      const x2 = computeTableAnchorX(anchor, columnIndex, currentColumns, tableWidth, currentMargins, currentPageWidth);
       const y2 = anchorY + (anchor.offsetV ?? 0);
       const zone = {
         imageBlockId: tableBlock.id,
@@ -74686,7 +74831,7 @@ function createFloatingObjectManager(columns, margins, pageWidth) {
       }
       const leftFloats = [];
       const rightFloats = [];
-      const columnOrigin = marginLeft + columnIndex * (columns.width + columns.gap);
+      const columnOrigin = marginLeft + columnIndex * (currentColumns.width + currentColumns.gap);
       const columnCenter = columnOrigin + baseWidth / 2;
       for (const zone of wrappingZones) {
         if (zone.wrapMode === "left") {
@@ -74725,6 +74870,22 @@ function createFloatingObjectManager(columns, margins, pageWidth) {
     },
     clear() {
       zones.length = 0;
+    },
+    /**
+     * Update layout context used for positioning and wrapping (columns, margins, page width).
+     * This method should be called when the layout configuration changes (e.g., section breaks,
+     * column changes, page size changes) to ensure floating objects are positioned and wrapped
+     * correctly relative to the new layout boundaries.
+     *
+     * @param nextColumns - Column layout configuration (width, gap, count)
+     * @param nextMargins - Optional page margins (left, right) in pixels
+     * @param nextPageWidth - Optional total page width in pixels
+     */
+    setLayoutContext(nextColumns, nextMargins, nextPageWidth) {
+      currentColumns = nextColumns;
+      currentMargins = nextMargins;
+      currentPageWidth = nextPageWidth;
+      marginLeft = Math.max(0, currentMargins?.left ?? 0);
     }
   };
 }
@@ -74824,7 +74985,14 @@ function computeNextSectionPropsAtBreak(blocks) {
     const props = {};
     if (source.kind !== "sectionBreak") return props;
     if (source.margins) {
-      props.margins = { header: source.margins.header, footer: source.margins.footer };
+      props.margins = {
+        header: source.margins.header,
+        footer: source.margins.footer,
+        top: source.margins.top,
+        right: source.margins.right,
+        bottom: source.margins.bottom,
+        left: source.margins.left
+      };
     }
     if (source.pageSize) {
       props.pageSize = { w: source.pageSize.w, h: source.pageSize.h };
@@ -74872,20 +75040,36 @@ function scheduleSectionBreak(block, state2, baseMargins, maxHeaderContentHeight
       next.activeOrientation = block.orientation;
       next.pendingOrientation = null;
     }
+    const headerDistance = typeof block.margins?.header === "number" ? Math.max(0, block.margins.header) : next.activeHeaderDistance;
+    const footerDistance = typeof block.margins?.footer === "number" ? Math.max(0, block.margins.footer) : next.activeFooterDistance;
+    const sectionTop = typeof block.margins?.top === "number" ? Math.max(0, block.margins.top) : baseMargins.top;
+    const sectionBottom = typeof block.margins?.bottom === "number" ? Math.max(0, block.margins.bottom) : baseMargins.bottom;
     if (block.margins?.header !== void 0) {
-      const headerDistance = Math.max(0, block.margins.header);
       next.activeHeaderDistance = headerDistance;
       next.pendingHeaderDistance = headerDistance;
-      next.activeTopMargin = calcRequiredTopMargin(headerDistance, baseMargins.top);
-      next.pendingTopMargin = next.activeTopMargin;
     }
     if (block.margins?.footer !== void 0) {
-      const footerDistance = Math.max(0, block.margins.footer);
       next.activeFooterDistance = footerDistance;
       next.pendingFooterDistance = footerDistance;
-      next.activeBottomMargin = calcRequiredBottomMargin(footerDistance, baseMargins.bottom);
+    }
+    if (block.margins?.top !== void 0 || block.margins?.header !== void 0) {
+      next.activeTopMargin = calcRequiredTopMargin(headerDistance, sectionTop);
+      next.pendingTopMargin = next.activeTopMargin;
+    }
+    if (block.margins?.bottom !== void 0 || block.margins?.footer !== void 0) {
+      next.activeBottomMargin = calcRequiredBottomMargin(footerDistance, sectionBottom);
       next.pendingBottomMargin = next.activeBottomMargin;
     }
+    if (block.margins?.left !== void 0) {
+      const leftMargin = Math.max(0, block.margins.left);
+      next.activeLeftMargin = leftMargin;
+      next.pendingLeftMargin = leftMargin;
+    }
+    if (block.margins?.right !== void 0) {
+      const rightMargin = Math.max(0, block.margins.right);
+      next.activeRightMargin = rightMargin;
+      next.pendingRightMargin = rightMargin;
+    }
     if (block.columns) {
       next.activeColumns = { count: block.columns.count, gap: block.columns.gap };
       next.pendingColumns = null;
@@ -74894,26 +75078,42 @@ function scheduleSectionBreak(block, state2, baseMargins, maxHeaderContentHeight
   }
   const headerPx = block.margins?.header;
   const footerPx = block.margins?.footer;
+  const topPx = block.margins?.top;
+  const bottomPx = block.margins?.bottom;
   const nextTop = next.pendingTopMargin ?? next.activeTopMargin;
   const nextBottom = next.pendingBottomMargin ?? next.activeBottomMargin;
+  const nextLeft = next.pendingLeftMargin ?? next.activeLeftMargin;
+  const nextRight = next.pendingRightMargin ?? next.activeRightMargin;
   const nextHeader = next.pendingHeaderDistance ?? next.activeHeaderDistance;
   const nextFooter = next.pendingFooterDistance ?? next.activeFooterDistance;
-  if (typeof headerPx === "number") {
-    const newHeaderDist = Math.max(0, headerPx);
+  if (typeof headerPx === "number" || typeof topPx === "number") {
+    const newHeaderDist = typeof headerPx === "number" ? Math.max(0, headerPx) : nextHeader;
+    const sectionTop = typeof topPx === "number" ? Math.max(0, topPx) : baseMargins.top;
     next.pendingHeaderDistance = newHeaderDist;
-    next.pendingTopMargin = calcRequiredTopMargin(newHeaderDist, baseMargins.top);
+    next.pendingTopMargin = calcRequiredTopMargin(newHeaderDist, sectionTop);
   } else {
     next.pendingTopMargin = nextTop;
     next.pendingHeaderDistance = nextHeader;
   }
-  if (typeof footerPx === "number") {
-    const newFooterDist = Math.max(0, footerPx);
+  if (typeof footerPx === "number" || typeof bottomPx === "number") {
+    const newFooterDist = typeof footerPx === "number" ? Math.max(0, footerPx) : nextFooter;
+    const sectionBottom = typeof bottomPx === "number" ? Math.max(0, bottomPx) : baseMargins.bottom;
     next.pendingFooterDistance = newFooterDist;
-    next.pendingBottomMargin = calcRequiredBottomMargin(newFooterDist, baseMargins.bottom);
+    next.pendingBottomMargin = calcRequiredBottomMargin(newFooterDist, sectionBottom);
   } else {
     next.pendingBottomMargin = nextBottom;
     next.pendingFooterDistance = nextFooter;
   }
+  if (typeof block.margins?.left === "number") {
+    next.pendingLeftMargin = Math.max(0, block.margins.left);
+  } else {
+    next.pendingLeftMargin = nextLeft;
+  }
+  if (typeof block.margins?.right === "number") {
+    next.pendingRightMargin = Math.max(0, block.margins.right);
+  } else {
+    next.pendingRightMargin = nextRight;
+  }
   if (block.pageSize) {
     next.pendingPageSize = { w: block.pageSize.w, h: block.pageSize.h };
   }
@@ -74973,6 +75173,12 @@ function applyPendingToActive(state2) {
   if (next.pendingBottomMargin != null) {
     next.activeBottomMargin = next.pendingBottomMargin;
   }
+  if (next.pendingLeftMargin != null) {
+    next.activeLeftMargin = next.pendingLeftMargin;
+  }
+  if (next.pendingRightMargin != null) {
+    next.activeRightMargin = next.pendingRightMargin;
+  }
   if (next.pendingHeaderDistance != null) {
     next.activeHeaderDistance = next.pendingHeaderDistance;
   }
@@ -74990,6 +75196,8 @@ function applyPendingToActive(state2) {
   }
   next.pendingTopMargin = null;
   next.pendingBottomMargin = null;
+  next.pendingLeftMargin = null;
+  next.pendingRightMargin = null;
   next.pendingHeaderDistance = null;
   next.pendingFooterDistance = null;
   next.pendingPageSize = null;
@@ -75218,7 +75426,8 @@ function layoutParagraphBlock(ctx2, anchors) {
   if (typeof remeasureParagraph2 === "function" && typeof measurementWidth === "number" && measurementWidth > remeasureWidth) {
     const firstLineIndent = calculateFirstLineIndent(block, measure);
     const newMeasure = remeasureParagraph2(block, columnWidth, firstLineIndent);
-    lines = normalizeLines(newMeasure);
+    const newLines = normalizeLines(newMeasure);
+    lines = newLines;
     didRemeasureForColumnWidth = true;
   }
   let fromLine = 0;
@@ -75300,7 +75509,8 @@ function layoutParagraphBlock(ctx2, anchors) {
     if (narrowestRemeasureWidth < remeasureWidth) {
       const firstLineIndent = calculateFirstLineIndent(block, measure);
       const newMeasure = remeasureParagraph2(block, narrowestRemeasureWidth, firstLineIndent);
-      lines = normalizeLines(newMeasure);
+      const newLines = normalizeLines(newMeasure);
+      lines = newLines;
       didRemeasureForFloats = true;
     }
   }
@@ -75644,6 +75854,94 @@ function getCellPadding(cellIdx, blockRow) {
 function getCellTotalLines(cell) {
   return getCellLines(cell).length;
 }
+function mergePmRange(target, range2) {
+  if (typeof range2.pmStart === "number") {
+    target.pmStart = target.pmStart == null ? range2.pmStart : Math.min(target.pmStart, range2.pmStart);
+  }
+  if (typeof range2.pmEnd === "number") {
+    target.pmEnd = target.pmEnd == null ? range2.pmEnd : Math.max(target.pmEnd, range2.pmEnd);
+  }
+}
+function computeCellPmRange(cell, cellMeasure, fromLine, toLine) {
+  const range2 = {};
+  if (!cell || !cellMeasure) return range2;
+  const cellBlocks = cell.blocks ?? (cell.paragraph ? [cell.paragraph] : []);
+  const blockMeasures = cellMeasure.blocks ?? (cellMeasure.paragraph ? [cellMeasure.paragraph] : []);
+  const maxBlocks = Math.min(cellBlocks.length, blockMeasures.length);
+  let cumulativeLineCount = 0;
+  for (let i = 0; i < maxBlocks; i++) {
+    const block = cellBlocks[i];
+    const blockMeasure = blockMeasures[i];
+    if (blockMeasure.kind === "paragraph" && block?.kind === "paragraph") {
+      const paraMeasure = blockMeasure;
+      const lines = paraMeasure.lines;
+      const blockLineCount = lines?.length ?? 0;
+      const blockStartGlobal = cumulativeLineCount;
+      const blockEndGlobal = cumulativeLineCount + blockLineCount;
+      const localFrom = Math.max(fromLine, blockStartGlobal) - blockStartGlobal;
+      const localTo = Math.min(toLine, blockEndGlobal) - blockStartGlobal;
+      if (lines && lines.length > 0 && localFrom < localTo) {
+        mergePmRange(range2, computeFragmentPmRange(block, lines, localFrom, localTo));
+      } else {
+        mergePmRange(range2, extractBlockPmRange(block));
+      }
+      cumulativeLineCount += blockLineCount;
+      continue;
+    }
+    mergePmRange(range2, extractBlockPmRange(block));
+  }
+  return range2;
+}
+function computeTableFragmentPmRange(block, measure, fromRow, toRow, partialRow) {
+  const range2 = {};
+  for (let rowIndex = fromRow; rowIndex < toRow; rowIndex++) {
+    const row = block.rows[rowIndex];
+    const rowMeasure = measure.rows[rowIndex];
+    if (!row || !rowMeasure) continue;
+    const isPartial = partialRow?.rowIndex === rowIndex;
+    const cellCount = Math.min(row.cells.length, rowMeasure.cells.length);
+    for (let cellIndex = 0; cellIndex < cellCount; cellIndex++) {
+      const cell = row.cells[cellIndex];
+      const cellMeasure = rowMeasure.cells[cellIndex];
+      if (!cell || !cellMeasure) continue;
+      const totalLines = getCellTotalLines(cellMeasure);
+      let fromLine = 0;
+      let toLine = totalLines;
+      if (isPartial) {
+        const hasValidFromLineByCell = partialRow?.fromLineByCell && cellIndex < partialRow.fromLineByCell.length;
+        const hasValidToLineByCell = partialRow?.toLineByCell && cellIndex < partialRow.toLineByCell.length;
+        if (hasValidFromLineByCell) {
+          const rawFrom = partialRow.fromLineByCell[cellIndex];
+          if (typeof rawFrom === "number" && rawFrom >= 0) {
+            fromLine = rawFrom;
+          }
+        }
+        if (hasValidToLineByCell) {
+          const rawTo = partialRow.toLineByCell[cellIndex];
+          if (typeof rawTo === "number") {
+            toLine = rawTo === -1 ? totalLines : rawTo;
+          }
+        }
+      }
+      fromLine = Math.max(0, Math.min(fromLine, totalLines));
+      toLine = Math.max(0, Math.min(toLine, totalLines));
+      if (toLine < fromLine) {
+        toLine = fromLine;
+      }
+      mergePmRange(range2, computeCellPmRange(cell, cellMeasure, fromLine, toLine));
+    }
+  }
+  return range2;
+}
+function applyTableFragmentPmRange(fragment, block, measure) {
+  const range2 = computeTableFragmentPmRange(block, measure, fragment.fromRow, fragment.toRow, fragment.partialRow);
+  if (range2.pmStart != null) {
+    fragment.pmStart = range2.pmStart;
+  }
+  if (range2.pmEnd != null) {
+    fragment.pmEnd = range2.pmEnd;
+  }
+}
 function computePartialRow(rowIndex, blockRow, measure, availableHeight, fromLineByCell) {
   const row = measure.rows[rowIndex];
   if (!row) {
@@ -75788,6 +76086,7 @@ function layoutMonolithicTable(context) {
     height,
     metadata
   };
+  applyTableFragmentPmRange(fragment, context.block, context.measure);
   state2.page.fragments.push(fragment);
   state2.cursorY += height;
 }
@@ -75866,6 +76165,7 @@ function layoutTableBlock({
       height,
       metadata
     };
+    applyTableFragmentPmRange(fragment, block, measure);
     state2.page.fragments.push(fragment);
     state2.cursorY += height;
     return;
@@ -75929,6 +76229,7 @@ function layoutTableBlock({
           partialRow: continuationPartialRow,
           metadata: generateFragmentMetadata(measure)
         };
+        applyTableFragmentPmRange(fragment2, block, measure);
         state2.page.fragments.push(fragment2);
         state2.cursorY += fragmentHeight2;
       }
@@ -75973,6 +76274,7 @@ function layoutTableBlock({
         partialRow: forcedPartialRow,
         metadata: generateFragmentMetadata(measure)
       };
+      applyTableFragmentPmRange(fragment2, block, measure);
       state2.page.fragments.push(fragment2);
       state2.cursorY += fragmentHeight2;
       pendingPartialRow = forcedPartialRow;
@@ -76008,6 +76310,7 @@ function layoutTableBlock({
       partialRow: partialRow || void 0,
       metadata: generateFragmentMetadata(measure)
     };
+    applyTableFragmentPmRange(fragment, block, measure);
     state2.page.fragments.push(fragment);
     state2.cursorY += fragmentHeight;
     if (partialRow && !partialRow.isLastPart) {
@@ -76025,7 +76328,7 @@ function createAnchoredTableFragment(block, measure, x2, y2) {
     columnBoundaries: generateColumnBoundaries(measure),
     coordinateSystem: "fragment"
   };
-  return {
+  const fragment = {
     kind: "table",
     blockId: block.id,
     fromRow: 0,
@@ -76036,6 +76339,8 @@ function createAnchoredTableFragment(block, measure, x2, y2) {
     height: measure.totalHeight ?? 0,
     metadata
   };
+  applyTableFragmentPmRange(fragment, block, measure);
+  return fragment;
 }
 function isPageRelativeAnchor(block) {
   const vRelativeFrom = block.anchor?.vRelativeFrom;
@@ -76457,8 +76762,8 @@ function layoutDocument(blocks, measures, options = {}) {
     header: options.margins?.header ?? options.margins?.top ?? DEFAULT_MARGINS$2.top,
     footer: options.margins?.footer ?? options.margins?.bottom ?? DEFAULT_MARGINS$2.bottom
   };
-  const contentWidth = pageSize.w - (margins.left + margins.right);
-  if (contentWidth <= 0) {
+  const baseContentWidth = pageSize.w - (margins.left + margins.right);
+  if (baseContentWidth <= 0) {
     throw new Error("layoutDocument: pageSize and margins yield non-positive content area");
   }
   const validateContentHeight = (height) => {
@@ -76488,8 +76793,12 @@ function layoutDocument(blocks, measures, options = {}) {
   const effectiveBottomMargin = maxFooterContentHeight > 0 ? Math.max(margins.bottom, footerDistance + maxFooterContentHeight) : margins.bottom;
   let activeTopMargin = effectiveTopMargin;
   let activeBottomMargin = effectiveBottomMargin;
+  let activeLeftMargin = margins.left;
+  let activeRightMargin = margins.right;
   let pendingTopMargin = null;
   let pendingBottomMargin = null;
+  let pendingLeftMargin = null;
+  let pendingRightMargin = null;
   let activeHeaderDistance = margins.header ?? margins.top;
   let pendingHeaderDistance = null;
   let activeFooterDistance = margins.footer ?? margins.bottom;
@@ -76502,10 +76811,11 @@ function layoutDocument(blocks, measures, options = {}) {
   let pendingOrientation = null;
   let activeVAlign = null;
   let pendingVAlign = null;
+  const paginatorMargins = { left: activeLeftMargin, right: activeRightMargin };
   const floatManager = createFloatingObjectManager(
-    normalizeColumns(activeColumns, contentWidth),
-    { left: margins.left, right: margins.right },
-    pageSize.w
+    normalizeColumns(activeColumns, activePageSize.w - (activeLeftMargin + activeRightMargin)),
+    { left: activeLeftMargin, right: activeRightMargin },
+    activePageSize.w
   );
   const nextSectionPropsAtBreak = computeNextSectionPropsAtBreak(blocks);
   const scheduleSectionBreakCompat = (block, state2, baseMargins) => {
@@ -76522,22 +76832,38 @@ function layoutDocument(blocks, measures, options = {}) {
         next.activeOrientation = block.orientation;
         next.pendingOrientation = null;
       }
+      const headerDistance2 = typeof block.margins?.header === "number" ? Math.max(0, block.margins.header) : next.activeHeaderDistance;
+      const footerDistance2 = typeof block.margins?.footer === "number" ? Math.max(0, block.margins.footer) : next.activeFooterDistance;
+      const sectionTop = typeof block.margins?.top === "number" ? Math.max(0, block.margins.top) : baseMargins.top;
+      const sectionBottom = typeof block.margins?.bottom === "number" ? Math.max(0, block.margins.bottom) : baseMargins.bottom;
       if (block.margins?.header !== void 0) {
-        const headerDist = Math.max(0, block.margins.header);
-        next.activeHeaderDistance = headerDist;
-        next.pendingHeaderDistance = headerDist;
-        const requiredTop = maxHeaderContentHeight > 0 ? headerDist + maxHeaderContentHeight : headerDist;
-        next.activeTopMargin = Math.max(baseMargins.top, requiredTop);
-        next.pendingTopMargin = next.activeTopMargin;
+        next.activeHeaderDistance = headerDistance2;
+        next.pendingHeaderDistance = headerDistance2;
       }
       if (block.margins?.footer !== void 0) {
-        const footerDistance2 = Math.max(0, block.margins.footer);
         next.activeFooterDistance = footerDistance2;
         next.pendingFooterDistance = footerDistance2;
+      }
+      if (block.margins?.top !== void 0 || block.margins?.header !== void 0) {
+        const requiredTop = maxHeaderContentHeight > 0 ? headerDistance2 + maxHeaderContentHeight : headerDistance2;
+        next.activeTopMargin = Math.max(sectionTop, requiredTop);
+        next.pendingTopMargin = next.activeTopMargin;
+      }
+      if (block.margins?.bottom !== void 0 || block.margins?.footer !== void 0) {
         const requiredBottom = maxFooterContentHeight > 0 ? footerDistance2 + maxFooterContentHeight : footerDistance2;
-        next.activeBottomMargin = Math.max(baseMargins.bottom, requiredBottom);
+        next.activeBottomMargin = Math.max(sectionBottom, requiredBottom);
         next.pendingBottomMargin = next.activeBottomMargin;
       }
+      if (block.margins?.left !== void 0) {
+        const leftMargin = Math.max(0, block.margins.left);
+        next.activeLeftMargin = leftMargin;
+        next.pendingLeftMargin = leftMargin;
+      }
+      if (block.margins?.right !== void 0) {
+        const rightMargin = Math.max(0, block.margins.right);
+        next.activeRightMargin = rightMargin;
+        next.pendingRightMargin = rightMargin;
+      }
       if (block.columns) {
         next.activeColumns = { count: block.columns.count, gap: block.columns.gap };
         next.pendingColumns = null;
@@ -76566,27 +76892,35 @@ function layoutDocument(blocks, measures, options = {}) {
     const headerPx = block.margins?.header;
     const footerPx = block.margins?.footer;
     const topPx = block.margins?.top;
+    const bottomPx = block.margins?.bottom;
+    const leftPx = block.margins?.left;
+    const rightPx = block.margins?.right;
     const nextTop = next.pendingTopMargin ?? next.activeTopMargin;
     const nextBottom = next.pendingBottomMargin ?? next.activeBottomMargin;
+    const nextLeft = next.pendingLeftMargin ?? next.activeLeftMargin;
+    const nextRight = next.pendingRightMargin ?? next.activeRightMargin;
     const nextHeader = next.pendingHeaderDistance ?? next.activeHeaderDistance;
     const nextFooter = next.pendingFooterDistance ?? next.activeFooterDistance;
     next.pendingHeaderDistance = typeof headerPx === "number" ? Math.max(0, headerPx) : nextHeader;
     next.pendingFooterDistance = typeof footerPx === "number" ? Math.max(0, footerPx) : nextFooter;
     if (typeof headerPx === "number" || typeof topPx === "number") {
-      const sectionTop = topPx ?? baseMargins.top;
+      const sectionTop = typeof topPx === "number" ? Math.max(0, topPx) : baseMargins.top;
       const sectionHeader = next.pendingHeaderDistance;
       const requiredTop = maxHeaderContentHeight > 0 ? sectionHeader + maxHeaderContentHeight : sectionHeader;
       next.pendingTopMargin = Math.max(sectionTop, requiredTop);
     } else {
       next.pendingTopMargin = nextTop;
     }
-    if (typeof footerPx === "number") {
+    if (typeof footerPx === "number" || typeof bottomPx === "number") {
       const sectionFooter = next.pendingFooterDistance;
+      const sectionBottom = typeof bottomPx === "number" ? Math.max(0, bottomPx) : baseMargins.bottom;
       const requiredBottom = maxFooterContentHeight > 0 ? sectionFooter + maxFooterContentHeight : sectionFooter;
-      next.pendingBottomMargin = Math.max(baseMargins.bottom, requiredBottom);
+      next.pendingBottomMargin = Math.max(sectionBottom, requiredBottom);
     } else {
       next.pendingBottomMargin = nextBottom;
     }
+    next.pendingLeftMargin = typeof leftPx === "number" ? Math.max(0, leftPx) : nextLeft;
+    next.pendingRightMargin = typeof rightPx === "number" ? Math.max(0, rightPx) : nextRight;
     if (block.pageSize) next.pendingPageSize = { w: block.pageSize.w, h: block.pageSize.h };
     if (block.orientation) next.pendingOrientation = block.orientation;
     const sectionType = block.type ?? "continuous";
@@ -76671,7 +77005,7 @@ function layoutDocument(blocks, measures, options = {}) {
   let activeSectionIndex = initialSectionMetadata?.sectionIndex ?? 0;
   let pendingSectionIndex = null;
   const paginator = createPaginator({
-    margins: { left: margins.left, right: margins.right },
+    margins: paginatorMargins,
     getActiveTopMargin: () => activeTopMargin,
     getActiveBottomMargin: () => activeBottomMargin,
     getActiveHeaderDistance: () => activeHeaderDistance,
@@ -76686,8 +77020,12 @@ function layoutDocument(blocks, measures, options = {}) {
         const applied = applyPendingToActive({
           activeTopMargin,
           activeBottomMargin,
+          activeLeftMargin,
+          activeRightMargin,
           pendingTopMargin,
           pendingBottomMargin,
+          pendingLeftMargin,
+          pendingRightMargin,
           activeHeaderDistance,
           activeFooterDistance,
           pendingHeaderDistance,
@@ -76702,8 +77040,12 @@ function layoutDocument(blocks, measures, options = {}) {
         });
         activeTopMargin = applied.activeTopMargin;
         activeBottomMargin = applied.activeBottomMargin;
+        activeLeftMargin = applied.activeLeftMargin;
+        activeRightMargin = applied.activeRightMargin;
         pendingTopMargin = applied.pendingTopMargin;
         pendingBottomMargin = applied.pendingBottomMargin;
+        pendingLeftMargin = applied.pendingLeftMargin;
+        pendingRightMargin = applied.pendingRightMargin;
         activeHeaderDistance = applied.activeHeaderDistance;
         activeFooterDistance = applied.activeFooterDistance;
         pendingHeaderDistance = applied.pendingHeaderDistance;
@@ -76715,6 +77057,14 @@ function layoutDocument(blocks, measures, options = {}) {
         activeOrientation = applied.activeOrientation;
         pendingOrientation = applied.pendingOrientation;
         cachedColumnsState.state = null;
+        paginatorMargins.left = activeLeftMargin;
+        paginatorMargins.right = activeRightMargin;
+        const contentWidth = activePageSize.w - (activeLeftMargin + activeRightMargin);
+        floatManager.setLayoutContext(
+          normalizeColumns(activeColumns, contentWidth),
+          { left: activeLeftMargin, right: activeRightMargin },
+          activePageSize.w
+        );
         if (pendingNumbering) {
           if (pendingNumbering.format) activeNumberFormat = pendingNumbering.format;
           if (typeof pendingNumbering.start === "number" && Number.isFinite(pendingNumbering.start)) {
@@ -76759,7 +77109,7 @@ function layoutDocument(blocks, measures, options = {}) {
   const getActiveColumnsForState = paginator.getActiveColumnsForState;
   let cachedColumnsState = { state: null, constraintIndex: -2, contentWidth: -1, colsConfig: null, normalized: null };
   const getCurrentColumns = () => {
-    const currentContentWidth = activePageSize.w - (margins.left + margins.right);
+    const currentContentWidth = activePageSize.w - (activeLeftMargin + activeRightMargin);
     const state2 = states[states.length - 1] ?? null;
     const colsConfig = state2 ? getActiveColumnsForState(state2) : activeColumns;
     const constraintIndex = state2 ? state2.activeConstraintIndex : -1;
@@ -76792,6 +77142,12 @@ function layoutDocument(blocks, measures, options = {}) {
     layoutLog(`  Current page: ${state2.page.number}, cursorY: ${state2.cursorY}`);
     activeColumns = newColumns;
     cachedColumnsState.state = null;
+    const contentWidth = activePageSize.w - (activeLeftMargin + activeRightMargin);
+    floatManager.setLayoutContext(
+      normalizeColumns(activeColumns, contentWidth),
+      { left: activeLeftMargin, right: activeRightMargin },
+      activePageSize.w
+    );
   };
   const anchoredByParagraph = collectAnchoredDrawings(blocks, measures);
   const anchoredTablesByParagraph = collectAnchoredTables(blocks, measures);
@@ -76823,10 +77179,10 @@ function layoutDocument(blocks, measures, options = {}) {
       if (alignV === "top") {
         anchorY = offsetV;
       } else if (alignV === "bottom") {
-        const pageHeight = contentBottom + margins.bottom;
+        const pageHeight = contentBottom + (state2.page.margins?.bottom ?? activeBottomMargin);
         anchorY = pageHeight - imageHeight + offsetV;
       } else if (alignV === "center") {
-        const pageHeight = contentBottom + margins.bottom;
+        const pageHeight = contentBottom + (state2.page.margins?.bottom ?? activeBottomMargin);
         anchorY = (pageHeight - imageHeight) / 2 + offsetV;
       } else {
         anchorY = offsetV;
@@ -76837,11 +77193,11 @@ function layoutDocument(blocks, measures, options = {}) {
     const anchorX = entry.block.anchor ? computeAnchorX(
       entry.block.anchor,
       state2.columnIndex,
-      normalizeColumns(activeColumns, contentWidth),
+      normalizeColumns(activeColumns, activePageSize.w - (activeLeftMargin + activeRightMargin)),
       entry.measure.width,
-      { left: margins.left, right: margins.right },
+      { left: activeLeftMargin, right: activeRightMargin },
       activePageSize.w
-    ) : margins.left;
+    ) : activeLeftMargin;
     floatManager.registerDrawing(entry.block, entry.measure, anchorY, state2.columnIndex, state2.page.number);
     preRegisteredPositions.set(entry.block.id, { anchorX, anchorY, pageNumber: state2.page.number });
   }
@@ -76879,8 +77235,12 @@ function layoutDocument(blocks, measures, options = {}) {
       const sectionState = {
         activeTopMargin,
         activeBottomMargin,
+        activeLeftMargin,
+        activeRightMargin,
         pendingTopMargin,
         pendingBottomMargin,
+        pendingLeftMargin,
+        pendingRightMargin,
         activeHeaderDistance,
         activeFooterDistance,
         pendingHeaderDistance,
@@ -76914,8 +77274,12 @@ function layoutDocument(blocks, measures, options = {}) {
       layoutLog(`[Layout] ========== END SECTION BREAK ==========`);
       activeTopMargin = updatedState.activeTopMargin;
       activeBottomMargin = updatedState.activeBottomMargin;
+      activeLeftMargin = updatedState.activeLeftMargin;
+      activeRightMargin = updatedState.activeRightMargin;
       pendingTopMargin = updatedState.pendingTopMargin;
       pendingBottomMargin = updatedState.pendingBottomMargin;
+      pendingLeftMargin = updatedState.pendingLeftMargin;
+      pendingRightMargin = updatedState.pendingRightMargin;
       activeHeaderDistance = updatedState.activeHeaderDistance;
       activeFooterDistance = updatedState.activeFooterDistance;
       pendingHeaderDistance = updatedState.pendingHeaderDistance;
@@ -77053,8 +77417,8 @@ function layoutDocument(blocks, measures, options = {}) {
           pageMargins: {
             top: activeTopMargin,
             bottom: activeBottomMargin,
-            left: margins.left,
-            right: margins.right
+            left: activeLeftMargin,
+            right: activeRightMargin
           },
           columns: getCurrentColumns(),
           placedAnchoredIds
@@ -77076,9 +77440,9 @@ function layoutDocument(blocks, measures, options = {}) {
         const cols = getCurrentColumns();
         let maxWidth;
         if (relativeFrom === "page") {
-          maxWidth = cols.count === 1 ? activePageSize.w - margins.left - margins.right : activePageSize.w;
+          maxWidth = cols.count === 1 ? activePageSize.w - (activeLeftMargin + activeRightMargin) : activePageSize.w;
         } else if (relativeFrom === "margin") {
-          maxWidth = activePageSize.w - margins.left - margins.right;
+          maxWidth = activePageSize.w - (activeLeftMargin + activeRightMargin);
         } else {
           maxWidth = cols.width;
         }
@@ -77238,6 +77602,9 @@ function layoutHeaderFooter(blocks, measures, constraints) {
   if (!Number.isFinite(height) || height <= 0) {
     throw new Error("layoutHeaderFooter: height must be positive");
   }
+  const maxBehindDocOverflow = Math.max(192, height * 4);
+  const minBehindDocY = -maxBehindDocOverflow;
+  const maxBehindDocY = height + maxBehindDocOverflow;
   const marginLeft = constraints.margins?.left ?? 0;
   const transformedBlocks = marginLeft > 0 ? blocks.map((block) => {
     const hasPageRelativeAnchor = (block.kind === "image" || block.kind === "drawing") && block.anchor?.hRelativeFrom === "page" && block.anchor.offsetH != null;
@@ -77268,6 +77635,18 @@ function layoutHeaderFooter(blocks, measures, constraints) {
       if (idx == null) continue;
       const block = blocks[idx];
       const measure = measures[idx];
+      const isAnchoredFragment = (fragment.kind === "image" || fragment.kind === "drawing") && fragment.isAnchored === true;
+      if (isAnchoredFragment) {
+        if (block.kind !== "image" && block.kind !== "drawing") {
+          throw new Error(
+            `Type mismatch: fragment kind is ${fragment.kind} but block kind is ${block.kind} for block ${block.id}`
+          );
+        }
+        const anchoredBlock = block;
+        if (anchoredBlock.anchor?.behindDoc && (fragment.y < minBehindDocY || fragment.y > maxBehindDocY)) {
+          continue;
+        }
+      }
       if (fragment.y < minY) minY = fragment.y;
       let bottom2 = fragment.y;
       if (fragment.kind === "para" && measure?.kind === "paragraph") {
@@ -78265,11 +78644,11 @@ function findWordBoundaries(blocks, pos) {
   if (text.length === 0) return null;
   const clampedPos = Math.max(0, Math.min(localPos, text.length));
   let wordStart = clampedPos;
-  while (wordStart > 0 && isWordChar(text[wordStart - 1])) {
+  while (wordStart > 0 && isWordChar$2(text[wordStart - 1])) {
     wordStart--;
   }
   let wordEnd = clampedPos;
-  while (wordEnd < text.length && isWordChar(text[wordEnd])) {
+  while (wordEnd < text.length && isWordChar$2(text[wordEnd])) {
     wordEnd++;
   }
   if (wordStart === wordEnd) {
@@ -78332,7 +78711,7 @@ function findBlockAtPosition(blocks, pos) {
   }
   return null;
 }
-function isWordChar(char) {
+function isWordChar$2(char) {
   return /[\p{L}\p{N}_]/u.test(char);
 }
 function isWhitespace(char) {
@@ -78367,6 +78746,29 @@ function fontString(run2) {
 function runText(run2) {
   return "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" ? "" : run2.text ?? "";
 }
+const isWordChar$1 = (char) => {
+  if (!char) return false;
+  const code = char.charCodeAt(0);
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || char === "'";
+};
+const capitalizeText$1 = (text, fullText, startOffset) => {
+  if (!text) return text;
+  const hasFullText = typeof startOffset === "number" && fullText != null;
+  let result = "";
+  for (let i = 0; i < text.length; i += 1) {
+    const prevChar = hasFullText ? startOffset + i > 0 ? fullText[startOffset + i - 1] : "" : i > 0 ? text[i - 1] : "";
+    const ch = text[i];
+    result += isWordChar$1(ch) && !isWordChar$1(prevChar) ? ch.toUpperCase() : ch;
+  }
+  return result;
+};
+const applyTextTransform$1 = (text, transform, fullText, startOffset) => {
+  if (!text || !transform || transform === "none") return text;
+  if (transform === "uppercase") return text.toUpperCase();
+  if (transform === "lowercase") return text.toLowerCase();
+  if (transform === "capitalize") return capitalizeText$1(text, fullText, startOffset);
+  return text;
+};
 const DEFAULT_TAB_INTERVAL_TWIPS$1 = 720;
 const TWIPS_PER_INCH$4 = 1440;
 const PX_PER_INCH$3 = 96;
@@ -78375,6 +78777,13 @@ const TAB_EPSILON$1 = 0.1;
 const WIDTH_FUDGE_PX = 0.5;
 const twipsToPx$2 = (twips) => twips / TWIPS_PER_PX$1;
 const pxToTwips$1 = (px) => Math.round(px * TWIPS_PER_PX$1);
+const markerFontString = (run2) => {
+  const size2 = run2?.fontSize ?? 16;
+  const family = run2?.fontFamily ?? "Arial";
+  const italic = run2?.italic ? "italic " : "";
+  const bold = run2?.bold ? "bold " : "";
+  return `${italic}${bold}${size2}px ${family}`.trim();
+};
 const buildTabStopsPx$1 = (indent, tabs, tabIntervalTwips) => {
   const paragraphIndentTwips = {
     left: pxToTwips$1(Math.max(0, indent?.left ?? 0)),
@@ -78405,7 +78814,8 @@ const getNextTabStopPx$1 = (currentX, tabStops, startIndex) => {
 };
 function measureRunSliceWidth(run2, fromChar, toChar) {
   const context = getCtx();
-  const text = runText(run2).slice(fromChar, toChar);
+  const fullText = runText(run2);
+  const text = applyTextTransform$1(fullText.slice(fromChar, toChar), run2.textTransform, fullText, fromChar);
   if (!context) {
     const textRun = isTextRun$2(run2) ? run2 : null;
     const size2 = textRun?.fontSize ?? 16;
@@ -78451,8 +78861,21 @@ function remeasureParagraph(block, maxWidth, firstLineIndent = 0) {
   const contentWidth = Math.max(1, maxWidth - indentLeft - indentRight);
   const markerTextStartX = wordLayout?.marker?.textStartX;
   const textStartPx = typeof markerTextStartX === "number" && Number.isFinite(markerTextStartX) ? markerTextStartX : typeof wordLayout?.textStartPx === "number" && Number.isFinite(wordLayout.textStartPx) ? wordLayout.textStartPx : void 0;
-  const treatAsHanging = textStartPx && indentLeft === 0 && indentHanging === 0;
-  const firstLineWidth = typeof textStartPx === "number" && textStartPx > indentLeft && !treatAsHanging ? Math.max(1, maxWidth - textStartPx - indentRight) : Math.max(1, contentWidth - rawFirstLineOffset);
+  const resolvedTextStartPx = resolveListTextStartPx(
+    wordLayout,
+    indentLeft,
+    indentFirstLine,
+    indentHanging,
+    (markerText, marker) => {
+      const context = getCtx();
+      if (!context) return 0;
+      context.font = markerFontString(marker.run);
+      return context.measureText(markerText).width;
+    }
+  );
+  const effectiveTextStartPx = resolvedTextStartPx ?? textStartPx;
+  const treatAsHanging = !wordLayout?.marker && effectiveTextStartPx && indentLeft === 0 && indentHanging === 0;
+  const firstLineWidth = typeof effectiveTextStartPx === "number" && effectiveTextStartPx > indentLeft && !treatAsHanging ? Math.max(1, maxWidth - effectiveTextStartPx - indentRight) : Math.max(1, contentWidth - rawFirstLineOffset);
   const tabStops = buildTabStopsPx$1(indent, attrs?.tabs, attrs?.tabIntervalTwips);
   let currentRun = 0;
   let currentChar = 0;
@@ -78992,7 +79415,7 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
   if (dirty.deletedBlockIds.length > 0) {
     measureCache.invalidate(dirty.deletedBlockIds);
   }
-  const { measurementWidth, measurementHeight } = resolveMeasurementConstraints(options);
+  const { measurementWidth, measurementHeight } = resolveMeasurementConstraints(options, nextBlocks);
   if (measurementWidth <= 0 || measurementHeight <= 0) {
     throw new Error("incrementalLayout: invalid measurement constraints resolved from options");
   }
@@ -79261,7 +79684,7 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
 const DEFAULT_PAGE_SIZE$1 = { w: 612, h: 792 };
 const DEFAULT_MARGINS$1 = { top: 72, right: 72, bottom: 72, left: 72 };
 const normalizeMargin = (value, fallback) => Number.isFinite(value) ? value : fallback;
-function resolveMeasurementConstraints(options) {
+function resolveMeasurementConstraints(options, blocks) {
   const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE$1;
   const margins = {
     top: normalizeMargin(options.margins?.top, DEFAULT_MARGINS$1.top),
@@ -79269,23 +79692,41 @@ function resolveMeasurementConstraints(options) {
     bottom: normalizeMargin(options.margins?.bottom, DEFAULT_MARGINS$1.bottom),
     left: normalizeMargin(options.margins?.left, DEFAULT_MARGINS$1.left)
   };
-  const contentWidth = pageSize.w - (margins.left + margins.right);
-  const contentHeight = pageSize.h - (margins.top + margins.bottom);
-  const columns = options.columns;
-  if (columns && columns.count > 1) {
+  const baseContentWidth = pageSize.w - (margins.left + margins.right);
+  const baseContentHeight = pageSize.h - (margins.top + margins.bottom);
+  const computeColumnWidth = (contentWidth, columns) => {
+    if (!columns || columns.count <= 1) return contentWidth;
     const gap = Math.max(0, columns.gap ?? 0);
     const totalGap = gap * (columns.count - 1);
-    const columnWidth = (contentWidth - totalGap) / columns.count;
-    if (columnWidth > 0) {
-      return {
-        measurementWidth: columnWidth,
-        measurementHeight: contentHeight
+    return (contentWidth - totalGap) / columns.count;
+  };
+  let measurementWidth = computeColumnWidth(baseContentWidth, options.columns);
+  let measurementHeight = baseContentHeight;
+  if (blocks && blocks.length > 0) {
+    for (const block of blocks) {
+      if (block.kind !== "sectionBreak") continue;
+      const sectionPageSize = block.pageSize ?? pageSize;
+      const sectionMargins = {
+        top: normalizeMargin(block.margins?.top, margins.top),
+        right: normalizeMargin(block.margins?.right, margins.right),
+        bottom: normalizeMargin(block.margins?.bottom, margins.bottom),
+        left: normalizeMargin(block.margins?.left, margins.left)
       };
+      const contentWidth = sectionPageSize.w - (sectionMargins.left + sectionMargins.right);
+      const contentHeight = sectionPageSize.h - (sectionMargins.top + sectionMargins.bottom);
+      if (contentWidth <= 0 || contentHeight <= 0) continue;
+      const columnWidth = computeColumnWidth(contentWidth, block.columns ?? options.columns);
+      if (columnWidth > measurementWidth) {
+        measurementWidth = columnWidth;
+      }
+      if (contentHeight > measurementHeight) {
+        measurementHeight = contentHeight;
+      }
     }
   }
   return {
-    measurementWidth: contentWidth,
-    measurementHeight: contentHeight
+    measurementWidth,
+    measurementHeight
   };
 }
 const serializeHeaderFooterResults = (kind, batch) => {
@@ -81352,6 +81793,7 @@ function isInRegisteredSurface(event) {
   }
   return false;
 }
+const SLASH_MENU_HANDLED_FLAG = "__sdHandledBySlashMenu";
 class PresentationInputBridge {
   /**
    * Creates a new PresentationInputBridge that forwards user input events from the visible layout
@@ -81565,6 +82007,10 @@ forwardCompositionEvent_fn = function(event) {
   __privateMethod$1(this, _PresentationInputBridge_instances, dispatchToTarget_fn).call(this, event, synthetic);
 };
 forwardContextMenu_fn = function(event) {
+  const handledBySlashMenu = Boolean(event[SLASH_MENU_HANDLED_FLAG]);
+  if (handledBySlashMenu) {
+    return;
+  }
   if (!__privateGet$1(this, _isEditable).call(this)) {
     return;
   }
@@ -85258,8 +85704,8 @@ function buildSdtCacheKey(nodeType, attrs, explicitKey) {
   }
   return void 0;
 }
-const DEFAULT_LIST_HANGING_PX$1 = 18;
-const LIST_MARKER_GAP$1 = 8;
+const DEFAULT_LIST_HANGING_PX = 18;
+const LIST_MARKER_GAP = 8;
 const DEFAULT_BULLET_GLYPH = "•";
 const DEFAULT_DECIMAL_PATTERN = "%1.";
 const ASCII_UPPERCASE_A = 65;
@@ -85670,7 +86116,7 @@ function computeWordParagraphLayout(input) {
   let markerBoxWidthPx;
   let markerX;
   if (hasFirstLineIndent) {
-    markerBoxWidthPx = glyphWidthPx != null && glyphWidthPx > 0 ? glyphWidthPx + LIST_MARKER_GAP$1 : DEFAULT_LIST_HANGING_PX$1;
+    markerBoxWidthPx = glyphWidthPx != null && glyphWidthPx > 0 ? glyphWidthPx + LIST_MARKER_GAP : DEFAULT_LIST_HANGING_PX;
     markerX = indentLeftPx + (firstLinePx ?? 0);
     layout.textStartPx = markerX + markerBoxWidthPx;
     layout.hangingPx = 0;
@@ -85770,12 +86216,12 @@ const resolveMarkerBoxWidth = (hangingPxRaw, glyphWidthPx) => {
   let markerBox = Math.max(hangingPxRaw || 0, 0);
   if (markerBox <= 0) {
     if (glyphWidthPx != null && glyphWidthPx > 0) {
-      markerBox = glyphWidthPx + LIST_MARKER_GAP$1;
+      markerBox = glyphWidthPx + LIST_MARKER_GAP;
     } else {
-      markerBox = DEFAULT_LIST_HANGING_PX$1;
+      markerBox = DEFAULT_LIST_HANGING_PX;
     }
-  } else if (glyphWidthPx != null && glyphWidthPx + LIST_MARKER_GAP$1 > markerBox) {
-    markerBox = glyphWidthPx + LIST_MARKER_GAP$1;
+  } else if (glyphWidthPx != null && glyphWidthPx + LIST_MARKER_GAP > markerBox) {
+    markerBox = glyphWidthPx + LIST_MARKER_GAP;
   }
   return markerBox;
 };
@@ -85795,7 +86241,7 @@ const buildMarkerLayout = ({
   textStartX: textStartPx,
   baselineOffsetPx: markerRun.baselineShift ?? 0,
   // Gutter is the small gap between marker and text, not the full marker box width
-  gutterWidthPx: LIST_MARKER_GAP$1,
+  gutterWidthPx: LIST_MARKER_GAP,
   justification: numbering.lvlJc ?? "left",
   suffix: normalizeSuffix$1(numbering.suffix) ?? "tab",
   run: markerRun,
@@ -86487,6 +86933,31 @@ const computeWordLayoutForParagraph = (paragraphAttrs, numberingProps, styleCont
     return null;
   }
 };
+const normalizeWordLayoutForIndent = (wordLayout, paragraphIndent) => {
+  const resolvedIndent = wordLayout.resolvedIndent ?? paragraphIndent ?? {};
+  const indentLeft = isFiniteNumber(resolvedIndent.left) ? resolvedIndent.left : 0;
+  const firstLine = isFiniteNumber(resolvedIndent.firstLine) ? resolvedIndent.firstLine : 0;
+  const hanging = isFiniteNumber(resolvedIndent.hanging) ? resolvedIndent.hanging : 0;
+  const shouldFirstLineIndentMode = firstLine > 0 && !hanging;
+  if (wordLayout.firstLineIndentMode === true && !shouldFirstLineIndentMode) {
+    wordLayout.firstLineIndentMode = false;
+  }
+  if (wordLayout.firstLineIndentMode === true) {
+    if (isFiniteNumber(wordLayout.textStartPx)) {
+      if (wordLayout.marker && (!isFiniteNumber(wordLayout.marker.textStartX) || wordLayout.marker.textStartX !== wordLayout.textStartPx)) {
+        wordLayout.marker.textStartX = wordLayout.textStartPx;
+      }
+    } else if (wordLayout.marker && isFiniteNumber(wordLayout.marker.textStartX)) {
+      wordLayout.textStartPx = wordLayout.marker.textStartX;
+    }
+  } else {
+    wordLayout.textStartPx = indentLeft;
+    if (wordLayout.marker) {
+      wordLayout.marker.textStartX = indentLeft;
+    }
+  }
+  return wordLayout;
+};
 const computeParagraphAttrs = (para, styleContext, listCounterContext, converterContext, hydrationOverride) => {
   const attrs = para.attrs ?? {};
   const paragraphProps = typeof attrs.paragraphProperties === "object" && attrs.paragraphProperties !== null ? attrs.paragraphProperties : {};
@@ -86809,8 +87280,11 @@ const computeParagraphAttrs = (para, styleContext, listCounterContext, converter
     let wordLayout = computeWordLayoutForParagraph(paragraphAttrs, enrichedNumberingProps, styleContext);
     if (!wordLayout && enrichedNumberingProps.resolvedLevelIndent) {
       const resolvedIndentPx = convertIndentTwipsToPx(enrichedNumberingProps.resolvedLevelIndent);
-      const firstLinePx = resolvedIndentPx?.firstLine ?? 0;
-      if (firstLinePx > 0) {
+      const baseIndent = resolvedIndentPx ?? enrichedNumberingProps.resolvedLevelIndent;
+      const mergedIndent = { ...baseIndent, ...paragraphAttrs.indent ?? {} };
+      const firstLinePx = isFiniteNumber(mergedIndent.firstLine) ? mergedIndent.firstLine : 0;
+      const hangingPx = isFiniteNumber(mergedIndent.hanging) ? mergedIndent.hanging : 0;
+      if (firstLinePx > 0 && !hangingPx) {
         wordLayout = {
           // Treat as first-line-indent mode: text starts after the marker+firstLine offset.
           firstLineIndentMode: true,
@@ -86818,10 +87292,13 @@ const computeParagraphAttrs = (para, styleContext, listCounterContext, converter
         };
       }
     }
-    if (wordLayout && (!wordLayout.textStartPx || !Number.isFinite(wordLayout.textStartPx)) && enrichedNumberingProps.resolvedLevelIndent) {
+    if (wordLayout && !Number.isFinite(wordLayout.textStartPx) && enrichedNumberingProps.resolvedLevelIndent) {
       const resolvedIndentPx = convertIndentTwipsToPx(enrichedNumberingProps.resolvedLevelIndent);
-      const firstLinePx = resolvedIndentPx?.firstLine ?? 0;
-      if (firstLinePx > 0) {
+      const baseIndent = resolvedIndentPx ?? enrichedNumberingProps.resolvedLevelIndent;
+      const mergedIndent = { ...baseIndent, ...paragraphAttrs.indent ?? {} };
+      const firstLinePx = isFiniteNumber(mergedIndent.firstLine) ? mergedIndent.firstLine : 0;
+      const hangingPx = isFiniteNumber(mergedIndent.hanging) ? mergedIndent.hanging : 0;
+      if (firstLinePx > 0 && !hangingPx) {
         wordLayout = {
           ...wordLayout,
           firstLineIndentMode: wordLayout.firstLineIndentMode ?? true,
@@ -86841,6 +87318,7 @@ const computeParagraphAttrs = (para, styleContext, listCounterContext, converter
           wordLayout.marker.suffix = listRendering.suffix;
         }
       }
+      wordLayout = normalizeWordLayoutForIndent(wordLayout, paragraphAttrs.indent);
       paragraphAttrs.wordLayout = wordLayout;
     }
     if (enrichedNumberingProps.resolvedLevelIndent) {
@@ -90957,11 +91435,6 @@ function initHeaderFooterRegistry({
     cleanups
   };
 }
-const LIST_MARKER_GAP = 8;
-const MIN_MARKER_GUTTER = 24;
-const DEFAULT_LIST_INDENT_BASE_PX = 24;
-const DEFAULT_LIST_INDENT_STEP_PX = 24;
-const DEFAULT_LIST_HANGING_PX = 18;
 function calculateRotatedBounds(input) {
   const width = Math.max(0, input.width);
   const height = Math.max(0, input.height);
@@ -91225,8 +91698,25 @@ async function measureParagraphBlock(block, maxWidth) {
   const rawTextStartPx = wordLayout?.textStartPx;
   const markerTextStartX = wordLayout?.marker?.textStartX;
   const textStartPx = typeof markerTextStartX === "number" && Number.isFinite(markerTextStartX) ? markerTextStartX : typeof rawTextStartPx === "number" && Number.isFinite(rawTextStartPx) ? rawTextStartPx : void 0;
-  if (typeof textStartPx === "number" && textStartPx > indentLeft) {
-    initialAvailableWidth = Math.max(1, maxWidth - textStartPx - indentRight);
+  const resolvedTextStartPx = resolveListTextStartPx(
+    wordLayout,
+    indentLeft,
+    firstLine,
+    hanging,
+    (markerText, marker) => {
+      const markerRun = {
+        fontFamily: toCssFontFamily(marker.run?.fontFamily) ?? marker.run?.fontFamily ?? "Arial",
+        fontSize: marker.run?.fontSize ?? 16,
+        bold: marker.run?.bold ?? false,
+        italic: marker.run?.italic ?? false
+      };
+      const { font: markerFont } = buildFontString(markerRun);
+      return measureText(markerText, markerFont, ctx2);
+    }
+  );
+  const effectiveTextStartPx = resolvedTextStartPx ?? textStartPx;
+  if (typeof effectiveTextStartPx === "number" && effectiveTextStartPx > indentLeft) {
+    initialAvailableWidth = Math.max(1, maxWidth - effectiveTextStartPx - indentRight);
   } else {
     initialAvailableWidth = Math.max(1, contentWidth - firstLineOffset);
   }
@@ -91313,7 +91803,7 @@ async function measureParagraphBlock(block, maxWidth) {
     pendingTabAlignment = null;
     return startX;
   };
-  const alignSegmentAtTab = (segmentText, font, runContext) => {
+  const alignSegmentAtTab = (segmentText, font, runContext, segmentStartChar) => {
     if (!pendingTabAlignment || !currentLine) return void 0;
     const { val } = pendingTabAlignment;
     let segmentWidth = 0;
@@ -91322,11 +91812,11 @@ async function measureParagraphBlock(block, maxWidth) {
       const idx = segmentText.indexOf(decimalSeparator);
       if (idx >= 0) {
         const beforeText = segmentText.slice(0, idx);
-        beforeDecimalWidth = beforeText.length > 0 ? measureRunWidth(beforeText, font, ctx2, runContext) : 0;
+        beforeDecimalWidth = beforeText.length > 0 ? measureRunWidth(beforeText, font, ctx2, runContext, segmentStartChar) : 0;
       }
-      segmentWidth = segmentText.length > 0 ? measureRunWidth(segmentText, font, ctx2, runContext) : 0;
+      segmentWidth = segmentText.length > 0 ? measureRunWidth(segmentText, font, ctx2, runContext, segmentStartChar) : 0;
     } else if (val === "end" || val === "center") {
-      segmentWidth = segmentText.length > 0 ? measureRunWidth(segmentText, font, ctx2, runContext) : 0;
+      segmentWidth = segmentText.length > 0 ? measureRunWidth(segmentText, font, ctx2, runContext, segmentStartChar) : 0;
     }
     return alignPendingTabForWidth(segmentWidth, beforeDecimalWidth);
   };
@@ -91378,8 +91868,8 @@ async function measureParagraphBlock(block, maxWidth) {
     const { font } = buildFontString(
       lastRun
     );
-    const fullWidth = measureRunWidth(sliceText, font, ctx2, lastRun);
-    const keptWidth = keptText.length > 0 ? measureRunWidth(keptText, font, ctx2, lastRun) : 0;
+    const fullWidth = measureRunWidth(sliceText, font, ctx2, lastRun, sliceStart);
+    const keptWidth = keptText.length > 0 ? measureRunWidth(keptText, font, ctx2, lastRun, sliceStart) : 0;
     const delta = Math.max(0, fullWidth - keptWidth);
     lineToTrim.width = roundValue(Math.max(0, lineToTrim.width - delta));
     lineToTrim.spaceCount = Math.max(0, lineToTrim.spaceCount - trimCount);
@@ -91590,7 +92080,8 @@ async function measureParagraphBlock(block, maxWidth) {
       continue;
     }
     if (isFieldAnnotationRun(run2)) {
-      const displayText = run2.displayLabel || "";
+      const rawDisplayText = run2.displayLabel || "";
+      const displayText = applyTextTransform(rawDisplayText, run2);
       const annotationFontSize = typeof run2.fontSize === "number" ? run2.fontSize : typeof run2.fontSize === "string" ? parseFloat(run2.fontSize) || DEFAULT_FIELD_ANNOTATION_FONT_SIZE : DEFAULT_FIELD_ANNOTATION_FONT_SIZE;
       const annotationFontFamily = run2.fontFamily || "Arial, sans-serif";
       const fontWeight = run2.bold ? "bold" : "normal";
@@ -91693,7 +92184,7 @@ async function measureParagraphBlock(block, maxWidth) {
         const spacesLength = segment.length;
         const spacesStartChar = charPosInRun;
         const spacesEndChar = charPosInRun + spacesLength;
-        const spacesWidth = measureRunWidth(segment, font, ctx2, run2);
+        const spacesWidth = measureRunWidth(segment, font, ctx2, run2, spacesStartChar);
         if (!currentLine) {
           currentLine = {
             fromRun: runIndex,
@@ -91757,7 +92248,7 @@ async function measureParagraphBlock(block, maxWidth) {
       }
       let segmentStartX;
       if (currentLine && pendingTabAlignment) {
-        segmentStartX = alignSegmentAtTab(segment, font, run2);
+        segmentStartX = alignSegmentAtTab(segment, font, run2, charPosInRun);
         if (segmentStartX == null) {
           segmentStartX = currentLine.width;
         }
@@ -91767,7 +92258,7 @@ async function measureParagraphBlock(block, maxWidth) {
         if (word2 === "") {
           const spaceStartChar = charPosInRun;
           const spaceEndChar = charPosInRun + 1;
-          const singleSpaceWidth = measureRunWidth(" ", font, ctx2, run2);
+          const singleSpaceWidth = measureRunWidth(" ", font, ctx2, run2, spaceStartChar);
           if (!currentLine) {
             currentLine = {
               fromRun: runIndex,
@@ -91818,12 +92309,12 @@ async function measureParagraphBlock(block, maxWidth) {
           charPosInRun = spaceEndChar;
           continue;
         }
-        const wordOnlyWidth = measureRunWidth(word2, font, ctx2, run2);
-        const shouldIncludeDelimiterSpace = wordIndex < lastNonEmptyWordIndex;
-        const spaceWidth = shouldIncludeDelimiterSpace ? measureRunWidth(" ", font, ctx2, run2) : 0;
-        const wordCommitWidth = wordOnlyWidth + spaceWidth;
         const wordStartChar = charPosInRun;
+        const wordOnlyWidth = measureRunWidth(word2, font, ctx2, run2, wordStartChar);
+        const shouldIncludeDelimiterSpace = wordIndex < lastNonEmptyWordIndex;
         const wordEndNoSpace = charPosInRun + word2.length;
+        const spaceWidth = shouldIncludeDelimiterSpace ? measureRunWidth(" ", font, ctx2, run2, wordEndNoSpace) : 0;
+        const wordCommitWidth = wordOnlyWidth + spaceWidth;
         const wordEndWithSpace = wordEndNoSpace + (shouldIncludeDelimiterSpace ? 1 : 0);
         const effectiveMaxWidth = currentLine ? currentLine.maxWidth : getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : contentWidth);
         if (wordOnlyWidth > effectiveMaxWidth && word2.length > 1) {
@@ -91842,7 +92333,7 @@ async function measureParagraphBlock(block, maxWidth) {
           const hasTabOnlyLine = currentLine && currentLine.segments && currentLine.segments.length === 0 && currentLine.width > 0;
           const remainingWidthAfterTab = hasTabOnlyLine ? currentLine.maxWidth - currentLine.width : lineMaxWidth;
           const chunkWidth = hasTabOnlyLine ? Math.max(remainingWidthAfterTab, lineMaxWidth * 0.25) : lineMaxWidth;
-          const chunks = breakWordIntoChunks(word2, chunkWidth - WIDTH_FUDGE_PX2, font, ctx2, run2);
+          const chunks = breakWordIntoChunks(word2, chunkWidth - WIDTH_FUDGE_PX2, font, ctx2, run2, wordStartChar);
           let chunkCharOffset = wordStartChar;
           for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
             const chunk = chunks[chunkIndex];
@@ -91966,7 +92457,7 @@ async function measureParagraphBlock(block, maxWidth) {
             if (candidateSpaces > 0) {
               const overflow = totalWidthWithWord - availableWidth;
               if (overflow > 0) {
-                const baseSpaceWidth = spaceWidth || measureRunWidth(" ", font, ctx2, run2) || Math.max(1, boundarySpacing);
+                const baseSpaceWidth = spaceWidth || measureRunWidth(" ", font, ctx2, run2, wordEndNoSpace) || Math.max(1, boundarySpacing);
                 const perSpaceCompression = overflow / candidateSpaces;
                 const maxPerSpaceCompression = baseSpaceWidth * 0.25;
                 if (perSpaceCompression <= maxPerSpaceCompression) {
@@ -92141,8 +92632,8 @@ async function measureParagraphBlock(block, maxWidth) {
     const { font: markerFont } = buildFontString(markerRun);
     const markerText = wordLayout.marker.markerText ?? "";
     const glyphWidth = markerText ? measureText(markerText, markerFont, ctx2) : 0;
-    const gutter = typeof wordLayout.marker.gutterWidthPx === "number" && isFinite(wordLayout.marker.gutterWidthPx) && wordLayout.marker.gutterWidthPx >= 0 ? wordLayout.marker.gutterWidthPx : LIST_MARKER_GAP;
-    const markerBoxWidth = Math.max(wordLayout.marker.markerBoxWidthPx ?? 0, glyphWidth + LIST_MARKER_GAP);
+    const gutter = typeof wordLayout.marker.gutterWidthPx === "number" && isFinite(wordLayout.marker.gutterWidthPx) && wordLayout.marker.gutterWidthPx >= 0 ? wordLayout.marker.gutterWidthPx : LIST_MARKER_GAP$1;
+    const markerBoxWidth = Math.max(wordLayout.marker.markerBoxWidthPx ?? 0, glyphWidth + LIST_MARKER_GAP$1);
     markerInfo = {
       markerWidth: markerBoxWidth,
       markerTextWidth: glyphWidth,
@@ -92486,7 +92977,7 @@ async function measureListBlock(block, constraints) {
       markerTextWidth = markerText ? measureText(markerText, markerFont, ctx2) : 0;
       indentLeft = resolveIndentLeft(item);
       const indentHanging = resolveIndentHanging(item);
-      markerWidth = Math.max(MIN_MARKER_GUTTER, markerTextWidth + LIST_MARKER_GAP, indentHanging);
+      markerWidth = Math.max(MIN_MARKER_GUTTER, markerTextWidth + LIST_MARKER_GAP$1, indentHanging);
     }
     const paragraphWidth = Math.max(1, constraints.maxWidth - indentLeft - markerWidth);
     const paragraphMeasure = await measureParagraphBlock(item.paragraph, paragraphWidth);
@@ -92512,16 +93003,46 @@ const getPrimaryRun = (paragraph) => {
     fontSize: 16
   };
 };
-const measureRunWidth = (text, font, ctx2, run2) => {
+const isWordChar = (char) => {
+  if (!char) return false;
+  const code = char.charCodeAt(0);
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || char === "'";
+};
+const capitalizeText = (text, fullText, startOffset) => {
+  if (!text) return text;
+  const hasFullText = typeof startOffset === "number" && fullText != null;
+  let result = "";
+  for (let i = 0; i < text.length; i += 1) {
+    const prevChar = hasFullText ? startOffset + i > 0 ? fullText[startOffset + i - 1] : "" : i > 0 ? text[i - 1] : "";
+    const ch = text[i];
+    result += isWordChar(ch) && !isWordChar(prevChar) ? ch.toUpperCase() : ch;
+  }
+  return result;
+};
+const applyTextTransform = (text, run2, startOffset) => {
+  const transform = run2.textTransform;
+  if (!text || !transform || transform === "none") return text;
+  if (transform === "uppercase") return text.toUpperCase();
+  if (transform === "lowercase") return text.toLowerCase();
+  if (transform === "capitalize") {
+    const fullText = "text" in run2 && typeof run2.text === "string" ? run2.text : text;
+    return capitalizeText(text, fullText, startOffset);
+  }
+  return text;
+};
+const measureRunWidth = (text, font, ctx2, run2, startOffset) => {
   const letterSpacing = run2.kind === "text" || run2.kind === void 0 ? run2.letterSpacing || 0 : 0;
-  const width = getMeasuredTextWidth(text, font, letterSpacing, ctx2);
+  const displayText = applyTextTransform(text, run2, startOffset);
+  const width = getMeasuredTextWidth(displayText, font, letterSpacing, ctx2);
   return roundValue(width);
 };
-const breakWordIntoChunks = (word2, maxWidth, font, ctx2, run2) => {
+const breakWordIntoChunks = (word2, maxWidth, font, ctx2, run2, startOffset) => {
   const chunks = [];
+  const baseOffset = typeof startOffset === "number" ? startOffset : 0;
   if (maxWidth <= 0) {
-    for (const char of word2) {
-      const charWidth = measureRunWidth(char, font, ctx2, run2);
+    for (let i = 0; i < word2.length; i++) {
+      const char = word2[i];
+      const charWidth = measureRunWidth(char, font, ctx2, run2, baseOffset + i);
       chunks.push({ text: char, width: charWidth });
     }
     return chunks;
@@ -92531,11 +93052,11 @@ const breakWordIntoChunks = (word2, maxWidth, font, ctx2, run2) => {
   for (let i = 0; i < word2.length; i++) {
     const char = word2[i];
     const testChunk = currentChunk + char;
-    const testWidth = measureRunWidth(testChunk, font, ctx2, run2);
+    const testWidth = measureRunWidth(testChunk, font, ctx2, run2, baseOffset);
     if (testWidth > maxWidth && currentChunk.length > 0) {
       chunks.push({ text: currentChunk, width: currentWidth });
       currentChunk = char;
-      currentWidth = measureRunWidth(char, font, ctx2, run2);
+      currentWidth = measureRunWidth(char, font, ctx2, run2, baseOffset + i);
     } else {
       currentChunk = testChunk;
       currentWidth = testWidth;
@@ -92589,7 +93110,8 @@ const measureDropCap = (ctx2, descriptor, spacing) => {
     italic: run2.italic
   });
   ctx2.font = font;
-  const metrics = ctx2.measureText(run2.text);
+  const displayText = applyTextTransform(run2.text, run2);
+  const metrics = ctx2.measureText(displayText);
   const advanceWidth = metrics.width;
   const paintedWidth = (metrics.actualBoundingBoxLeft || 0) + (metrics.actualBoundingBoxRight || 0);
   const textWidth = Math.max(advanceWidth, paintedWidth);
@@ -92615,7 +93137,7 @@ const resolveIndentHanging = (item) => {
   if (indentHanging > 0) {
     return indentHanging;
   }
-  return DEFAULT_LIST_HANGING_PX;
+  return DEFAULT_LIST_HANGING_PX$1;
 };
 const buildTabStopsPx = (indent, tabs, tabIntervalTwips) => {
   const paragraphIndentTwips = {
@@ -92821,6 +93343,9 @@ const _PresentationEditor = class _PresentationEditor2 extends EventEmitter$1 {
       if (event.button !== 0) {
         return;
       }
+      if (event.ctrlKey && navigator.platform.includes("Mac")) {
+        return;
+      }
       __privateSet(this, _pendingMarginClick, null);
       const target = event.target;
       if (target?.closest?.(".superdoc-ruler-handle") != null) {
@@ -98230,6 +98755,8 @@ const SlashMenu = Extension.create({
                   const cbRect = containingBlock.getBoundingClientRect();
                   left2 -= cbRect.left;
                   top2 -= cbRect.top;
+                  left2 += containingBlock.scrollLeft || 0;
+                  top2 += containingBlock.scrollTop || 0;
                 } catch (error) {
                   console.warn("SlashMenu: Failed to adjust for containing block", error);
                 }
@@ -129568,7 +130095,7 @@ const _sfc_main$8 = {
       if (open) {
         nextTick(() => {
           if (searchInput.value) {
-            searchInput.value.focus();
+            searchInput.value.focus({ preventScroll: true });
           }
         });
       }
@@ -129673,15 +130200,31 @@ const _sfc_main$8 = {
     };
     const handleGlobalOutsideClick = (event) => {
       if (isOpen.value && menuRef.value && !menuRef.value.contains(event.target)) {
-        moveCursorToMouseEvent(event, props.editor);
+        const isCtrlClickOnMac = event.ctrlKey && isMacOS();
+        const isLeftClick = event.button === 0 && !isCtrlClickOnMac;
+        if (isLeftClick) {
+          moveCursorToMouseEvent(event, props.editor);
+        }
         closeMenu({ restoreCursor: false });
       }
     };
-    const handleRightClick = async (event) => {
+    const shouldHandleContextMenu = (event) => {
       const readOnly = !props.editor?.isEditable;
       const contextMenuDisabled = props.editor?.options?.disableContextMenu;
       const bypass = shouldBypassContextMenu(event);
-      if (readOnly || contextMenuDisabled || bypass) {
+      return !readOnly && !contextMenuDisabled && !bypass;
+    };
+    const handleRightClickCapture = (event) => {
+      try {
+        if (shouldHandleContextMenu(event)) {
+          event[SLASH_MENU_HANDLED_FLAG] = true;
+        }
+      } catch (error) {
+        console.warn("[SlashMenu] Error in capture phase context menu handler:", error);
+      }
+    };
+    const handleRightClick = async (event) => {
+      if (!shouldHandleContextMenu(event)) {
         return;
       }
       event.preventDefault();
@@ -129792,6 +130335,7 @@ const _sfc_main$8 = {
       props.editor.on("slashMenu:open", slashMenuOpenHandler);
       contextMenuTarget = getEditorSurfaceElement(props.editor);
       if (contextMenuTarget) {
+        contextMenuTarget.addEventListener("contextmenu", handleRightClickCapture, true);
         contextMenuTarget.addEventListener("contextmenu", handleRightClick);
       }
       slashMenuCloseHandler = () => {
@@ -129815,6 +130359,7 @@ const _sfc_main$8 = {
             props.editor.off("slashMenu:close", slashMenuCloseHandler);
           }
           props.editor.off("update", handleEditorUpdate);
+          contextMenuTarget?.removeEventListener("contextmenu", handleRightClickCapture, true);
           contextMenuTarget?.removeEventListener("contextmenu", handleRightClick);
         } catch (error) {
           console.warn("[SlashMenu] Error during cleanup:", error);
@@ -131781,6 +132326,12 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
       if (props.options?.suppressSkeletonLoader || !props.options?.collaborationProvider) editorReady.value = true;
     });
     const handleMarginClick = (event) => {
+      if (event.button !== 0) {
+        return;
+      }
+      if (event.ctrlKey && isMacOS()) {
+        return;
+      }
       if (event.target.classList.contains("ProseMirror")) return;
       onMarginClickCursorChange(event, activeEditor.value);
     };
@@ -131919,7 +132470,7 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const SuperEditor = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-209a1e8b"]]);
+const SuperEditor = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-c9a3c876"]]);
 const _hoisted_1 = ["innerHTML"];
 const _sfc_main = {
   __name: "SuperInput",