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

package/dist/superdoc.umd.js

@@ -42428,7 +42428,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     static getStoredSuperdocVersion(docx) {
       return _SuperConverter2.getStoredCustomProperty(docx, "SuperdocVersion");
     }
-    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-next.3") {
+    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-next.5") {
       return _SuperConverter2.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
     }
     /**
@@ -67513,7 +67513,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   const shouldSkipNodeView = (editor) => {
     return isHeadless(editor);
   };
-  const summaryVersion = "1.0.0-next.3";
+  const summaryVersion = "1.0.0-next.5";
   const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
   const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
   function mapAttributes(attrs) {
@@ -68302,7 +68302,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         { default: remarkStringify2 },
         { default: remarkGfm2 }
       ] = await Promise.all([
-        Promise.resolve().then(() => indexDLOSgUP),
+        Promise.resolve().then(() => indexBUoOdDUj),
         Promise.resolve().then(() => indexDRCvimau),
         Promise.resolve().then(() => indexC_x_N6Uh),
         Promise.resolve().then(() => indexD_sWOSiG),
@@ -68507,7 +68507,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
      * Process collaboration migrations
      */
     processCollaborationMigrations() {
-      console.debug("[checkVersionMigrations] Current editor version", "1.0.0-next.3");
+      console.debug("[checkVersionMigrations] Current editor version", "1.0.0-next.5");
       if (!this.options.ydoc) return;
       const metaMap = this.options.ydoc.getMap("meta");
       let docVersion = metaMap.get("version");
@@ -74112,6 +74112,34 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       tabStopPosUsed: nextStop.pos
     };
   }
+  const SPACE_CHARS$1 = /* @__PURE__ */ new Set([" ", " "]);
+  function shouldApplyJustify(params2) {
+    const { alignment: alignment2, hasExplicitPositioning, isLastLineOfParagraph, paragraphEndsWithLineBreak, skipJustifyOverride } = params2;
+    if (alignment2 !== "justify" && alignment2 !== "both") {
+      return false;
+    }
+    if (skipJustifyOverride === true) {
+      return false;
+    }
+    if (hasExplicitPositioning) {
+      return false;
+    }
+    if (isLastLineOfParagraph && !paragraphEndsWithLineBreak) {
+      return false;
+    }
+    return true;
+  }
+  function calculateJustifySpacing(params2) {
+    const { lineWidth, availableWidth, spaceCount, shouldJustify } = params2;
+    if (!shouldJustify) {
+      return 0;
+    }
+    if (spaceCount <= 0) {
+      return 0;
+    }
+    const slack = availableWidth - lineWidth;
+    return slack / spaceCount;
+  }
   function resolveSpacingIndent$1(style2, numbering) {
     const spacing = {
       before: style2.spacing?.before ?? 0,
@@ -74378,13 +74406,14 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         };
       }
     }
+    const normalizedAlign = normalizeAlignment(resolvedExtended.justification);
     const hydrated = {
       resolved,
       spacing: resolvedSpacing,
       indent: resolvedIndent,
       borders: cloneIfObject(resolvedExtended.borders),
       shading: cloneIfObject(resolvedExtended.shading),
-      alignment: resolvedExtended.justification,
+      alignment: normalizedAlign,
       tabStops: cloneIfObject(resolvedExtended.tabStops),
       keepLines: resolvedExtended.keepLines,
       keepNext: resolvedExtended.keepNext,
@@ -75085,7 +75114,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     } else if (styleAlignment) {
       paragraphAttrs.alignment = styleAlignment;
     } else if (computed2.paragraph.alignment) {
-      paragraphAttrs.alignment = computed2.paragraph.alignment;
+      paragraphAttrs.alignment = normalizeAlignment(computed2.paragraph.alignment);
     }
     const spacingPx = spacingPtToPx(spacing, normalizedSpacing);
     if (spacingPx) paragraphAttrs.spacing = spacingPx;
@@ -78042,7 +78071,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   let measurementCanvas = null;
   let measurementCtx = null;
   const TAB_CHAR_LENGTH = 1;
-  const SPACE_CHARS = /* @__PURE__ */ new Set([" ", " "]);
+  const SPACE_CHARS = SPACE_CHARS$1;
   const isTabRun$1 = (run2) => run2?.kind === "tab";
   function getMeasurementContext() {
     if (measurementCtx) return measurementCtx;
@@ -78068,29 +78097,50 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return spaces;
   };
-  const getJustifyAdjustment = (block, line, availableWidthOverride, alignmentOverride) => {
+  const getJustifyAdjustment = (block, line, availableWidthOverride, alignmentOverride, isLastLineOfParagraph, paragraphEndsWithLineBreak, skipJustifyOverride) => {
     if (block.kind !== "paragraph") {
       return { extraPerSpace: 0, totalSpaces: 0 };
     }
-    const alignment2 = alignmentOverride ?? block.attrs?.alignment;
-    const hasExplicitPositioning = line.segments?.some((seg) => seg.x !== void 0);
-    const availableWidth = availableWidthOverride ?? line.maxWidth ?? line.width;
-    const slack = Math.max(0, availableWidth - line.width);
-    if (alignment2 !== "justify" || hasExplicitPositioning || slack <= 0) {
+    if (block.runs.length === 0) {
       return { extraPerSpace: 0, totalSpaces: 0 };
     }
-    const runs2 = sliceRunsForLine$1(block, line);
-    const totalSpaces = runs2.reduce((sum, run2) => {
-      if (isTabRun$1(run2) || "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation") {
-        return sum;
-      }
-      return sum + countSpaces(run2.text ?? "");
-    }, 0);
-    if (totalSpaces <= 0) {
+    const alignment2 = alignmentOverride ?? block.attrs?.alignment;
+    const hasExplicitPositioning = line.segments?.some((seg) => seg.x !== void 0) ?? false;
+    const lastRunIndex = block.runs.length - 1;
+    const lastRun = block.runs[lastRunIndex];
+    const derivedIsLastLine = line.toRun >= lastRunIndex;
+    const derivedEndsWithLineBreak = lastRun ? lastRun.kind === "lineBreak" : false;
+    const shouldJustify = shouldApplyJustify({
+      alignment: alignment2,
+      hasExplicitPositioning,
+      isLastLineOfParagraph: derivedIsLastLine,
+      paragraphEndsWithLineBreak: derivedEndsWithLineBreak,
+      skipJustifyOverride
+    });
+    if (!shouldJustify) {
       return { extraPerSpace: 0, totalSpaces: 0 };
     }
+    let totalSpaces = line.spaceCount ?? 0;
+    if (totalSpaces === 0) {
+      const runs2 = sliceRunsForLine$1(block, line);
+      totalSpaces = runs2.reduce((sum, run2) => {
+        if (isTabRun$1(run2) || "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation") {
+          return sum;
+        }
+        return sum + countSpaces(run2.text ?? "");
+      }, 0);
+    }
+    const availableWidth = availableWidthOverride ?? line.maxWidth ?? line.width;
+    const lineWidth = line.naturalWidth ?? line.width;
+    const extraPerSpace = calculateJustifySpacing({
+      lineWidth,
+      availableWidth,
+      spaceCount: totalSpaces,
+      shouldJustify: true
+      // Already checked above
+    });
     return {
-      extraPerSpace: slack / totalSpaces,
+      extraPerSpace,
       totalSpaces
     };
   };
@@ -78157,7 +78207,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     line.width;
     const justify = getJustifyAdjustment(block, line, availableWidth, alignmentOverride);
     const alignment2 = alignmentOverride ?? (block.kind === "paragraph" ? block.attrs?.alignment : void 0);
-    const renderedLineWidth = alignment2 === "justify" ? line.width + Math.max(0, availableWidth - line.width) : line.width;
+    const renderedLineWidth = alignment2 === "justify" && justify.extraPerSpace !== 0 ? availableWidth : line.width;
     const hasExplicitPositioning = line.segments?.some((seg) => seg.x !== void 0);
     const alignmentOffset = !hasExplicitPositioning && alignment2 === "center" ? Math.max(0, (availableWidth - renderedLineWidth) / 2) : !hasExplicitPositioning && alignment2 === "right" ? Math.max(0, availableWidth - renderedLineWidth) : 0;
     if (hasExplicitPositioning && line.segments && ctx2) {
@@ -78200,13 +78250,13 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         const textUpToTarget = text2.slice(0, offsetInRun);
         const measured2 = ctx2.measureText(textUpToTarget);
         const spacingWidth = computeLetterSpacingWidth(run2, offsetInRun, runLength);
-        const spacesInPortion = justify.extraPerSpace > 0 ? countSpaces(textUpToTarget) : 0;
+        const spacesInPortion = justify.extraPerSpace !== 0 ? countSpaces(textUpToTarget) : 0;
         return alignmentOffset + currentX + measured2.width + spacingWidth + justify.extraPerSpace * (spaceTally + spacesInPortion);
       }
       ctx2.font = getRunFontString(run2);
       const measured = ctx2.measureText(text2);
       const runLetterSpacing = computeLetterSpacingWidth(run2, runLength, runLength);
-      const spacesInRun = justify.extraPerSpace > 0 ? countSpaces(text2) : 0;
+      const spacesInRun = justify.extraPerSpace !== 0 ? countSpaces(text2) : 0;
       currentX += measured.width + runLetterSpacing + justify.extraPerSpace * spacesInRun;
       spaceTally += spacesInRun;
       currentCharOffset += runLength;
@@ -83358,9 +83408,66 @@ ${l}
         const firstLineOffset = suppressFirstLineIndent ? 0 : (paraIndent?.firstLine ?? 0) - (paraIndent?.hanging ?? 0);
         const lastRun = block.runs.length > 0 ? block.runs[block.runs.length - 1] : null;
         const paragraphEndsWithLineBreak = lastRun?.kind === "lineBreak";
+        let listFirstLineMarkerTabWidth;
+        if (!fragment.continuesFromPrev && fragment.markerWidth && wordLayout?.marker) {
+          const markerBoxWidth = fragment.markerWidth;
+          const markerTextWidth = fragment.markerTextWidth != null && isFinite(fragment.markerTextWidth) && fragment.markerTextWidth >= 0 ? fragment.markerTextWidth : markerBoxWidth;
+          const suffix2 = wordLayout.marker.suffix ?? "tab";
+          if (suffix2 === "tab") {
+            const markerJustification = wordLayout.marker.justification ?? "left";
+            const isFirstLineIndentMode = wordLayout.firstLineIndentMode === true;
+            let markerStartPos;
+            if (isFirstLineIndentMode && wordLayout.marker.markerX !== void 0 && Number.isFinite(wordLayout.marker.markerX)) {
+              markerStartPos = wordLayout.marker.markerX;
+            } else {
+              const hanging = paraIndent?.hanging ?? 0;
+              const firstLine = paraIndent?.firstLine ?? 0;
+              markerStartPos = paraIndentLeft - hanging + firstLine;
+            }
+            const validMarkerStartPos = Number.isFinite(markerStartPos) ? markerStartPos : 0;
+            let tabWidth;
+            if (markerJustification === "left") {
+              const currentPos = validMarkerStartPos + markerTextWidth;
+              if (isFirstLineIndentMode) {
+                const textStartTarget = wordLayout.marker.textStartX !== void 0 && Number.isFinite(wordLayout.marker.textStartX) ? wordLayout.marker.textStartX : wordLayout.textStartPx;
+                if (textStartTarget !== void 0 && Number.isFinite(textStartTarget) && textStartTarget > currentPos) {
+                  tabWidth = textStartTarget - currentPos;
+                } else {
+                  tabWidth = LIST_MARKER_GAP$1;
+                }
+              } else {
+                const firstLine = paraIndent?.firstLine ?? 0;
+                const textStart = paraIndentLeft + firstLine;
+                tabWidth = textStart - currentPos;
+                if (tabWidth <= 0) {
+                  tabWidth = DEFAULT_TAB_INTERVAL_PX$1 - currentPos % DEFAULT_TAB_INTERVAL_PX$1;
+                } else if (tabWidth < LIST_MARKER_GAP$1) {
+                  tabWidth = LIST_MARKER_GAP$1;
+                }
+              }
+            } else {
+              const gutterWidth = fragment.markerGutter ?? wordLayout.marker.gutterWidthPx;
+              tabWidth = gutterWidth !== void 0 && Number.isFinite(gutterWidth) && gutterWidth > 0 ? gutterWidth : LIST_MARKER_GAP$1;
+            }
+            if (tabWidth < LIST_MARKER_GAP$1) {
+              tabWidth = LIST_MARKER_GAP$1;
+            }
+            listFirstLineMarkerTabWidth = validMarkerStartPos + markerTextWidth + tabWidth;
+          } else if (suffix2 === "space") {
+            const hanging = paraIndent?.hanging ?? 0;
+            const firstLine = paraIndent?.firstLine ?? 0;
+            const markerStartPos = paraIndentLeft - hanging + firstLine;
+            const validMarkerStartPos = Number.isFinite(markerStartPos) ? markerStartPos : 0;
+            listFirstLineMarkerTabWidth = validMarkerStartPos + markerTextWidth + 4;
+          }
+        }
         lines.forEach((line, index2) => {
-          const fallbackAvailableWidth = Math.max(0, fragment.width - (paraIndentLeft + paraIndentRight));
-          const availableWidthOverride = line.maxWidth ?? fallbackAvailableWidth;
+          const positiveIndentReduction = Math.max(0, paraIndentLeft) + Math.max(0, paraIndentRight);
+          const fallbackAvailableWidth = Math.max(0, fragment.width - positiveIndentReduction);
+          let availableWidthOverride = line.maxWidth != null ? Math.min(line.maxWidth, fallbackAvailableWidth) : fallbackAvailableWidth;
+          if (index2 === 0 && listFirstLineMarkerTabWidth != null) {
+            availableWidthOverride = fragment.width - listFirstLineMarkerTabWidth - Math.max(0, paraIndentRight);
+          }
           const isLastLineOfFragment = index2 === lines.length - 1;
           const isLastLineOfParagraph = isLastLineOfFragment && !fragment.continuesOnNext;
           const shouldSkipJustifyForLastLine = isLastLineOfParagraph && !paragraphEndsWithLineBreak;
@@ -83386,7 +83493,10 @@ ${l}
               }
             } else if (paraIndentLeft && paraIndentLeft > 0) {
               lineEl.style.paddingLeft = `${paraIndentLeft}px`;
-            } else if (!isFirstLine && paraIndent?.hanging && paraIndent.hanging > 0) {
+            } else if (!isFirstLine && paraIndent?.hanging && paraIndent.hanging > 0 && // Only apply hanging padding when left indent is NOT negative.
+            // When left indent is negative, the fragment position already accounts for it.
+            // Adding padding here would shift body lines right, causing right-side overflow.
+            !(paraIndentLeft != null && paraIndentLeft < 0)) {
               lineEl.style.paddingLeft = `${paraIndent.hanging}px`;
             }
           }
@@ -83415,6 +83525,7 @@ ${l}
             lineEl.style.paddingLeft = `${validMarkerStartPos}px`;
             const markerContainer = this.doc.createElement("span");
             markerContainer.style.display = "inline-block";
+            markerContainer.style.wordSpacing = "0px";
             const markerEl = this.doc.createElement("span");
             markerEl.classList.add("superdoc-paragraph-marker");
             markerEl.textContent = wordLayout.marker.markerText ?? "";
@@ -83500,10 +83611,15 @@ ${l}
                 }
               }
               tabEl.style.display = "inline-block";
+              tabEl.style.wordSpacing = "0px";
               tabEl.style.width = `${tabWidth}px`;
               lineEl.prepend(tabEl);
             } else if (suffix2 === "space") {
-              lineEl.prepend(this.doc.createTextNode(" "));
+              const spaceEl = this.doc.createElement("span");
+              spaceEl.classList.add("superdoc-marker-suffix-space");
+              spaceEl.style.wordSpacing = "0px";
+              spaceEl.textContent = " ";
+              lineEl.prepend(spaceEl);
             }
             lineEl.prepend(markerContainer);
           }
@@ -84795,11 +84911,8 @@ ${l}
         el.setAttribute("styleid", styleId);
       }
       const alignment2 = block.attrs?.alignment;
-      const effectiveAlignment = alignment2;
-      if (effectiveAlignment === "center" || effectiveAlignment === "right") {
-        el.style.textAlign = effectiveAlignment;
-      } else if (effectiveAlignment === "justify") {
-        el.style.textAlign = "left";
+      if (alignment2 === "center" || alignment2 === "right") {
+        el.style.textAlign = alignment2;
       } else {
         el.style.textAlign = "left";
       }
@@ -84810,9 +84923,8 @@ ${l}
       if (lineRange.pmEnd != null) {
         el.dataset.pmEnd = String(lineRange.pmEnd);
       }
-      const runsForLine = sliceRunsForLine(block, line);
+      let runsForLine = sliceRunsForLine(block, line);
       const trackedConfig = this.resolveTrackedChangesConfig(block);
-      runsForLine.length > 0 ? runsForLine.filter((r2) => (r2.kind === "text" || r2.kind === void 0) && "text" in r2 && r2.text != null).map((r2) => r2.text) : gatherTextSlicesForLine(block, line);
       if (runsForLine.length === 0) {
         const span = this.doc.createElement("span");
         span.innerHTML = "&nbsp;";
@@ -84859,7 +84971,156 @@ ${l}
         });
       }
       const hasExplicitPositioning = line.segments?.some((seg) => seg.x !== void 0);
-      availableWidthOverride ?? line.maxWidth ?? line.width;
+      const availableWidth = availableWidthOverride ?? line.maxWidth ?? line.width;
+      const justifyShouldApply = shouldApplyJustify({
+        alignment: block.attrs?.alignment,
+        hasExplicitPositioning: hasExplicitPositioning ?? false,
+        // Caller already folds last-line + trailing lineBreak behavior into skipJustify.
+        isLastLineOfParagraph: false,
+        paragraphEndsWithLineBreak: false,
+        skipJustifyOverride: skipJustify
+      });
+      const countSpaces2 = (text2) => {
+        let count = 0;
+        for (let i2 = 0; i2 < text2.length; i2 += 1) {
+          if (SPACE_CHARS$1.has(text2[i2])) count += 1;
+        }
+        return count;
+      };
+      if (justifyShouldApply) {
+        const stableDataAttrs = (attrs) => {
+          if (!attrs) return void 0;
+          const keys2 = Object.keys(attrs).sort();
+          const out = {};
+          keys2.forEach((key2) => {
+            out[key2] = attrs[key2];
+          });
+          return out;
+        };
+        const mergeSignature = (run2) => JSON.stringify({
+          kind: run2.kind ?? "text",
+          fontFamily: run2.fontFamily,
+          fontSize: run2.fontSize,
+          bold: run2.bold ?? false,
+          italic: run2.italic ?? false,
+          letterSpacing: run2.letterSpacing ?? null,
+          color: run2.color ?? null,
+          underline: run2.underline ?? null,
+          strike: run2.strike ?? false,
+          highlight: run2.highlight ?? null,
+          textTransform: run2.textTransform ?? null,
+          token: run2.token ?? null,
+          pageRefMetadata: run2.pageRefMetadata ?? null,
+          trackedChange: run2.trackedChange ?? null,
+          sdt: run2.sdt ?? null,
+          link: run2.link ?? null,
+          comments: run2.comments ?? null,
+          dataAttrs: stableDataAttrs(run2.dataAttrs) ?? null
+        });
+        const isWhitespaceOnly = (text2) => {
+          if (text2.length === 0) return false;
+          for (let i2 = 0; i2 < text2.length; i2 += 1) {
+            if (!SPACE_CHARS$1.has(text2[i2])) return false;
+          }
+          return true;
+        };
+        const cloneTextRun = (run2) => ({
+          ...run2,
+          comments: run2.comments ? [...run2.comments] : void 0,
+          dataAttrs: run2.dataAttrs ? { ...run2.dataAttrs } : void 0,
+          underline: run2.underline ? { ...run2.underline } : void 0,
+          pageRefMetadata: run2.pageRefMetadata ? { ...run2.pageRefMetadata } : void 0
+        });
+        const normalized = runsForLine.map((run2) => {
+          if (run2.kind !== "text" && run2.kind !== void 0 || !("text" in run2)) return run2;
+          return cloneTextRun(run2);
+        });
+        const merged = [];
+        for (let i2 = 0; i2 < normalized.length; i2 += 1) {
+          const run2 = normalized[i2];
+          if (run2.kind !== "text" && run2.kind !== void 0 || !("text" in run2)) {
+            merged.push(run2);
+            continue;
+          }
+          const textRun = run2;
+          if (!isWhitespaceOnly(textRun.text ?? "")) {
+            merged.push(textRun);
+            continue;
+          }
+          const prev = merged[merged.length - 1];
+          if (prev && (prev.kind === "text" || prev.kind === void 0) && "text" in prev) {
+            const prevTextRun = prev;
+            if (mergeSignature(prevTextRun) === mergeSignature(textRun)) {
+              const extra = textRun.text ?? "";
+              prevTextRun.text = (prevTextRun.text ?? "") + extra;
+              if (prevTextRun.pmStart != null) {
+                prevTextRun.pmEnd = prevTextRun.pmStart + prevTextRun.text.length;
+              } else if (prevTextRun.pmEnd != null) {
+                prevTextRun.pmEnd = prevTextRun.pmEnd + extra.length;
+              }
+              continue;
+            }
+          }
+          const next2 = normalized[i2 + 1];
+          if (next2 && (next2.kind === "text" || next2.kind === void 0) && "text" in next2) {
+            const nextTextRun = next2;
+            if (mergeSignature(nextTextRun) === mergeSignature(textRun)) {
+              const extra = textRun.text ?? "";
+              nextTextRun.text = extra + (nextTextRun.text ?? "");
+              if (textRun.pmStart != null) {
+                nextTextRun.pmStart = textRun.pmStart;
+              } else if (nextTextRun.pmStart != null) {
+                nextTextRun.pmStart = nextTextRun.pmStart - extra.length;
+              }
+              if (nextTextRun.pmStart != null && nextTextRun.pmEnd == null) {
+                nextTextRun.pmEnd = nextTextRun.pmStart + nextTextRun.text.length;
+              }
+              continue;
+            }
+          }
+          merged.push(textRun);
+        }
+        runsForLine = merged;
+        const hasNonSpaceText = runsForLine.some(
+          (run2) => (run2.kind === "text" || run2.kind === void 0) && "text" in run2 && (run2.text ?? "").trim().length > 0
+        );
+        if (hasNonSpaceText) {
+          for (let i2 = runsForLine.length - 1; i2 >= 0; i2 -= 1) {
+            const run2 = runsForLine[i2];
+            if (run2.kind !== "text" && run2.kind !== void 0 || !("text" in run2)) continue;
+            const text2 = run2.text ?? "";
+            let trimCount = 0;
+            for (let j2 = text2.length - 1; j2 >= 0 && text2[j2] === " "; j2 -= 1) {
+              trimCount += 1;
+            }
+            if (trimCount === 0) break;
+            const nextText = text2.slice(0, Math.max(0, text2.length - trimCount));
+            if (nextText.length === 0) {
+              runsForLine.splice(i2, 1);
+              continue;
+            }
+            run2.text = nextText;
+            if (run2.pmEnd != null) {
+              run2.pmEnd = run2.pmEnd - trimCount;
+            }
+            break;
+          }
+        }
+      }
+      const spaceCount = line.spaceCount ?? runsForLine.reduce((sum, run2) => {
+        if (run2.kind !== "text" && run2.kind !== void 0 || !("text" in run2) || run2.text == null) return sum;
+        return sum + countSpaces2(run2.text);
+      }, 0);
+      const lineWidth = line.naturalWidth ?? line.width;
+      const spacingPerSpace = calculateJustifySpacing({
+        lineWidth,
+        availableWidth,
+        spaceCount,
+        shouldJustify: justifyShouldApply
+      });
+      if (spacingPerSpace !== 0) {
+        el.style.wordSpacing = `${spacingPerSpace}px`;
+      }
       if (hasExplicitPositioning && line.segments) {
         const paraIndent = block.attrs?.indent;
         const indentLeft = paraIndent?.left ?? 0;
@@ -85731,7 +85992,7 @@ ${l}
       element2.setAttribute("styleid", attrs.styleId);
     }
     if (attrs.alignment) {
-      element2.style.textAlign = attrs.alignment;
+      element2.style.textAlign = attrs.alignment === "justify" || attrs.alignment === "both" ? "left" : attrs.alignment;
     }
     if (attrs.dropCap) {
       element2.classList.add("sd-editor-dropcap");
@@ -85796,23 +86057,6 @@ ${l}
     if (!shading?.fill) return;
     element2.style.backgroundColor = shading.fill;
   };
-  const gatherTextSlicesForLine = (block, line) => {
-    const slices = [];
-    const startRun = line.fromRun ?? 0;
-    const endRun = line.toRun ?? startRun;
-    for (let runIndex = startRun; runIndex <= endRun; runIndex += 1) {
-      const run2 = block.runs[runIndex];
-      if (!run2 || run2.kind !== "text" && run2.kind !== void 0 || !("text" in run2) || !run2.text) continue;
-      const isFirst = runIndex === startRun;
-      const isLast = runIndex === endRun;
-      const start2 = isFirst ? line.fromChar ?? 0 : 0;
-      const end2 = isLast ? line.toChar ?? run2.text.length : run2.text.length;
-      if (start2 >= end2) continue;
-      const slice2 = run2.text.slice(start2, end2);
-      if (slice2) slices.push(slice2);
-    }
-    return slices;
-  };
   const sliceRunsForLine = (block, line) => {
     const result = [];
     for (let runIndex = line.fromRun; runIndex <= line.toRun; runIndex += 1) {
@@ -86434,7 +86678,8 @@ ${l}
     let indentAdjust = paraIndentLeft;
     if (isListItem2 && isFirstLine && isFirstLineIndentMode) {
       const textStartFallback = paraIndentLeft + Math.max(firstLineIndent, 0) + markerWidth;
-      indentAdjust = typeof wordLayout?.textStartPx === "number" && Number.isFinite(wordLayout.textStartPx) ? wordLayout.textStartPx : textStartFallback;
+      const markerTextStartX = wordLayout?.marker?.textStartX;
+      indentAdjust = typeof markerTextStartX === "number" && Number.isFinite(markerTextStartX) ? markerTextStartX : typeof wordLayout?.textStartPx === "number" && Number.isFinite(wordLayout.textStartPx) ? wordLayout.textStartPx : textStartFallback;
     } else if (isFirstLine && !isListItem2) {
       indentAdjust += firstLineOffset;
     }
@@ -87124,6 +87369,20 @@ ${l}
     }
     return value;
   };
+  function calculateFirstLineIndent(block, measure) {
+    const wordLayout = block.attrs?.wordLayout;
+    if (!wordLayout?.firstLineIndentMode) {
+      return 0;
+    }
+    if (!wordLayout.marker || !measure.marker) {
+      return 0;
+    }
+    const markerWidthRaw = measure.marker.markerWidth ?? wordLayout.marker.markerBoxWidthPx ?? 0;
+    const markerWidth = Number.isFinite(markerWidthRaw) && markerWidthRaw >= 0 ? markerWidthRaw : 0;
+    const gutterWidthRaw = measure.marker.gutterWidth ?? 0;
+    const gutterWidth = Number.isFinite(gutterWidthRaw) && gutterWidthRaw >= 0 ? gutterWidthRaw : 0;
+    return markerWidth + gutterWidth;
+  }
   function layoutParagraphBlock(ctx2, anchors) {
     const { block, measure, columnWidth, ensurePage, advanceColumn, columnX, floatManager } = ctx2;
     const remeasureParagraph2 = ctx2.remeasureParagraph;
@@ -87253,17 +87512,8 @@ ${l}
     const remeasureWidth = Math.max(1, columnWidth - indentLeft - indentRight);
     let didRemeasureForColumnWidth = false;
     if (typeof remeasureParagraph2 === "function" && typeof measurementWidth === "number" && measurementWidth > remeasureWidth) {
-      let firstLineIndent = 0;
-      const wordLayout = block.attrs?.wordLayout;
-      if (wordLayout?.marker && measure.marker) {
-        const markerJustification = wordLayout.marker.justification ?? "left";
-        if (markerJustification === "left") {
-          const markerWidth = measure.marker.markerWidth ?? 0;
-          const gutterWidth = measure.marker.gutterWidth ?? wordLayout.marker.gutterWidthPx ?? 0;
-          firstLineIndent = markerWidth + gutterWidth;
-        }
-      }
-      const newMeasure = remeasureParagraph2(block, remeasureWidth, firstLineIndent);
+      const firstLineIndent = calculateFirstLineIndent(block, measure);
+      const newMeasure = remeasureParagraph2(block, columnWidth, firstLineIndent);
       lines = normalizeLines(newMeasure);
       didRemeasureForColumnWidth = true;
     }
@@ -87344,16 +87594,7 @@ ${l}
       }
       const narrowestRemeasureWidth = Math.max(1, narrowestWidth - indentLeft - indentRight);
       if (narrowestRemeasureWidth < remeasureWidth) {
-        let firstLineIndent = 0;
-        const wordLayout = block.attrs?.wordLayout;
-        if (wordLayout?.marker && measure.marker) {
-          const markerJustification = wordLayout.marker.justification ?? "left";
-          if (markerJustification === "left") {
-            const markerWidth = measure.marker.markerWidth ?? 0;
-            const gutterWidth = measure.marker.gutterWidth ?? wordLayout.marker.gutterWidthPx ?? 0;
-            firstLineIndent = markerWidth + gutterWidth;
-          }
-        }
+        const firstLineIndent = calculateFirstLineIndent(block, measure);
         const newMeasure = remeasureParagraph2(block, narrowestRemeasureWidth, firstLineIndent);
         lines = normalizeLines(newMeasure);
         didRemeasureForFloats = true;
@@ -90500,7 +90741,8 @@ ${l}
     const indentHanging = Math.max(0, indent2?.hanging ?? 0);
     const rawFirstLineOffset = Math.max(0, firstLineIndent || indentFirstLine - indentHanging);
     const contentWidth = Math.max(1, maxWidth - indentLeft - indentRight);
-    const textStartPx = wordLayout?.textStartPx;
+    const markerTextStartX = wordLayout?.marker?.textStartX;
+    const textStartPx = typeof markerTextStartX === "number" && Number.isFinite(markerTextStartX) ? markerTextStartX : typeof wordLayout?.textStartPx === "number" && Number.isFinite(wordLayout.textStartPx) ? wordLayout.textStartPx : void 0;
     const treatAsHanging = textStartPx && indentLeft === 0 && indentHanging === 0;
     const firstLineWidth = typeof textStartPx === "number" && textStartPx > indentLeft && !treatAsHanging ? Math.max(1, maxWidth - textStartPx - indentRight) : Math.max(1, contentWidth - rawFirstLineOffset);
     const tabStops = buildTabStopsPx$1(indent2, attrs?.tabs, attrs?.tabIntervalTwips);
@@ -90512,6 +90754,7 @@ ${l}
       const startRun = currentRun;
       const startChar = currentChar;
       let width = 0;
+      let widthAtLastBreak = -1;
       let lastBreakRun = -1;
       let lastBreakChar = -1;
       let endRun = currentRun;
@@ -90529,6 +90772,7 @@ ${l}
           endChar = 1;
           lastBreakRun = r2;
           lastBreakChar = 1;
+          widthAtLastBreak = width;
           continue;
         }
         const text2 = runText(run2);
@@ -90539,6 +90783,7 @@ ${l}
             if (lastBreakRun >= 0) {
               endRun = lastBreakRun;
               endChar = lastBreakChar;
+              width = widthAtLastBreak >= 0 ? widthAtLastBreak : width;
             } else {
               endRun = r2;
               endChar = c2;
@@ -90553,6 +90798,7 @@ ${l}
           if (ch === " " || ch === "	" || ch === "-") {
             lastBreakRun = r2;
             lastBreakChar = c2 + 1;
+            widthAtLastBreak = width;
           }
         }
         if (didBreakInThisLine) break;
@@ -92263,7 +92509,9 @@ ${l}
         }
         const markerWidth = fragment.markerWidth ?? measure.marker?.markerWidth ?? 0;
         const isListItem3 = markerWidth > 0;
-        const alignmentOverride = isListItem3 ? "left" : void 0;
+        const paraAlignment = block.attrs?.alignment;
+        const isJustified = paraAlignment === "justify" || paraAlignment === "both";
+        const alignmentOverride = isListItem3 && !isJustified ? "left" : void 0;
         const pos = mapPointToPm(block, line, pageRelativePoint.x - fragment.x, isRTL, availableWidth, alignmentOverride);
         if (pos == null) {
           logClickStage("warn", "no-position", {
@@ -92330,7 +92578,9 @@ ${l}
         }
         const cellMarkerWidth = cellMeasure.marker?.markerWidth ?? 0;
         const isListItem3 = cellMarkerWidth > 0;
-        const alignmentOverride = isListItem3 ? "left" : void 0;
+        const cellAlignment = cellBlock.attrs?.alignment;
+        const isJustified = cellAlignment === "justify" || cellAlignment === "both";
+        const alignmentOverride = isListItem3 && !isJustified ? "left" : void 0;
         const pos = mapPointToPm(cellBlock, line, localX, isRTL, availableWidth, alignmentOverride);
         if (pos != null) {
           logClickStage("log", "success", {
@@ -92499,7 +92749,9 @@ ${l}
             const charOffsetTo = pmPosToCharOffset(block, line, sliceTo);
             const markerWidth = fragment.markerWidth ?? measure.marker?.markerWidth ?? 0;
             const isListItemFlag = isListItem(markerWidth, block);
-            const alignmentOverride = isListItemFlag ? "left" : void 0;
+            const blockAlignment = block.attrs?.alignment;
+            const isJustified = blockAlignment === "justify" || blockAlignment === "both";
+            const alignmentOverride = isListItemFlag && !isJustified ? "left" : void 0;
             const startX = mapPmToX(block, line, charOffsetFrom, fragment.width, alignmentOverride);
             const endX = mapPmToX(block, line, charOffsetTo, fragment.width, alignmentOverride);
             const indent2 = extractParagraphIndent(block.attrs?.indent);
@@ -93241,7 +93493,9 @@ ${l}
     const contentWidth = Math.max(1, maxWidth - indentLeft - indentRight);
     const bodyContentWidth = contentWidth;
     let initialAvailableWidth;
-    const textStartPx = wordLayout?.textStartPx;
+    const rawTextStartPx = wordLayout?.textStartPx;
+    const markerTextStartX = wordLayout?.marker?.textStartX;
+    const textStartPx = typeof markerTextStartX === "number" && Number.isFinite(markerTextStartX) ? markerTextStartX : typeof rawTextStartPx === "number" && Number.isFinite(rawTextStartPx) ? rawTextStartPx : void 0;
     if (typeof textStartPx === "number" && textStartPx > indentLeft) {
       initialAvailableWidth = Math.max(1, maxWidth - textStartPx - indentRight);
     } else {
@@ -93376,12 +93630,40 @@ ${l}
         runsToProcess.push(run2);
       }
     }
+    const trimTrailingWrapSpaces = (lineToTrim) => {
+      const lastRun = runsToProcess[lineToTrim.toRun];
+      if (!lastRun || !("text" in lastRun) || typeof lastRun.text !== "string") return;
+      const sliceStart = lineToTrim.toRun === lineToTrim.fromRun ? lineToTrim.fromChar : 0;
+      const sliceEnd = lineToTrim.toChar;
+      if (sliceEnd <= sliceStart) return;
+      const sliceText = lastRun.text.slice(sliceStart, sliceEnd);
+      let trimCount = 0;
+      for (let i2 = sliceText.length - 1; i2 >= 0 && sliceText[i2] === " "; i2 -= 1) {
+        trimCount += 1;
+      }
+      if (trimCount === 0) return;
+      if (lineToTrim.fromRun === lineToTrim.toRun && sliceText.trim().length === 0) {
+        return;
+      }
+      const keptText = sliceText.slice(0, Math.max(0, sliceText.length - trimCount));
+      const { font } = buildFontString(
+        lastRun
+      );
+      const fullWidth = measureRunWidth(sliceText, font, ctx2, lastRun);
+      const keptWidth = keptText.length > 0 ? measureRunWidth(keptText, font, ctx2, lastRun) : 0;
+      const delta = Math.max(0, fullWidth - keptWidth);
+      lineToTrim.width = roundValue(Math.max(0, lineToTrim.width - delta));
+      lineToTrim.spaceCount = Math.max(0, lineToTrim.spaceCount - trimCount);
+      if (lineToTrim.naturalWidth != null && typeof lineToTrim.naturalWidth === "number") {
+        lineToTrim.naturalWidth = roundValue(Math.max(0, lineToTrim.naturalWidth - delta));
+      }
+    };
     for (let runIndex = 0; runIndex < runsToProcess.length; runIndex++) {
       const run2 = runsToProcess[runIndex];
       if (run2.kind === "break") {
         if (currentLine) {
           const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-          const { spaceCount: _sc, ...lineBase } = currentLine;
+          const lineBase = currentLine;
           const completedLine = { ...lineBase, ...metrics };
           addBarTabsToLine(completedLine);
           lines.push(completedLine);
@@ -93426,7 +93708,7 @@ ${l}
             toRun: runIndex,
             toChar: 0,
             width: 0,
-            maxWidth: getEffectiveWidth(initialAvailableWidth),
+            maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
             segments: [],
             ...metrics
           };
@@ -93461,7 +93743,7 @@ ${l}
             width: 0,
             maxFontSize: 12,
             // Default font size for tabs
-            maxWidth: getEffectiveWidth(initialAvailableWidth),
+            maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
             segments: [],
             spaceCount: 0
           };
@@ -93511,7 +93793,7 @@ ${l}
             width: imageWidth,
             maxFontSize: imageHeight,
             // Use image height for line height calculation
-            maxWidth: getEffectiveWidth(initialAvailableWidth),
+            maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
             spaceCount: 0,
             segments: [
               {
@@ -93527,8 +93809,9 @@ ${l}
         }
         const appliedTabAlign = lastAppliedTabAlign;
         if (currentLine.width + imageWidth > currentLine.maxWidth && currentLine.width > 0) {
+          trimTrailingWrapSpaces(currentLine);
           const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-          const { spaceCount: _sc, ...lineBase } = currentLine;
+          const lineBase = currentLine;
           const completedLine = {
             ...lineBase,
             ...metrics
@@ -93601,7 +93884,7 @@ ${l}
             // Field annotations are atomic units
             width: annotationWidth,
             maxFontSize: annotationHeight,
-            maxWidth: getEffectiveWidth(initialAvailableWidth),
+            maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
             spaceCount: 0,
             segments: [
               {
@@ -93616,8 +93899,9 @@ ${l}
           continue;
         }
         if (currentLine.width + annotationWidth > currentLine.maxWidth && currentLine.width > 0) {
+          trimTrailingWrapSpaces(currentLine);
           const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-          const { spaceCount: _sc, ...lineBase } = currentLine;
+          const lineBase = currentLine;
           const completedLine = {
             ...lineBase,
             ...metrics
@@ -93690,15 +93974,16 @@ ${l}
               width: spacesWidth,
               maxFontSize: run2.fontSize,
               maxFontInfo: getFontInfoFromRun(run2),
-              maxWidth: getEffectiveWidth(initialAvailableWidth),
+              maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
               segments: [{ runIndex, fromChar: spacesStartChar, toChar: spacesEndChar, width: spacesWidth }],
               spaceCount: spacesLength
             };
           } else {
             const boundarySpacing = currentLine.width > 0 ? run2.letterSpacing ?? 0 : 0;
             if (currentLine.width + boundarySpacing + spacesWidth > currentLine.maxWidth - WIDTH_FUDGE_PX2 && currentLine.width > 0) {
+              trimTrailingWrapSpaces(currentLine);
               const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-              const { spaceCount: _sc, ...lineBase } = currentLine;
+              const lineBase = currentLine;
               const completedLine = {
                 ...lineBase,
                 ...metrics
@@ -93734,6 +94019,13 @@ ${l}
           continue;
         }
         const words = segment.split(" ");
+        let lastNonEmptyWordIndex = -1;
+        for (let i2 = words.length - 1; i2 >= 0; i2 -= 1) {
+          if (words[i2] !== "") {
+            lastNonEmptyWordIndex = i2;
+            break;
+          }
+        }
         let segmentStartX;
         if (currentLine && pendingTabAlignment) {
           segmentStartX = alignSegmentAtTab(segment, font, run2);
@@ -93756,15 +94048,16 @@ ${l}
                 width: singleSpaceWidth,
                 maxFontSize: run2.fontSize,
                 maxFontInfo: getFontInfoFromRun(run2),
-                maxWidth: getEffectiveWidth(initialAvailableWidth),
+                maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
                 segments: [{ runIndex, fromChar: spaceStartChar, toChar: spaceEndChar, width: singleSpaceWidth }],
                 spaceCount: 1
               };
             } else {
               const boundarySpacing2 = currentLine.width > 0 ? run2.letterSpacing ?? 0 : 0;
               if (currentLine.width + boundarySpacing2 + singleSpaceWidth > currentLine.maxWidth - WIDTH_FUDGE_PX2 && currentLine.width > 0) {
+                trimTrailingWrapSpaces(currentLine);
                 const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-                const { spaceCount: _sc, ...lineBase } = currentLine;
+                const lineBase = currentLine;
                 const completedLine = { ...lineBase, ...metrics };
                 addBarTabsToLine(completedLine);
                 lines.push(completedLine);
@@ -93796,19 +94089,19 @@ ${l}
             charPosInRun = spaceEndChar;
             continue;
           }
-          const isLastWordInSegment = wordIndex === words.length - 1;
-          const isLastWord = isLastWordInSegment && isLastSegment;
           const wordOnlyWidth = measureRunWidth(word, font, ctx2, run2);
-          const spaceWidth = isLastWord ? 0 : measureRunWidth(" ", font, ctx2, run2);
-          const wordCommitWidth = isLastWord ? wordOnlyWidth : wordOnlyWidth + spaceWidth;
+          const shouldIncludeDelimiterSpace = wordIndex < lastNonEmptyWordIndex;
+          const spaceWidth = shouldIncludeDelimiterSpace ? measureRunWidth(" ", font, ctx2, run2) : 0;
+          const wordCommitWidth = wordOnlyWidth + spaceWidth;
           const wordStartChar = charPosInRun;
           const wordEndNoSpace = charPosInRun + word.length;
-          const wordEndWithSpace = charPosInRun + (isLastWord ? word.length : word.length + 1);
+          const wordEndWithSpace = wordEndNoSpace + (shouldIncludeDelimiterSpace ? 1 : 0);
           const effectiveMaxWidth = currentLine ? currentLine.maxWidth : getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : contentWidth);
           if (wordOnlyWidth > effectiveMaxWidth && word.length > 1) {
             if (currentLine && currentLine.width > 0 && currentLine.segments && currentLine.segments.length > 0) {
+              trimTrailingWrapSpaces(currentLine);
               const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-              const { spaceCount: _sc, ...lineBase } = currentLine;
+              const lineBase = currentLine;
               const completedLine = { ...lineBase, ...metrics };
               addBarTabsToLine(completedLine);
               lines.push(completedLine);
@@ -93842,7 +94135,7 @@ ${l}
                 });
                 if (isLastChunk) {
                   const ls = run2.letterSpacing ?? 0;
-                  if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
+                  if (shouldIncludeDelimiterSpace && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
                     currentLine.toChar = wordEndWithSpace;
                     currentLine.width = roundValue(currentLine.width + spaceWidth + ls);
                     charPosInRun = wordEndWithSpace;
@@ -93851,8 +94144,9 @@ ${l}
                     charPosInRun = wordEndWithSpace;
                   }
                 } else {
+                  trimTrailingWrapSpaces(currentLine);
                   const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-                  const { spaceCount: _sc, ...lineBase } = currentLine;
+                  const lineBase = currentLine;
                   const completedLine = { ...lineBase, ...metrics };
                   addBarTabsToLine(completedLine);
                   lines.push(completedLine);
@@ -93874,7 +94168,7 @@ ${l}
                   spaceCount: 0
                 };
                 const ls = run2.letterSpacing ?? 0;
-                if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
+                if (shouldIncludeDelimiterSpace && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
                   currentLine.toChar = wordEndWithSpace;
                   currentLine.width = roundValue(currentLine.width + spaceWidth + ls);
                   charPosInRun = wordEndWithSpace;
@@ -93911,12 +94205,12 @@ ${l}
               width: wordOnlyWidth,
               maxFontSize: run2.fontSize,
               maxFontInfo: getFontInfoFromRun(run2),
-              maxWidth: getEffectiveWidth(initialAvailableWidth),
+              maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
               segments: [{ runIndex, fromChar: wordStartChar, toChar: wordEndNoSpace, width: wordOnlyWidth }],
               spaceCount: 0
             };
             const ls = run2.letterSpacing ?? 0;
-            if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
+            if (shouldIncludeDelimiterSpace && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
               currentLine.toChar = wordEndWithSpace;
               currentLine.width = roundValue(currentLine.width + spaceWidth + ls);
               charPosInRun = wordEndWithSpace;
@@ -93930,15 +94224,16 @@ ${l}
           const boundarySpacing = currentLine.width > 0 ? run2.letterSpacing ?? 0 : 0;
           const justifyAlignment = block.attrs?.alignment === "justify";
           const totalWidthWithWord = currentLine.width + boundarySpacing + wordCommitWidth + // Safe cast: only TextRuns produce word segments from split(), other run types are handled earlier
-          (isLastWord ? 0 : run2.letterSpacing ?? 0);
+          (shouldIncludeDelimiterSpace ? run2.letterSpacing ?? 0 : 0);
           const availableWidth = currentLine.maxWidth - WIDTH_FUDGE_PX2;
           let shouldBreak = currentLine.width + boundarySpacing + wordOnlyWidth > availableWidth && currentLine.width > 0 && !isTocEntry;
           let compressedWidth = null;
           if (shouldBreak && justifyAlignment) {
-            const isParagraphLastWord = isLastWord && runIndex === runsToProcess.length - 1;
+            const isLastNonEmptyWordInSegment = wordIndex === lastNonEmptyWordIndex;
+            const isParagraphLastWord = isLastSegment && isLastNonEmptyWordInSegment && runIndex === runsToProcess.length - 1;
             if (!isParagraphLastWord) {
               const existingSpaces = currentLine.spaceCount ?? 0;
-              const candidateSpaces = existingSpaces + (isLastWord ? 0 : 1);
+              const candidateSpaces = existingSpaces + (shouldIncludeDelimiterSpace ? 1 : 0);
               if (candidateSpaces > 0) {
                 const overflow = totalWidthWithWord - availableWidth;
                 if (overflow > 0) {
@@ -93954,8 +94249,9 @@ ${l}
             }
           }
           if (shouldBreak) {
+            trimTrailingWrapSpaces(currentLine);
             const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-            const { spaceCount: _sc, ...lineBase } = currentLine;
+            const lineBase = currentLine;
             const completedLine = {
               ...lineBase,
               ...metrics
@@ -93976,7 +94272,7 @@ ${l}
               segments: [{ runIndex, fromChar: wordStartChar, toChar: wordEndNoSpace, width: wordOnlyWidth }],
               spaceCount: 0
             };
-            if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
+            if (shouldIncludeDelimiterSpace && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
               currentLine.toChar = wordEndWithSpace;
               currentLine.width = roundValue(currentLine.width + spaceWidth + (run2.letterSpacing ?? 0));
               charPosInRun = wordEndWithSpace;
@@ -93986,7 +94282,7 @@ ${l}
             }
           } else {
             currentLine.toRun = runIndex;
-            if (!isLastWord && currentLine.width + boundarySpacing + wordOnlyWidth + spaceWidth > currentLine.maxWidth - WIDTH_FUDGE_PX2) {
+            if (shouldIncludeDelimiterSpace && currentLine.width + boundarySpacing + wordOnlyWidth + spaceWidth > currentLine.maxWidth - WIDTH_FUDGE_PX2) {
               currentLine.toChar = wordEndNoSpace;
               currentLine.width = roundValue(currentLine.width + boundarySpacing + wordOnlyWidth);
               currentLine.maxFontInfo = updateMaxFontInfo(currentLine.maxFontSize, currentLine.maxFontInfo, run2);
@@ -94000,8 +94296,9 @@ ${l}
                 wordOnlyWidth,
                 useExplicitXHere ? segmentStartX : void 0
               );
+              trimTrailingWrapSpaces(currentLine);
               const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-              const { spaceCount: _sc, ...lineBase } = currentLine;
+              const lineBase = currentLine;
               const completedLine = { ...lineBase, ...metrics };
               addBarTabsToLine(completedLine);
               lines.push(completedLine);
@@ -94011,20 +94308,23 @@ ${l}
               charPosInRun = wordEndNoSpace + 1;
               continue;
             }
-            const newToChar = isLastWord ? wordEndNoSpace : wordEndWithSpace;
+            const newToChar = shouldIncludeDelimiterSpace ? wordEndWithSpace : wordEndNoSpace;
             currentLine.toChar = newToChar;
             const useExplicitX = wordIndex === 0 && segmentStartX !== void 0;
             const explicitX = useExplicitX ? segmentStartX : void 0;
-            const targetWidth = compressedWidth != null ? compressedWidth : currentLine.width + boundarySpacing + wordCommitWidth + (isLastWord ? 0 : run2.letterSpacing ?? 0);
+            const targetWidth = compressedWidth != null ? compressedWidth : currentLine.width + boundarySpacing + wordCommitWidth + (shouldIncludeDelimiterSpace ? run2.letterSpacing ?? 0 : 0);
+            if (compressedWidth != null) {
+              currentLine.naturalWidth = roundValue(totalWidthWithWord);
+            }
             currentLine.width = roundValue(targetWidth);
             currentLine.maxFontInfo = updateMaxFontInfo(currentLine.maxFontSize, currentLine.maxFontInfo, run2);
             currentLine.maxFontSize = Math.max(currentLine.maxFontSize, run2.fontSize);
             appendSegment(currentLine.segments, runIndex, wordStartChar, newToChar, wordCommitWidth, explicitX);
-            if (!isLastWord) {
+            if (shouldIncludeDelimiterSpace) {
               currentLine.spaceCount += 1;
             }
           }
-          charPosInRun = isLastWord ? wordEndNoSpace : wordEndWithSpace;
+          charPosInRun = shouldIncludeDelimiterSpace ? wordEndWithSpace : wordEndNoSpace;
         }
         if (lastAppliedTabAlign && currentLine) {
           const appliedTab = lastAppliedTabAlign;
@@ -94044,7 +94344,7 @@ ${l}
               width: 0,
               maxFontSize: run2.fontSize,
               maxFontInfo: getFontInfoFromRun(run2),
-              maxWidth: getEffectiveWidth(initialAvailableWidth),
+              maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
               segments: [],
               spaceCount: 0
             };
@@ -94092,7 +94392,7 @@ ${l}
     }
     if (currentLine) {
       const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-      const { spaceCount: _sc, ...lineBase } = currentLine;
+      const lineBase = currentLine;
       const finalLine = {
         ...lineBase,
         ...metrics
@@ -151830,7 +152130,8 @@ ${style2}
           measurementTimeoutId.value = null;
         }
         const totalComments = getFloatingComments.value.length;
-        if (totalComments === 0) {
+        const measuredComments = renderedSizes.value.length;
+        if (totalComments === 0 || measuredComments === 0) {
           return;
         }
         nextTick(processLocations);
@@ -151911,7 +152212,7 @@ ${style2}
       };
     }
   };
-  const FloatingComments = /* @__PURE__ */ _export_sfc(_sfc_main$a, [["__scopeId", "data-v-6905dd07"]]);
+  const FloatingComments = /* @__PURE__ */ _export_sfc(_sfc_main$a, [["__scopeId", "data-v-1402ce8c"]]);
   const _sfc_main$9 = {
     __name: "TextField",
     props: {
@@ -153443,7 +153744,7 @@ ${style2}
       this.config.colors = shuffleArray(this.config.colors);
       this.userColorMap = /* @__PURE__ */ new Map();
       this.colorIndex = 0;
-      this.version = "1.0.0-next.3";
+      this.version = "1.0.0-next.5";
       this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config2.superdocId || v4();
       this.colors = this.config.colors;
@@ -155916,7 +156217,7 @@ ${style2}
       value && typeof value === "object" && "byteLength" in value && "byteOffset" in value
     );
   }
-  const indexDLOSgUP = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  const indexBUoOdDUj = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     __proto__: null,
     unified
   }, Symbol.toStringTag, { value: "Module" }));