@superdoc-dev/mcp 0.3.0-next.63 → 0.3.0-next.64

package/dist/index.js

@@ -199223,7 +199223,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) => {
@@ -199280,9 +199280,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) => ({
@@ -199293,6 +199295,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({
@@ -199301,6 +199304,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;
@@ -243264,7 +243283,8 @@ function resolveParagraphContent(fragment, 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;
@@ -249133,8 +249153,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;
@@ -259636,6 +259656,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;
@@ -259658,7 +259679,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;
@@ -259669,10 +259690,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,
@@ -259680,7 +259700,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)
@@ -260021,7 +260051,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;
@@ -260043,6 +260074,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,
@@ -260059,7 +260091,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;
@@ -260111,7 +260144,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)
@@ -260186,6 +260220,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,
@@ -260201,7 +260236,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;
@@ -260248,7 +260284,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;
@@ -260356,6 +260393,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 === "") {
@@ -260397,6 +260446,7 @@ async function measureParagraphBlock(block, maxWidth) {
               pendingLeader = null;
               lastAppliedTabAlign = null;
               activeTabGroup = null;
+              clearWrapState();
               currentLine = {
                 fromRun: runIndex,
                 fromChar: spaceStartChar,
@@ -260421,11 +260471,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;
             }
           }
@@ -260453,6 +260507,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;
@@ -260498,6 +260553,7 @@ async function measureParagraphBlock(block, maxWidth) {
                 pendingTabAlignment = null;
                 pendingLeader = null;
                 currentLine = null;
+                clearWrapState();
               }
             } else if (isLastChunk) {
               currentLine = {
@@ -260545,6 +260601,7 @@ async function measureParagraphBlock(block, maxWidth) {
               };
               addBarTabsToLine(chunkLine);
               lines.push(chunkLine);
+              clearWrapState();
             }
             chunkCharOffset = chunkEndChar;
           }
@@ -260606,6 +260663,8 @@ async function measureParagraphBlock(block, maxWidth) {
           }
         }
         if (shouldBreak) {
+          if (wordIndex === 0 && hasPendingSegmentTabGeometry)
+            clearWrapState();
           trimTrailingWrapSpaces(currentLine);
           const metrics = finalizeLineMetrics(currentLine, spacing);
           const completedLine = {
@@ -260658,7 +260717,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 = {
@@ -260688,7 +260747,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;
         }
@@ -260741,7 +260800,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;
@@ -281921,7 +281981,7 @@ menclose::after {
   if (transform2 === "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) => {
@@ -281935,10 +281995,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,
@@ -282163,6 +282230,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;
@@ -282175,7 +282246,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) {
@@ -282190,14 +282260,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)
@@ -282229,10 +282313,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);
@@ -282250,10 +282336,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);
@@ -289615,11 +289703,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;
@@ -289629,7 +289717,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;
@@ -289679,10 +289768,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,
@@ -291349,7 +291445,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();
@@ -319225,7 +319321,7 @@ function print() { __p += __j.call(arguments, '') }
               availableWidthOverride = fragment.width - listFirstLineTextStartPx - Math.max(0, paraIndentRight);
             const isFirstLine = index2 === 0 && !paraContinuesFromPrev;
             const isListFirstLine = Boolean(hasListFirstLineMarker && fragment.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, fragment.fromLine + index2, shouldSkipJustifyForLastLine, expandedRunsForBlock, shouldUseResolvedListTextStart ? listFirstLineTextStartPx : undefined);
@@ -321019,6 +321115,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,
@@ -321026,7 +321123,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 count = 0;
@@ -321193,12 +321290,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;
@@ -321242,9 +321341,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";
@@ -321354,10 +321454,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);
             }
           });
         }
@@ -328987,7 +329087,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/mcp",
-  "version": "0.3.0-next.63",
+  "version": "0.3.0-next.64",
   "type": "module",
   "engines": {
     "node": ">=20"