superdoc 1.0.0-beta.92 → 1.0.0-beta.94

package/dist/chunks/{PdfViewer-CrMwuKcn.es.js → PdfViewer-BR7hR5hX.es.js}

@@ -1,5 +1,5 @@
 import { y as defineComponent, z as h, O as Transition, a0 as process$1, J as watchEffect, a as computed, r as ref, j as onMounted, W as onUnmounted, b as createElementBlock, o as openBlock, f as createBaseVNode, e as createCommentVNode, u as createVNode, v as unref } from "./vue-Dysv_7z5.es.js";
-import { d as derived, c, a as cB, f as fadeInTransition, b as cM, N as NBaseLoading, w as warnOnce, u as useConfig, e as useTheme, p as pxfy, g as createKey, h as useThemeClass, i as useCompitable, _ as _export_sfc, j as useSuperdocStore, s as storeToRefs, k as useSelection } from "./index-CUUqzJ4M.es.js";
+import { d as derived, c, a as cB, f as fadeInTransition, b as cM, N as NBaseLoading, w as warnOnce, u as useConfig, e as useTheme, p as pxfy, g as createKey, h as useThemeClass, i as useCompitable, _ as _export_sfc, j as useSuperdocStore, s as storeToRefs, k as useSelection } from "./index-JAE9iqTX.es.js";
 function self(vars) {
   const {
     opacityDisabled,

package/dist/chunks/{PdfViewer-BYKB8fT_.cjs → PdfViewer-CC_fv7lS.cjs}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const vue = require("./vue-jWLMl8Ts.cjs");
-const superdoc = require("./index-BZloH4nq.cjs");
+const superdoc = require("./index-DHRt1tCk.cjs");
 function self(vars) {
   const {
     opacityDisabled,

package/dist/chunks/{index-CqnVFwjL-zbanjw1O.cjs → index-BstIHBcW-6lPNsqaA.cjs}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const superEditor_es = require("./super-editor.es-DvpDTsC4.cjs");
+const superEditor_es = require("./super-editor.es-DXKgM3JR.cjs");
 const indexCvBqQJbG = require("./index-CvBqQJbG-Dwm0THD7.cjs");
 function bail(error) {
   if (error) {

package/dist/chunks/{index-CqnVFwjL-DJT5AqWq.es.js → index-BstIHBcW-BxKvjs-R.es.js}

@@ -1,4 +1,4 @@
-import { s as getDefaultExportFromCjs$2 } from "./super-editor.es-ALp2ApyE.es.js";
+import { s as getDefaultExportFromCjs$2 } from "./super-editor.es-C1RjP_IO.es.js";
 import { V as VFile } from "./index-CvBqQJbG-CvBqQJbG.es.js";
 function bail(error) {
   if (error) {

package/dist/chunks/{index-BZloH4nq.cjs → index-DHRt1tCk.cjs}

@@ -1,5 +1,5 @@
 "use strict";
-const superEditor_es = require("./super-editor.es-DvpDTsC4.cjs");
+const superEditor_es = require("./super-editor.es-DXKgM3JR.cjs");
 const blankDocx = require("./blank-docx-DfW3Eeh2.cjs");
 const eventemitter3 = require("./eventemitter3-DQmQUge-.cjs");
 const provider = require("@hocuspocus/provider");
@@ -17268,7 +17268,7 @@ const _sfc_main = {
   __name: "SuperDoc",
   emits: ["selection-update"],
   setup(__props, { emit: __emit }) {
-    const PdfViewer = vue.defineAsyncComponent(() => Promise.resolve().then(() => require("./PdfViewer-BYKB8fT_.cjs")));
+    const PdfViewer = vue.defineAsyncComponent(() => Promise.resolve().then(() => require("./PdfViewer-CC_fv7lS.cjs")));
     const superdocStore = useSuperdocStore();
     const commentsStore = useCommentsStore();
     const {
@@ -18157,7 +18157,7 @@ class SuperDoc extends eventemitter3.EventEmitter {
     this.config.colors = shuffleArray(this.config.colors);
     this.userColorMap = /* @__PURE__ */ new Map();
     this.colorIndex = 0;
-    this.version = "1.0.0-beta.92";
+    this.version = "1.0.0-beta.94";
     this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
     this.superdocId = config.superdocId || uuid.v4();
     this.colors = this.config.colors;

package/dist/chunks/{index-CUUqzJ4M.es.js → index-JAE9iqTX.es.js}

@@ -1,4 +1,4 @@
-import { q as index, C as CommentsPluginKey, h as TrackChangesBasePluginKey, E as Editor, n as getRichTextExtensions, f as SuperInput, P as PresentationEditor, e as SuperEditor, A as AIWriter, g as SuperToolbar, i as createZip } from "./super-editor.es-ALp2ApyE.es.js";
+import { q as index, C as CommentsPluginKey, h as TrackChangesBasePluginKey, E as Editor, n as getRichTextExtensions, f as SuperInput, P as PresentationEditor, e as SuperEditor, A as AIWriter, g as SuperToolbar, i as createZip } from "./super-editor.es-C1RjP_IO.es.js";
 import { B as BlankDOCX } from "./blank-docx-ABm6XYAA.es.js";
 import { E as EventEmitter } from "./eventemitter3-CcXAdeql.es.js";
 import { HocuspocusProvider, HocuspocusProviderWebsocket } from "@hocuspocus/provider";
@@ -17251,7 +17251,7 @@ const _sfc_main = {
   __name: "SuperDoc",
   emits: ["selection-update"],
   setup(__props, { emit: __emit }) {
-    const PdfViewer = defineAsyncComponent(() => import("./PdfViewer-CrMwuKcn.es.js"));
+    const PdfViewer = defineAsyncComponent(() => import("./PdfViewer-BR7hR5hX.es.js"));
     const superdocStore = useSuperdocStore();
     const commentsStore = useCommentsStore();
     const {
@@ -18140,7 +18140,7 @@ class SuperDoc extends EventEmitter {
     this.config.colors = shuffleArray(this.config.colors);
     this.userColorMap = /* @__PURE__ */ new Map();
     this.colorIndex = 0;
-    this.version = "1.0.0-beta.92";
+    this.version = "1.0.0-beta.94";
     this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
     this.superdocId = config.superdocId || v4();
     this.colors = this.config.colors;

package/dist/chunks/{super-editor.es-ALp2ApyE.es.js → super-editor.es-C1RjP_IO.es.js}

@@ -42380,7 +42380,7 @@ const _SuperConverter = class _SuperConverter2 {
   static getStoredSuperdocVersion(docx) {
     return _SuperConverter2.getStoredCustomProperty(docx, "SuperdocVersion");
   }
-  static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-beta.92") {
+  static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-beta.94") {
     return _SuperConverter2.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
   }
   /**
@@ -56530,12 +56530,12 @@ const findTrackedMarkBetween = ({
   const { doc: doc2 } = tr;
   const startPos = Math.max(from2 - offset2, 0);
   const endPos = Math.min(to + offset2, doc2.content.size);
-  let markFound;
-  doc2.nodesBetween(startPos, endPos, (node, pos) => {
+  let markFound = null;
+  const tryMatch = (node, pos) => {
     if (!node || node?.nodeSize === void 0) {
       return;
     }
-    const mark = node.marks.find(
+    const mark = node.marks?.find(
       (mark2) => mark2.type.name === markName && Object.keys(attrs).every((attr) => mark2.attrs[attr] === attrs[attr])
     );
     if (mark && !markFound) {
@@ -56544,24 +56544,36 @@ const findTrackedMarkBetween = ({
         to: pos + node.nodeSize,
         mark
       };
+      return false;
     }
+  };
+  doc2.nodesBetween(startPos, endPos, (node, pos) => {
+    return tryMatch(node, pos);
   });
-  const nodeAtEndPosition = doc2.nodeAt(endPos);
-  if (nodeAtEndPosition?.type?.name === "run") {
-    const node = nodeAtEndPosition.content?.content?.[0];
-    const isTextNode = node?.type?.name === "text";
-    if (isTextNode) {
-      const mark = node.marks.find(
-        (mark2) => mark2.type.name === markName && Object.keys(attrs).every((attr) => mark2.attrs[attr] === attrs[attr])
-      );
-      if (mark && !markFound) {
-        markFound = {
-          from: endPos,
-          to: endPos + node.nodeSize,
-          mark
-        };
+  const inspectAroundPosition = (pos) => {
+    if (pos < 0 || pos > doc2.content.size) {
+      return;
+    }
+    const resolved = doc2.resolve(pos);
+    const before = resolved.nodeBefore;
+    if (before?.type?.name === "run") {
+      const beforeStart = Math.max(pos - before.nodeSize, 0);
+      const node = before.content?.content?.[0];
+      if (node?.type?.name === "text") {
+        tryMatch(node, beforeStart);
+      }
+    }
+    const after = resolved.nodeAfter;
+    if (after?.type?.name === "run") {
+      const node = after.content?.content?.[0];
+      if (node?.type?.name === "text") {
+        tryMatch(node, pos);
       }
     }
+  };
+  if (!markFound) {
+    inspectAroundPosition(startPos);
+    inspectAroundPosition(endPos);
   }
   return markFound;
 };
@@ -59586,7 +59598,7 @@ const isHeadless = (editor) => {
 const shouldSkipNodeView = (editor) => {
   return isHeadless(editor);
 };
-const summaryVersion = "1.0.0-beta.92";
+const summaryVersion = "1.0.0-beta.94";
 const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
 const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
 function mapAttributes(attrs) {
@@ -60375,7 +60387,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
       { default: remarkStringify },
       { default: remarkGfm }
     ] = await Promise.all([
-      import("./index-CqnVFwjL-DJT5AqWq.es.js"),
+      import("./index-BstIHBcW-BxKvjs-R.es.js"),
       import("./index-DRCvimau-Cw339678.es.js"),
       import("./index-C_x_N6Uh-DJn8hIEt.es.js"),
       import("./index-D_sWOSiG-DE96TaT5.es.js"),
@@ -60580,7 +60592,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
    * Process collaboration migrations
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.92");
+    console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.94");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -77457,10 +77469,31 @@ const deriveBlockVersion = (block) => {
         textRun.letterSpacing != null ? textRun.letterSpacing : "",
         textRun.pmStart ?? "",
         textRun.pmEnd ?? "",
-        textRun.token ?? ""
+        textRun.token ?? "",
+        // Tracked changes - force re-render when added or removed tracked change
+        textRun.trackedChange ? 1 : 0
       ].join(",");
     }).join("|");
-    return markerVersion ? `${markerVersion}|${runsVersion}` : runsVersion;
+    const attrs = block.attrs;
+    const paragraphAttrsVersion = attrs ? [
+      attrs.alignment ?? "",
+      attrs.spacing?.before ?? "",
+      attrs.spacing?.after ?? "",
+      attrs.spacing?.line ?? "",
+      attrs.spacing?.lineRule ?? "",
+      attrs.indent?.left ?? "",
+      attrs.indent?.right ?? "",
+      attrs.indent?.firstLine ?? "",
+      attrs.indent?.hanging ?? "",
+      attrs.borders ? JSON.stringify(attrs.borders) : "",
+      attrs.shading?.fill ?? "",
+      attrs.shading?.color ?? "",
+      attrs.direction ?? "",
+      attrs.rtl ? "1" : "",
+      attrs.tabs?.length ? JSON.stringify(attrs.tabs) : ""
+    ].join(":") : "";
+    const parts = [markerVersion, runsVersion, paragraphAttrsVersion].filter(Boolean);
+    return parts.join("|");
   }
   if (block.kind === "list") {
     return block.items.map((item) => `${item.id}:${item.marker.text}:${deriveBlockVersion(item.paragraph)}`).join("|");
@@ -81207,6 +81240,33 @@ const MAX_CACHE_SIZE$1 = 1e4;
 const BYTES_PER_ENTRY_ESTIMATE = 5e3;
 const NORMALIZED_WHITESPACE = /\s+/g;
 const normalizeText = (text) => text.replace(NORMALIZED_WHITESPACE, " ");
+const hashParagraphBorder = (border) => {
+  const parts = [];
+  if (border.style !== void 0) parts.push(`s:${border.style}`);
+  if (border.width !== void 0) parts.push(`w:${border.width}`);
+  if (border.color !== void 0) parts.push(`c:${border.color}`);
+  if (border.space !== void 0) parts.push(`sp:${border.space}`);
+  return parts.join(",");
+};
+const hashParagraphBorders = (borders) => {
+  const parts = [];
+  if (borders.top) parts.push(`t:[${hashParagraphBorder(borders.top)}]`);
+  if (borders.right) parts.push(`r:[${hashParagraphBorder(borders.right)}]`);
+  if (borders.bottom) parts.push(`b:[${hashParagraphBorder(borders.bottom)}]`);
+  if (borders.left) parts.push(`l:[${hashParagraphBorder(borders.left)}]`);
+  return parts.join(";");
+};
+const hashParagraphFrame = (frame) => {
+  const parts = [];
+  if (frame.wrap !== void 0) parts.push(`w:${frame.wrap}`);
+  if (frame.x !== void 0) parts.push(`x:${frame.x}`);
+  if (frame.y !== void 0) parts.push(`y:${frame.y}`);
+  if (frame.xAlign !== void 0) parts.push(`xa:${frame.xAlign}`);
+  if (frame.yAlign !== void 0) parts.push(`ya:${frame.yAlign}`);
+  if (frame.hAnchor !== void 0) parts.push(`ha:${frame.hAnchor}`);
+  if (frame.vAnchor !== void 0) parts.push(`va:${frame.vAnchor}`);
+  return parts.join(",");
+};
 const hashRuns = (block) => {
   if (block.kind === "table") {
     const tableBlock = block;
@@ -81302,7 +81362,59 @@ const hashRuns = (block) => {
       numberingKey = `|num:${np.numId ?? ""}:${np.ilvl ?? 0}:${markerTextKey}`;
     }
   }
-  return `${trackedMode}:${trackedEnabled ? "on" : "off"}|${runsHash}${numberingKey}`;
+  let paragraphAttrsKey = "";
+  if (block.attrs) {
+    const attrs = block.attrs;
+    const parts = [];
+    if (attrs.alignment) parts.push(`al:${attrs.alignment}`);
+    if (attrs.spacing) {
+      const s2 = attrs.spacing;
+      if (s2.before !== void 0) parts.push(`sb:${s2.before}`);
+      if (s2.after !== void 0) parts.push(`sa:${s2.after}`);
+      if (s2.line !== void 0) parts.push(`sl:${s2.line}`);
+      if (s2.lineRule) parts.push(`sr:${s2.lineRule}`);
+    }
+    if (attrs.indent) {
+      const ind = attrs.indent;
+      if (ind.left !== void 0) parts.push(`il:${ind.left}`);
+      if (ind.right !== void 0) parts.push(`ir:${ind.right}`);
+      if (ind.firstLine !== void 0) parts.push(`if:${ind.firstLine}`);
+      if (ind.hanging !== void 0) parts.push(`ih:${ind.hanging}`);
+    }
+    if (attrs.borders) {
+      parts.push(`br:${hashParagraphBorders(attrs.borders)}`);
+    }
+    if (attrs.shading) {
+      const sh = attrs.shading;
+      if (sh.fill) parts.push(`shf:${sh.fill}`);
+      if (sh.color) parts.push(`shc:${sh.color}`);
+    }
+    if (attrs.tabs && attrs.tabs.length > 0) {
+      const tabsHash = attrs.tabs.map((t) => `${t.val ?? ""}:${t.pos ?? ""}:${t.leader ?? ""}`).join(",");
+      parts.push(`tb:${tabsHash}`);
+    }
+    if (attrs.direction) parts.push(`dir:${attrs.direction}`);
+    if (attrs.rtl) parts.push("rtl");
+    if (attrs.keepNext) parts.push("kn");
+    if (attrs.keepLines) parts.push("kl");
+    if (attrs.floatAlignment) parts.push(`fa:${attrs.floatAlignment}`);
+    if (attrs.contextualSpacing) parts.push("cs");
+    if (attrs.suppressFirstLineIndent) parts.push("sfi");
+    if (attrs.dropCap) parts.push(`dc:${attrs.dropCap}`);
+    if (attrs.dropCapDescriptor) {
+      const dcd = attrs.dropCapDescriptor;
+      parts.push(`dcd:${dcd.mode ?? ""}:${dcd.lines ?? ""}`);
+    }
+    if (attrs.frame) {
+      parts.push(`fr:${hashParagraphFrame(attrs.frame)}`);
+    }
+    if (attrs.tabIntervalTwips !== void 0) parts.push(`ti:${attrs.tabIntervalTwips}`);
+    if (attrs.decimalSeparator) parts.push(`ds:${attrs.decimalSeparator}`);
+    if (parts.length > 0) {
+      paragraphAttrsKey = `|pa:${parts.join(":")}`;
+    }
+  }
+  return `${trackedMode}:${trackedEnabled ? "on" : "off"}|${runsHash}${numberingKey}${paragraphAttrsKey}`;
 };
 const createStats = () => ({
   hits: 0,
@@ -82187,6 +82299,75 @@ const getTrackedChangeKey = (run2) => {
   }
   return "";
 };
+const paragraphSpacingEqual = (a, b2) => {
+  if (a === b2) return true;
+  if (!a || !b2) return !a && !b2;
+  return a.before === b2.before && a.after === b2.after && a.line === b2.line && a.lineRule === b2.lineRule && a.beforeAutospacing === b2.beforeAutospacing && a.afterAutospacing === b2.afterAutospacing;
+};
+const paragraphIndentEqual = (a, b2) => {
+  if (a === b2) return true;
+  if (!a || !b2) return !a && !b2;
+  return a.left === b2.left && a.right === b2.right && a.firstLine === b2.firstLine && a.hanging === b2.hanging;
+};
+const paragraphBorderEqual = (a, b2) => {
+  if (a === b2) return true;
+  if (!a || !b2) return !a && !b2;
+  return a.style === b2.style && a.width === b2.width && a.color === b2.color && a.space === b2.space;
+};
+const paragraphBordersEqual = (a, b2) => {
+  if (a === b2) return true;
+  if (!a || !b2) return !a && !b2;
+  return paragraphBorderEqual(a.top, b2.top) && paragraphBorderEqual(a.right, b2.right) && paragraphBorderEqual(a.bottom, b2.bottom) && paragraphBorderEqual(a.left, b2.left);
+};
+const paragraphShadingEqual = (a, b2) => {
+  if (a === b2) return true;
+  if (!a || !b2) return !a && !b2;
+  return a.fill === b2.fill && a.color === b2.color && a.val === b2.val && a.themeColor === b2.themeColor && a.themeFill === b2.themeFill && a.themeFillShade === b2.themeFillShade && a.themeFillTint === b2.themeFillTint && a.themeShade === b2.themeShade && a.themeTint === b2.themeTint;
+};
+const tabStopEqual = (a, b2) => {
+  return a.val === b2.val && a.pos === b2.pos && a.leader === b2.leader;
+};
+const tabStopsEqual = (a, b2) => {
+  if (a === b2) return true;
+  if (!a || !b2) return !a && !b2;
+  if (a.length !== b2.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    if (!tabStopEqual(a[i], b2[i])) return false;
+  }
+  return true;
+};
+const paragraphFrameEqual = (a, b2) => {
+  if (a === b2) return true;
+  if (!a || !b2) return !a && !b2;
+  return a.wrap === b2.wrap && a.x === b2.x && a.y === b2.y && a.xAlign === b2.xAlign && a.yAlign === b2.yAlign && a.hAnchor === b2.hAnchor && a.vAnchor === b2.vAnchor;
+};
+const dropCapDescriptorEqual = (a, b2) => {
+  if (a === b2) return true;
+  if (!a || !b2) return !a && !b2;
+  if (a.mode !== b2.mode || a.lines !== b2.lines) return false;
+  const runA = a.run;
+  const runB = b2.run;
+  if (!runA || !runB) return !runA && !runB;
+  if (runA.text !== runB.text || runA.fontFamily !== runB.fontFamily || runA.fontSize !== runB.fontSize || runA.bold !== runB.bold || runA.italic !== runB.italic || runA.color !== runB.color) {
+    return false;
+  }
+  return true;
+};
+const paragraphAttrsEqual = (a, b2) => {
+  if (a === b2) return true;
+  if (!a || !b2) return !a && !b2;
+  if (a.alignment !== b2.alignment || a.contextualSpacing !== b2.contextualSpacing || a.suppressFirstLineIndent !== b2.suppressFirstLineIndent || a.dropCap !== b2.dropCap || a.decimalSeparator !== b2.decimalSeparator || a.tabIntervalTwips !== b2.tabIntervalTwips || a.keepNext !== b2.keepNext || a.keepLines !== b2.keepLines || a.direction !== b2.direction || a.rtl !== b2.rtl || a.floatAlignment !== b2.floatAlignment) {
+    return false;
+  }
+  if (!paragraphSpacingEqual(a.spacing, b2.spacing)) return false;
+  if (!paragraphIndentEqual(a.indent, b2.indent)) return false;
+  if (!paragraphBordersEqual(a.borders, b2.borders)) return false;
+  if (!paragraphShadingEqual(a.shading, b2.shading)) return false;
+  if (!tabStopsEqual(a.tabs, b2.tabs)) return false;
+  if (!paragraphFrameEqual(a.frame, b2.frame)) return false;
+  if (!dropCapDescriptorEqual(a.dropCapDescriptor, b2.dropCapDescriptor)) return false;
+  return true;
+};
 const paragraphBlocksEqual = (a, b2) => {
   const aMode = a.attrs?.trackedChangesMode ?? "review";
   const bMode = b2.attrs?.trackedChangesMode ?? "review";
@@ -82194,6 +82375,7 @@ const paragraphBlocksEqual = (a, b2) => {
   const aEnabled = resolveTrackedChangesEnabled(a.attrs, true);
   const bEnabled = resolveTrackedChangesEnabled(b2.attrs, true);
   if (aEnabled !== bEnabled) return false;
+  if (!paragraphAttrsEqual(a.attrs, b2.attrs)) return false;
   if (a.runs.length !== b2.runs.length) return false;
   for (let i = 0; i < a.runs.length; i += 1) {
     const runA = a.runs[i];
@@ -84839,6 +85021,104 @@ async function measureParagraphBlock(block, maxWidth) {
         const wordStartChar = charPosInRun;
         const wordEndNoSpace = charPosInRun + word.length;
         const wordEndWithSpace = charPosInRun + (isLastWord ? word.length : word.length + 1);
+        const effectiveMaxWidth = currentLine ? currentLine.maxWidth : getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : contentWidth);
+        if (wordOnlyWidth > effectiveMaxWidth && word.length > 1) {
+          if (currentLine && currentLine.width > 0 && currentLine.segments.length > 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;
+            currentLine = null;
+          }
+          const lineMaxWidth = getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : contentWidth);
+          const hasTabOnlyLine = currentLine && currentLine.segments.length === 0 && currentLine.width > 0;
+          const remainingWidthAfterTab = hasTabOnlyLine ? currentLine.maxWidth - currentLine.width : lineMaxWidth;
+          const chunkWidth = hasTabOnlyLine ? Math.max(remainingWidthAfterTab, lineMaxWidth * 0.25) : lineMaxWidth;
+          const chunks = breakWordIntoChunks(word, chunkWidth - WIDTH_FUDGE_PX, font, ctx2, run2);
+          let chunkCharOffset = wordStartChar;
+          for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+            const chunk = chunks[chunkIndex];
+            const chunkStartChar = chunkCharOffset;
+            const chunkEndChar = chunkCharOffset + chunk.text.length;
+            const isLastChunk = chunkIndex === chunks.length - 1;
+            const isFirstChunk = chunkIndex === 0;
+            if (isFirstChunk && hasTabOnlyLine && currentLine) {
+              currentLine.toRun = runIndex;
+              currentLine.toChar = chunkEndChar;
+              currentLine.width = roundValue(currentLine.width + chunk.width);
+              currentLine.maxFontSize = Math.max(currentLine.maxFontSize, run2.fontSize);
+              currentLine.maxFontInfo = getFontInfoFromRun(run2);
+              currentLine.segments.push({
+                runIndex,
+                fromChar: chunkStartChar,
+                toChar: chunkEndChar,
+                width: chunk.width
+              });
+              if (isLastChunk) {
+                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;
+                }
+              } else {
+                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;
+                currentLine = null;
+              }
+            } else if (isLastChunk) {
+              currentLine = {
+                fromRun: runIndex,
+                fromChar: chunkStartChar,
+                toRun: runIndex,
+                toChar: chunkEndChar,
+                width: chunk.width,
+                maxFontSize: run2.fontSize,
+                maxFontInfo: getFontInfoFromRun(run2),
+                maxWidth: getEffectiveWidth(contentWidth),
+                segments: [{ runIndex, fromChar: chunkStartChar, toChar: chunkEndChar, width: chunk.width }],
+                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;
+              }
+            } else {
+              const chunkLineMaxWidth = getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : contentWidth);
+              const metrics = calculateTypographyMetrics(run2.fontSize, spacing, getFontInfoFromRun(run2));
+              const chunkLine = {
+                fromRun: runIndex,
+                fromChar: chunkStartChar,
+                toRun: runIndex,
+                toChar: chunkEndChar,
+                width: chunk.width,
+                maxWidth: chunkLineMaxWidth,
+                segments: [{ runIndex, fromChar: chunkStartChar, toChar: chunkEndChar, width: chunk.width }],
+                ...metrics
+              };
+              addBarTabsToLine(chunkLine);
+              lines.push(chunkLine);
+            }
+            chunkCharOffset = chunkEndChar;
+          }
+          continue;
+        }
         if (!currentLine) {
           currentLine = {
             fromRun: runIndex,
@@ -85417,6 +85697,35 @@ const measureRunWidth = (text, font, ctx2, run2) => {
   const width = getMeasuredTextWidth(text, font, letterSpacing, ctx2);
   return roundValue(width);
 };
+const breakWordIntoChunks = (word, maxWidth, font, ctx2, run2) => {
+  const chunks = [];
+  if (maxWidth <= 0) {
+    for (const char of word) {
+      const charWidth = measureRunWidth(char, font, ctx2, run2);
+      chunks.push({ text: char, width: charWidth });
+    }
+    return chunks;
+  }
+  let currentChunk = "";
+  let currentWidth = 0;
+  for (let i = 0; i < word.length; i++) {
+    const char = word[i];
+    const testChunk = currentChunk + char;
+    const testWidth = measureRunWidth(testChunk, font, ctx2, run2);
+    if (testWidth > maxWidth && currentChunk.length > 0) {
+      chunks.push({ text: currentChunk, width: currentWidth });
+      currentChunk = char;
+      currentWidth = measureRunWidth(char, font, ctx2, run2);
+    } else {
+      currentChunk = testChunk;
+      currentWidth = testWidth;
+    }
+  }
+  if (currentChunk.length > 0) {
+    chunks.push({ text: currentChunk, width: currentWidth });
+  }
+  return chunks;
+};
 const appendSegment = (segments, runIndex, fromChar, toChar, width, x2) => {
   if (!segments) return;
   const last = segments[segments.length - 1];