@harbour-enterprises/superdoc 2.0.0-next.2 → 2.0.0-next.4

package/dist/chunks/{super-editor.es-BM-ulSRj.cjs → super-editor.es-CeYiIfGN.cjs}

@@ -42427,7 +42427,7 @@ const _SuperConverter = class _SuperConverter2 {
   static getStoredSuperdocVersion(docx) {
     return _SuperConverter2.getStoredCustomProperty(docx, "SuperdocVersion");
   }
-  static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "2.0.0-next.2") {
+  static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "2.0.0-next.4") {
     return _SuperConverter2.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
   }
   /**
@@ -60508,7 +60508,7 @@ const isHeadless = (editor) => {
 const shouldSkipNodeView = (editor) => {
   return isHeadless(editor);
 };
-const summaryVersion = "2.0.0-next.2";
+const summaryVersion = "2.0.0-next.4";
 const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
 const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
 function mapAttributes(attrs) {
@@ -61297,7 +61297,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
       { default: remarkStringify },
       { default: remarkGfm }
     ] = await Promise.all([
-      Promise.resolve().then(() => require("./index-BqPa6D4q-Dulj8zfc.cjs")),
+      Promise.resolve().then(() => require("./index-YoL4XmHs-DgX6YU__.cjs")),
       Promise.resolve().then(() => require("./index-DRCvimau-H4Ck3S9a.cjs")),
       Promise.resolve().then(() => require("./index-C_x_N6Uh-Db3CUJMX.cjs")),
       Promise.resolve().then(() => require("./index-D_sWOSiG-BtDZzJ6I.cjs")),
@@ -61502,7 +61502,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
    * Process collaboration migrations
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "2.0.0-next.2");
+    console.debug("[checkVersionMigrations] Current editor version", "2.0.0-next.4");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -68754,7 +68754,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";
@@ -69681,6 +69681,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;
@@ -69759,7 +69760,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;
               }
@@ -69786,6 +69787,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;
@@ -69911,7 +69927,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;
                 }
@@ -71445,6 +71461,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;
@@ -73638,6 +73671,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") {
@@ -73813,17 +73868,19 @@ 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 transform = isTabRun$1(run2) || "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" ? void 0 : run2.textTransform;
+    const displayText = applyTextTransform$2(text, transform);
     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;
@@ -73862,8 +73919,10 @@ 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 transform = "textTransform" in run2 ? run2.textTransform : void 0;
+      const displayText = applyTextTransform$2(text, transform);
+      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);
@@ -73959,12 +74018,14 @@ 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 transform = isTabRun$1(run2) || "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" ? void 0 : run2.textTransform;
+    const displayText = applyTextTransform$2(text, transform);
     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) {
@@ -73974,7 +74035,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);
@@ -73987,7 +74048,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;
@@ -74418,6 +74479,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 !== void 0 && markerTextWidth < 0) {
+    markerTextWidth = markerBoxWidth;
+  }
+  const finalMarkerTextWidth = Math.max(0, markerTextWidth ?? 0);
+  let markerStartPos;
+  if (wordLayout?.firstLineIndentMode === true && typeof marker.markerX === "number" && Number.isFinite(marker.markerX)) {
+    markerStartPos = marker.markerX;
+  } else {
+    markerStartPos = indentLeft - hanging + firstLine;
+  }
+  if (!Number.isFinite(markerStartPos)) {
+    markerStartPos = 0;
+  }
+  const currentPos = markerStartPos + finalMarkerTextWidth;
+  const suffix2 = marker.suffix ?? "tab";
+  if (suffix2 === "space") {
+    return markerStartPos + finalMarkerTextWidth + SPACE_SUFFIX_GAP_PX;
+  }
+  if (suffix2 === "nothing") {
+    return markerStartPos + finalMarkerTextWidth;
+  }
+  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 + finalMarkerTextWidth + 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 + finalMarkerTextWidth + 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 + finalMarkerTextWidth + tabWidth;
+}
 function getWordLayoutConfig(block) {
   if (!block || block.kind !== "paragraph") {
     return void 0;
@@ -74450,9 +74588,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;
   }
@@ -74608,7 +74753,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) {
@@ -74621,7 +74769,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,
@@ -74655,7 +74803,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,
@@ -74703,7 +74851,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") {
@@ -74742,6 +74890,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);
     }
   };
 }
@@ -74841,7 +75005,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 };
@@ -74889,20 +75060,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;
@@ -74911,26 +75098,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 };
   }
@@ -74990,6 +75193,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;
   }
@@ -75007,6 +75216,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;
@@ -75235,7 +75446,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;
@@ -75317,7 +75529,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;
     }
   }
@@ -75661,6 +75874,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) {
@@ -75805,6 +76106,7 @@ function layoutMonolithicTable(context) {
     height,
     metadata
   };
+  applyTableFragmentPmRange(fragment, context.block, context.measure);
   state2.page.fragments.push(fragment);
   state2.cursorY += height;
 }
@@ -75883,6 +76185,7 @@ function layoutTableBlock({
       height,
       metadata
     };
+    applyTableFragmentPmRange(fragment, block, measure);
     state2.page.fragments.push(fragment);
     state2.cursorY += height;
     return;
@@ -75946,6 +76249,7 @@ function layoutTableBlock({
           partialRow: continuationPartialRow,
           metadata: generateFragmentMetadata(measure)
         };
+        applyTableFragmentPmRange(fragment2, block, measure);
         state2.page.fragments.push(fragment2);
         state2.cursorY += fragmentHeight2;
       }
@@ -75990,6 +76294,7 @@ function layoutTableBlock({
         partialRow: forcedPartialRow,
         metadata: generateFragmentMetadata(measure)
       };
+      applyTableFragmentPmRange(fragment2, block, measure);
       state2.page.fragments.push(fragment2);
       state2.cursorY += fragmentHeight2;
       pendingPartialRow = forcedPartialRow;
@@ -76025,6 +76330,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) {
@@ -76042,7 +76348,7 @@ function createAnchoredTableFragment(block, measure, x2, y2) {
     columnBoundaries: generateColumnBoundaries(measure),
     coordinateSystem: "fragment"
   };
-  return {
+  const fragment = {
     kind: "table",
     blockId: block.id,
     fromRow: 0,
@@ -76053,6 +76359,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;
@@ -76474,8 +76782,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) => {
@@ -76505,8 +76813,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;
@@ -76519,10 +76831,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) => {
@@ -76539,22 +76852,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;
@@ -76583,27 +76912,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";
@@ -76688,7 +77025,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,
@@ -76703,8 +77040,12 @@ function layoutDocument(blocks, measures, options = {}) {
         const applied = applyPendingToActive({
           activeTopMargin,
           activeBottomMargin,
+          activeLeftMargin,
+          activeRightMargin,
           pendingTopMargin,
           pendingBottomMargin,
+          pendingLeftMargin,
+          pendingRightMargin,
           activeHeaderDistance,
           activeFooterDistance,
           pendingHeaderDistance,
@@ -76719,8 +77060,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;
@@ -76732,6 +77077,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)) {
@@ -76776,7 +77129,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;
@@ -76809,6 +77162,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);
@@ -76840,10 +77199,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;
@@ -76854,11 +77213,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 });
   }
@@ -76896,8 +77255,12 @@ function layoutDocument(blocks, measures, options = {}) {
       const sectionState = {
         activeTopMargin,
         activeBottomMargin,
+        activeLeftMargin,
+        activeRightMargin,
         pendingTopMargin,
         pendingBottomMargin,
+        pendingLeftMargin,
+        pendingRightMargin,
         activeHeaderDistance,
         activeFooterDistance,
         pendingHeaderDistance,
@@ -76931,8 +77294,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;
@@ -77070,8 +77437,8 @@ function layoutDocument(blocks, measures, options = {}) {
           pageMargins: {
             top: activeTopMargin,
             bottom: activeBottomMargin,
-            left: margins.left,
-            right: margins.right
+            left: activeLeftMargin,
+            right: activeRightMargin
           },
           columns: getCurrentColumns(),
           placedAnchoredIds
@@ -77093,9 +77460,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;
         }
@@ -78282,11 +78649,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) {
@@ -78349,7 +78716,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) {
@@ -78384,6 +78751,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;
@@ -78392,6 +78782,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)),
@@ -78422,7 +78819,9 @@ 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 transform = isTextRun$2(run2) ? run2.textTransform : void 0;
+  const text = applyTextTransform$1(fullText.slice(fromChar, toChar), transform, fullText, fromChar);
   if (!context) {
     const textRun = isTextRun$2(run2) ? run2 : null;
     const size2 = textRun?.fontSize ?? 16;
@@ -78468,8 +78867,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;
@@ -79009,7 +79421,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");
   }
@@ -79278,7 +79690,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),
@@ -79286,23 +79698,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) => {
@@ -81692,14 +82122,15 @@ function getAtomNodeTypes(schema) {
   if (!schema) return [];
   const types2 = [];
   try {
-    schema.nodes.forEach((nodeType, name) => {
+    for (const name in schema.nodes) {
       if (name === "text") {
-        return;
+        continue;
       }
-      if (nodeType.isAtom || nodeType.isLeaf) {
+      const nodeType = schema.nodes[name];
+      if (nodeType && (nodeType.isAtom || nodeType.isLeaf)) {
         types2.push(name);
       }
-    });
+    }
   } catch {
     return [];
   }
@@ -85280,8 +85711,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;
@@ -85692,7 +86123,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;
@@ -85792,12 +86223,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;
 };
@@ -85817,7 +86248,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,
@@ -86509,6 +86940,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 : {};
@@ -86831,8 +87287,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,
@@ -86840,10 +87299,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,
@@ -86863,6 +87325,7 @@ const computeParagraphAttrs = (para, styleContext, listCounterContext, converter
           wordLayout.marker.suffix = listRendering.suffix;
         }
       }
+      wordLayout = normalizeWordLayoutForIndent(wordLayout, paragraphAttrs.indent);
       paragraphAttrs.wordLayout = wordLayout;
     }
     if (enrichedNumberingProps.resolvedLevelIndent) {
@@ -90979,11 +91442,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);
@@ -91247,8 +91705,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);
   }
@@ -91335,7 +91810,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;
@@ -91344,11 +91819,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);
   };
@@ -91400,8 +91875,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);
@@ -91612,7 +92087,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";
@@ -91715,7 +92191,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,
@@ -91779,7 +92255,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;
         }
@@ -91789,7 +92265,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,
@@ -91840,12 +92316,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) {
@@ -91864,7 +92340,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];
@@ -91988,7 +92464,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) {
@@ -92163,8 +92639,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,
@@ -92508,7 +92984,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);
@@ -92534,16 +93010,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 = "textTransform" in run2 ? run2.textTransform : void 0;
+  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;
@@ -92553,11 +93059,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;
@@ -92611,7 +93117,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);
@@ -92637,7 +93144,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 = {