@harbour-enterprises/superdoc 1.3.0-next.3 → 1.3.0-next.5

package/dist/superdoc.umd.js

@@ -30890,8 +30890,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       hash: attrs.hash
     };
     const annotationAttrsJson = JSON.stringify(annotationAttrs);
+    const sanitizedDisplayLabel = attrs.displayLabel === "undefined" || attrs.displayLabel === void 0 ? "" : attrs.displayLabel;
     const sdtPrElements = [
-      { name: "w:alias", attributes: { "w:val": attrs.displayLabel } },
+      { name: "w:alias", attributes: { "w:val": sanitizedDisplayLabel } },
       { name: "w:tag", attributes: { "w:val": annotationAttrsJson } },
       { name: "w:id", attributes: { "w:val": id } }
     ];
@@ -36365,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.3") {
+    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.3.0-next.5") {
       return SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
     }
     /**
@@ -49668,8 +49669,12 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       const hasMatchingId = changeMarks.find((mark2) => mark2.attrs.id === id);
       if (hasMatchingId) nodesWithMark.push(node3);
     });
+    const nodesToProcess = nodesWithMark.length ? nodesWithMark : node2 ? [node2] : [];
+    if (!nodesToProcess.length) {
+      return;
+    }
     const { deletionText, trackedChangeText } = getTrackedChangeText({
-      nodes: nodesWithMark.length ? nodesWithMark : [node2],
+      nodes: nodesToProcess,
       mark: trackedMark,
       trackedChangeType,
       isDeletionInsertion
@@ -52998,6 +53003,45 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       console.warn("[collaboration] Failed to update Ydoc docx data", error);
     }
   };
+  let isApplyingRemoteChanges = false;
+  const isApplyingRemoteHeaderFooterChanges = () => isApplyingRemoteChanges;
+  const pushHeaderFooterToYjs = (editor, type, sectionId, content2) => {
+    if (isApplyingRemoteChanges) return;
+    const ydoc = editor?.options?.ydoc;
+    if (!ydoc) return;
+    const headerFooterMap = ydoc.getMap("headerFooterJson");
+    const key2 = `${type}:${sectionId}`;
+    const existing = headerFooterMap.get(key2)?.content;
+    if (existing && JSON.stringify(existing) === JSON.stringify(content2)) {
+      return;
+    }
+    ydoc.transact(() => headerFooterMap.set(key2, { type, sectionId, content: content2 }), {
+      event: "header-footer-update",
+      user: editor.options.user
+    });
+  };
+  const applyRemoteHeaderFooterChanges = (editor, key2, data) => {
+    if (!editor || editor.isDestroyed || !editor.converter) return;
+    const { type, sectionId, content: content2 } = data;
+    if (!type || !sectionId || !content2) return;
+    isApplyingRemoteChanges = true;
+    try {
+      const storage = editor.converter[`${type}s`];
+      if (storage) storage[sectionId] = content2;
+      editor.converter.headerFooterModified = true;
+      const editors = editor.converter[`${type}Editors`];
+      editors?.forEach((item) => {
+        if (item.id === sectionId && item.editor) {
+          item.editor.replaceContent(content2);
+        }
+      });
+      editor.emit("remoteHeaderFooterChanged", { type, sectionId, content: content2 });
+    } finally {
+      setTimeout(() => {
+        isApplyingRemoteChanges = false;
+      }, 0);
+    }
+  };
   new PluginKey("collaboration");
   const Collaboration = Extension.create({
     name: "collaboration",
@@ -53026,6 +53070,18 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           }
         });
       });
+      const headerFooterMap = this.options.ydoc.getMap("headerFooterJson");
+      headerFooterMap.observe((event) => {
+        if (event.transaction.local) return;
+        event.changes.keys.forEach((change, key2) => {
+          if (change.action === "add" || change.action === "update") {
+            const data = headerFooterMap.get(key2);
+            if (data) {
+              applyRemoteHeaderFooterChanges(this.editor, key2, data);
+            }
+          }
+        });
+      });
       return [syncPlugin];
     },
     addCommands() {
@@ -62020,7 +62076,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       return false;
     }
   };
-  const summaryVersion = "1.3.0-next.3";
+  const summaryVersion = "1.3.0-next.5";
   const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
   const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
   function mapAttributes(attrs) {
@@ -64654,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.3");
+      console.debug("[checkVersionMigrations] Current editor version", "1.3.0-next.5");
       if (!this.options.ydoc) return;
       const metaMap = this.options.ydoc.getMap("meta");
       let docVersion = metaMap.get("version");
@@ -74233,7 +74289,12 @@ ${l}
         const hanging = paraIndent?.hanging ?? 0;
         const isFirstLineOfPara = lineIndex === 0 || lineIndex === void 0;
         const firstLineOffsetForCumX = isFirstLineOfPara ? firstLine - hanging : 0;
-        const indentOffset = indentLeft + firstLineOffsetForCumX;
+        const wordLayoutValue = block.attrs?.wordLayout;
+        const wordLayout = isMinimalWordLayout(wordLayoutValue) ? wordLayoutValue : void 0;
+        const isListParagraph = Boolean(wordLayout?.marker);
+        const rawTextStartPx = typeof wordLayout?.marker?.textStartX === "number" && Number.isFinite(wordLayout.marker.textStartX) ? wordLayout.marker.textStartX : typeof wordLayout?.textStartPx === "number" && Number.isFinite(wordLayout.textStartPx) ? wordLayout.textStartPx : void 0;
+        const listIndentOffset = isFirstLineOfPara ? rawTextStartPx ?? indentLeft : indentLeft;
+        const indentOffset = isListParagraph ? listIndentOffset : indentLeft + firstLineOffsetForCumX;
         let cumulativeX = 0;
         const segmentsByRun = /* @__PURE__ */ new Map();
         line.segments.forEach((segment) => {
@@ -86780,6 +86841,15 @@ ${l}
     if (px == null || !Number.isFinite(px)) return void 0;
     return px / PX_PER_PT;
   };
+  const convertIndentTwipsToPx$1 = (indent2) => {
+    if (!indent2) return void 0;
+    const result = {};
+    if (isFiniteNumber(indent2.left)) result.left = twipsToPx$1(indent2.left);
+    if (isFiniteNumber(indent2.right)) result.right = twipsToPx$1(indent2.right);
+    if (isFiniteNumber(indent2.firstLine)) result.firstLine = twipsToPx$1(indent2.firstLine);
+    if (isFiniteNumber(indent2.hanging)) result.hanging = twipsToPx$1(indent2.hanging);
+    return Object.keys(result).length ? result : void 0;
+  };
   const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
   const isPlainObject$4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
   const normalizePrefix = (value) => {
@@ -87850,6 +87920,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;
@@ -89764,8 +89847,11 @@ ${l}
     const hydrated = hydrationOverride ?? hydrateParagraphStyleAttrs(para, converterContext);
     const mergedSpacing = mergeSpacingSources(hydrated?.spacing, paragraphProps.spacing, attrs.spacing);
     const normalizedSpacing = normalizeParagraphSpacing(mergedSpacing);
-    const indentSource = attrs.indent ?? paragraphProps.indent ?? hydrated?.indent;
-    const normalizedIndent = normalizePxIndent(indentSource) ?? normalizeParagraphIndent(indentSource ?? attrs.textIndent);
+    const normalizeIndentObject = (value) => {
+      if (!value || typeof value !== "object") return;
+      return normalizePxIndent(value) ?? convertIndentTwipsToPx(value);
+    };
+    const normalizedIndent = normalizeIndentObject(attrs.indent) ?? convertIndentTwipsToPx(paragraphProps.indent) ?? convertIndentTwipsToPx(hydrated?.indent) ?? normalizeParagraphIndent(attrs.textIndent);
     const unwrapTabStops = (tabStops) => {
       if (!Array.isArray(tabStops)) {
         return void 0;
@@ -91335,9 +91421,12 @@ ${l}
         };
       } else {
         const spacingSource = para.attrs?.spacing !== void 0 ? para.attrs.spacing : paragraphProps.spacing !== void 0 ? paragraphProps.spacing : paragraphHydration?.spacing;
-        const indentSource = para.attrs?.indent ?? paragraphProps.indent ?? paragraphHydration?.indent;
+        const normalizeIndentObject = (value) => {
+          if (!value || typeof value !== "object") return;
+          return normalizePxIndent(value) ?? convertIndentTwipsToPx$1(value);
+        };
         const normalizedSpacing = normalizeParagraphSpacing(spacingSource);
-        const normalizedIndent = normalizePxIndent(indentSource) ?? normalizeParagraphIndent(indentSource ?? para.attrs?.textIndent);
+        const normalizedIndent = normalizeIndentObject(para.attrs?.indent) ?? convertIndentTwipsToPx$1(paragraphProps.indent) ?? convertIndentTwipsToPx$1(paragraphHydration?.indent) ?? normalizeParagraphIndent(para.attrs?.textIndent);
         const styleNodeAttrs = paragraphHydration?.tabStops && !para.attrs?.tabStops && !para.attrs?.tabs ? { ...para.attrs ?? {}, tabStops: paragraphHydration.tabStops } : para.attrs ?? {};
         const styleNode = buildStyleNodeFromAttrs(styleNodeAttrs, normalizedSpacing, normalizedIndent);
         if (styleNodeAttrs.styleId == null && paragraphProps.styleId) {
@@ -91592,6 +91681,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,
@@ -91608,6 +91701,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;
@@ -93058,6 +93168,9 @@ ${l}
   };
   const onHeaderFooterDataUpdate = async ({ editor, transaction }, mainEditor, sectionId, type) => {
     if (!type || !sectionId) return;
+    if (isApplyingRemoteHeaderFooterChanges()) {
+      return;
+    }
     const updatedData = editor.getUpdatedJson();
     const editorsList = mainEditor.converter[`${type}Editors`];
     if (Array.isArray(editorsList)) {
@@ -93081,6 +93194,7 @@ ${l}
     if (editor.docChanged && mainEditor.converter) {
       mainEditor.converter.headerFooterModified = true;
     }
+    pushHeaderFooterToYjs(mainEditor, type, sectionId, updatedData);
     await updateYdocDocxData(mainEditor);
   };
   const setEditorToolbar = ({ editor }, mainEditor) => {
@@ -94588,6 +94702,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") {
@@ -94711,6 +94896,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);
@@ -94890,6 +95076,7 @@ ${l}
         continue;
       }
       if (isTabRun(run2)) {
+        activeTabGroup = null;
         if (!currentLine) {
           currentLine = {
             fromRun: runIndex,
@@ -94914,12 +95101,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);
@@ -94927,6 +95108,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)) {
@@ -94937,7 +95148,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) {
@@ -94962,10 +95176,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;
@@ -94978,6 +95196,7 @@ ${l}
           tabStopCursor = 0;
           pendingTabAlignment = null;
           lastAppliedTabAlign = null;
+          activeTabGroup = null;
           currentLine = {
             fromRun: runIndex,
             fromChar: 0,
@@ -95010,6 +95229,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);
@@ -95185,7 +95407,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;
@@ -95222,6 +95448,7 @@ ${l}
                 tabStopCursor = 0;
                 pendingTabAlignment = null;
                 lastAppliedTabAlign = null;
+                activeTabGroup = null;
                 currentLine = {
                   fromRun: runIndex,
                   fromChar: spaceStartChar,
@@ -95240,7 +95467,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;
               }
             }
@@ -95388,7 +95627,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;
@@ -95453,15 +95692,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;
@@ -95476,8 +95714,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);
@@ -95499,6 +95742,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) {
@@ -97929,6 +98178,17 @@ ${l}
         event: "collaborationReady",
         handler: handleCollaborationReady
       });
+      const handleRemoteHeaderFooterChanged = (payload) => {
+        this.#headerFooterAdapter?.invalidate(payload.sectionId);
+        this.#headerFooterManager?.refresh();
+        this.#pendingDocChange = true;
+        this.#scheduleRerender();
+      };
+      this.#editor.on("remoteHeaderFooterChanged", handleRemoteHeaderFooterChanged);
+      this.#editorListeners.push({
+        event: "remoteHeaderFooterChanged",
+        handler: handleRemoteHeaderFooterChanged
+      });
     }
     /**
      * Setup awareness event subscriptions for remote cursor tracking.
@@ -143604,7 +143864,7 @@ ${reason}`);
       this.config.colors = shuffleArray(this.config.colors);
       this.userColorMap = /* @__PURE__ */ new Map();
       this.colorIndex = 0;
-      this.version = "1.3.0-next.3";
+      this.version = "1.3.0-next.5";
       this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config2.superdocId || v4();
       this.colors = this.config.colors;