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

package/dist/superdoc.umd.js

@@ -42428,7 +42428,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     static getStoredSuperdocVersion(docx) {
       return _SuperConverter2.getStoredCustomProperty(docx, "SuperdocVersion");
     }
-    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "2.0.0-next.2") {
+    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "2.0.0-next.4") {
       return _SuperConverter2.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
     }
     /**
@@ -68384,7 +68384,7 @@ ${err.toString()}`);
   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) {
@@ -69173,7 +69173,7 @@ ${err.toString()}`);
         { default: remarkStringify2 },
         { default: remarkGfm2 }
       ] = await Promise.all([
-        Promise.resolve().then(() => indexBqPa6D4q),
+        Promise.resolve().then(() => indexYoL4XmHs),
         Promise.resolve().then(() => indexDRCvimau),
         Promise.resolve().then(() => indexC_x_N6Uh),
         Promise.resolve().then(() => indexD_sWOSiG),
@@ -69378,7 +69378,7 @@ ${err.toString()}`);
      * 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");
@@ -76630,7 +76630,7 @@ ${l}
     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";
@@ -77557,6 +77557,7 @@ ${l}
         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;
@@ -77635,7 +77636,7 @@ ${l}
                 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;
                 }
@@ -77662,6 +77663,21 @@ ${l}
           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;
@@ -77787,7 +77803,7 @@ ${l}
                   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;
                   }
@@ -79321,6 +79337,23 @@ ${l}
       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;
@@ -81514,6 +81547,28 @@ ${l}
   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 code2 = char.charCodeAt(0);
+    return code2 >= 48 && code2 <= 57 || code2 >= 65 && code2 <= 90 || code2 >= 97 && code2 <= 122 || char === "'";
+  };
+  const capitalizeText$2 = (text2) => {
+    if (!text2) return text2;
+    let result = "";
+    for (let i2 = 0; i2 < text2.length; i2 += 1) {
+      const prevChar = i2 > 0 ? text2[i2 - 1] : "";
+      const ch = text2[i2];
+      result += isWordChar$3(ch) && !isWordChar$3(prevChar) ? ch.toUpperCase() : ch;
+    }
+    return result;
+  };
+  const applyTextTransform$2 = (text2, transform) => {
+    if (!text2 || !transform || transform === "none") return text2;
+    if (transform === "uppercase") return text2.toUpperCase();
+    if (transform === "lowercase") return text2.toLowerCase();
+    if (transform === "capitalize") return capitalizeText$2(text2);
+    return text2;
+  };
   function getMeasurementContext() {
     if (measurementCtx) return measurementCtx;
     if (typeof document === "undefined") {
@@ -81689,17 +81744,19 @@ ${l}
       }
       const text2 = "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" ? "" : run2.text ?? "";
       const runLength = text2.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(text2, transform);
       if (currentCharOffset + runLength >= charOffset) {
         const offsetInRun = charOffset - currentCharOffset;
         ctx2.font = getRunFontString(run2);
-        const textUpToTarget = text2.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(text2.slice(0, offsetInRun)) : 0;
         return alignmentOffset + currentX + measured2.width + spacingWidth + justify.extraPerSpace * (spaceTally + spacesInPortion);
       }
       ctx2.font = getRunFontString(run2);
-      const measured = ctx2.measureText(text2);
+      const measured = ctx2.measureText(displayText);
       const runLetterSpacing = computeLetterSpacingWidth(run2, runLength, runLength);
       const spacesInRun = justify.extraPerSpace !== 0 ? countSpaces(text2) : 0;
       currentX += measured.width + runLetterSpacing + justify.extraPerSpace * spacesInRun;
@@ -81738,8 +81795,10 @@ ${l}
           return segmentBaseX + (offsetInSegment >= segmentChars ? segment.width ?? 0 : 0);
         }
         const text2 = run2.text ?? "";
-        const segmentText = text2.slice(segment.fromChar, segment.toChar);
-        const textUpToTarget = segmentText.slice(0, offsetInSegment);
+        const transform = "textTransform" in run2 ? run2.textTransform : void 0;
+        const displayText = applyTextTransform$2(text2, 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);
@@ -81835,12 +81894,14 @@ ${l}
       }
       const text2 = "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation" ? "" : run2.text ?? "";
       const runLength = text2.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(text2, transform);
       if (runLength === 0) continue;
       ctx2.font = getRunFontString(run2);
       for (let i2 = 0; i2 <= runLength; i2++) {
-        const textUpToChar = text2.slice(0, i2);
+        const textUpToChar = displayText.slice(0, i2);
         const measured2 = ctx2.measureText(textUpToChar);
-        const spacesInPortion = justify.extraPerSpace > 0 ? countSpaces(textUpToChar) : 0;
+        const spacesInPortion = justify.extraPerSpace > 0 ? countSpaces(text2.slice(0, i2)) : 0;
         const charX = currentX + measured2.width + computeLetterSpacingWidth(run2, i2, runLength) + justify.extraPerSpace * (spaceTally + spacesInPortion);
         if (charX >= safeX) {
           if (i2 === 0) {
@@ -81850,7 +81911,7 @@ ${l}
               pmPosition: pmPosition3
             };
           }
-          const prevText = text2.slice(0, i2 - 1);
+          const prevText = displayText.slice(0, i2 - 1);
           const prevMeasured = ctx2.measureText(prevText);
           const prevX = currentX + prevMeasured.width + computeLetterSpacingWidth(run2, i2 - 1, runLength);
           const distToPrev = Math.abs(safeX - prevX);
@@ -81863,7 +81924,7 @@ ${l}
           };
         }
       }
-      const measured = ctx2.measureText(text2);
+      const measured = ctx2.measureText(displayText);
       const runLetterSpacing = computeLetterSpacingWidth(run2, runLength, runLength);
       const spacesInRun = justify.extraPerSpace > 0 ? countSpaces(text2) : 0;
       currentX += measured.width + runLetterSpacing + justify.extraPerSpace * spacesInRun;
@@ -82294,6 +82355,83 @@ ${l}
     }
     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;
@@ -82326,9 +82464,16 @@ ${l}
     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;
     }
@@ -82484,7 +82629,10 @@ ${l}
   }
   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) {
@@ -82497,7 +82645,7 @@ ${l}
         }
         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,
@@ -82531,7 +82679,7 @@ ${l}
         }
         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,
@@ -82579,7 +82727,7 @@ ${l}
         }
         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") {
@@ -82618,6 +82766,22 @@ ${l}
       },
       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);
       }
     };
   }
@@ -82717,7 +82881,14 @@ ${l}
       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 };
@@ -82765,20 +82936,36 @@ ${l}
         next2.activeOrientation = block.orientation;
         next2.pendingOrientation = null;
       }
+      const headerDistance = typeof block.margins?.header === "number" ? Math.max(0, block.margins.header) : next2.activeHeaderDistance;
+      const footerDistance = typeof block.margins?.footer === "number" ? Math.max(0, block.margins.footer) : next2.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);
         next2.activeHeaderDistance = headerDistance;
         next2.pendingHeaderDistance = headerDistance;
-        next2.activeTopMargin = calcRequiredTopMargin(headerDistance, baseMargins.top);
-        next2.pendingTopMargin = next2.activeTopMargin;
       }
       if (block.margins?.footer !== void 0) {
-        const footerDistance = Math.max(0, block.margins.footer);
         next2.activeFooterDistance = footerDistance;
         next2.pendingFooterDistance = footerDistance;
-        next2.activeBottomMargin = calcRequiredBottomMargin(footerDistance, baseMargins.bottom);
+      }
+      if (block.margins?.top !== void 0 || block.margins?.header !== void 0) {
+        next2.activeTopMargin = calcRequiredTopMargin(headerDistance, sectionTop);
+        next2.pendingTopMargin = next2.activeTopMargin;
+      }
+      if (block.margins?.bottom !== void 0 || block.margins?.footer !== void 0) {
+        next2.activeBottomMargin = calcRequiredBottomMargin(footerDistance, sectionBottom);
         next2.pendingBottomMargin = next2.activeBottomMargin;
       }
+      if (block.margins?.left !== void 0) {
+        const leftMargin = Math.max(0, block.margins.left);
+        next2.activeLeftMargin = leftMargin;
+        next2.pendingLeftMargin = leftMargin;
+      }
+      if (block.margins?.right !== void 0) {
+        const rightMargin = Math.max(0, block.margins.right);
+        next2.activeRightMargin = rightMargin;
+        next2.pendingRightMargin = rightMargin;
+      }
       if (block.columns) {
         next2.activeColumns = { count: block.columns.count, gap: block.columns.gap };
         next2.pendingColumns = null;
@@ -82787,26 +82974,42 @@ ${l}
     }
     const headerPx = block.margins?.header;
     const footerPx = block.margins?.footer;
+    const topPx = block.margins?.top;
+    const bottomPx = block.margins?.bottom;
     const nextTop = next2.pendingTopMargin ?? next2.activeTopMargin;
     const nextBottom = next2.pendingBottomMargin ?? next2.activeBottomMargin;
+    const nextLeft = next2.pendingLeftMargin ?? next2.activeLeftMargin;
+    const nextRight = next2.pendingRightMargin ?? next2.activeRightMargin;
     const nextHeader = next2.pendingHeaderDistance ?? next2.activeHeaderDistance;
     const nextFooter = next2.pendingFooterDistance ?? next2.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;
       next2.pendingHeaderDistance = newHeaderDist;
-      next2.pendingTopMargin = calcRequiredTopMargin(newHeaderDist, baseMargins.top);
+      next2.pendingTopMargin = calcRequiredTopMargin(newHeaderDist, sectionTop);
     } else {
       next2.pendingTopMargin = nextTop;
       next2.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;
       next2.pendingFooterDistance = newFooterDist;
-      next2.pendingBottomMargin = calcRequiredBottomMargin(newFooterDist, baseMargins.bottom);
+      next2.pendingBottomMargin = calcRequiredBottomMargin(newFooterDist, sectionBottom);
     } else {
       next2.pendingBottomMargin = nextBottom;
       next2.pendingFooterDistance = nextFooter;
     }
+    if (typeof block.margins?.left === "number") {
+      next2.pendingLeftMargin = Math.max(0, block.margins.left);
+    } else {
+      next2.pendingLeftMargin = nextLeft;
+    }
+    if (typeof block.margins?.right === "number") {
+      next2.pendingRightMargin = Math.max(0, block.margins.right);
+    } else {
+      next2.pendingRightMargin = nextRight;
+    }
     if (block.pageSize) {
       next2.pendingPageSize = { w: block.pageSize.w, h: block.pageSize.h };
     }
@@ -82866,6 +83069,12 @@ ${l}
     if (next2.pendingBottomMargin != null) {
       next2.activeBottomMargin = next2.pendingBottomMargin;
     }
+    if (next2.pendingLeftMargin != null) {
+      next2.activeLeftMargin = next2.pendingLeftMargin;
+    }
+    if (next2.pendingRightMargin != null) {
+      next2.activeRightMargin = next2.pendingRightMargin;
+    }
     if (next2.pendingHeaderDistance != null) {
       next2.activeHeaderDistance = next2.pendingHeaderDistance;
     }
@@ -82883,6 +83092,8 @@ ${l}
     }
     next2.pendingTopMargin = null;
     next2.pendingBottomMargin = null;
+    next2.pendingLeftMargin = null;
+    next2.pendingRightMargin = null;
     next2.pendingHeaderDistance = null;
     next2.pendingFooterDistance = null;
     next2.pendingPageSize = null;
@@ -83111,7 +83322,8 @@ ${l}
     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;
@@ -83193,7 +83405,8 @@ ${l}
       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;
       }
     }
@@ -83537,6 +83750,94 @@ ${l}
   function getCellTotalLines(cell2) {
     return getCellLines(cell2).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(cell2, cellMeasure, fromLine, toLine) {
+    const range2 = {};
+    if (!cell2 || !cellMeasure) return range2;
+    const cellBlocks = cell2.blocks ?? (cell2.paragraph ? [cell2.paragraph] : []);
+    const blockMeasures = cellMeasure.blocks ?? (cellMeasure.paragraph ? [cellMeasure.paragraph] : []);
+    const maxBlocks = Math.min(cellBlocks.length, blockMeasures.length);
+    let cumulativeLineCount = 0;
+    for (let i2 = 0; i2 < maxBlocks; i2++) {
+      const block = cellBlocks[i2];
+      const blockMeasure = blockMeasures[i2];
+      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 row2 = block.rows[rowIndex];
+      const rowMeasure = measure.rows[rowIndex];
+      if (!row2 || !rowMeasure) continue;
+      const isPartial = partialRow?.rowIndex === rowIndex;
+      const cellCount = Math.min(row2.cells.length, rowMeasure.cells.length);
+      for (let cellIndex = 0; cellIndex < cellCount; cellIndex++) {
+        const cell2 = row2.cells[cellIndex];
+        const cellMeasure = rowMeasure.cells[cellIndex];
+        if (!cell2 || !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(cell2, 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 row2 = measure.rows[rowIndex];
     if (!row2) {
@@ -83681,6 +83982,7 @@ ${l}
       height,
       metadata
     };
+    applyTableFragmentPmRange(fragment, context.block, context.measure);
     state2.page.fragments.push(fragment);
     state2.cursorY += height;
   }
@@ -83759,6 +84061,7 @@ ${l}
         height,
         metadata
       };
+      applyTableFragmentPmRange(fragment, block, measure);
       state2.page.fragments.push(fragment);
       state2.cursorY += height;
       return;
@@ -83822,6 +84125,7 @@ ${l}
             partialRow: continuationPartialRow,
             metadata: generateFragmentMetadata(measure)
           };
+          applyTableFragmentPmRange(fragment2, block, measure);
           state2.page.fragments.push(fragment2);
           state2.cursorY += fragmentHeight2;
         }
@@ -83866,6 +84170,7 @@ ${l}
           partialRow: forcedPartialRow,
           metadata: generateFragmentMetadata(measure)
         };
+        applyTableFragmentPmRange(fragment2, block, measure);
         state2.page.fragments.push(fragment2);
         state2.cursorY += fragmentHeight2;
         pendingPartialRow = forcedPartialRow;
@@ -83901,6 +84206,7 @@ ${l}
         partialRow: partialRow || void 0,
         metadata: generateFragmentMetadata(measure)
       };
+      applyTableFragmentPmRange(fragment, block, measure);
       state2.page.fragments.push(fragment);
       state2.cursorY += fragmentHeight;
       if (partialRow && !partialRow.isLastPart) {
@@ -83918,7 +84224,7 @@ ${l}
       columnBoundaries: generateColumnBoundaries(measure),
       coordinateSystem: "fragment"
     };
-    return {
+    const fragment = {
       kind: "table",
       blockId: block.id,
       fromRow: 0,
@@ -83929,6 +84235,8 @@ ${l}
       height: measure.totalHeight ?? 0,
       metadata
     };
+    applyTableFragmentPmRange(fragment, block, measure);
+    return fragment;
   }
   function isPageRelativeAnchor(block) {
     const vRelativeFrom = block.anchor?.vRelativeFrom;
@@ -84350,8 +84658,8 @@ ${l}
       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) => {
@@ -84381,8 +84689,12 @@ ${l}
     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;
@@ -84395,10 +84707,11 @@ ${l}
     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(blocks2);
     const scheduleSectionBreakCompat = (block, state2, baseMargins) => {
@@ -84415,22 +84728,38 @@ ${l}
           next2.activeOrientation = block.orientation;
           next2.pendingOrientation = null;
         }
+        const headerDistance2 = typeof block.margins?.header === "number" ? Math.max(0, block.margins.header) : next2.activeHeaderDistance;
+        const footerDistance2 = typeof block.margins?.footer === "number" ? Math.max(0, block.margins.footer) : next2.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);
-          next2.activeHeaderDistance = headerDist;
-          next2.pendingHeaderDistance = headerDist;
-          const requiredTop = maxHeaderContentHeight > 0 ? headerDist + maxHeaderContentHeight : headerDist;
-          next2.activeTopMargin = Math.max(baseMargins.top, requiredTop);
-          next2.pendingTopMargin = next2.activeTopMargin;
+          next2.activeHeaderDistance = headerDistance2;
+          next2.pendingHeaderDistance = headerDistance2;
         }
         if (block.margins?.footer !== void 0) {
-          const footerDistance2 = Math.max(0, block.margins.footer);
           next2.activeFooterDistance = footerDistance2;
           next2.pendingFooterDistance = footerDistance2;
+        }
+        if (block.margins?.top !== void 0 || block.margins?.header !== void 0) {
+          const requiredTop = maxHeaderContentHeight > 0 ? headerDistance2 + maxHeaderContentHeight : headerDistance2;
+          next2.activeTopMargin = Math.max(sectionTop, requiredTop);
+          next2.pendingTopMargin = next2.activeTopMargin;
+        }
+        if (block.margins?.bottom !== void 0 || block.margins?.footer !== void 0) {
           const requiredBottom = maxFooterContentHeight > 0 ? footerDistance2 + maxFooterContentHeight : footerDistance2;
-          next2.activeBottomMargin = Math.max(baseMargins.bottom, requiredBottom);
+          next2.activeBottomMargin = Math.max(sectionBottom, requiredBottom);
           next2.pendingBottomMargin = next2.activeBottomMargin;
         }
+        if (block.margins?.left !== void 0) {
+          const leftMargin = Math.max(0, block.margins.left);
+          next2.activeLeftMargin = leftMargin;
+          next2.pendingLeftMargin = leftMargin;
+        }
+        if (block.margins?.right !== void 0) {
+          const rightMargin = Math.max(0, block.margins.right);
+          next2.activeRightMargin = rightMargin;
+          next2.pendingRightMargin = rightMargin;
+        }
         if (block.columns) {
           next2.activeColumns = { count: block.columns.count, gap: block.columns.gap };
           next2.pendingColumns = null;
@@ -84459,27 +84788,35 @@ ${l}
       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 = next2.pendingTopMargin ?? next2.activeTopMargin;
       const nextBottom = next2.pendingBottomMargin ?? next2.activeBottomMargin;
+      const nextLeft = next2.pendingLeftMargin ?? next2.activeLeftMargin;
+      const nextRight = next2.pendingRightMargin ?? next2.activeRightMargin;
       const nextHeader = next2.pendingHeaderDistance ?? next2.activeHeaderDistance;
       const nextFooter = next2.pendingFooterDistance ?? next2.activeFooterDistance;
       next2.pendingHeaderDistance = typeof headerPx === "number" ? Math.max(0, headerPx) : nextHeader;
       next2.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 = next2.pendingHeaderDistance;
         const requiredTop = maxHeaderContentHeight > 0 ? sectionHeader + maxHeaderContentHeight : sectionHeader;
         next2.pendingTopMargin = Math.max(sectionTop, requiredTop);
       } else {
         next2.pendingTopMargin = nextTop;
       }
-      if (typeof footerPx === "number") {
+      if (typeof footerPx === "number" || typeof bottomPx === "number") {
         const sectionFooter = next2.pendingFooterDistance;
+        const sectionBottom = typeof bottomPx === "number" ? Math.max(0, bottomPx) : baseMargins.bottom;
         const requiredBottom = maxFooterContentHeight > 0 ? sectionFooter + maxFooterContentHeight : sectionFooter;
-        next2.pendingBottomMargin = Math.max(baseMargins.bottom, requiredBottom);
+        next2.pendingBottomMargin = Math.max(sectionBottom, requiredBottom);
       } else {
         next2.pendingBottomMargin = nextBottom;
       }
+      next2.pendingLeftMargin = typeof leftPx === "number" ? Math.max(0, leftPx) : nextLeft;
+      next2.pendingRightMargin = typeof rightPx === "number" ? Math.max(0, rightPx) : nextRight;
       if (block.pageSize) next2.pendingPageSize = { w: block.pageSize.w, h: block.pageSize.h };
       if (block.orientation) next2.pendingOrientation = block.orientation;
       const sectionType = block.type ?? "continuous";
@@ -84564,7 +84901,7 @@ ${l}
     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,
@@ -84579,8 +84916,12 @@ ${l}
           const applied = applyPendingToActive({
             activeTopMargin,
             activeBottomMargin,
+            activeLeftMargin,
+            activeRightMargin,
             pendingTopMargin,
             pendingBottomMargin,
+            pendingLeftMargin,
+            pendingRightMargin,
             activeHeaderDistance,
             activeFooterDistance,
             pendingHeaderDistance,
@@ -84595,8 +84936,12 @@ ${l}
           });
           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;
@@ -84608,6 +84953,14 @@ ${l}
           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)) {
@@ -84652,7 +85005,7 @@ ${l}
     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;
@@ -84685,6 +85038,12 @@ ${l}
       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(blocks2, measures);
     const anchoredTablesByParagraph = collectAnchoredTables(blocks2, measures);
@@ -84716,10 +85075,10 @@ ${l}
         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;
@@ -84730,11 +85089,11 @@ ${l}
       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 });
     }
@@ -84772,8 +85131,12 @@ ${l}
         const sectionState = {
           activeTopMargin,
           activeBottomMargin,
+          activeLeftMargin,
+          activeRightMargin,
           pendingTopMargin,
           pendingBottomMargin,
+          pendingLeftMargin,
+          pendingRightMargin,
           activeHeaderDistance,
           activeFooterDistance,
           pendingHeaderDistance,
@@ -84807,8 +85170,12 @@ ${l}
         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;
@@ -84946,8 +85313,8 @@ ${l}
             pageMargins: {
               top: activeTopMargin,
               bottom: activeBottomMargin,
-              left: margins.left,
-              right: margins.right
+              left: activeLeftMargin,
+              right: activeRightMargin
             },
             columns: getCurrentColumns(),
             placedAnchoredIds
@@ -84969,9 +85336,9 @@ ${l}
           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;
           }
@@ -86158,11 +86525,11 @@ ${l}
     if (text2.length === 0) return null;
     const clampedPos = Math.max(0, Math.min(localPos, text2.length));
     let wordStart = clampedPos;
-    while (wordStart > 0 && isWordChar(text2[wordStart - 1])) {
+    while (wordStart > 0 && isWordChar$2(text2[wordStart - 1])) {
       wordStart--;
     }
     let wordEnd = clampedPos;
-    while (wordEnd < text2.length && isWordChar(text2[wordEnd])) {
+    while (wordEnd < text2.length && isWordChar$2(text2[wordEnd])) {
       wordEnd++;
     }
     if (wordStart === wordEnd) {
@@ -86225,7 +86592,7 @@ ${l}
     }
     return null;
   }
-  function isWordChar(char) {
+  function isWordChar$2(char) {
     return /[\p{L}\p{N}_]/u.test(char);
   }
   function isWhitespace$1(char) {
@@ -86260,6 +86627,29 @@ ${l}
   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 code2 = char.charCodeAt(0);
+    return code2 >= 48 && code2 <= 57 || code2 >= 65 && code2 <= 90 || code2 >= 97 && code2 <= 122 || char === "'";
+  };
+  const capitalizeText$1 = (text2, fullText, startOffset) => {
+    if (!text2) return text2;
+    const hasFullText = typeof startOffset === "number" && fullText != null;
+    let result = "";
+    for (let i2 = 0; i2 < text2.length; i2 += 1) {
+      const prevChar = hasFullText ? startOffset + i2 > 0 ? fullText[startOffset + i2 - 1] : "" : i2 > 0 ? text2[i2 - 1] : "";
+      const ch = text2[i2];
+      result += isWordChar$1(ch) && !isWordChar$1(prevChar) ? ch.toUpperCase() : ch;
+    }
+    return result;
+  };
+  const applyTextTransform$1 = (text2, transform, fullText, startOffset) => {
+    if (!text2 || !transform || transform === "none") return text2;
+    if (transform === "uppercase") return text2.toUpperCase();
+    if (transform === "lowercase") return text2.toLowerCase();
+    if (transform === "capitalize") return capitalizeText$1(text2, fullText, startOffset);
+    return text2;
+  };
   const DEFAULT_TAB_INTERVAL_TWIPS$1 = 720;
   const TWIPS_PER_INCH$4 = 1440;
   const PX_PER_INCH$3 = 96;
@@ -86268,6 +86658,13 @@ ${l}
   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 = (indent2, tabs, tabIntervalTwips) => {
     const paragraphIndentTwips = {
       left: pxToTwips$1(Math.max(0, indent2?.left ?? 0)),
@@ -86298,7 +86695,9 @@ ${l}
   };
   function measureRunSliceWidth(run2, fromChar, toChar) {
     const context = getCtx();
-    const text2 = runText(run2).slice(fromChar, toChar);
+    const fullText = runText(run2);
+    const transform = isTextRun$2(run2) ? run2.textTransform : void 0;
+    const text2 = applyTextTransform$1(fullText.slice(fromChar, toChar), transform, fullText, fromChar);
     if (!context) {
       const textRun = isTextRun$2(run2) ? run2 : null;
       const size2 = textRun?.fontSize ?? 16;
@@ -86344,8 +86743,21 @@ ${l}
     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(indent2, attrs?.tabs, attrs?.tabIntervalTwips);
     let currentRun = 0;
     let currentChar = 0;
@@ -86885,7 +87297,7 @@ ${l}
     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");
     }
@@ -87154,7 +87566,7 @@ ${l}
   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, blocks2) {
     const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE$1;
     const margins = {
       top: normalizeMargin(options.margins?.top, DEFAULT_MARGINS$1.top),
@@ -87162,23 +87574,41 @@ ${l}
       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 (blocks2 && blocks2.length > 0) {
+      for (const block of blocks2) {
+        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, batch2) => {
@@ -89568,14 +89998,15 @@ ${l}
     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 [];
     }
@@ -93156,8 +93587,8 @@ ${l}
     }
     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;
@@ -93568,7 +93999,7 @@ ${l}
     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;
@@ -93668,12 +94099,12 @@ ${l}
     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;
   };
@@ -93693,7 +94124,7 @@ ${l}
     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,
@@ -94385,6 +94816,31 @@ ${l}
       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 : {};
@@ -94707,8 +95163,11 @@ ${l}
       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,
@@ -94716,10 +95175,13 @@ ${l}
           };
         }
       }
-      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,
@@ -94739,6 +95201,7 @@ ${l}
             wordLayout.marker.suffix = listRendering.suffix;
           }
         }
+        wordLayout = normalizeWordLayoutForIndent(wordLayout, paragraphAttrs.indent);
         paragraphAttrs.wordLayout = wordLayout;
       }
       if (enrichedNumberingProps.resolvedLevelIndent) {
@@ -98855,11 +99318,6 @@ ${l}
       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(input2) {
     const width = Math.max(0, input2.width);
     const height = Math.max(0, input2.height);
@@ -99123,8 +99581,25 @@ ${l}
     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);
     }
@@ -99211,7 +99686,7 @@ ${l}
       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;
@@ -99220,11 +99695,11 @@ ${l}
         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);
     };
@@ -99276,8 +99751,8 @@ ${l}
       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);
@@ -99488,7 +99963,8 @@ ${l}
         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";
@@ -99591,7 +100067,7 @@ ${l}
           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,
@@ -99655,7 +100131,7 @@ ${l}
         }
         let segmentStartX;
         if (currentLine && pendingTabAlignment) {
-          segmentStartX = alignSegmentAtTab(segment, font, run2);
+          segmentStartX = alignSegmentAtTab(segment, font, run2, charPosInRun);
           if (segmentStartX == null) {
             segmentStartX = currentLine.width;
           }
@@ -99665,7 +100141,7 @@ ${l}
           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,
@@ -99716,12 +100192,12 @@ ${l}
             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) {
@@ -99740,7 +100216,7 @@ ${l}
             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];
@@ -99864,7 +100340,7 @@ ${l}
               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) {
@@ -100039,8 +100515,8 @@ ${l}
       const { font: markerFont } = buildFontString(markerRun);
       const markerText = wordLayout.marker.markerText ?? "";
       const glyphWidth = markerText ? measureText(markerText, markerFont, ctx2) : 0;
-      const gutter = typeof wordLayout.marker.gutterWidthPx === "number" && isFinite(wordLayout.marker.gutterWidthPx) && wordLayout.marker.gutterWidthPx >= 0 ? wordLayout.marker.gutterWidthPx : LIST_MARKER_GAP;
-      const markerBoxWidth = Math.max(wordLayout.marker.markerBoxWidthPx ?? 0, glyphWidth + LIST_MARKER_GAP);
+      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,
@@ -100384,7 +100860,7 @@ ${l}
         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);
@@ -100410,16 +100886,46 @@ ${l}
       fontSize: 16
     };
   };
-  const measureRunWidth = (text2, font, ctx2, run2) => {
+  const isWordChar = (char) => {
+    if (!char) return false;
+    const code2 = char.charCodeAt(0);
+    return code2 >= 48 && code2 <= 57 || code2 >= 65 && code2 <= 90 || code2 >= 97 && code2 <= 122 || char === "'";
+  };
+  const capitalizeText = (text2, fullText, startOffset) => {
+    if (!text2) return text2;
+    const hasFullText = typeof startOffset === "number" && fullText != null;
+    let result = "";
+    for (let i2 = 0; i2 < text2.length; i2 += 1) {
+      const prevChar = hasFullText ? startOffset + i2 > 0 ? fullText[startOffset + i2 - 1] : "" : i2 > 0 ? text2[i2 - 1] : "";
+      const ch = text2[i2];
+      result += isWordChar(ch) && !isWordChar(prevChar) ? ch.toUpperCase() : ch;
+    }
+    return result;
+  };
+  const applyTextTransform = (text2, run2, startOffset) => {
+    const transform = "textTransform" in run2 ? run2.textTransform : void 0;
+    if (!text2 || !transform || transform === "none") return text2;
+    if (transform === "uppercase") return text2.toUpperCase();
+    if (transform === "lowercase") return text2.toLowerCase();
+    if (transform === "capitalize") {
+      const fullText = "text" in run2 && typeof run2.text === "string" ? run2.text : text2;
+      return capitalizeText(text2, fullText, startOffset);
+    }
+    return text2;
+  };
+  const measureRunWidth = (text2, font, ctx2, run2, startOffset) => {
     const letterSpacing = run2.kind === "text" || run2.kind === void 0 ? run2.letterSpacing || 0 : 0;
-    const width = getMeasuredTextWidth(text2, font, letterSpacing, ctx2);
+    const displayText = applyTextTransform(text2, 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 i2 = 0; i2 < word2.length; i2++) {
+        const char = word2[i2];
+        const charWidth = measureRunWidth(char, font, ctx2, run2, baseOffset + i2);
         chunks.push({ text: char, width: charWidth });
       }
       return chunks;
@@ -100429,11 +100935,11 @@ ${l}
     for (let i2 = 0; i2 < word2.length; i2++) {
       const char = word2[i2];
       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 + i2);
       } else {
         currentChunk = testChunk;
         currentWidth = testWidth;
@@ -100487,7 +100993,8 @@ ${l}
       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);
@@ -100513,7 +101020,7 @@ ${l}
     if (indentHanging > 0) {
       return indentHanging;
     }
-    return DEFAULT_LIST_HANGING_PX;
+    return DEFAULT_LIST_HANGING_PX$1;
   };
   const buildTabStopsPx = (indent2, tabs, tabIntervalTwips) => {
     const paragraphIndentTwips = {
@@ -157258,7 +157765,7 @@ ${style2}
       this.config.colors = shuffleArray(this.config.colors);
       this.userColorMap = /* @__PURE__ */ new Map();
       this.colorIndex = 0;
-      this.version = "2.0.0-next.2";
+      this.version = "2.0.0-next.4";
       this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config2.superdocId || v4();
       this.colors = this.config.colors;
@@ -159731,7 +160238,7 @@ ${style2}
       value && typeof value === "object" && "byteLength" in value && "byteOffset" in value
     );
   }
-  const indexBqPa6D4q = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  const indexYoL4XmHs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     __proto__: null,
     unified
   }, Symbol.toStringTag, { value: "Module" }));