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

package/dist/superdoc.umd.js

@@ -36366,7 +36366,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     static getStoredSuperdocVersion(docx) {
       return SuperConverter.getStoredCustomProperty(docx, "SuperdocVersion");
     }
-    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.3.0-next.4") {
+    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.3.0-next.6") {
       return SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
     }
     /**
@@ -62076,7 +62076,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       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) {
@@ -64710,7 +64710,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
      * 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");
@@ -77585,8 +77585,7 @@ ${l}
     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) {
@@ -79643,6 +79642,45 @@ ${l}
       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),
@@ -79650,9 +79688,6 @@ ${l}
       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),
@@ -79660,8 +79695,12 @@ ${l}
       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;
@@ -79670,6 +79709,10 @@ ${l}
     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;
@@ -79875,6 +79918,7 @@ ${l}
     }
     let activeSectionIndex = initialSectionMetadata?.sectionIndex ?? 0;
     let pendingSectionIndex = null;
+    const sectionFirstPageNumbers = /* @__PURE__ */ new Map();
     const paginator = createPaginator({
       margins: paginatorMargins,
       getActiveTopMargin: () => activeTopMargin,
@@ -79888,6 +79932,7 @@ ${l}
       createPage,
       onNewPage: (state) => {
         if (!state) {
+          const isEnteringNewSection = pendingSectionIndex !== null;
           const applied = applyPendingToActive({
             activeTopMargin,
             activeBottomMargin,
@@ -79955,7 +80000,69 @@ ${l}
             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) {
@@ -80161,6 +80268,20 @@ ${l}
         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) {
@@ -80179,7 +80300,6 @@ ${l}
         }
         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;
@@ -82369,6 +82489,7 @@ ${l}
       `[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)) {
@@ -82408,7 +82529,8 @@ ${l}
         }
       }
       if (hasHeaderBlocksByRId && headerFooter.headerBlocksByRId) {
-        for (const [_rId, blocks2] of headerFooter.headerBlocksByRId) {
+        headerContentHeightsByRId = /* @__PURE__ */ new Map();
+        for (const [rId, blocks2] of headerFooter.headerBlocksByRId) {
           if (!blocks2 || blocks2.length === 0) continue;
           const measureConstraints = {
             maxWidth: headerFooter.constraints.width,
@@ -82420,8 +82542,7 @@ ${l}
             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);
           }
         }
       }
@@ -82429,6 +82550,7 @@ ${l}
       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)) {
@@ -82471,7 +82593,8 @@ ${l}
           }
         }
         if (hasFooterBlocksByRId && headerFooter.footerBlocksByRId) {
-          for (const [_rId, blocks2] of headerFooter.footerBlocksByRId) {
+          footerContentHeightsByRId = /* @__PURE__ */ new Map();
+          for (const [rId, blocks2] of headerFooter.footerBlocksByRId) {
             if (!blocks2 || blocks2.length === 0) continue;
             const measureConstraints = {
               maxWidth: headerFooter.constraints.width,
@@ -82483,8 +82606,7 @@ ${l}
               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);
             }
           }
         }
@@ -82499,9 +82621,13 @@ ${l}
     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();
@@ -82549,9 +82675,13 @@ ${l}
         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();
@@ -87920,6 +88050,19 @@ ${l}
     const effectiveMarks = nodeMarks.length > 0 ? nodeMarks : marksAsAttrs;
     const marks = [...effectiveMarks, ...inheritedMarks ?? []];
     applyMarksToRun(run2, marks, hyperlinkConfig, themeColors);
+    if (marksAsAttrs.length > 0) {
+      run2._explicitFont = true;
+    }
+    console.debug("[token-debug] tokenNodeToRun", {
+      token,
+      fontFamily: run2.fontFamily,
+      fontSize: run2.fontSize,
+      defaultFont,
+      defaultSize,
+      nodeMarksCount: nodeMarks.length,
+      marksAsAttrsCount: marksAsAttrs.length,
+      inheritedMarksCount: inheritedMarks?.length ?? 0
+    });
     return run2;
   }
   const EIGHTHS_PER_POINT = 8;
@@ -91668,6 +91811,10 @@ ${l}
       if (TOKEN_INLINE_TYPES.has(node2.type)) {
         const tokenKind = TOKEN_INLINE_TYPES.get(node2.type);
         if (tokenKind) {
+          const marksAsAttrs = Array.isArray(node2.attrs?.marksAsAttrs) ? node2.attrs.marksAsAttrs : [];
+          const nodeMarks = node2.marks ?? [];
+          const effectiveMarks = nodeMarks.length > 0 ? nodeMarks : marksAsAttrs;
+          const mergedMarks = [...effectiveMarks, ...inheritedMarks ?? []];
           const tokenRun = tokenNodeToRun(
             node2,
             positions,
@@ -91684,6 +91831,23 @@ ${l}
           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;
@@ -94668,6 +94832,77 @@ ${l}
   function isFieldAnnotationRun(run2) {
     return run2.kind === "fieldAnnotation";
   }
+  function measureTabAlignmentGroup(startRunIndex, runs2, ctx2, decimalSeparator = ".") {
+    const result = {
+      totalWidth: 0,
+      runs: [],
+      endRunIndex: runs2.length
+    };
+    let foundDecimal = false;
+    for (let i2 = startRunIndex; i2 < runs2.length; i2++) {
+      const run2 = runs2[i2];
+      if (isTabRun(run2)) {
+        result.endRunIndex = i2;
+        break;
+      }
+      if (isLineBreakRun(run2) || run2.kind === "break" && run2.breakType === "line") {
+        result.endRunIndex = i2;
+        break;
+      }
+      if (run2.kind === "text" || run2.kind === void 0) {
+        const textRun = run2;
+        const text2 = textRun.text || "";
+        if (text2.length > 0) {
+          const { font } = buildFontString(textRun);
+          const width = measureRunWidth(text2, font, ctx2, textRun, 0);
+          let beforeDecimalWidth;
+          if (!foundDecimal) {
+            const decimalIdx = text2.indexOf(decimalSeparator);
+            if (decimalIdx >= 0) {
+              foundDecimal = true;
+              const beforeText = text2.slice(0, decimalIdx);
+              beforeDecimalWidth = beforeText.length > 0 ? measureRunWidth(beforeText, font, ctx2, textRun, 0) : 0;
+              result.beforeDecimalWidth = result.totalWidth + beforeDecimalWidth;
+            }
+          }
+          result.runs.push({
+            runIndex: i2,
+            width,
+            text: text2,
+            beforeDecimalWidth
+          });
+          result.totalWidth += width;
+        } else {
+          result.runs.push({ runIndex: i2, width: 0, text: "" });
+        }
+        continue;
+      }
+      if (isImageRun(run2)) {
+        const leftSpace = run2.distLeft ?? 0;
+        const rightSpace = run2.distRight ?? 0;
+        const imageWidth = run2.width + leftSpace + rightSpace;
+        result.runs.push({ runIndex: i2, width: imageWidth });
+        result.totalWidth += imageWidth;
+        continue;
+      }
+      if (isFieldAnnotationRun(run2)) {
+        const fontSize2 = run2.fontSize ?? DEFAULT_FIELD_ANNOTATION_FONT_SIZE;
+        const { font } = buildFontString({
+          fontFamily: run2.fontFamily ?? "Arial",
+          fontSize: fontSize2,
+          bold: run2.bold,
+          italic: run2.italic
+        });
+        const textWidth = run2.displayLabel ? measureRunWidth(run2.displayLabel, font, ctx2, run2, 0) : 0;
+        const pillWidth = textWidth + FIELD_ANNOTATION_PILL_PADDING;
+        result.runs.push({ runIndex: i2, width: pillWidth });
+        result.totalWidth += pillWidth;
+        continue;
+      }
+      result.runs.push({ runIndex: i2, width: 0 });
+    }
+    return result;
+  }
   async function measureBlock(block, constraints) {
     const normalized = normalizeConstraints(constraints);
     if (block.kind === "drawing") {
@@ -94791,6 +95026,7 @@ ${l}
     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);
@@ -94970,6 +95206,7 @@ ${l}
         continue;
       }
       if (isTabRun(run2)) {
+        activeTabGroup = null;
         if (!currentLine) {
           currentLine = {
             fromRun: runIndex,
@@ -94994,12 +95231,6 @@ ${l}
         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 from2 = Math.min(originX, clampedTarget);
@@ -95007,6 +95238,36 @@ ${l}
           if (!currentLine.leaders) currentLine.leaders = [];
           currentLine.leaders.push({ from: from2, 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(run2)) {
@@ -95017,7 +95278,10 @@ ${l}
         const bottomSpace = run2.distBottom ?? 0;
         const imageHeight = run2.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) {
@@ -95042,10 +95306,14 @@ ${l}
               }
             ]
           };
+          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;
@@ -95058,6 +95326,7 @@ ${l}
           tabStopCursor = 0;
           pendingTabAlignment = null;
           lastAppliedTabAlign = null;
+          activeTabGroup = null;
           currentLine = {
             fromRun: runIndex,
             fromChar: 0,
@@ -95090,6 +95359,9 @@ ${l}
             ...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);
@@ -95265,7 +95537,11 @@ ${l}
           }
         }
         let segmentStartX;
-        if (currentLine && pendingTabAlignment) {
+        let inActiveTabGroup = false;
+        if (activeTabGroup && currentLine) {
+          segmentStartX = activeTabGroup.currentX;
+          inActiveTabGroup = true;
+        } else if (currentLine && pendingTabAlignment) {
           segmentStartX = alignSegmentAtTab(segment, font, run2, charPosInRun);
           if (segmentStartX == null) {
             segmentStartX = currentLine.width;
@@ -95302,6 +95578,7 @@ ${l}
                 tabStopCursor = 0;
                 pendingTabAlignment = null;
                 lastAppliedTabAlign = null;
+                activeTabGroup = null;
                 currentLine = {
                   fromRun: runIndex,
                   fromChar: spaceStartChar,
@@ -95320,7 +95597,19 @@ ${l}
                 currentLine.width = roundValue(currentLine.width + boundarySpacing2 + singleSpaceWidth);
                 currentLine.maxFontInfo = updateMaxFontInfo(currentLine.maxFontSize, currentLine.maxFontInfo, run2);
                 currentLine.maxFontSize = Math.max(currentLine.maxFontSize, run2.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;
               }
             }
@@ -95468,7 +95757,7 @@ ${l}
           const totalWidthWithWord = currentLine.width + boundarySpacing + wordCommitWidth + // Safe cast: only TextRuns produce word segments from split(), other run types are handled earlier
           (shouldIncludeDelimiterSpace ? run2.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;
@@ -95533,15 +95822,14 @@ ${l}
               currentLine.width = roundValue(currentLine.width + boundarySpacing + wordOnlyWidth);
               currentLine.maxFontInfo = updateMaxFontInfo(currentLine.maxFontSize, currentLine.maxFontInfo, run2);
               currentLine.maxFontSize = Math.max(currentLine.maxFontSize, run2.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;
@@ -95556,8 +95844,13 @@ ${l}
             }
             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 ? run2.letterSpacing ?? 0 : 0);
             if (compressedWidth != null) {
               currentLine.naturalWidth = roundValue(totalWidthWithWord);
@@ -95579,6 +95872,12 @@ ${l}
           }
         }
         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) {
@@ -99867,7 +100166,26 @@ ${l}
         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;
         }
@@ -143695,7 +144013,7 @@ ${reason}`);
       this.config.colors = shuffleArray(this.config.colors);
       this.userColorMap = /* @__PURE__ */ new Map();
       this.colorIndex = 0;
-      this.version = "1.3.0-next.4";
+      this.version = "1.3.0-next.6";
       this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config2.superdocId || v4();
       this.colors = this.config.colors;