@harbour-enterprises/superdoc 1.3.0-next.4 → 1.3.0-next.6

package/dist/chunks/{index-Buh63pW6.cjs → index-C4RVDXKX.cjs}

@@ -1,7 +1,7 @@
 "use strict";
 const jszip = require("./jszip-C8_CqJxM.cjs");
 const helpers$1 = require("./helpers-nOdwpmwb.cjs");
-const superEditor_converter = require("./SuperConverter-qB6m0K1X.cjs");
+const superEditor_converter = require("./SuperConverter-BdOf8skU.cjs");
 const vue = require("./vue-De9wkgLl.cjs");
 require("./jszip.min-BPh2MMAa.cjs");
 const eventemitter3 = require("./eventemitter3-BQuRcMPI.cjs");
@@ -15351,7 +15351,7 @@ const canUseDOM = () => {
     return false;
   }
 };
-const summaryVersion = "1.3.0-next.4";
+const summaryVersion = "1.3.0-next.6";
 const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
 const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
 function mapAttributes(attrs) {
@@ -17984,7 +17984,7 @@ class Editor extends EventEmitter {
    * Process collaboration migrations
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "1.3.0-next.4");
+    console.debug("[checkVersionMigrations] Current editor version", "1.3.0-next.6");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -30859,8 +30859,7 @@ function getHeaderFooterTypeForSection(pageNumber, sectionIndex, identifier, opt
   const titlePgEnabled = sectionTitlePg === true;
   const isFirstPageOfSection = sectionPageNumber === 1;
   if (isFirstPageOfSection && titlePgEnabled) {
-    if (hasFirst) return "first";
-    if (!hasDefault && !hasEven && !hasOdd) return null;
+    if (hasFirst || hasDefault || hasEven || hasOdd) return "first";
     return null;
   }
   if (identifier.alternateHeaders) {
@@ -32916,6 +32915,45 @@ function layoutDocument(blocks, measures, options = {}) {
     return height;
   };
   const headerContentHeights = options.headerContentHeights;
+  const footerContentHeights = options.footerContentHeights;
+  const headerContentHeightsByRId = options.headerContentHeightsByRId;
+  const footerContentHeightsByRId = options.footerContentHeightsByRId;
+  const getVariantTypeForPage = (sectionPageNumber, titlePgEnabled, alternateHeaders) => {
+    if (sectionPageNumber === 1 && titlePgEnabled) {
+      return "first";
+    }
+    return "default";
+  };
+  const getHeaderHeightForPage = (variantType, headerRef) => {
+    if (headerRef && headerContentHeightsByRId?.has(headerRef)) {
+      return validateContentHeight(headerContentHeightsByRId.get(headerRef));
+    }
+    if (headerContentHeights) {
+      return validateContentHeight(headerContentHeights[variantType]);
+    }
+    return 0;
+  };
+  const getFooterHeightForPage = (variantType, footerRef) => {
+    if (footerRef && footerContentHeightsByRId?.has(footerRef)) {
+      return validateContentHeight(footerContentHeightsByRId.get(footerRef));
+    }
+    if (footerContentHeights) {
+      return validateContentHeight(footerContentHeights[variantType]);
+    }
+    return 0;
+  };
+  const calculateEffectiveTopMargin = (headerContentHeight, currentHeaderDistance, baseTopMargin) => {
+    if (headerContentHeight > 0) {
+      return Math.max(baseTopMargin, currentHeaderDistance + headerContentHeight);
+    }
+    return baseTopMargin;
+  };
+  const calculateEffectiveBottomMargin = (footerContentHeight, currentFooterDistance, baseBottomMargin) => {
+    if (footerContentHeight > 0) {
+      return Math.max(baseBottomMargin, currentFooterDistance + footerContentHeight);
+    }
+    return baseBottomMargin;
+  };
   const maxHeaderContentHeight = headerContentHeights ? Math.max(
     0,
     validateContentHeight(headerContentHeights.default),
@@ -32923,9 +32961,6 @@ function layoutDocument(blocks, measures, options = {}) {
     validateContentHeight(headerContentHeights.even),
     validateContentHeight(headerContentHeights.odd)
   ) : 0;
-  const headerDistance = margins.header ?? margins.top;
-  const effectiveTopMargin = maxHeaderContentHeight > 0 ? Math.max(margins.top, headerDistance + maxHeaderContentHeight) : margins.top;
-  const footerContentHeights = options.footerContentHeights;
   const maxFooterContentHeight = footerContentHeights ? Math.max(
     0,
     validateContentHeight(footerContentHeights.default),
@@ -32933,8 +32968,12 @@ function layoutDocument(blocks, measures, options = {}) {
     validateContentHeight(footerContentHeights.even),
     validateContentHeight(footerContentHeights.odd)
   ) : 0;
+  const headerDistance = margins.header ?? margins.top;
   const footerDistance = margins.footer ?? margins.bottom;
-  const effectiveBottomMargin = maxFooterContentHeight > 0 ? Math.max(margins.bottom, footerDistance + maxFooterContentHeight) : margins.bottom;
+  const defaultHeaderHeight = getHeaderHeightForPage("default", void 0);
+  const defaultFooterHeight = getFooterHeightForPage("default", void 0);
+  const effectiveTopMargin = calculateEffectiveTopMargin(defaultHeaderHeight, headerDistance, margins.top);
+  const effectiveBottomMargin = calculateEffectiveBottomMargin(defaultFooterHeight, footerDistance, margins.bottom);
   let activeTopMargin = effectiveTopMargin;
   let activeBottomMargin = effectiveBottomMargin;
   let activeLeftMargin = margins.left;
@@ -32943,6 +32982,10 @@ function layoutDocument(blocks, measures, options = {}) {
   let pendingBottomMargin = null;
   let pendingLeftMargin = null;
   let pendingRightMargin = null;
+  let activeSectionBaseTopMargin = margins.top;
+  let activeSectionBaseBottomMargin = margins.bottom;
+  let pendingSectionBaseTopMargin = null;
+  let pendingSectionBaseBottomMargin = null;
   let activeHeaderDistance = margins.header ?? margins.top;
   let pendingHeaderDistance = null;
   let activeFooterDistance = margins.footer ?? margins.bottom;
@@ -33148,6 +33191,7 @@ function layoutDocument(blocks, measures, options = {}) {
   }
   let activeSectionIndex = initialSectionMetadata?.sectionIndex ?? 0;
   let pendingSectionIndex = null;
+  const sectionFirstPageNumbers = /* @__PURE__ */ new Map();
   const paginator = createPaginator({
     margins: paginatorMargins,
     getActiveTopMargin: () => activeTopMargin,
@@ -33161,6 +33205,7 @@ function layoutDocument(blocks, measures, options = {}) {
     createPage,
     onNewPage: (state) => {
       if (!state) {
+        const isEnteringNewSection = pendingSectionIndex !== null;
         const applied = applyPendingToActive({
           activeTopMargin,
           activeBottomMargin,
@@ -33228,7 +33273,69 @@ function layoutDocument(blocks, measures, options = {}) {
           activeVAlign = pendingVAlign;
           pendingVAlign = null;
         }
+        if (pendingSectionBaseTopMargin !== null) {
+          activeSectionBaseTopMargin = pendingSectionBaseTopMargin;
+          pendingSectionBaseTopMargin = null;
+        }
+        if (pendingSectionBaseBottomMargin !== null) {
+          activeSectionBaseBottomMargin = pendingSectionBaseBottomMargin;
+          pendingSectionBaseBottomMargin = null;
+        }
         pageCount += 1;
+        const newPageNumber = pageCount;
+        if (isEnteringNewSection || !sectionFirstPageNumbers.has(activeSectionIndex)) {
+          sectionFirstPageNumbers.set(activeSectionIndex, newPageNumber);
+        }
+        const firstPageInSection = sectionFirstPageNumbers.get(activeSectionIndex) ?? newPageNumber;
+        const sectionPageNumber = newPageNumber - firstPageInSection + 1;
+        const sectionMetadata = sectionMetadataList[activeSectionIndex];
+        const titlePgEnabled = sectionMetadata?.titlePg ?? false;
+        const variantType = getVariantTypeForPage(sectionPageNumber, titlePgEnabled);
+        let headerRef = activeSectionRefs?.headerRefs?.[variantType];
+        let footerRef = activeSectionRefs?.footerRefs?.[variantType];
+        let effectiveVariantType = variantType;
+        if (!headerRef && variantType !== "default" && activeSectionIndex > 0) {
+          const prevSectionMetadata = sectionMetadataList[activeSectionIndex - 1];
+          if (prevSectionMetadata?.headerRefs?.[variantType]) {
+            headerRef = prevSectionMetadata.headerRefs[variantType];
+            layoutLog(
+              `[Layout] Page ${newPageNumber}: Inheriting header '${variantType}' from section ${activeSectionIndex - 1}: ${headerRef}`
+            );
+          }
+        }
+        if (!footerRef && variantType !== "default" && activeSectionIndex > 0) {
+          const prevSectionMetadata = sectionMetadataList[activeSectionIndex - 1];
+          if (prevSectionMetadata?.footerRefs?.[variantType]) {
+            footerRef = prevSectionMetadata.footerRefs[variantType];
+            layoutLog(
+              `[Layout] Page ${newPageNumber}: Inheriting footer '${variantType}' from section ${activeSectionIndex - 1}: ${footerRef}`
+            );
+          }
+        }
+        if (!headerRef && variantType !== "default" && activeSectionRefs?.headerRefs?.default) {
+          headerRef = activeSectionRefs.headerRefs.default;
+          effectiveVariantType = "default";
+        }
+        if (!footerRef && variantType !== "default" && activeSectionRefs?.footerRefs?.default) {
+          footerRef = activeSectionRefs.footerRefs.default;
+        }
+        const headerHeight = getHeaderHeightForPage(effectiveVariantType, headerRef);
+        const footerHeight = getFooterHeightForPage(
+          variantType !== "default" && !activeSectionRefs?.footerRefs?.[variantType] ? "default" : variantType,
+          footerRef
+        );
+        activeTopMargin = calculateEffectiveTopMargin(headerHeight, activeHeaderDistance, activeSectionBaseTopMargin);
+        activeBottomMargin = calculateEffectiveBottomMargin(
+          footerHeight,
+          activeFooterDistance,
+          activeSectionBaseBottomMargin
+        );
+        layoutLog(
+          `[Layout] Page ${newPageNumber}: Using variant '${variantType}' - headerHeight: ${headerHeight}, footerHeight: ${footerHeight}`
+        );
+        layoutLog(
+          `[Layout] Page ${newPageNumber}: Adjusted margins - top: ${activeTopMargin}, bottom: ${activeBottomMargin} (base: ${activeSectionBaseTopMargin}, ${activeSectionBaseBottomMargin})`
+        );
         return;
       }
       if (state?.page) {
@@ -33434,6 +33541,20 @@ function layoutDocument(blocks, measures, options = {}) {
       pendingColumns = updatedState.pendingColumns;
       activeOrientation = updatedState.activeOrientation;
       pendingOrientation = updatedState.pendingOrientation;
+      const isFirstSection = effectiveBlock.attrs?.isFirstSection && states.length === 0;
+      const blockTopMargin = effectiveBlock.margins?.top;
+      const blockBottomMargin = effectiveBlock.margins?.bottom;
+      if (isFirstSection) {
+        activeSectionBaseTopMargin = typeof blockTopMargin === "number" ? blockTopMargin : margins.top;
+        activeSectionBaseBottomMargin = typeof blockBottomMargin === "number" ? blockBottomMargin : margins.bottom;
+      } else if (blockTopMargin !== void 0 || blockBottomMargin !== void 0) {
+        if (blockTopMargin !== void 0) {
+          pendingSectionBaseTopMargin = typeof blockTopMargin === "number" ? blockTopMargin : margins.top;
+        }
+        if (blockBottomMargin !== void 0) {
+          pendingSectionBaseBottomMargin = typeof blockBottomMargin === "number" ? blockBottomMargin : margins.bottom;
+        }
+      }
       if (effectiveBlock.vAlign) {
         const isFirstSection2 = effectiveBlock.attrs?.isFirstSection && states.length === 0;
         if (isFirstSection2) {
@@ -33452,7 +33573,6 @@ function layoutDocument(blocks, measures, options = {}) {
       }
       const sectionIndexRaw = effectiveBlock.attrs?.sectionIndex;
       const metadataIndex = typeof sectionIndexRaw === "number" ? sectionIndexRaw : Number(sectionIndexRaw ?? NaN);
-      const isFirstSection = effectiveBlock.attrs?.isFirstSection && states.length === 0;
       if (Number.isFinite(metadataIndex)) {
         if (isFirstSection) {
           activeSectionIndex = metadataIndex;
@@ -35640,6 +35760,7 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
     `[Perf] 4.1 Measure all blocks: ${(measureEnd - measureStart).toFixed(2)}ms (${cacheMisses} measured, ${cacheHits} cached)`
   );
   let headerContentHeights;
+  let headerContentHeightsByRId;
   const hasHeaderBlocks = headerFooter?.headerBlocks && Object.keys(headerFooter.headerBlocks).length > 0;
   const hasHeaderBlocksByRId = headerFooter?.headerBlocksByRId && headerFooter.headerBlocksByRId.size > 0;
   if (headerFooter?.constraints && (hasHeaderBlocks || hasHeaderBlocksByRId)) {
@@ -35679,7 +35800,8 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
       }
     }
     if (hasHeaderBlocksByRId && headerFooter.headerBlocksByRId) {
-      for (const [_rId, blocks] of headerFooter.headerBlocksByRId) {
+      headerContentHeightsByRId = /* @__PURE__ */ new Map();
+      for (const [rId, blocks] of headerFooter.headerBlocksByRId) {
         if (!blocks || blocks.length === 0) continue;
         const measureConstraints = {
           maxWidth: headerFooter.constraints.width,
@@ -35691,8 +35813,7 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
           height: headerFooter.constraints.height
         });
         if (layout2.height > 0) {
-          const currentDefault = headerContentHeights.default ?? 0;
-          headerContentHeights.default = Math.max(currentDefault, layout2.height);
+          headerContentHeightsByRId.set(rId, layout2.height);
         }
       }
     }
@@ -35700,6 +35821,7 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
     perfLog(`[Perf] 4.1.5 Pre-layout headers for height: ${(hfPreEnd - hfPreStart).toFixed(2)}ms`);
   }
   let footerContentHeights;
+  let footerContentHeightsByRId;
   const hasFooterBlocks = headerFooter?.footerBlocks && Object.keys(headerFooter.footerBlocks).length > 0;
   const hasFooterBlocksByRId = headerFooter?.footerBlocksByRId && headerFooter.footerBlocksByRId.size > 0;
   if (headerFooter?.constraints && (hasFooterBlocks || hasFooterBlocksByRId)) {
@@ -35742,7 +35864,8 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
         }
       }
       if (hasFooterBlocksByRId && headerFooter.footerBlocksByRId) {
-        for (const [_rId, blocks] of headerFooter.footerBlocksByRId) {
+        footerContentHeightsByRId = /* @__PURE__ */ new Map();
+        for (const [rId, blocks] of headerFooter.footerBlocksByRId) {
           if (!blocks || blocks.length === 0) continue;
           const measureConstraints = {
             maxWidth: headerFooter.constraints.width,
@@ -35754,8 +35877,7 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
             height: headerFooter.constraints.height
           });
           if (layout2.height > 0) {
-            const currentDefault = footerContentHeights.default ?? 0;
-            footerContentHeights.default = Math.max(currentDefault, layout2.height);
+            footerContentHeightsByRId.set(rId, layout2.height);
           }
         }
       }
@@ -35770,9 +35892,13 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
   let layout = layoutDocument(nextBlocks, measures, {
     ...options,
     headerContentHeights,
-    // Pass header heights to prevent overlap
+    // Pass header heights to prevent overlap (per-variant)
     footerContentHeights,
-    // Pass footer heights to prevent overlap
+    // Pass footer heights to prevent overlap (per-variant)
+    headerContentHeightsByRId,
+    // Pass header heights by rId for per-page margin calculation
+    footerContentHeightsByRId,
+    // Pass footer heights by rId for per-page margin calculation
     remeasureParagraph: (block, maxWidth, firstLineIndent) => remeasureParagraph(block, maxWidth, firstLineIndent)
   });
   const layoutEnd = performance.now();
@@ -35820,9 +35946,13 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
       layout = layoutDocument(currentBlocks, currentMeasures, {
         ...options,
         headerContentHeights,
-        // Pass header heights to prevent overlap
+        // Pass header heights to prevent overlap (per-variant)
         footerContentHeights,
-        // Pass footer heights to prevent overlap
+        // Pass footer heights to prevent overlap (per-variant)
+        headerContentHeightsByRId,
+        // Pass header heights by rId for per-page margin calculation
+        footerContentHeightsByRId,
+        // Pass footer heights by rId for per-page margin calculation
         remeasureParagraph: (block, maxWidth, firstLineIndent) => remeasureParagraph(block, maxWidth, firstLineIndent)
       });
       const relayoutEnd = performance.now();
@@ -41246,6 +41376,19 @@ function tokenNodeToRun(node, positions, defaultFont, defaultSize, inheritedMark
   const effectiveMarks = nodeMarks.length > 0 ? nodeMarks : marksAsAttrs;
   const marks = [...effectiveMarks, ...inheritedMarks ?? []];
   applyMarksToRun(run, marks, hyperlinkConfig, themeColors);
+  if (marksAsAttrs.length > 0) {
+    run._explicitFont = true;
+  }
+  console.debug("[token-debug] tokenNodeToRun", {
+    token,
+    fontFamily: run.fontFamily,
+    fontSize: run.fontSize,
+    defaultFont,
+    defaultSize,
+    nodeMarksCount: nodeMarks.length,
+    marksAsAttrsCount: marksAsAttrs.length,
+    inheritedMarksCount: inheritedMarks?.length ?? 0
+  });
   return run;
 }
 const EIGHTHS_PER_POINT = 8;
@@ -44994,6 +45137,10 @@ function paragraphToFlowBlocks$1(para, nextBlockId, positions, defaultFont, defa
     if (TOKEN_INLINE_TYPES.has(node.type)) {
       const tokenKind = TOKEN_INLINE_TYPES.get(node.type);
       if (tokenKind) {
+        const marksAsAttrs = Array.isArray(node.attrs?.marksAsAttrs) ? node.attrs.marksAsAttrs : [];
+        const nodeMarks = node.marks ?? [];
+        const effectiveMarks = nodeMarks.length > 0 ? nodeMarks : marksAsAttrs;
+        const mergedMarks = [...effectiveMarks, ...inheritedMarks ?? []];
         const tokenRun = tokenNodeToRun(
           node,
           positions,
@@ -45010,6 +45157,23 @@ function paragraphToFlowBlocks$1(para, nextBlockId, positions, defaultFont, defa
         const inlineStyleId = getInlineStyleId(inheritedMarks);
         applyRunStyles2(tokenRun, inlineStyleId, activeRunStyleId);
         applyBaseRunDefaults(tokenRun, baseRunDefaults, defaultFont, defaultSize);
+        if (mergedMarks.length > 0) {
+          applyMarksToRun(
+            tokenRun,
+            mergedMarks,
+            hyperlinkConfig,
+            themeColors,
+            converterContext?.backgroundColor
+          );
+        }
+        console.debug("[token-debug] paragraph-token-run", {
+          token: tokenRun.token,
+          fontFamily: tokenRun.fontFamily,
+          fontSize: tokenRun.fontSize,
+          inlineStyleId,
+          runStyleId: activeRunStyleId,
+          mergedMarksCount: mergedMarks.length
+        });
         currentRuns.push(tokenRun);
       }
       return;
@@ -47994,6 +48158,77 @@ function isLineBreakRun(run) {
 function isFieldAnnotationRun(run) {
   return run.kind === "fieldAnnotation";
 }
+function measureTabAlignmentGroup(startRunIndex, runs, ctx2, decimalSeparator = ".") {
+  const result = {
+    totalWidth: 0,
+    runs: [],
+    endRunIndex: runs.length
+  };
+  let foundDecimal = false;
+  for (let i = startRunIndex; i < runs.length; i++) {
+    const run = runs[i];
+    if (isTabRun(run)) {
+      result.endRunIndex = i;
+      break;
+    }
+    if (isLineBreakRun(run) || run.kind === "break" && run.breakType === "line") {
+      result.endRunIndex = i;
+      break;
+    }
+    if (run.kind === "text" || run.kind === void 0) {
+      const textRun = run;
+      const text = textRun.text || "";
+      if (text.length > 0) {
+        const { font } = buildFontString(textRun);
+        const width = measureRunWidth(text, font, ctx2, textRun, 0);
+        let beforeDecimalWidth;
+        if (!foundDecimal) {
+          const decimalIdx = text.indexOf(decimalSeparator);
+          if (decimalIdx >= 0) {
+            foundDecimal = true;
+            const beforeText = text.slice(0, decimalIdx);
+            beforeDecimalWidth = beforeText.length > 0 ? measureRunWidth(beforeText, font, ctx2, textRun, 0) : 0;
+            result.beforeDecimalWidth = result.totalWidth + beforeDecimalWidth;
+          }
+        }
+        result.runs.push({
+          runIndex: i,
+          width,
+          text,
+          beforeDecimalWidth
+        });
+        result.totalWidth += width;
+      } else {
+        result.runs.push({ runIndex: i, width: 0, text: "" });
+      }
+      continue;
+    }
+    if (isImageRun(run)) {
+      const leftSpace = run.distLeft ?? 0;
+      const rightSpace = run.distRight ?? 0;
+      const imageWidth = run.width + leftSpace + rightSpace;
+      result.runs.push({ runIndex: i, width: imageWidth });
+      result.totalWidth += imageWidth;
+      continue;
+    }
+    if (isFieldAnnotationRun(run)) {
+      const fontSize2 = run.fontSize ?? DEFAULT_FIELD_ANNOTATION_FONT_SIZE;
+      const { font } = buildFontString({
+        fontFamily: run.fontFamily ?? "Arial",
+        fontSize: fontSize2,
+        bold: run.bold,
+        italic: run.italic
+      });
+      const textWidth = run.displayLabel ? measureRunWidth(run.displayLabel, font, ctx2, run, 0) : 0;
+      const pillWidth = textWidth + FIELD_ANNOTATION_PILL_PADDING;
+      result.runs.push({ runIndex: i, width: pillWidth });
+      result.totalWidth += pillWidth;
+      continue;
+    }
+    result.runs.push({ runIndex: i, width: 0 });
+  }
+  return result;
+}
 async function measureBlock(block, constraints) {
   const normalized = normalizeConstraints(constraints);
   if (block.kind === "drawing") {
@@ -48117,6 +48352,7 @@ async function measureParagraphBlock(block, maxWidth) {
   let pendingTabAlignment = null;
   let lastAppliedTabAlign = null;
   const warnedTabVals = /* @__PURE__ */ new Set();
+  let activeTabGroup = null;
   const validateTabStopVal = (stop) => {
     if (!ALLOWED_TAB_VALS.has(stop.val) && !warnedTabVals.has(stop.val)) {
       warnedTabVals.add(stop.val);
@@ -48296,6 +48532,7 @@ async function measureParagraphBlock(block, maxWidth) {
       continue;
     }
     if (isTabRun(run)) {
+      activeTabGroup = null;
       if (!currentLine) {
         currentLine = {
           fromRun: runIndex,
@@ -48320,12 +48557,6 @@ async function measureParagraphBlock(block, maxWidth) {
       currentLine.maxFontSize = Math.max(currentLine.maxFontSize, 12);
       currentLine.toRun = runIndex;
       currentLine.toChar = 1;
-      if (stop) {
-        validateTabStopVal(stop);
-        pendingTabAlignment = { target: clampedTarget, val: stop.val };
-      } else {
-        pendingTabAlignment = null;
-      }
       if (stop && stop.leader && stop.leader !== "none") {
         const leaderStyle = stop.leader;
         const from3 = Math.min(originX, clampedTarget);
@@ -48333,6 +48564,36 @@ async function measureParagraphBlock(block, maxWidth) {
         if (!currentLine.leaders) currentLine.leaders = [];
         currentLine.leaders.push({ from: from3, to, style: leaderStyle });
       }
+      if (stop) {
+        validateTabStopVal(stop);
+        if (stop.val === "end" || stop.val === "center" || stop.val === "decimal") {
+          const groupMeasure = measureTabAlignmentGroup(runIndex + 1, runsToProcess, ctx2, decimalSeparator);
+          if (groupMeasure.totalWidth > 0) {
+            let groupStartX;
+            if (stop.val === "end") {
+              groupStartX = Math.max(0, clampedTarget - groupMeasure.totalWidth);
+            } else if (stop.val === "center") {
+              groupStartX = Math.max(0, clampedTarget - groupMeasure.totalWidth / 2);
+            } else {
+              const beforeDecimal = groupMeasure.beforeDecimalWidth ?? groupMeasure.totalWidth;
+              groupStartX = Math.max(0, clampedTarget - beforeDecimal);
+            }
+            activeTabGroup = {
+              measure: groupMeasure,
+              startX: groupStartX,
+              currentX: groupStartX,
+              target: clampedTarget,
+              val: stop.val
+            };
+            currentLine.width = roundValue(groupStartX);
+          }
+          pendingTabAlignment = null;
+        } else {
+          pendingTabAlignment = { target: clampedTarget, val: stop.val };
+        }
+      } else {
+        pendingTabAlignment = null;
+      }
       continue;
     }
     if (isImageRun(run)) {
@@ -48343,7 +48604,10 @@ async function measureParagraphBlock(block, maxWidth) {
       const bottomSpace = run.distBottom ?? 0;
       const imageHeight = run.height + topSpace + bottomSpace;
       let imageStartX;
-      if (pendingTabAlignment && currentLine) {
+      if (activeTabGroup && currentLine) {
+        imageStartX = activeTabGroup.currentX;
+        activeTabGroup.currentX = roundValue(activeTabGroup.currentX + imageWidth);
+      } else if (pendingTabAlignment && currentLine) {
         imageStartX = alignPendingTabForWidth(imageWidth);
       }
       if (!currentLine) {
@@ -48368,10 +48632,14 @@ async function measureParagraphBlock(block, maxWidth) {
             }
           ]
         };
+        if (activeTabGroup && runIndex + 1 >= activeTabGroup.measure.endRunIndex) {
+          activeTabGroup = null;
+        }
         continue;
       }
       const appliedTabAlign = lastAppliedTabAlign;
-      if (currentLine.width + imageWidth > currentLine.maxWidth && currentLine.width > 0) {
+      const skipFitCheck = activeTabGroup !== null;
+      if (!skipFitCheck && currentLine.width + imageWidth > currentLine.maxWidth && currentLine.width > 0) {
         trimTrailingWrapSpaces(currentLine);
         const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
         const lineBase = currentLine;
@@ -48384,6 +48652,7 @@ async function measureParagraphBlock(block, maxWidth) {
         tabStopCursor = 0;
         pendingTabAlignment = null;
         lastAppliedTabAlign = null;
+        activeTabGroup = null;
         currentLine = {
           fromRun: runIndex,
           fromChar: 0,
@@ -48416,6 +48685,9 @@ async function measureParagraphBlock(block, maxWidth) {
           ...imageStartX !== void 0 ? { x: imageStartX } : {}
         });
       }
+      if (activeTabGroup && runIndex + 1 >= activeTabGroup.measure.endRunIndex) {
+        activeTabGroup = null;
+      }
       const tabAlign = appliedTabAlign;
       if (tabAlign && currentLine && tabAlign.val === "end") {
         currentLine.width = roundValue(tabAlign.target);
@@ -48591,7 +48863,11 @@ async function measureParagraphBlock(block, maxWidth) {
         }
       }
       let segmentStartX;
-      if (currentLine && pendingTabAlignment) {
+      let inActiveTabGroup = false;
+      if (activeTabGroup && currentLine) {
+        segmentStartX = activeTabGroup.currentX;
+        inActiveTabGroup = true;
+      } else if (currentLine && pendingTabAlignment) {
         segmentStartX = alignSegmentAtTab(segment, font, run, charPosInRun);
         if (segmentStartX == null) {
           segmentStartX = currentLine.width;
@@ -48628,6 +48904,7 @@ async function measureParagraphBlock(block, maxWidth) {
               tabStopCursor = 0;
               pendingTabAlignment = null;
               lastAppliedTabAlign = null;
+              activeTabGroup = null;
               currentLine = {
                 fromRun: runIndex,
                 fromChar: spaceStartChar,
@@ -48646,7 +48923,19 @@ async function measureParagraphBlock(block, maxWidth) {
               currentLine.width = roundValue(currentLine.width + boundarySpacing2 + singleSpaceWidth);
               currentLine.maxFontInfo = updateMaxFontInfo(currentLine.maxFontSize, currentLine.maxFontInfo, run);
               currentLine.maxFontSize = Math.max(currentLine.maxFontSize, run.fontSize);
-              appendSegment(currentLine.segments, runIndex, spaceStartChar, spaceEndChar, singleSpaceWidth);
+              let spaceExplicitX;
+              if (inActiveTabGroup && activeTabGroup) {
+                spaceExplicitX = activeTabGroup.currentX;
+                activeTabGroup.currentX = roundValue(activeTabGroup.currentX + singleSpaceWidth);
+              }
+              appendSegment(
+                currentLine.segments,
+                runIndex,
+                spaceStartChar,
+                spaceEndChar,
+                singleSpaceWidth,
+                spaceExplicitX
+              );
               currentLine.spaceCount += 1;
             }
           }
@@ -48794,7 +49083,7 @@ async function measureParagraphBlock(block, maxWidth) {
         const totalWidthWithWord = currentLine.width + boundarySpacing + wordCommitWidth + // Safe cast: only TextRuns produce word segments from split(), other run types are handled earlier
         (shouldIncludeDelimiterSpace ? run.letterSpacing ?? 0 : 0);
         const availableWidth = currentLine.maxWidth - WIDTH_FUDGE_PX2;
-        let shouldBreak = currentLine.width + boundarySpacing + wordOnlyWidth > availableWidth && currentLine.width > 0 && !isTocEntry;
+        let shouldBreak = !inActiveTabGroup && currentLine.width + boundarySpacing + wordOnlyWidth > availableWidth && currentLine.width > 0 && !isTocEntry;
         let compressedWidth = null;
         if (shouldBreak && justifyAlignment) {
           const isLastNonEmptyWordInSegment = wordIndex === lastNonEmptyWordIndex;
@@ -48859,15 +49148,14 @@ async function measureParagraphBlock(block, maxWidth) {
             currentLine.width = roundValue(currentLine.width + boundarySpacing + wordOnlyWidth);
             currentLine.maxFontInfo = updateMaxFontInfo(currentLine.maxFontSize, currentLine.maxFontInfo, run);
             currentLine.maxFontSize = Math.max(currentLine.maxFontSize, run.fontSize);
-            const useExplicitXHere = wordIndex === 0 && segmentStartX !== void 0;
-            appendSegment(
-              currentLine.segments,
-              runIndex,
-              wordStartChar,
-              wordEndNoSpace,
-              wordOnlyWidth,
-              useExplicitXHere ? segmentStartX : void 0
-            );
+            let explicitXHere;
+            if (inActiveTabGroup && activeTabGroup) {
+              explicitXHere = activeTabGroup.currentX;
+              activeTabGroup.currentX = roundValue(activeTabGroup.currentX + wordOnlyWidth);
+            } else if (wordIndex === 0 && segmentStartX !== void 0) {
+              explicitXHere = segmentStartX;
+            }
+            appendSegment(currentLine.segments, runIndex, wordStartChar, wordEndNoSpace, wordOnlyWidth, explicitXHere);
             trimTrailingWrapSpaces(currentLine);
             const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
             const lineBase = currentLine;
@@ -48882,8 +49170,13 @@ async function measureParagraphBlock(block, maxWidth) {
           }
           const newToChar = shouldIncludeDelimiterSpace ? wordEndWithSpace : wordEndNoSpace;
           currentLine.toChar = newToChar;
-          const useExplicitX = wordIndex === 0 && segmentStartX !== void 0;
-          const explicitX = useExplicitX ? segmentStartX : void 0;
+          let explicitX;
+          if (inActiveTabGroup && activeTabGroup) {
+            explicitX = activeTabGroup.currentX;
+            activeTabGroup.currentX = roundValue(activeTabGroup.currentX + wordCommitWidth);
+          } else if (wordIndex === 0 && segmentStartX !== void 0) {
+            explicitX = segmentStartX;
+          }
           const targetWidth = compressedWidth != null ? compressedWidth : currentLine.width + boundarySpacing + wordCommitWidth + (shouldIncludeDelimiterSpace ? run.letterSpacing ?? 0 : 0);
           if (compressedWidth != null) {
             currentLine.naturalWidth = roundValue(totalWidthWithWord);
@@ -48905,6 +49198,12 @@ async function measureParagraphBlock(block, maxWidth) {
         }
       }
       lastAppliedTabAlign = null;
+      if (activeTabGroup && runIndex + 1 >= activeTabGroup.measure.endRunIndex) {
+        if (currentLine && activeTabGroup.val === "end") {
+          currentLine.width = roundValue(activeTabGroup.target);
+        }
+        activeTabGroup = null;
+      }
       if (!isLastSegment) {
         pendingTabAlignment = null;
         if (!currentLine) {
@@ -53234,7 +53533,26 @@ class PresentationEditor extends EventEmitter {
       const firstPageInSection = sectionFirstPageNumbers.get(sectionIndex);
       const sectionPageNumber = typeof firstPageInSection === "number" ? pageNumber - firstPageInSection + 1 : pageNumber;
       const headerFooterType = multiSectionId ? getHeaderFooterTypeForSection(pageNumber, sectionIndex, multiSectionId, { kind, sectionPageNumber }) : getHeaderFooterType(pageNumber, legacyIdentifier, { kind });
-      const sectionRId = page?.sectionRefs && kind === "header" ? page.sectionRefs.headerRefs?.[headerFooterType] ?? void 0 : page?.sectionRefs && kind === "footer" ? page.sectionRefs.footerRefs?.[headerFooterType] ?? void 0 : void 0;
+      let sectionRId;
+      if (page?.sectionRefs && kind === "header") {
+        sectionRId = page.sectionRefs.headerRefs?.[headerFooterType];
+        if (!sectionRId && headerFooterType && headerFooterType !== "default" && sectionIndex > 0 && multiSectionId) {
+          const prevSectionIds = multiSectionId.sectionHeaderIds.get(sectionIndex - 1);
+          sectionRId = prevSectionIds?.[headerFooterType] ?? void 0;
+        }
+        if (!sectionRId && headerFooterType !== "default") {
+          sectionRId = page.sectionRefs.headerRefs?.default;
+        }
+      } else if (page?.sectionRefs && kind === "footer") {
+        sectionRId = page.sectionRefs.footerRefs?.[headerFooterType];
+        if (!sectionRId && headerFooterType && headerFooterType !== "default" && sectionIndex > 0 && multiSectionId) {
+          const prevSectionIds = multiSectionId.sectionFooterIds.get(sectionIndex - 1);
+          sectionRId = prevSectionIds?.[headerFooterType] ?? void 0;
+        }
+        if (!sectionRId && headerFooterType !== "default") {
+          sectionRId = page.sectionRefs.footerRefs?.default;
+        }
+      }
       if (!headerFooterType) {
         return null;
       }