@harbour-enterprises/superdoc 1.0.0-beta.87 → 1.0.0-beta.89

package/dist/chunks/{super-editor.es-C43B4f8Z.cjs → super-editor.es-D8F0msfn.cjs}

@@ -19631,9 +19631,9 @@ function encodeCSSFromPPr(paragraphProperties, hasPreviousParagraph, nextParagra
   const { spacing, indent, borders, justification } = paragraphProperties;
   const nextStyleId = nextParagraphProps?.styleId;
   if (spacing) {
-    const getEffectiveBefore = (nextSpacing, isListItem) => {
+    const getEffectiveBefore = (nextSpacing, isListItem2) => {
       if (!nextSpacing) return 0;
-      if (nextSpacing.beforeAutospacing && isListItem) {
+      if (nextSpacing.beforeAutospacing && isListItem2) {
         return 0;
       }
       return nextSpacing.before || 0;
@@ -20014,7 +20014,7 @@ function addTextDecorationEntries(targetSet, value) {
   }
   String(value).split(/\s+/).map((entry) => entry.trim()).filter(Boolean).forEach((entry) => targetSet.add(entry));
 }
-const getSpacingStyle = (spacing, isListItem) => {
+const getSpacingStyle = (spacing, isListItem2) => {
   let { before, after, line, lineRule, beforeAutospacing, afterAutospacing } = spacing;
   line = twipsToLines(line);
   if (line != null && line < 1) {
@@ -20025,13 +20025,13 @@ const getSpacingStyle = (spacing, isListItem) => {
   }
   before = twipsToPixels$2(before);
   if (beforeAutospacing) {
-    if (isListItem) {
+    if (isListItem2) {
       before = 0;
     }
   }
   after = twipsToPixels$2(after);
   if (afterAutospacing) {
-    if (isListItem) {
+    if (isListItem2) {
       after = 0;
     }
   }
@@ -42397,7 +42397,7 @@ const _SuperConverter = class _SuperConverter2 {
   static getStoredSuperdocVersion(docx) {
     return _SuperConverter2.getStoredCustomProperty(docx, "SuperdocVersion");
   }
-  static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-beta.87") {
+  static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-beta.89") {
     return _SuperConverter2.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
   }
   /**
@@ -59603,7 +59603,7 @@ const isHeadless = (editor) => {
 const shouldSkipNodeView = (editor) => {
   return isHeadless(editor);
 };
-const summaryVersion = "1.0.0-beta.87";
+const summaryVersion = "1.0.0-beta.89";
 const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
 const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
 function mapAttributes(attrs) {
@@ -60392,7 +60392,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
       { default: remarkStringify },
       { default: remarkGfm }
     ] = await Promise.all([
-      Promise.resolve().then(() => require("./index-rv7o9043-DD5SvBoC.cjs")),
+      Promise.resolve().then(() => require("./index-DcTrJ8db-kUMXGs8M.cjs")),
       Promise.resolve().then(() => require("./index-DRCvimau-H4Ck3S9a.cjs")),
       Promise.resolve().then(() => require("./index-C_x_N6Uh-Db3CUJMX.cjs")),
       Promise.resolve().then(() => require("./index-D_sWOSiG-BtDZzJ6I.cjs")),
@@ -60597,7 +60597,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
    * Process collaboration migrations
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.87");
+    console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.89");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -73509,7 +73509,14 @@ const renderTableCell = (deps) => {
         let renderedHeight = 0;
         for (let lineIdx = localStartLine; lineIdx < localEndLine && lineIdx < lines.length; lineIdx++) {
           const line = lines[lineIdx];
-          const lineEl = renderLine(block, line, { ...context, section: "body" });
+          const isLastLine = lineIdx === lines.length - 1;
+          const lineEl = renderLine(
+            block,
+            line,
+            { ...context, section: "body" },
+            lineIdx,
+            isLastLine
+          );
           lineEl.style.paddingLeft = "";
           lineEl.style.paddingRight = "";
           lineEl.style.textIndent = "";
@@ -76141,8 +76148,11 @@ const _DomPainter = class _DomPainter2 {
     const applyFragmentFrameWithSection = (el, frag) => {
       this.applyFragmentFrame(el, frag, context.section);
     };
-    const renderLineForTableCell = (block, line, ctx2) => {
-      return this.renderLine(block, line, ctx2, void 0, void 0, true);
+    const renderLineForTableCell = (block, line, ctx2, lineIndex, isLastLine) => {
+      const lastRun = block.runs.length > 0 ? block.runs[block.runs.length - 1] : null;
+      const paragraphEndsWithLineBreak = lastRun?.kind === "lineBreak";
+      const shouldSkipJustify = isLastLine && !paragraphEndsWithLineBreak;
+      return this.renderLine(block, line, ctx2, void 0, lineIndex, shouldSkipJustify);
     };
     const renderDrawingContentForTableCell = (block) => {
       if (block.drawingKind === "image") {
@@ -76751,9 +76761,10 @@ const _DomPainter = class _DomPainter2 {
       el.setAttribute("styleid", styleId);
     }
     const alignment2 = block.attrs?.alignment;
-    if (alignment2 === "center" || alignment2 === "right") {
-      el.style.textAlign = alignment2;
-    } else if (alignment2 === "justify") {
+    const effectiveAlignment = alignment2;
+    if (effectiveAlignment === "center" || effectiveAlignment === "right") {
+      el.style.textAlign = effectiveAlignment;
+    } else if (effectiveAlignment === "justify") {
       el.style.textAlign = "left";
     } else {
       el.style.textAlign = "left";
@@ -76815,16 +76826,16 @@ const _DomPainter = class _DomPainter2 {
     }
     const hasExplicitPositioning = line.segments?.some((seg) => seg.x !== void 0);
     const availableWidth = availableWidthOverride ?? line.maxWidth ?? line.width;
-    const shouldJustify = !skipJustify && alignment2 === "justify" && !hasExplicitPositioning;
+    const shouldJustify = !skipJustify && effectiveAlignment === "justify" && !hasExplicitPositioning;
     if (shouldJustify) {
       const spaceCount = textSlices.reduce(
         (sum, s2) => sum + Array.from(s2).filter((ch) => ch === " " || ch === " ").length,
         0
       );
-      const slack = Math.max(0, availableWidth - line.width);
-      if (spaceCount > 0 && slack > 0) {
-        const extraPerSpace = slack / spaceCount;
-        el.style.wordSpacing = `${extraPerSpace}px`;
+      const slack = availableWidth - line.width;
+      if (spaceCount > 0 && slack !== 0) {
+        const spacingPerSpace = slack / spaceCount;
+        el.style.wordSpacing = `${spacingPerSpace}px`;
       }
     }
     if (hasExplicitPositioning && line.segments) {
@@ -78285,6 +78296,50 @@ function findCharIndexAtX(textNode, container, targetX) {
   }
   return index2;
 }
+function getWordLayoutConfig(block) {
+  if (!block || block.kind !== "paragraph") {
+    return void 0;
+  }
+  return block.attrs?.wordLayout;
+}
+function isListItem(markerWidth, block) {
+  const hasMarkerWidth = markerWidth > 0;
+  if (hasMarkerWidth) {
+    return true;
+  }
+  if (!block || block.kind !== "paragraph") {
+    return false;
+  }
+  const wordLayout = getWordLayoutConfig(block);
+  const hasListAttrs = block.attrs?.listItem != null || wordLayout?.marker != null;
+  if (hasListAttrs) {
+    return true;
+  }
+  const hangingIndent = block.attrs?.indent?.hanging ?? 0;
+  const paraIndentLeft = block.attrs?.indent?.left ?? 0;
+  const hasHangingIndentPattern = hangingIndent > 0 && paraIndentLeft > 0;
+  return hasHangingIndentPattern;
+}
+function calculateTextStartIndent(params2) {
+  const { isFirstLine, isListItem: isListItem2, markerWidth, paraIndentLeft, firstLineIndent, hangingIndent, wordLayout } = params2;
+  const firstLineOffset = firstLineIndent - hangingIndent;
+  const isFirstLineIndentMode = wordLayout?.firstLineIndentMode === true;
+  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;
+  } else if (isFirstLine && !isListItem2) {
+    indentAdjust += firstLineOffset;
+  }
+  return indentAdjust;
+}
+function extractParagraphIndent(indent) {
+  const left2 = typeof indent?.left === "number" && Number.isFinite(indent.left) ? indent.left : 0;
+  const right2 = typeof indent?.right === "number" && Number.isFinite(indent.right) ? indent.right : 0;
+  const firstLine = typeof indent?.firstLine === "number" && Number.isFinite(indent.firstLine) ? indent.firstLine : 0;
+  const hanging = typeof indent?.hanging === "number" && Number.isFinite(indent.hanging) ? indent.hanging : 0;
+  return { left: left2, right: right2, firstLine, hanging };
+}
 const defaultHeaderFooterIdentifier = () => ({
   headerIds: { default: null, first: null, even: null, odd: null },
   footerIds: { default: null, first: null, even: null, odd: null },
@@ -83296,8 +83351,8 @@ function clickToPosition(layout, blocks, measures, containerPoint, domContainer,
       );
     }
     const markerWidth = fragment.markerWidth ?? measure.marker?.markerWidth ?? 0;
-    const isListItem = markerWidth > 0;
-    const alignmentOverride = isListItem ? "left" : void 0;
+    const isListItem3 = markerWidth > 0;
+    const alignmentOverride = isListItem3 ? "left" : void 0;
     const pos = mapPointToPm(block, line, pageRelativePoint.x - fragment.x, isRTL, availableWidth, alignmentOverride);
     if (pos == null) {
       logClickStage("warn", "no-position", {
@@ -83341,8 +83396,8 @@ function clickToPosition(layout, blocks, measures, containerPoint, domContainer,
         );
       }
       const cellMarkerWidth = cellMeasure.marker?.markerWidth ?? 0;
-      const isListItem = cellMarkerWidth > 0;
-      const alignmentOverride = isListItem ? "left" : void 0;
+      const isListItem3 = cellMarkerWidth > 0;
+      const alignmentOverride = isListItem3 ? "left" : void 0;
       const pos = mapPointToPm(cellBlock, line, localX, isRTL, availableWidth, alignmentOverride);
       if (pos != null) {
         logClickStage("log", "success", {
@@ -83500,17 +83555,22 @@ function selectionToRects(layout, blocks, measures, from2, to) {
           const charOffsetFrom = pmPosToCharOffset(block, line, sliceFrom);
           const charOffsetTo = pmPosToCharOffset(block, line, sliceTo);
           const markerWidth = fragment.markerWidth ?? measure.marker?.markerWidth ?? 0;
-          const isListItem = markerWidth > 0;
-          const alignmentOverride = isListItem ? "left" : void 0;
+          const isListItemFlag = isListItem(markerWidth, block);
+          const alignmentOverride = isListItemFlag ? "left" : void 0;
           const startX = mapPmToX(block, line, charOffsetFrom, fragment.width, alignmentOverride);
           const endX = mapPmToX(block, line, charOffsetTo, fragment.width, alignmentOverride);
-          const paraIndentLeft = block.attrs?.indent?.left ?? 0;
-          const firstLineOffset = (block.attrs?.indent?.firstLine ?? 0) - (block.attrs?.indent?.hanging ?? 0);
+          const indent = extractParagraphIndent(block.attrs?.indent);
+          const wordLayout = getWordLayoutConfig(block);
           const isFirstLine = index2 === fragment.fromLine;
-          let indentAdjust = paraIndentLeft;
-          if (isFirstLine && !isListItem) {
-            indentAdjust += firstLineOffset;
-          }
+          const indentAdjust = calculateTextStartIndent({
+            isFirstLine,
+            isListItem: isListItemFlag,
+            markerWidth,
+            paraIndentLeft: indent.left,
+            firstLineIndent: indent.firstLine,
+            hangingIndent: indent.hanging,
+            wordLayout
+          });
           const rectX = fragment.x + indentAdjust + Math.min(startX, endX);
           const rectWidth = Math.max(1, Math.abs(endX - startX));
           const lineOffset = lineHeightBeforeIndex(measure, index2) - lineHeightBeforeIndex(measure, fragment.fromLine);
@@ -83613,9 +83673,12 @@ function selectionToRects(layout, blocks, measures, from2, to) {
             let blockTopCursor = padding.top + verticalOffset;
             renderedBlocks.forEach((info) => {
               const paragraphMarkerWidth = info.measure.marker?.markerWidth ?? 0;
-              const isListItem = paragraphMarkerWidth > 0;
-              const alignmentOverride = isListItem ? "left" : void 0;
-              const paraIndentLeft = info.block.kind === "paragraph" ? info.block.attrs?.indent?.left ?? 0 : 0;
+              const cellIsListItem = isListItem(paragraphMarkerWidth, info.block);
+              const alignmentOverride = cellIsListItem ? "left" : void 0;
+              const cellIndent = extractParagraphIndent(
+                info.block.kind === "paragraph" ? info.block.attrs?.indent : void 0
+              );
+              const cellWordLayout = getWordLayoutConfig(info.block);
               const intersectingLines = findLinesIntersectingRange(info.block, info.measure, from2, to);
               intersectingLines.forEach(({ line, index: index2 }) => {
                 if (index2 < info.startLine || index2 >= info.endLine) {
@@ -83631,7 +83694,17 @@ function selectionToRects(layout, blocks, measures, from2, to) {
                 const availableWidth = Math.max(1, cellMeasure.width - padding.left - padding.right);
                 const startX = mapPmToX(info.block, line, charOffsetFrom, availableWidth, alignmentOverride);
                 const endX = mapPmToX(info.block, line, charOffsetTo, availableWidth, alignmentOverride);
-                const rectX = fragment.x + cellX + padding.left + paraIndentLeft + Math.min(startX, endX);
+                const isFirstLine = index2 === info.startLine;
+                const textIndentAdjust = calculateTextStartIndent({
+                  isFirstLine,
+                  isListItem: cellIsListItem,
+                  markerWidth: paragraphMarkerWidth,
+                  paraIndentLeft: cellIndent.left,
+                  firstLineIndent: cellIndent.firstLine,
+                  hangingIndent: cellIndent.hanging,
+                  wordLayout: cellWordLayout
+                });
+                const rectX = fragment.x + cellX + padding.left + textIndentAdjust + Math.min(startX, endX);
                 const rectWidth = Math.max(1, Math.abs(endX - startX));
                 const lineOffset = lineHeightBeforeIndex(info.measure, index2) - lineHeightBeforeIndex(info.measure, info.startLine);
                 const rectY = fragment.y + rowOffset + blockTopCursor + lineOffset;
@@ -84003,9 +84076,7 @@ function getMeasuredTextWidth(text, font, letterSpacing, ctx2) {
   try {
     ctx2.font = font;
     const metrics = ctx2.measureText(text);
-    const advanceWidth = metrics.width;
-    const paintedWidth = (metrics.actualBoundingBoxLeft || 0) + (metrics.actualBoundingBoxRight || 0);
-    const baseWidth = Math.max(advanceWidth, paintedWidth);
+    const baseWidth = metrics.width;
     const extra = letterSpacing ? Math.max(0, text.length - 1) * letterSpacing : 0;
     const width = baseWidth + extra;
     cache$1.set(key2, { width });
@@ -84214,7 +84285,8 @@ async function measureParagraphBlock(block, maxWidth) {
   const isWordLayoutList = Boolean(wordLayout?.marker);
   const suppressFirstLine = block.attrs?.suppressFirstLineIndent === true;
   const rawFirstLineOffset = suppressFirstLine ? 0 : firstLine - hanging;
-  const firstLineOffset = isWordLayoutList ? 0 : rawFirstLineOffset;
+  const clampedFirstLineOffset = Math.max(0, rawFirstLineOffset);
+  const firstLineOffset = isWordLayoutList ? 0 : clampedFirstLineOffset;
   const contentWidth = Math.max(1, maxWidth - indentLeft - indentRight);
   let leftJustifiedMarkerSpace = 0;
   if (wordLayout?.marker) {
@@ -84367,7 +84439,8 @@ async function measureParagraphBlock(block, maxWidth) {
     if (run2.kind === "break") {
       if (currentLine) {
         const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-        const completedLine = { ...currentLine, ...metrics };
+        const { spaceCount: _sc, ...lineBase } = currentLine;
+        const completedLine = { ...lineBase, ...metrics };
         addBarTabsToLine(completedLine);
         lines.push(completedLine);
         currentLine = null;
@@ -84428,7 +84501,8 @@ async function measureParagraphBlock(block, maxWidth) {
         width: 0,
         maxFontSize: lastFontSize,
         maxWidth: nextLineMaxWidth,
-        segments: []
+        segments: [],
+        spaceCount: 0
       };
       tabStopCursor = 0;
       pendingTabAlignment = null;
@@ -84446,7 +84520,8 @@ async function measureParagraphBlock(block, maxWidth) {
           maxFontSize: 12,
           // Default font size for tabs
           maxWidth: getEffectiveWidth(initialAvailableWidth),
-          segments: []
+          segments: [],
+          spaceCount: 0
         };
       }
       const originX = currentLine.width;
@@ -84495,6 +84570,7 @@ async function measureParagraphBlock(block, maxWidth) {
           maxFontSize: imageHeight,
           // Use image height for line height calculation
           maxWidth: getEffectiveWidth(initialAvailableWidth),
+          spaceCount: 0,
           segments: [
             {
               runIndex,
@@ -84510,8 +84586,9 @@ async function measureParagraphBlock(block, maxWidth) {
       const appliedTabAlign = lastAppliedTabAlign;
       if (currentLine.width + imageWidth > currentLine.maxWidth && currentLine.width > 0) {
         const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
+        const { spaceCount: _sc, ...lineBase } = currentLine;
         const completedLine = {
-          ...currentLine,
+          ...lineBase,
           ...metrics
         };
         addBarTabsToLine(completedLine);
@@ -84527,6 +84604,7 @@ async function measureParagraphBlock(block, maxWidth) {
           width: imageWidth,
           maxFontSize: imageHeight,
           maxWidth: getEffectiveWidth(contentWidth),
+          spaceCount: 0,
           segments: [
             {
               runIndex,
@@ -84582,6 +84660,7 @@ async function measureParagraphBlock(block, maxWidth) {
           width: annotationWidth,
           maxFontSize: annotationHeight,
           maxWidth: getEffectiveWidth(initialAvailableWidth),
+          spaceCount: 0,
           segments: [
             {
               runIndex,
@@ -84596,8 +84675,9 @@ async function measureParagraphBlock(block, maxWidth) {
       }
       if (currentLine.width + annotationWidth > currentLine.maxWidth && currentLine.width > 0) {
         const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
+        const { spaceCount: _sc, ...lineBase } = currentLine;
         const completedLine = {
-          ...currentLine,
+          ...lineBase,
           ...metrics
         };
         addBarTabsToLine(completedLine);
@@ -84613,6 +84693,7 @@ async function measureParagraphBlock(block, maxWidth) {
           width: annotationWidth,
           maxFontSize: annotationHeight,
           maxWidth: getEffectiveWidth(contentWidth),
+          spaceCount: 0,
           segments: [
             {
               runIndex,
@@ -84668,14 +84749,16 @@ async function measureParagraphBlock(block, maxWidth) {
             maxFontSize: run2.fontSize,
             maxFontInfo: getFontInfoFromRun(run2),
             maxWidth: getEffectiveWidth(initialAvailableWidth),
-            segments: [{ runIndex, fromChar: spacesStartChar, toChar: spacesEndChar, width: spacesWidth }]
+            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_PX && currentLine.width > 0) {
             const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
+            const { spaceCount: _sc, ...lineBase } = currentLine;
             const completedLine = {
-              ...currentLine,
+              ...lineBase,
               ...metrics
             };
             addBarTabsToLine(completedLine);
@@ -84692,7 +84775,8 @@ async function measureParagraphBlock(block, maxWidth) {
               maxFontSize: run2.fontSize,
               maxFontInfo: getFontInfoFromRun(run2),
               maxWidth: getEffectiveWidth(contentWidth),
-              segments: [{ runIndex, fromChar: spacesStartChar, toChar: spacesEndChar, width: spacesWidth }]
+              segments: [{ runIndex, fromChar: spacesStartChar, toChar: spacesEndChar, width: spacesWidth }],
+              spaceCount: spacesLength
             };
           } else {
             currentLine.toRun = runIndex;
@@ -84701,6 +84785,7 @@ async function measureParagraphBlock(block, maxWidth) {
             currentLine.maxFontInfo = updateMaxFontInfo(currentLine.maxFontSize, currentLine.maxFontInfo, run2);
             currentLine.maxFontSize = Math.max(currentLine.maxFontSize, run2.fontSize);
             appendSegment(currentLine.segments, runIndex, spacesStartChar, spacesEndChar, spacesWidth);
+            currentLine.spaceCount += spacesLength;
           }
         }
         charPosInRun = spacesEndChar;
@@ -84717,7 +84802,56 @@ async function measureParagraphBlock(block, maxWidth) {
       for (let wordIndex = 0; wordIndex < words.length; wordIndex++) {
         const word = words[wordIndex];
         if (word === "") {
-          charPosInRun += 1;
+          const spaceStartChar = charPosInRun;
+          const spaceEndChar = charPosInRun + 1;
+          const singleSpaceWidth = measureRunWidth(" ", font, ctx2, run2);
+          if (!currentLine) {
+            currentLine = {
+              fromRun: runIndex,
+              fromChar: spaceStartChar,
+              toRun: runIndex,
+              toChar: spaceEndChar,
+              width: singleSpaceWidth,
+              maxFontSize: run2.fontSize,
+              maxFontInfo: getFontInfoFromRun(run2),
+              maxWidth: getEffectiveWidth(initialAvailableWidth),
+              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_PX && currentLine.width > 0) {
+              const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
+              const { spaceCount: _sc, ...lineBase } = currentLine;
+              const completedLine = { ...lineBase, ...metrics };
+              addBarTabsToLine(completedLine);
+              lines.push(completedLine);
+              tabStopCursor = 0;
+              pendingTabAlignment = null;
+              lastAppliedTabAlign = null;
+              currentLine = {
+                fromRun: runIndex,
+                fromChar: spaceStartChar,
+                toRun: runIndex,
+                toChar: spaceEndChar,
+                width: singleSpaceWidth,
+                maxFontSize: run2.fontSize,
+                maxFontInfo: getFontInfoFromRun(run2),
+                maxWidth: getEffectiveWidth(contentWidth),
+                segments: [{ runIndex, fromChar: spaceStartChar, toChar: spaceEndChar, width: singleSpaceWidth }],
+                spaceCount: 1
+              };
+            } else {
+              currentLine.toRun = runIndex;
+              currentLine.toChar = spaceEndChar;
+              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);
+              currentLine.spaceCount += 1;
+            }
+          }
+          charPosInRun = spaceEndChar;
           continue;
         }
         const isLastWordInSegment = wordIndex === words.length - 1;
@@ -84738,13 +84872,15 @@ async function measureParagraphBlock(block, maxWidth) {
             maxFontSize: run2.fontSize,
             maxFontInfo: getFontInfoFromRun(run2),
             maxWidth: getEffectiveWidth(initialAvailableWidth),
-            segments: [{ runIndex, fromChar: wordStartChar, toChar: wordEndNoSpace, width: wordOnlyWidth }]
+            segments: [{ runIndex, fromChar: wordStartChar, toChar: wordEndNoSpace, width: wordOnlyWidth }],
+            spaceCount: 0
           };
           const ls = run2.letterSpacing ?? 0;
           if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX) {
             currentLine.toChar = wordEndWithSpace;
             currentLine.width = roundValue(currentLine.width + spaceWidth + ls);
             charPosInRun = wordEndWithSpace;
+            currentLine.spaceCount += 1;
           } else {
             charPosInRun = wordEndWithSpace;
           }
@@ -84752,10 +84888,36 @@ async function measureParagraphBlock(block, maxWidth) {
         }
         const isTocEntry = block.attrs?.isTocEntry;
         const boundarySpacing = currentLine.width > 0 ? run2.letterSpacing ?? 0 : 0;
-        if (currentLine.width + boundarySpacing + wordOnlyWidth > currentLine.maxWidth - WIDTH_FUDGE_PX && currentLine.width > 0 && !isTocEntry) {
+        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);
+        const availableWidth = currentLine.maxWidth - WIDTH_FUDGE_PX;
+        let shouldBreak = currentLine.width + boundarySpacing + wordOnlyWidth > availableWidth && currentLine.width > 0 && !isTocEntry;
+        let compressedWidth = null;
+        if (shouldBreak && justifyAlignment) {
+          const isParagraphLastWord = isLastWord && runIndex === runsToProcess.length - 1;
+          if (!isParagraphLastWord) {
+            const existingSpaces = currentLine.spaceCount ?? 0;
+            const candidateSpaces = existingSpaces + (isLastWord ? 0 : 1);
+            if (candidateSpaces > 0) {
+              const overflow = totalWidthWithWord - availableWidth;
+              if (overflow > 0) {
+                const baseSpaceWidth = spaceWidth || measureRunWidth(" ", font, ctx2, run2) || Math.max(1, boundarySpacing);
+                const perSpaceCompression = overflow / candidateSpaces;
+                const maxPerSpaceCompression = baseSpaceWidth * 0.25;
+                if (perSpaceCompression <= maxPerSpaceCompression) {
+                  shouldBreak = false;
+                  compressedWidth = availableWidth;
+                }
+              }
+            }
+          }
+        }
+        if (shouldBreak) {
           const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
+          const { spaceCount: _sc, ...lineBase } = currentLine;
           const completedLine = {
-            ...currentLine,
+            ...lineBase,
             ...metrics
           };
           addBarTabsToLine(completedLine);
@@ -84771,12 +84933,14 @@ async function measureParagraphBlock(block, maxWidth) {
             maxFontSize: run2.fontSize,
             maxFontInfo: getFontInfoFromRun(run2),
             maxWidth: getEffectiveWidth(contentWidth),
-            segments: [{ runIndex, fromChar: wordStartChar, toChar: wordEndNoSpace, width: wordOnlyWidth }]
+            segments: [{ runIndex, fromChar: wordStartChar, toChar: wordEndNoSpace, width: wordOnlyWidth }],
+            spaceCount: 0
           };
           if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX) {
             currentLine.toChar = wordEndWithSpace;
             currentLine.width = roundValue(currentLine.width + spaceWidth + (run2.letterSpacing ?? 0));
             charPosInRun = wordEndWithSpace;
+            currentLine.spaceCount += 1;
           } else {
             charPosInRun = wordEndWithSpace;
           }
@@ -84797,7 +84961,8 @@ async function measureParagraphBlock(block, maxWidth) {
               useExplicitXHere ? segmentStartX : void 0
             );
             const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-            const completedLine = { ...currentLine, ...metrics };
+            const { spaceCount: _sc, ...lineBase } = currentLine;
+            const completedLine = { ...lineBase, ...metrics };
             addBarTabsToLine(completedLine);
             lines.push(completedLine);
             tabStopCursor = 0;
@@ -84810,12 +84975,14 @@ async function measureParagraphBlock(block, maxWidth) {
           currentLine.toChar = newToChar;
           const useExplicitX = wordIndex === 0 && segmentStartX !== void 0;
           const explicitX = useExplicitX ? segmentStartX : void 0;
-          currentLine.width = roundValue(
-            currentLine.width + boundarySpacing + wordCommitWidth + (isLastWord ? 0 : run2.letterSpacing ?? 0)
-          );
+          const targetWidth = compressedWidth != null ? compressedWidth : currentLine.width + boundarySpacing + wordCommitWidth + (isLastWord ? 0 : run2.letterSpacing ?? 0);
+          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) {
+            currentLine.spaceCount += 1;
+          }
         }
         charPosInRun = isLastWord ? wordEndNoSpace : wordEndWithSpace;
       }
@@ -84838,7 +85005,8 @@ async function measureParagraphBlock(block, maxWidth) {
             maxFontSize: run2.fontSize,
             maxFontInfo: getFontInfoFromRun(run2),
             maxWidth: getEffectiveWidth(initialAvailableWidth),
-            segments: []
+            segments: [],
+            spaceCount: 0
           };
         }
         const originX = currentLine.width;
@@ -84884,8 +85052,9 @@ async function measureParagraphBlock(block, maxWidth) {
   }
   if (currentLine) {
     const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
+    const { spaceCount: _sc, ...lineBase } = currentLine;
     const finalLine = {
-      ...currentLine,
+      ...lineBase,
       ...metrics
     };
     addBarTabsToLine(finalLine);
@@ -91175,18 +91344,78 @@ computeCaretLayoutRectGeometry_fn = function(pos, includeDomFallback = true) {
   if (range2.pmStart == null || range2.pmEnd == null) return null;
   const pmOffset = pmPosToCharOffset(block, line, pos);
   const markerWidth = fragment.markerWidth ?? measure.marker?.markerWidth ?? 0;
-  const paraIndentLeft = block.attrs?.indent?.left ?? 0;
-  const paraIndentRight = block.attrs?.indent?.right ?? 0;
-  const availableWidth = Math.max(0, fragment.width - (paraIndentLeft + paraIndentRight));
+  const indent = extractParagraphIndent(block.attrs?.indent);
+  const availableWidth = Math.max(0, fragment.width - (indent.left + indent.right));
   const charX = measureCharacterX(block, line, pmOffset, availableWidth);
-  const firstLineOffset = (block.attrs?.indent?.firstLine ?? 0) - (block.attrs?.indent?.hanging ?? 0);
   const isFirstLine = index2 === fragment.fromLine;
-  const isListFirstLine = isFirstLine && !fragment.continuesFromPrev && (fragment.markerWidth ?? 0) > 0;
-  let indentAdjust = 0;
-  if (!isListFirstLine) {
-    indentAdjust = paraIndentLeft + (isFirstLine ? firstLineOffset : 0);
+  const isListItemFlag = isListItem(markerWidth, block);
+  const isListFirstLine = isFirstLine && !fragment.continuesFromPrev && isListItemFlag;
+  const wordLayout = getWordLayoutConfig(block);
+  const isFirstLineIndentMode = wordLayout?.firstLineIndentMode === true;
+  if (isListFirstLine && isFirstLineIndentMode) {
+    const textStartPx = calculateTextStartIndent({
+      isFirstLine,
+      isListItem: isListItemFlag,
+      markerWidth,
+      paraIndentLeft: indent.left,
+      firstLineIndent: indent.firstLine,
+      hangingIndent: indent.hanging,
+      wordLayout
+    });
+    const localX2 = fragment.x + textStartPx + charX;
+    const lineOffset2 = __privateMethod$1(this, _PresentationEditor_instances, lineHeightBeforeIndex_fn).call(this, measure.lines, fragment.fromLine, index2);
+    const localY2 = fragment.y + lineOffset2;
+    const result2 = {
+      pageIndex: hit.pageIndex,
+      x: localX2,
+      y: localY2,
+      height: line.lineHeight
+    };
+    const pageEl2 = __privateGet$1(this, _painterHost)?.querySelector(
+      `.superdoc-page[data-page-index="${hit.pageIndex}"]`
+    );
+    const pageRect2 = pageEl2?.getBoundingClientRect();
+    const zoom2 = __privateGet$1(this, _layoutOptions).zoom ?? 1;
+    let domCaretX2 = null;
+    let domCaretY2 = null;
+    const spanEls2 = pageEl2?.querySelectorAll("span[data-pm-start][data-pm-end]") ?? [];
+    for (const spanEl of spanEls2) {
+      const pmStart = Number(spanEl.dataset.pmStart);
+      const pmEnd = Number(spanEl.dataset.pmEnd);
+      if (pos >= pmStart && pos <= pmEnd && spanEl.firstChild?.nodeType === Node.TEXT_NODE) {
+        const textNode = spanEl.firstChild;
+        const charIndex = Math.min(pos - pmStart, textNode.length);
+        const rangeObj = document.createRange();
+        rangeObj.setStart(textNode, charIndex);
+        rangeObj.setEnd(textNode, charIndex);
+        const rangeRect = rangeObj.getBoundingClientRect();
+        if (pageRect2) {
+          domCaretX2 = (rangeRect.left - pageRect2.left) / zoom2;
+          domCaretY2 = (rangeRect.top - pageRect2.top) / zoom2;
+        }
+        break;
+      }
+    }
+    if (includeDomFallback && domCaretX2 != null && domCaretY2 != null) {
+      return {
+        pageIndex: hit.pageIndex,
+        x: domCaretX2,
+        y: domCaretY2,
+        height: line.lineHeight
+      };
+    }
+    return result2;
   }
-  const localX = fragment.x + markerWidth + indentAdjust + charX;
+  const indentAdjust = calculateTextStartIndent({
+    isFirstLine,
+    isListItem: isListItemFlag,
+    markerWidth,
+    paraIndentLeft: indent.left,
+    firstLineIndent: indent.firstLine,
+    hangingIndent: indent.hanging,
+    wordLayout
+  });
+  const localX = fragment.x + indentAdjust + charX;
   const lineOffset = __privateMethod$1(this, _PresentationEditor_instances, lineHeightBeforeIndex_fn).call(this, measure.lines, fragment.fromLine, index2);
   const localY = fragment.y + lineOffset;
   const result = {