@superdoc-dev/cli 0.8.0-next.79 → 0.8.0-next.80

package/dist/index.js

@@ -207687,7 +207687,7 @@ var init_remark_gfm_eZN6yzWQ_es = __esm(() => {
   init_remark_gfm_BhnWr3yf_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-ItIaPxzW.es.js
+// ../../packages/superdoc/dist/chunks/src-C-jV2TZI.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -207744,9 +207744,11 @@ function cssColorToHex(cssColor) {
   return trimmed;
 }
 function computeTabStops$1(context) {
-  const { explicitStops, defaultTabInterval, paragraphIndent } = context;
+  const { explicitStops, defaultTabInterval, paragraphIndent, rawParagraphIndent } = context;
   const leftIndent = paragraphIndent.left ?? 0;
   const hanging = paragraphIndent.hanging ?? 0;
+  const rawLeftIndent = rawParagraphIndent?.left ?? leftIndent;
+  const rawHanging = rawParagraphIndent?.hanging ?? hanging;
   const effectiveMinIndent = Math.max(0, leftIndent - hanging);
   const clearPositions = explicitStops.filter((stop) => stop.val === "clear").map((stop) => stop.pos);
   const filteredExplicitStops = explicitStops.filter((stop) => stop.val !== "clear").filter((stop) => stop.pos >= effectiveMinIndent).map((stop) => ({
@@ -207757,6 +207759,7 @@ function computeTabStops$1(context) {
   const stops = [...filteredExplicitStops];
   const hasStartAlignedExplicit = filteredExplicitStops.some((stop) => stop.val === "start");
   const hasExplicitStops = filteredExplicitStops.length > 0;
+  const hasClearAtPosition = (position4) => clearPositions.some((clearPos) => Math.abs(clearPos - position4) < TAB_POSITION_TOLERANCE_TWIPS);
   const hasClearAtLeftIndent = clearPositions.some((clearPos) => Math.abs(clearPos - leftIndent) < TAB_POSITION_TOLERANCE_TWIPS);
   if (!hasExplicitStops && !hasClearAtLeftIndent && hanging > 0 && leftIndent > effectiveMinIndent)
     stops.push({
@@ -207765,6 +207768,22 @@ function computeTabStops$1(context) {
       leader: "none",
       source: "default"
     });
+  const firstLineOrigin = rawLeftIndent - rawHanging;
+  if (firstLineOrigin < 0 && !hasClearAtPosition(0) && !stops.some((stop) => Math.abs(stop.pos) < TAB_POSITION_TOLERANCE_TWIPS))
+    stops.push({
+      val: "start",
+      pos: 0,
+      leader: "none",
+      source: "default"
+    });
+  const leftIndentStop = Math.abs(rawLeftIndent);
+  if (rawHanging > 0 && leftIndentStop > 0 && firstLineOrigin < leftIndentStop && !hasClearAtPosition(leftIndentStop) && !stops.some((stop) => Math.abs(stop.pos - leftIndentStop) < TAB_POSITION_TOLERANCE_TWIPS))
+    stops.push({
+      val: "start",
+      pos: leftIndentStop,
+      leader: "none",
+      source: "default"
+    });
   const defaultStart = !hasStartAlignedExplicit ? 0 : Math.max(maxExplicit, leftIndent);
   let pos = defaultStart;
   const targetLimit = Math.max(defaultStart, leftIndent, maxExplicit) + 14400;
@@ -251728,7 +251747,8 @@ function resolveParagraphContent(fragment2, block, measure) {
         if (!hasExplicitSegmentPositioning)
           textIndentPx = firstLineOffset;
       }
-      availableWidth = adjustAvailableWidthForTextIndent(availableWidth, textIndentPx, line.maxWidth);
+      const availableWidthIndentOffset = isFirstLine && !isListFirstLine && line.hasExplicitTabStops !== true ? firstLineOffset : textIndentPx;
+      availableWidth = adjustAvailableWidthForTextIndent(availableWidth, availableWidthIndentOffset, line.maxWidth);
       const indentLeft = paraIndent?.left ?? 0;
       const firstLine = paraIndent?.firstLine ?? 0;
       const hanging = paraIndent?.hanging ?? 0;
@@ -257597,8 +257617,8 @@ function remeasureParagraph(block, maxWidth, firstLineIndent = 0) {
   const wordLayout = attrs?.wordLayout;
   const rawIndentLeft = typeof indent2?.left === "number" && Number.isFinite(indent2.left) ? indent2.left : 0;
   const rawIndentRight = typeof indent2?.right === "number" && Number.isFinite(indent2.right) ? indent2.right : 0;
-  const indentLeft = Math.max(0, rawIndentLeft);
-  const indentRight = Math.max(0, rawIndentRight);
+  const indentLeft = rawIndentLeft;
+  const indentRight = rawIndentRight;
   const indentFirstLine = Math.max(0, indent2?.firstLine ?? 0);
   const indentHanging = Math.max(0, indent2?.hanging ?? 0);
   const baseFirstLineOffset = attrs?.suppressFirstLineIndent === true ? 0 : firstLineIndent || indentFirstLine - indentHanging;
@@ -268100,6 +268120,7 @@ async function measureParagraphBlock(block, maxWidth) {
   let hasSeenTextRun = false;
   let tabStopCursor = 0;
   let pendingTabAlignment = null;
+  let pendingSegmentPrecedingTabEndX;
   let pendingLeader = null;
   let pendingRunSpacing = 0;
   let lastAppliedTabAlign = null;
@@ -268122,7 +268143,7 @@ async function measureParagraphBlock(block, maxWidth) {
       return;
     if (segmentWidth < 0)
       segmentWidth = 0;
-    const { target, val } = pendingTabAlignment;
+    const { target, val, compensateNegativeLeft } = pendingTabAlignment;
     let startX = currentLine.width;
     if (val === "decimal") {
       const beforeWidth = beforeDecimalWidth ?? 0;
@@ -268133,10 +268154,9 @@ async function measureParagraphBlock(block, maxWidth) {
       startX = Math.max(0, target - segmentWidth / 2);
     else
       startX = Math.max(0, target);
-    if (pendingLeader) {
-      const effectiveIndent = lines.length === 0 ? indentLeft + rawFirstLineOffset : indentLeft;
+    const effectiveIndent = lines.length === 0 ? indentLeft + rawFirstLineOffset : indentLeft;
+    if (pendingLeader)
       pendingLeader.to = startX + effectiveIndent;
-    }
     currentLine.width = roundValue(startX);
     lastAppliedTabAlign = {
       target,
@@ -268144,7 +268164,17 @@ async function measureParagraphBlock(block, maxWidth) {
     };
     pendingTabAlignment = null;
     pendingLeader = null;
-    return startX;
+    const shouldCompensateNegativeLeft = compensateNegativeLeft === true;
+    pendingSegmentPrecedingTabEndX = shouldCompensateNegativeLeft ? startX : undefined;
+    return shouldCompensateNegativeLeft ? startX - Math.min(effectiveIndent, 0) : startX;
+  };
+  const consumePendingPrecedingTabEndX = () => {
+    const value = pendingSegmentPrecedingTabEndX;
+    pendingSegmentPrecedingTabEndX = undefined;
+    return value;
+  };
+  const clearPendingPrecedingTabEndX = () => {
+    pendingSegmentPrecedingTabEndX = undefined;
   };
   const alignSegmentAtTab = (segmentText, font, runContext, segmentStartChar) => {
     if (!pendingTabAlignment || !currentLine)
@@ -268485,7 +268515,8 @@ async function measureParagraphBlock(block, maxWidth) {
         } else
           pendingTabAlignment = {
             target: clampedTarget - effectiveIndent,
-            val: stop.val
+            val: stop.val,
+            compensateNegativeLeft: stop.val === "start" && indentLeft < 0 && effectiveIndent === indentLeft && stop.source !== "explicit"
           };
       } else {
         pendingTabAlignment = null;
@@ -268507,6 +268538,7 @@ async function measureParagraphBlock(block, maxWidth) {
         activeTabGroup.currentX = roundValue(activeTabGroup.currentX + imageWidth);
       } else if (pendingTabAlignment && currentLine)
         imageStartX = alignPendingTabForWidth(imageWidth);
+      const imagePrecedingTabEndX = imageStartX !== undefined ? consumePendingPrecedingTabEndX() : undefined;
       if (!currentLine) {
         currentLine = {
           fromRun: runIndex,
@@ -268523,7 +268555,8 @@ async function measureParagraphBlock(block, maxWidth) {
             fromChar: 0,
             toChar: 1,
             width: imageWidth,
-            ...imageStartX !== undefined ? { x: imageStartX } : {}
+            ...imageStartX !== undefined ? { x: imageStartX } : {},
+            ...imagePrecedingTabEndX !== undefined ? { precedingTabEndX: imagePrecedingTabEndX } : {}
           }]
         };
         pendingRunSpacing = 0;
@@ -268575,7 +268608,8 @@ async function measureParagraphBlock(block, maxWidth) {
           fromChar: 0,
           toChar: 1,
           width: imageWidth,
-          ...imageStartX !== undefined ? { x: imageStartX } : {}
+          ...imageStartX !== undefined ? { x: imageStartX } : {},
+          ...imagePrecedingTabEndX !== undefined ? { precedingTabEndX: imagePrecedingTabEndX } : {}
         });
       }
       if (activeTabGroup && runIndex + 1 >= activeTabGroup.measure.endRunIndex)
@@ -268650,6 +268684,7 @@ async function measureParagraphBlock(block, maxWidth) {
       let annotationStartX;
       if (pendingTabAlignment && currentLine)
         annotationStartX = alignPendingTabForWidth(annotationWidth);
+      const annotationPrecedingTabEndX = annotationStartX !== undefined ? consumePendingPrecedingTabEndX() : undefined;
       if (!currentLine) {
         currentLine = {
           fromRun: runIndex,
@@ -268665,7 +268700,8 @@ async function measureParagraphBlock(block, maxWidth) {
             fromChar: 0,
             toChar: 1,
             width: annotationWidth,
-            ...annotationStartX !== undefined ? { x: annotationStartX } : {}
+            ...annotationStartX !== undefined ? { x: annotationStartX } : {},
+            ...annotationPrecedingTabEndX !== undefined ? { precedingTabEndX: annotationPrecedingTabEndX } : {}
           }]
         };
         pendingRunSpacing = 0;
@@ -268712,7 +268748,8 @@ async function measureParagraphBlock(block, maxWidth) {
           fromChar: 0,
           toChar: 1,
           width: annotationWidth,
-          ...annotationStartX !== undefined ? { x: annotationStartX } : {}
+          ...annotationStartX !== undefined ? { x: annotationStartX } : {},
+          ...annotationPrecedingTabEndX !== undefined ? { precedingTabEndX: annotationPrecedingTabEndX } : {}
         });
       }
       const tabAlign = lastAppliedTabAlign;
@@ -268820,6 +268857,18 @@ async function measureParagraphBlock(block, maxWidth) {
         if (segmentStartX == null)
           segmentStartX = currentLine.width;
       }
+      let hasPendingSegmentTabGeometry = segmentStartX !== undefined;
+      const consumeSegmentPrecedingTabEndX = () => {
+        if (!hasPendingSegmentTabGeometry)
+          return;
+        hasPendingSegmentTabGeometry = false;
+        return consumePendingPrecedingTabEndX();
+      };
+      const clearWrapState = () => {
+        segmentStartX = undefined;
+        hasPendingSegmentTabGeometry = false;
+        clearPendingPrecedingTabEndX();
+      };
       for (let wordIndex = 0;wordIndex < words.length; wordIndex++) {
         const word$1 = words[wordIndex];
         if (word$1 === "") {
@@ -268861,6 +268910,7 @@ async function measureParagraphBlock(block, maxWidth) {
               pendingLeader = null;
               lastAppliedTabAlign = null;
               activeTabGroup = null;
+              clearWrapState();
               currentLine = {
                 fromRun: runIndex,
                 fromChar: spaceStartChar,
@@ -268885,11 +268935,15 @@ async function measureParagraphBlock(block, maxWidth) {
               currentLine.maxFontInfo = updateMaxFontInfo(currentLine.maxFontSize, currentLine.maxFontInfo, run2);
               currentLine.maxFontSize = Math.max(currentLine.maxFontSize, lineHeightFontSize(run2));
               let spaceExplicitX;
+              let spacePrecedingTabEndX;
               if (inActiveTabGroup && activeTabGroup) {
                 spaceExplicitX = activeTabGroup.currentX;
                 activeTabGroup.currentX = roundValue(activeTabGroup.currentX + singleSpaceWidth);
+              } else if (wordIndex === 0 && segmentStartX !== undefined) {
+                spaceExplicitX = segmentStartX;
+                spacePrecedingTabEndX = consumeSegmentPrecedingTabEndX();
               }
-              appendSegment(currentLine.segments, runIndex, spaceStartChar, spaceEndChar, singleSpaceWidth, spaceExplicitX);
+              appendSegment(currentLine.segments, runIndex, spaceStartChar, spaceEndChar, singleSpaceWidth, spaceExplicitX, spacePrecedingTabEndX);
               currentLine.spaceCount += 1;
             }
           }
@@ -268917,6 +268971,7 @@ async function measureParagraphBlock(block, maxWidth) {
             pendingTabAlignment = null;
             pendingLeader = null;
             currentLine = null;
+            clearWrapState();
           }
           const lineMaxWidth = getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : contentWidth);
           const hasTabOnlyLine = currentLine && currentLine.segments && currentLine.segments.length === 0 && currentLine.width > 0;
@@ -268962,6 +269017,7 @@ async function measureParagraphBlock(block, maxWidth) {
                 pendingTabAlignment = null;
                 pendingLeader = null;
                 currentLine = null;
+                clearWrapState();
               }
             } else if (isLastChunk) {
               currentLine = {
@@ -269009,6 +269065,7 @@ async function measureParagraphBlock(block, maxWidth) {
               };
               addBarTabsToLine(chunkLine);
               lines.push(chunkLine);
+              clearWrapState();
             }
             chunkCharOffset = chunkEndChar;
           }
@@ -269070,6 +269127,8 @@ async function measureParagraphBlock(block, maxWidth) {
           }
         }
         if (shouldBreak) {
+          if (wordIndex === 0 && hasPendingSegmentTabGeometry)
+            clearWrapState();
           trimTrailingWrapSpaces(currentLine);
           const metrics = finalizeLineMetrics(currentLine, spacing);
           const completedLine = {
@@ -269122,7 +269181,7 @@ async function measureParagraphBlock(block, maxWidth) {
               activeTabGroup.currentX = roundValue(activeTabGroup.currentX + wordOnlyWidth);
             } else if (wordIndex === 0 && segmentStartX !== undefined)
               explicitXHere = segmentStartX;
-            appendSegment(currentLine.segments, runIndex, wordStartChar, wordEndNoSpace, wordOnlyWidth, explicitXHere);
+            appendSegment(currentLine.segments, runIndex, wordStartChar, wordEndNoSpace, wordOnlyWidth, explicitXHere, wordIndex === 0 ? consumeSegmentPrecedingTabEndX() : undefined);
             trimTrailingWrapSpaces(currentLine);
             const metrics = finalizeLineMetrics(currentLine, spacing);
             const completedLine = {
@@ -269152,7 +269211,7 @@ async function measureParagraphBlock(block, maxWidth) {
           currentLine.width = roundValue(targetWidth);
           currentLine.maxFontInfo = updateMaxFontInfo(currentLine.maxFontSize, currentLine.maxFontInfo, run2);
           currentLine.maxFontSize = Math.max(currentLine.maxFontSize, lineHeightFontSize(run2));
-          appendSegment(currentLine.segments, runIndex, wordStartChar, newToChar, wordCommitWidth, explicitX);
+          appendSegment(currentLine.segments, runIndex, wordStartChar, newToChar, wordCommitWidth, explicitX, wordIndex === 0 ? consumeSegmentPrecedingTabEndX() : undefined);
           if (shouldIncludeDelimiterSpace)
             currentLine.spaceCount += 1;
         }
@@ -269205,7 +269264,8 @@ async function measureParagraphBlock(block, maxWidth) {
           validateTabStopVal(stop);
           pendingTabAlignment = {
             target: clampedTarget - effectiveIndent,
-            val: stop.val
+            val: stop.val,
+            compensateNegativeLeft: stop.val === "start" && indentLeft < 0 && effectiveIndent === indentLeft && stop.source !== "explicit"
           };
         } else {
           pendingTabAlignment = null;
@@ -290385,7 +290445,7 @@ menclose::after {
   if (transform === "capitalize")
     return capitalizeText$2(text5, fullText, startOffset);
   return text5;
-}, DEFAULT_TAB_INTERVAL_TWIPS$2 = 720, TWIPS_PER_PX$2, TAB_EPSILON$1 = 0.1, WIDTH_FUDGE_PX = 0.5, twipsToPx$2 = (twips) => twips / TWIPS_PER_PX$2, pxToTwips$1 = (px) => Math.round(px * TWIPS_PER_PX$2), sanitizeIndent$1 = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0, sanitizeDecimalSeparator$1 = (value) => value === "," ? "," : ".", getRunWidth = (run2) => {
+}, DEFAULT_TAB_INTERVAL_TWIPS$2 = 720, TWIPS_PER_PX$2, TAB_EPSILON$1 = 0.1, WIDTH_FUDGE_PX = 0.5, twipsToPx$2 = (twips) => twips / TWIPS_PER_PX$2, pxToTwips$1 = (px) => Math.round(px * TWIPS_PER_PX$2), sanitizeIndent$1 = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0, sanitizeRawIndent = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0, sanitizeDecimalSeparator$1 = (value) => value === "," ? "," : ".", getRunWidth = (run2) => {
   const width = run2.width;
   return typeof width === "number" ? width : 0;
 }, isLineBreakRun$1 = (run2) => run2.kind === "lineBreak" || run2.kind === "break" && run2.breakType === "line", markerFontString = (run2) => {
@@ -290399,10 +290459,17 @@ menclose::after {
     firstLine: pxToTwips$1(sanitizeIndent$1(indent2?.firstLine)),
     hanging: pxToTwips$1(sanitizeIndent$1(indent2?.hanging))
   };
+  const rawParagraphIndentTwips = {
+    left: pxToTwips$1(sanitizeRawIndent(indent2?.left)),
+    right: pxToTwips$1(sanitizeRawIndent(indent2?.right)),
+    firstLine: pxToTwips$1(sanitizeRawIndent(indent2?.firstLine)),
+    hanging: pxToTwips$1(sanitizeIndent$1(indent2?.hanging))
+  };
   return computeTabStops$1({
     explicitStops: tabs ?? [],
     defaultTabInterval: tabIntervalTwips ?? DEFAULT_TAB_INTERVAL_TWIPS$2,
-    paragraphIndent: paragraphIndentTwips
+    paragraphIndent: paragraphIndentTwips,
+    rawParagraphIndent: rawParagraphIndentTwips
   }).map((stop) => ({
     pos: twipsToPx$2(stop.pos),
     val: stop.val,
@@ -290627,6 +290694,10 @@ menclose::after {
       }
       const clampedTarget = Number.isFinite(maxAbsWidth) ? Math.min(target, maxAbsWidth) : target;
       const relativeTarget = clampedTarget - effectiveIndent;
+      const stopVal = stop?.val ?? "start";
+      const shouldCompensateNegativeLeft = stopVal === "start" && indentLeft < 0 && effectiveIndent === indentLeft && stop?.source !== "explicit";
+      const paintTarget = shouldCompensateNegativeLeft ? relativeTarget - Math.min(effectiveIndent, 0) : relativeTarget;
+      const precedingTabEndX = shouldCompensateNegativeLeft ? relativeTarget : undefined;
       lineWidth = Math.max(lineWidth, relativeTarget);
       if (stop?.source === "explicit")
         line.hasExplicitTabStops = true;
@@ -290639,7 +290710,6 @@ menclose::after {
         };
         leaders.push(currentLeader);
       }
-      const stopVal = stop?.val ?? "start";
       if (stopVal === "end" || stopVal === "center" || stopVal === "decimal") {
         const groupMeasure = measureTabAlignmentGroupInLine(runs2, line, startRunIndex, startChar, decimalSeparator);
         if (groupMeasure.totalWidth > 0) {
@@ -290654,14 +290724,28 @@ menclose::after {
           }
           if (currentLeader)
             currentLeader.to = groupStartX + effectiveIndent;
-          pendingTabAlignStartX = groupStartX;
+          pendingTabAlignStartX = {
+            layoutX: groupStartX,
+            paintX: groupStartX
+          };
         } else
           cursorX = Math.max(cursorX, relativeTarget);
-      } else
+      } else {
         cursorX = Math.max(cursorX, relativeTarget);
+        pendingTabAlignStartX = {
+          layoutX: relativeTarget,
+          paintX: paintTarget,
+          ...precedingTabEndX !== undefined ? { precedingTabEndX } : {}
+        };
+      }
       if (run2 && run2.kind === "tab")
         run2.width = Math.max(0, relativeTarget - originX);
     };
+    const consumePendingTabAlignStart = () => {
+      const pending = pendingTabAlignStartX;
+      pendingTabAlignStartX = null;
+      return pending;
+    };
     for (let runIndex = line.fromRun;runIndex <= line.toRun; runIndex += 1) {
       const run2 = runs2[runIndex];
       if (!run2)
@@ -290693,10 +290777,12 @@ menclose::after {
             toChar: i4,
             width: segmentWidth
           };
-          if (pendingTabAlignStartX != null) {
-            segment.x = pendingTabAlignStartX;
-            cursorX = pendingTabAlignStartX + segmentWidth;
-            pendingTabAlignStartX = null;
+          const pendingTabAlign = consumePendingTabAlignStart();
+          if (pendingTabAlign != null) {
+            segment.x = pendingTabAlign.paintX;
+            if (pendingTabAlign.precedingTabEndX !== undefined)
+              segment.precedingTabEndX = pendingTabAlign.precedingTabEndX;
+            cursorX = pendingTabAlign.layoutX + segmentWidth;
           } else
             cursorX += segmentWidth;
           lineWidth = Math.max(lineWidth, cursorX);
@@ -290714,10 +290800,12 @@ menclose::after {
           toChar: sliceEnd,
           width: segmentWidth
         };
-        if (pendingTabAlignStartX != null) {
-          segment.x = pendingTabAlignStartX;
-          cursorX = pendingTabAlignStartX + segmentWidth;
-          pendingTabAlignStartX = null;
+        const pendingTabAlign = consumePendingTabAlignStart();
+        if (pendingTabAlign != null) {
+          segment.x = pendingTabAlign.paintX;
+          if (pendingTabAlign.precedingTabEndX !== undefined)
+            segment.precedingTabEndX = pendingTabAlign.precedingTabEndX;
+          cursorX = pendingTabAlign.layoutX + segmentWidth;
         } else
           cursorX += segmentWidth;
         lineWidth = Math.max(lineWidth, cursorX);
@@ -298079,11 +298167,11 @@ menclose::after {
       width: currentWidth
     });
   return chunks;
-}, appendSegment = (segments, runIndex, fromChar, toChar, width, x) => {
+}, appendSegment = (segments, runIndex, fromChar, toChar, width, x, precedingTabEndX) => {
   if (!segments)
     return;
   const last2 = segments[segments.length - 1];
-  if (last2 && last2.runIndex === runIndex && last2.toChar === fromChar && x === undefined) {
+  if (last2 && last2.runIndex === runIndex && last2.toChar === fromChar && last2.x === undefined && last2.precedingTabEndX === undefined && x === undefined && precedingTabEndX === undefined) {
     last2.toChar = toChar;
     last2.width += width;
     return;
@@ -298093,7 +298181,8 @@ menclose::after {
     fromChar,
     toChar,
     width,
-    x
+    ...x !== undefined ? { x } : {},
+    ...precedingTabEndX !== undefined ? { precedingTabEndX } : {}
   });
 }, resolveLineHeight = (spacing, fontSize, maxHeight = -1) => {
   let computedHeight = spacing?.line ?? WORD_SINGLE_LINE_SPACING_MULTIPLIER;
@@ -298143,10 +298232,17 @@ menclose::after {
     firstLine: pxToTwips(sanitizePositive(indent2?.firstLine)),
     hanging: pxToTwips(sanitizePositive(indent2?.hanging))
   };
+  const rawParagraphIndentTwips = {
+    left: pxToTwips(sanitizeIndent(indent2?.left)),
+    right: pxToTwips(sanitizeIndent(indent2?.right)),
+    firstLine: pxToTwips(sanitizeIndent(indent2?.firstLine)),
+    hanging: pxToTwips(sanitizePositive(indent2?.hanging))
+  };
   return computeTabStops({
     explicitStops: tabs ?? [],
     defaultTabInterval: tabIntervalTwips ?? DEFAULT_TAB_INTERVAL_TWIPS,
-    paragraphIndent: paragraphIndentTwips
+    paragraphIndent: paragraphIndentTwips,
+    rawParagraphIndent: rawParagraphIndentTwips
   }).map((stop) => ({
     pos: twipsToPx(stop.pos),
     val: stop.val,
@@ -299813,7 +299909,7 @@ menclose::after {
     return;
   console.log(...args$1);
 }, HEADER_FOOTER_INIT_BUDGET_MS = 200, MAX_ZOOM_WARNING_THRESHOLD = 10, MAX_SELECTION_RECTS_PER_USER = 100, SEMANTIC_RESIZE_DEBOUNCE_MS = 120, MIN_SEMANTIC_CONTENT_WIDTH_PX = 1, GLOBAL_PERFORMANCE, PresentationEditor, ICONS, TEXTS, tableActionsOptions;
-var init_src_ItIaPxzW_es = __esm(() => {
+var init_src_C_jV2TZI_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
   init_SuperConverter_D1o6_yKI_es();
   init_jszip_C49i9kUs_es();
@@ -327689,7 +327785,7 @@ function print() { __p += __j.call(arguments, '') }
               availableWidthOverride = fragment2.width - listFirstLineTextStartPx - Math.max(0, paraIndentRight);
             const isFirstLine = index2 === 0 && !paraContinuesFromPrev;
             const isListFirstLine = Boolean(hasListFirstLineMarker && fragment2.markerTextWidth);
-            if (isFirstLine && !isListFirstLine && !hasExplicitSegmentPositioning)
+            if (isFirstLine && !isListFirstLine && line.hasExplicitTabStops !== true)
               availableWidthOverride = adjustAvailableWidthForTextIndent(availableWidthOverride, firstLineOffset, line.maxWidth);
             const shouldSkipJustifyForLastLine = index2 === lines.length - 1 && !paraContinuesOnNext && !paragraphEndsWithLineBreak;
             const lineEl = this.renderLine(block, line, context, availableWidthOverride, fragment2.fromLine + index2, shouldSkipJustifyForLastLine, expandedRunsForBlock, shouldUseResolvedListTextStart ? listFirstLineTextStartPx : undefined);
@@ -329483,6 +329579,7 @@ function print() { __p += __j.call(arguments, '') }
           el.appendChild(barEl);
         });
       const hasExplicitPositioning = line.segments?.some((seg) => seg.x !== undefined);
+      const hasMultipleExplicitPositionedSegments = (line.segments?.filter((seg) => seg.x !== undefined).length ?? 0) > 1;
       const availableWidth = availableWidthOverride ?? line.maxWidth ?? line.width;
       const justifyShouldApply = shouldApplyJustify({
         alignment: block.attrs?.alignment,
@@ -329490,7 +329587,7 @@ function print() { __p += __j.call(arguments, '') }
         hasExplicitTabStops: line.hasExplicitTabStops === true,
         isLastLineOfParagraph: false,
         paragraphEndsWithLineBreak: false,
-        skipJustifyOverride: skipJustify
+        skipJustifyOverride: skipJustify || hasMultipleExplicitPositionedSegments
       });
       const countSpaces$1 = (text5) => {
         let count2 = 0;
@@ -329657,12 +329754,14 @@ function print() { __p += __j.call(arguments, '') }
           else
             segmentsByRun.set(segment.runIndex, [segment]);
         });
-        const findImmediateNextSegmentX = (fromRunIndex) => {
+        const findImmediateNextSegment = (fromRunIndex) => {
           const nextRunIdx = fromRunIndex + 1;
           if (nextRunIdx <= line.toRun) {
             const nextSegments = segmentsByRun.get(nextRunIdx);
-            if (nextSegments && nextSegments.length > 0)
-              return nextSegments[0].x;
+            if (nextSegments && nextSegments.length > 0) {
+              const firstSegment = nextSegments[0];
+              return firstSegment.x !== undefined || firstSegment.precedingTabEndX !== undefined ? firstSegment : undefined;
+            }
           }
         };
         let geoSdtWrapper = null;
@@ -329706,9 +329805,10 @@ function print() { __p += __j.call(arguments, '') }
           if (!baseRun)
             continue;
           if (baseRun.kind === "tab") {
-            const immediateNextX = findImmediateNextSegmentX(runIndex);
+            const immediateNextSegment = findImmediateNextSegment(runIndex);
             const tabStartX = cumulativeX;
-            const tabEndX = immediateNextX !== undefined ? immediateNextX : tabStartX + (baseRun.width ?? 0);
+            const measuredTabEndX = tabStartX + (baseRun.width ?? 0);
+            const tabEndX = immediateNextSegment?.precedingTabEndX ?? immediateNextSegment?.x ?? measuredTabEndX;
             const actualTabWidth = tabEndX - tabStartX;
             const tabEl = this.doc.createElement("span");
             tabEl.style.position = "absolute";
@@ -329818,10 +329918,10 @@ function print() { __p += __j.call(arguments, '') }
               elem.style.position = "absolute";
               elem.style.left = `${xPos}px`;
               appendToLineGeo(elem, segmentRun, xPos, segment.width);
-              const width = segment.width;
-              cumulativeX = baseX + width;
+              const visualWidth = segment.width + (spacingPerSpace !== 0 ? spacingPerSpace * countSpaces$1(segmentText) : 0);
+              cumulativeX = baseX + visualWidth;
               if (geoSdtWrapper)
-                geoSdtMaxRight = Math.max(geoSdtMaxRight, xPos + width);
+                geoSdtMaxRight = Math.max(geoSdtMaxRight, xPos + visualWidth);
             }
           });
         }
@@ -337451,7 +337551,7 @@ var init_zipper_BxRAi0_5_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_ItIaPxzW_es();
+  init_src_C_jV2TZI_es();
   init_SuperConverter_D1o6_yKI_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc-dev/cli",
-  "version": "0.8.0-next.79",
+  "version": "0.8.0-next.80",
   "type": "module",
   "bin": {
     "superdoc": "./dist/index.js"
@@ -26,19 +26,19 @@
     "typescript": "^5.9.2",
     "@superdoc/document-api": "0.0.1",
     "@superdoc/pm-adapter": "0.0.0",
-    "@superdoc/super-editor": "0.0.1",
-    "superdoc": "1.31.0"
+    "superdoc": "1.31.0",
+    "@superdoc/super-editor": "0.0.1"
   },
   "module": "src/index.ts",
   "publishConfig": {
     "access": "public"
   },
   "optionalDependencies": {
-    "@superdoc-dev/cli-darwin-arm64": "0.8.0-next.79",
-    "@superdoc-dev/cli-darwin-x64": "0.8.0-next.79",
-    "@superdoc-dev/cli-linux-x64": "0.8.0-next.79",
-    "@superdoc-dev/cli-linux-arm64": "0.8.0-next.79",
-    "@superdoc-dev/cli-windows-x64": "0.8.0-next.79"
+    "@superdoc-dev/cli-darwin-arm64": "0.8.0-next.80",
+    "@superdoc-dev/cli-darwin-x64": "0.8.0-next.80",
+    "@superdoc-dev/cli-linux-x64": "0.8.0-next.80",
+    "@superdoc-dev/cli-linux-arm64": "0.8.0-next.80",
+    "@superdoc-dev/cli-windows-x64": "0.8.0-next.80"
   },
   "scripts": {
     "predev": "node scripts/ensure-superdoc-build.js",