postext 1.14.1 → 1.15.1

package/dist/measure/rich.js

@@ -1,3 +1,4 @@
+import { uprightArabicSpans, uprightFace } from '../uprightArabic';
 import { createBoundingBox } from '../vdt';
 import { hyphenateText, withoutSlashJoints } from '../hyphenate';
 import { richTokensToItems, computeBreakpoints, reconstructRichLines, } from '../knuthPlass';
@@ -8,6 +9,7 @@ import { isRuntLastLine } from './runts';
 import { computeJustifiedSpaceRatio, hasOverfullLine } from './plain';
 import { quoteFamily } from './font';
 import { trimChipLineEdges } from './chipEdges';
+import { directChipRuns } from '../design/bidiText';
 import { cjkJoinBreaks, hasCJK } from './cjk';
 import { composeCjkParagraph, cjkWordBreaks, composesAsCjk, spanMarks } from './cjkCompose';
 import { graphemeCount, graphemesOf } from './graphemes';
@@ -17,6 +19,10 @@ import { sliceSpan } from '../parse/links';
 import { NO_BREAK_SPACES, WORDS_AND_SPACES_RE, isBlankText, isBreakingSpace, isBreakingSpaceRun } from './spaces';
 import { breaksAfterDash, breaksAfterHardHyphen, hasCompound, isDash, raggedStretchPx } from './breakRules';
 import { GEMINATE_DOT, endsInsideGeminate, withLineEndHyphen } from './geminate';
+import { insideJoiningWord, joiningScriptIn, wordLetterSpacing } from './joining';
+import { applyLineDirections, applySegmentLanguages, getMeasureDirection, spanLanguages } from './bidiLines';
+import { TATWEEL, justifyLinesWithKashida, kashidaCapacity } from './kashida';
+import { needsBidi, resolveParagraph, spanIsolates } from '../bidi';
 /** Whether a resolved swatch colour can fill the square: a six- or
  *  eight-digit hex (`#rrggbb`, `#rrggbbaa`) or an `rgb()` / `rgba()`
  *  colour. Anything else leaves the swatch an empty outline. */
@@ -101,13 +107,14 @@ export function stackedScriptPairs(scripts) {
 /** Font a token is measured with: its span font, or the script font of a
  *  superscript / subscript. */
 function tokenFont(t, normalFont, boldFont, italicFont, boldItalicFont) {
-    return t.scriptFont ?? pickSpanFont(t.bold, t.italic, normalFont, boldFont, italicFont, boldItalicFont);
+    return t.scriptFont ?? t.faceFont ?? pickSpanFont(t.bold, t.italic, normalFont, boldFont, italicFont, boldItalicFont);
 }
 /** The script, small-caps and Chinese-mark fields a token derived from
  *  another (a split, a hyphenated head) carries on. */
 function scriptOf(t) {
     return {
         ...(t.script ? { script: t.script, scriptFont: t.scriptFont, baselineShift: t.baselineShift } : {}),
+        ...(t.faceFont ? { faceFont: t.faceFont } : {}),
         ...(t.smallCaps ? { smallCaps: true } : {}),
         ...(t.cjkMarks ? { cjkMarks: t.cjkMarks } : {}),
         ...(t.inserted ? { inserted: true } : {}),
@@ -273,7 +280,8 @@ export function chipToken(span, normalFont, boldFont, italicFont, boldItalicFont
             runs.push({
                 text: piece.text,
                 fontString: piece.font,
-                width: measureTextWidth(piece.text, piece.font) + letterSpacingPx * graphemeCount(piece.text),
+                // A run of a joining script takes no tracking (`measure/joining.ts`).
+                width: measureTextWidth(piece.text, piece.font) + wordLetterSpacing(piece.text, letterSpacingPx) * graphemeCount(piece.text),
                 ...(bold ? { bold: true } : {}),
                 ...(italic ? { italic: true } : {}),
                 ...(baselineShift !== undefined ? { baselineShift } : {}),
@@ -292,6 +300,9 @@ export function chipToken(span, normalFont, boldFont, italicFont, boldItalicFont
         first.width = 0;
         first.stacked = true;
     }
+    // Right-to-left runs cut where the direction changes, and their order
+    // (`VDTChip.order`).
+    const directed = directChipRuns(runs, (t, f) => measureTextWidth(t, f) + wordLetterSpacing(t, letterSpacingPx) * graphemeCount(t));
     const textWidth = runs.reduce((sum, r) => sum + r.width, 0);
     const paddingX = box?.paddingXPx ?? 0;
     const paddingY = box?.paddingYPx ?? 0;
@@ -311,7 +322,8 @@ export function chipToken(span, normalFont, boldFont, italicFont, boldItalicFont
         width: boxWidth,
         chip: {
             styleId: box?.styleId ?? '',
-            runs,
+            runs: directed.runs,
+            ...(directed.order ? { order: directed.order } : {}),
             marginLeft: 0,
             marginRight: 0,
             boxWidth,
@@ -426,6 +438,10 @@ export function urlBreakIndices(text) {
  * not break there, and it must not reach the line text.
  */
 function syllabify(word, hyphenate) {
+    // A word of a joining script is never divided, not even at a soft hyphen
+    // its author typed: its letters connect (`measure/joining.ts`).
+    if (joiningScriptIn(word))
+        return { clean: word.includes(SOFT_HYPHEN) ? word.split(SOFT_HYPHEN).join('') : word, soft: [] };
     const hyphenated = hyphenate ? withoutSlashJoints(word, hyphenateText(word)) : word;
     if (!hyphenated.includes(SOFT_HYPHEN))
         return { clean: hyphenated, soft: [] };
@@ -509,13 +525,25 @@ function wordBreakPoints(clean, soft, font, letterSpacingPx, smallCaps, dashBrea
  * the word carries falls after it and adds none (`hard`): never "fisica-" |
  * "-universitaria" nor "fisica--". Null when not even one character fits,
  * or, with `syllablesOnly`, when no no-break space or syllable does.
+ *
+ * A word of a joining script (Arabic…) is never cut between its letters,
+ * and no hyphen marks a cut in it: only at a no-break space, or where it
+ * touches a run of another script (`ABCكتاب`), with nothing added. Null
+ * when no such place fits: the word then runs past the measure, and the
+ * line says so (`VDTLine.wordOverflow`).
  */
 export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, syllablesOnly = false) {
     const text = token.text;
     if (text.length < 2)
         return null;
-    const hyphenW = measureTextWidth('-', font) + letterSpacingPx;
-    const widthBefore = (idx) => textWidth(text.slice(0, idx), font, token.smallCaps) + (letterSpacingPx === 0 ? 0 : letterSpacingPx * graphemeCount(text.slice(0, idx)));
+    // Styled runs of one Arabic word (`RichToken.runs`) are one shaped word.
+    if (token.runs)
+        return null;
+    const joining = joiningScriptIn(text);
+    // The word was measured untracked (`wordLetterSpacing`): its pieces too.
+    const spacing = joining ? 0 : letterSpacingPx;
+    const hyphenW = measureTextWidth('-', font) + spacing;
+    const widthBefore = (idx) => textWidth(text.slice(0, idx), font, token.smallCaps) + (spacing === 0 ? 0 : spacing * graphemeCount(text.slice(0, idx)));
     const flags = { bold: token.bold, italic: token.italic, captionLabel: token.captionLabel, ...scriptOf(token) };
     // A group glued by no-break spaces too wide for any line: the space is
     // the least bad place to part it (EF-66). The line ends before it and the
@@ -534,7 +562,7 @@ export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, sylla
     // No hyphen where the cut falls next to an ideograph, or right after a
     // hyphen of the text.
     const afterHyphen = (idx) => text[idx - 1] === '-';
-    const markW = (idx) => (afterHyphen(idx) || hasCJK(text.slice(idx - 1, idx + 1)) ? 0 : hyphenW);
+    const markW = (idx) => (joining || afterHyphen(idx) || hasCJK(text.slice(idx - 1, idx + 1)) ? 0 : hyphenW);
     const fits = (idx) => widthBefore(idx) + markW(idx) <= lineMaxWidth;
     // The longest prefix that fits without its mark, found by doubling then
     // halving (prefix widths grow with their length): no cut past it fits,
@@ -572,6 +600,9 @@ export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, sylla
             // on it.
             if (text[idx] === '-')
                 continue;
+            // Never between the letters of a word of a joining script.
+            if (joining && insideJoiningWord(text, idx))
+                continue;
             if (fits(idx)) {
                 at = idx;
                 break;
@@ -768,7 +799,7 @@ export function atomicSpanToken(span, normalFont, boldFont, italicFont, boldItal
             ...(markerFont ? { markerFont } : {}),
             ...(span.smallCaps ? { smallCaps: true } : {}),
             kind: 'text',
-            width: textWidth(span.text, refFont, span.smallCaps) + (letterSpacingPx === 0 ? 0 : letterSpacingPx * graphemeCount(span.text)),
+            width: textWidth(span.text, refFont, span.smallCaps) + (letterSpacingPx === 0 ? 0 : wordLetterSpacing(span.text, letterSpacingPx) * graphemeCount(span.text)),
             ...(span.ref ? { refResourceId: span.ref.resourceId, ...(span.ref.anchor ? { refAnchor: true } : {}), ...(span.ref.pageIndex !== undefined ? { refPageIndex: span.ref.pageIndex } : {}) } : {}),
             ...(span.footnote ? { footnoteId: span.footnote.id } : {}),
         };
@@ -780,7 +811,7 @@ export function atomicSpanToken(span, normalFont, boldFont, italicFont, boldItal
             bold: span.bold,
             italic: span.italic,
             kind: 'text',
-            width: textWidth(span.text, font, false) + (letterSpacingPx === 0 ? 0 : letterSpacingPx * graphemeCount(span.text)),
+            width: textWidth(span.text, font, false) + (letterSpacingPx === 0 ? 0 : wordLetterSpacing(span.text, letterSpacingPx) * graphemeCount(span.text)),
             labelTab: span.labelTab,
         };
     }
@@ -830,6 +861,7 @@ export function tokenSegment(t) {
         ...(t.labelTab ? { labelTab: true } : {}),
         ...(t.script ? { script: t.script, fontString: t.scriptFont, baselineShift: t.baselineShift } : {}),
         ...(t.markerFont && !t.script ? { fontString: t.markerFont } : {}),
+        ...(t.faceFont && !t.script ? { fontString: t.faceFont } : {}),
         ...(t.stacked === 'first' ? { stacked: true } : {}),
         ...(t.smallCaps ? { smallCaps: true } : {}),
     };
@@ -842,6 +874,8 @@ export function tokenSegment(t) {
         seg.cjkMarks = t.cjkMarks;
     if (t.inserted)
         seg.inserted = true;
+    if (t.runs)
+        seg.runs = t.runs;
     return seg;
 }
 /**
@@ -874,7 +908,12 @@ dashBreaks = false,
 keepCompounds = false, 
 /** Whether the spans hold CJK characters (`hasCJK` of their text): only
  *  then is each word looked into. */
-cjkText = true) {
+cjkText = true, 
+/** The paragraph's bidi levels (`measure/bidiLines.ts`), when it has
+ *  right-to-left text: a word whose level changes inside it (`ABC،`,
+ *  `و١٤٤٥`, `(API)` in Arabic) is cut there into words that touch, each
+ *  measured as it is painted, as a run of its own direction. */
+bidi) {
     const tokens = [];
     // Which characters of the joined text sit in a compound, a word (across
     // runs: "*after*-dinner") with a hyphen between two letters.
@@ -882,17 +921,23 @@ cjkText = true) {
     let spanStart = 0;
     // Tracking: every character (spaces included) advances `letterSpacingPx`
     // more, exactly as canvas `letterSpacing` / CSS `letter-spacing` / PDF `Tc`
-    // paint it, so measured widths stay in step with the renderers.
-    const track = (text) => (letterSpacingPx === 0 ? 0 : letterSpacingPx * graphemeCount(text));
+    // paint it, so measured widths stay in step with the renderers. A word of
+    // a joining script takes none: the renderers paint it untracked too.
+    const track = (text) => (letterSpacingPx === 0 ? 0 : wordLetterSpacing(text, letterSpacingPx) * graphemeCount(text));
     /** The script fields of a span's tokens (font at the script size, shift). */
+    // The span's own face: its style's, unslanted for the Arabic words of a
+    // slanted style (`uprightArabic.ts`).
+    const faceOf = (span) => {
+        const face = pickSpanFont(span.bold, span.italic, normalFont, boldFont, italicFont, boldItalicFont);
+        return span.upright ? uprightFace(face) : face;
+    };
     const scriptFieldsOf = (span) => {
         if (!span.script)
-            return {};
-        const base = pickSpanFont(span.bold, span.italic, normalFont, boldFont, italicFont, boldItalicFont);
-        const m = scriptMetrics(base, span.script);
+            return span.upright ? { faceFont: faceOf(span) } : {};
+        const m = scriptMetrics(faceOf(span), span.script);
         return { script: span.script, scriptFont: m.font, baselineShift: m.baselineShift };
     };
-    const spanFont = (span) => scriptFieldsOf(span).scriptFont ?? pickSpanFont(span.bold, span.italic, normalFont, boldFont, italicFont, boldItalicFont);
+    const spanFont = (span) => scriptFieldsOf(span).scriptFont ?? faceOf(span);
     for (const span of spans) {
         const spanBase = spanStart;
         spanStart += span.text.length;
@@ -925,15 +970,16 @@ cjkText = true) {
         // its soft hyphens can be told apart from the ones the source carries.
         // A no-break space is no boundary: it stays inside the word it glues
         // ("37 °C"), which the line then never breaks at (EF-66).
-        const parts = span.text.match(WORDS_AND_SPACES_RE);
-        if (!parts)
+        const matched = span.text.match(WORDS_AND_SPACES_RE);
+        if (!matched)
             continue;
+        const parts = bidi ? cutAtLevels(matched, spanBase, bidi) : matched;
         let partStart = spanBase;
         for (const part of parts) {
             const partAt = partStart;
             partStart += part.length;
             const isSpace = isBreakingSpaceRun(part);
-            if (!isSpace && URL_LIKE_RE.test(part.replace(/\u00AD/g, ''))) {
+            if (!isSpace && URL_LIKE_RE.test(part.replace(/\u00AD/g, '')) && !(letterSpacingPx !== 0 && joiningScriptIn(part))) {
                 const clean = part.replace(/\u00AD/g, '');
                 const breakPoints = urlBreakIndices(clean).map((charIndex) => ({
                     charIndex,
@@ -962,7 +1008,10 @@ cjkText = true) {
                 : undefined;
             // A word that holds CJK characters: measured unit by unit, once each.
             const cjk = cjkText && !isSpace && hasCJK(clean) ? cjkWordBreaks(clean, font, sc, letterSpacingPx) : undefined;
-            const breakPoints = isSpace ? [] : wordBreakPoints(clean, soft, font, letterSpacingPx, sc, dashBreaks, touching, cjk);
+            // A word of a joining script is measured untracked, its break points
+            // (after a hyphen or a dash it carries) too.
+            const wordSpacing = isSpace ? letterSpacingPx : wordLetterSpacing(clean, letterSpacingPx);
+            const breakPoints = isSpace ? [] : wordBreakPoints(clean, soft, font, wordSpacing, sc, dashBreaks, touching, cjk);
             if (breakPoints.length > 0) {
                 tokens.push({
                     text: clean,
@@ -978,19 +1027,26 @@ cjkText = true) {
                 });
             }
             else {
+                // A word of a joining script loses the soft hyphens it may not
+                // break at (`syllabify`); any other keeps its text as written.
+                const word = clean !== part && !isSpace && joiningScriptIn(part) ? clean : part;
                 tokens.push({
-                    text: part,
+                    text: word,
                     bold: span.bold,
                     italic: span.italic,
                     captionLabel: span.captionLabel,
                     ...scriptFields,
                     ...(isSpace ? {} : scFields),
                     kind: isSpace ? 'space' : 'text',
-                    width: textWidth(part, font, sc && !isSpace) + track(part),
+                    width: textWidth(word, font, sc && !isSpace) + track(word),
                 });
             }
         }
     }
+    // A word of a joining script cut into runs by a style change is one
+    // word again (only text that holds such a script is looked at).
+    if (spans.length > 1)
+        joinStyledRuns(tokens, normalFont, boldFont, italicFont, boldItalicFont);
     if (tokens.some((t) => t.script))
         stackScriptTokens(tokens, normalFont, boldFont, italicFont, boldItalicFont);
     if (tokens.some((t) => t.chip)) {
@@ -1000,6 +1056,108 @@ cjkText = true) {
         markDashJoins(tokens);
     return tokens;
 }
+/** A token that may be one run of a word set in several styles: plain
+ *  text, nothing set as a whole (a reference, a note marker, a chip, a
+ *  formula, a swatch), no script, small capitals, vertical run or marks. */
+function isStyledRunPart(t) {
+    return t !== undefined && t.kind === 'text' && !t.mathRender && !t.swatch && !t.chip && t.refResourceId === undefined
+        && t.footnoteId === undefined && !t.labelTab && !t.script && !t.stacked && !t.smallCaps && !t.tcy && !t.orientation
+        && !t.cjkMarks && !t.inserted && !t.runs;
+}
+/** Whether two runs that touch (no space between) are pieces of one word
+ *  of a joining script: the cut between them falls between two of its
+ *  letters, or before a mark (see `insideJoiningWord`). */
+function joinsAcross(a, b) {
+    if (a.length === 0 || b.length === 0)
+        return false;
+    if (a.charCodeAt(a.length - 1) < 0x0600 && b.charCodeAt(0) < 0x0600)
+        return false;
+    return insideJoiningWord(a + b, a.length);
+}
+/**
+ * Join the runs a style change cuts a word of a joining script into
+ * (`كتا**ب**`, a coloured letter or vowel sign in a primer) back into one
+ * token. Measured in pieces, each piece would be shaped alone: the letters
+ * at the cut would take their isolated or final forms, the widths would be
+ * off by a fifth or more (engine-ltr-audit §1.4), and the renderers would
+ * paint a broken word. The token is measured whole in the style of its
+ * longest run (an approximation when the runs differ in weight, never in
+ * joining) and keeps each run's text and style (`runs`), so the renderers
+ * shape the word once and give each run its style. It never breaks.
+ */
+function joinStyledRuns(tokens, normalFont, boldFont, italicFont, boldItalicFont) {
+    for (let i = 0; i + 1 < tokens.length; i++) {
+        if (!isStyledRunPart(tokens[i]))
+            continue;
+        // Each next run is read against the whole word so far: a run of marks
+        // alone (`ب**َ**يت`, a coloured fatha) has no letter of its own to join
+        // from, the letter it sits on does.
+        let j = i + 1;
+        let word = tokens[i].text;
+        while (j < tokens.length && isStyledRunPart(tokens[j]) && joinsAcross(word, tokens[j].text)) {
+            word += tokens[j].text;
+            j++;
+        }
+        if (j === i + 1)
+            continue;
+        const parts = tokens.slice(i, j);
+        const runs = [];
+        let dominant = parts[0];
+        let most = -1;
+        for (const p of parts) {
+            const last = runs[runs.length - 1];
+            if (last && !!last.bold === p.bold && !!last.italic === p.italic)
+                last.text += p.text;
+            else
+                runs.push({ text: p.text, ...(p.bold ? { bold: true } : {}), ...(p.italic ? { italic: true } : {}) });
+            const n = graphemeCount(p.text);
+            if (n > most) {
+                most = n;
+                dominant = p;
+            }
+        }
+        const text = parts.map((p) => p.text).join('');
+        const merged = {
+            text,
+            bold: dominant.bold,
+            italic: dominant.italic,
+            ...(parts[0].captionLabel ? { captionLabel: true } : {}),
+            kind: 'text',
+            width: textWidth(text, tokenFont(dominant, normalFont, boldFont, italicFont, boldItalicFont), false),
+            ...(dominant.faceFont ? { faceFont: dominant.faceFont } : {}),
+            ...(runs.length > 1 ? { runs } : {}),
+            ...(parts[parts.length - 1].dashJoin ? { dashJoin: true } : {}),
+        };
+        tokens.splice(i, j - i, merged);
+    }
+}
+/** The words of a span (`parts`, starting at `from` in the paragraph) cut
+ *  where their bidi level changes, never between two letters of a joining
+ *  script. Spaces are left whole. */
+function cutAtLevels(parts, from, bidi) {
+    const out = [];
+    let at = from;
+    for (const part of parts) {
+        const start = at;
+        at += part.length;
+        if (isBreakingSpaceRun(part)) {
+            out.push(part);
+            continue;
+        }
+        let piece = 0;
+        for (let k = 1; k < part.length; k++) {
+            if (bidi.levels[start + k] === bidi.levels[start + k - 1] || insideJoiningWord(part, k))
+                continue;
+            const c = part.charCodeAt(k);
+            if (c >= 0xDC00 && c <= 0xDFFF)
+                continue;
+            out.push(part.slice(piece, k));
+            piece = k;
+        }
+        out.push(part.slice(piece));
+    }
+    return out;
+}
 /** A run of words a dash break may read across: not a formula, a swatch,
  *  a chip or one of two stacked scripts. */
 function isWordRun(t) {
@@ -1195,6 +1353,8 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
     // with it, read against the whole paragraph (#222).
     if (measuringVertically())
         spans = sidewaysNumberSpans(spans, getMeasureUprightDigits(), getMeasureRegion());
+    // Arabic letters are never slanted (#376, `uprightArabic.ts`).
+    spans = uprightArabicSpans(spans, italicFont, boldItalicFont, normalFont, boldFont);
     // Chinese, Japanese or Korean text: its own composer, which breaks
     // between characters under the document's line-break rules and spreads
     // justified lines between them — also text with no two CJK letters in a
@@ -1214,7 +1374,13 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
     const textAlign = options?.textAlign ?? 'left';
     const letterSpacingPx = options?.letterSpacingPx ?? 0;
     const hyphenationZonePx = shouldHyphenate ? options?.hyphenationZonePx : undefined;
-    const tokens = tokenizeSpans(spans, normalFont, boldFont, italicFont, boldItalicFont, shouldHyphenate, letterSpacingPx, options?.breakAfterDashes === true, options?.hyphenateCompounds === false, cjkText);
+    // A paragraph with right-to-left text: its levels, read once, cut its
+    // words where they change direction and give its lines their order.
+    const bidi = paragraphBidi(spans, plainText, options);
+    // The languages the paragraph's isolates name (`:ltr[…]{lang=en}`), set
+    // on the segments of their text (`VDTLineSegment.lang`).
+    const languages = spans.some((sp) => sp.direction?.lang !== undefined || sp.direction?.outer !== undefined) ? spanLanguages(spans) : [];
+    const tokens = tokenizeSpans(spans, normalFont, boldFont, italicFont, boldItalicFont, shouldHyphenate, letterSpacingPx, options?.breakAfterDashes === true, options?.hyphenateCompounds === false, cjkText, bidi);
     if (options?.labelColumnPx !== undefined)
         setLabelTabs(tokens, (t) => t.labelTab, options.labelColumnPx, (t, w) => { t.width = w; });
     const repeatHyphen = options?.repeatHyphen === true;
@@ -1223,6 +1389,19 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
     if (tokens.length === 0) {
         return { lines: [], totalHeight: 0 };
     }
+    // Kashida justification (#375): a justified paragraph with Arabic words.
+    const kashida = textAlign === 'justify' && options?.kashida && bidi ? options.kashida : undefined;
+    if (kashida)
+        markKashidaCapacity(tokens, kashida, normalFont, boldFont, italicFont, boldItalicFont);
+    const fontOf = (seg) => seg.fontString ?? pickSpanFont(!!seg.bold, !!seg.italic, normalFont, boldFont, italicFont, boldItalicFont);
+    const withKashida = (lines) => {
+        if (!kashida)
+            return;
+        justifyLinesWithKashida(lines, (li) => {
+            const indent = indentPx > 0 ? (hanging ? (li === 0 ? 0 : indentPx) : (li === 0 ? indentPx : 0)) : 0;
+            return lineMeasure(maxWidthPx, options?.restWidths, li) - indent;
+        }, normalSpaceWidth, kashida, (seg, text) => textWidth(text, fontOf(seg), false));
+    };
     // Knuth-Plass optimal line breaking path. A Latin paragraph quoting CJK
     // words takes it too: the breaks next to their characters are free
     // penalties, as a hyphenation point that adds nothing. Ragged text takes
@@ -1274,6 +1453,11 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
             if (!hasOverfullLine(kpLines, lineWidthFn, ragged)) {
                 if (hasSmallCaps)
                     expandSmallCaps(kpLines, normalFont, boldFont, italicFont, boldItalicFont, letterSpacingPx);
+                if (bidi)
+                    withDirections(kpLines, bidi, normalFont, boldFont, italicFont, boldItalicFont);
+                if (languages.length > 0)
+                    applySegmentLanguages(kpLines, plainText, languages);
+                withKashida(kpLines);
                 return {
                     lines: kpLines,
                     totalHeight: kpLines.length * lineHeightPx,
@@ -1307,6 +1491,8 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
         let lineSyllable = false;
         // The line ends after a hyphen the word carries (EF-140).
         let lineHardHyphen = false;
+        // A word of a joining script wider than the line runs past it.
+        let lineWordOverflow = false;
         // Consume leading spaces at line start (skip them)
         while (tokenIdx < tokens.length && tokens[tokenIdx].kind === 'space') {
             tokenIdx++;
@@ -1477,6 +1663,10 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
             }
             // No viable split. If line is empty, force-fit this token; else break to next line.
             if (lineTokens.length === 0) {
+                // A word of a joining script wider than the line is never cut: it
+                // runs past the measure, and the line says so.
+                if (token.width > lineMaxWidth && token.kind === 'text' && joiningScriptIn(token.text))
+                    lineWordOverflow = true;
                 lineTokens.push(token);
                 lineWidth += token.width;
                 tokenIdx++;
@@ -1514,12 +1704,50 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
             segments,
             isLastLine,
             ...(justifiedSpaceRatio !== undefined ? { justifiedSpaceRatio } : {}),
+            ...(lineWordOverflow ? { wordOverflow: true } : {}),
         });
         y += lineHeightPx;
         lineIndex++;
     }
     if (hasSmallCaps)
         expandSmallCaps(lines, normalFont, boldFont, italicFont, boldItalicFont, letterSpacingPx);
+    if (bidi)
+        withDirections(lines, bidi, normalFont, boldFont, italicFont, boldItalicFont);
+    if (languages.length > 0)
+        applySegmentLanguages(lines, plainText, languages);
+    withKashida(lines);
     return { lines, totalHeight: y };
 }
+/** Give each Arabic word of a justified paragraph its kashida capacity
+ *  (`RichToken.kashida`), which Knuth–Plass counts as the stretch of its
+ *  box. A word in pieces (styled runs of a Latin word, a reference label, a
+ *  footnote marker) takes none. */
+function markKashidaCapacity(tokens, options, normalFont, boldFont, italicFont, boldItalicFont) {
+    for (const t of tokens) {
+        if (t.kind !== 'text' || t.inserted || t.mathRender || t.swatch || t.chip || t.refResourceId !== undefined || t.footnoteId !== undefined || t.script)
+            continue;
+        if (!joiningScriptIn(t.text))
+            continue;
+        const font = tokenFont(t, normalFont, boldFont, italicFont, boldItalicFont);
+        const capacity = kashidaCapacity(t.text, options, measureTextWidth(TATWEEL, font));
+        if (capacity > 0)
+            t.kashida = capacity;
+    }
+}
+/** A paragraph's bidi levels (UAX #9, with its inline `:rtl[…]` /
+ *  `:ltr[…]` isolates), when it is set right to left, holds a
+ *  right-to-left letter or sets a right-to-left isolate; undefined for any
+ *  other, which is measured as it always was. */
+function paragraphBidi(spans, plainText, options) {
+    const base = options?.direction ?? getMeasureDirection();
+    const isolated = spans.some((s) => s.direction?.dir === 'rtl');
+    if (base !== 'rtl' && !isolated && !needsBidi(plainText))
+        return undefined;
+    return resolveParagraph(plainText, base, spans.some((s) => s.direction) ? spanIsolates(spans) : undefined);
+}
+/** The directions of a paragraph's lines (`measure/bidiLines.ts`). A piece
+ *  of a segment is measured in its font. */
+function withDirections(lines, bidi, normalFont, boldFont, italicFont, boldItalicFont) {
+    applyLineDirections(lines, bidi, (seg, piece) => textWidth(piece, seg.fontString ?? pickSpanFont(!!seg.bold, !!seg.italic, normalFont, boldFont, italicFont, boldItalicFont), false));
+}
 //# sourceMappingURL=rich.js.map