postext 1.27.0 → 1.28.0

package/dist/measure/rich.js

@@ -2,30 +2,33 @@ import { FORCED_BREAK, measureForcedBreaks } from './hardBreaks';
 import { placeTab } from './tabs';
 import { uprightArabicSpans, uprightFace } from '../uprightArabic';
 import { createBoundingBox } from '../vdt';
-import { hyphenateText, withoutSlashJoints } from '../hyphenate';
+import { getHyphenationRulesKey, hyphenateByDictionary, hyphenateText, softHyphenBreaks, withoutSlashJoints } from '../hyphenate';
 import { richTokensToItems, computeBreakpoints, reconstructRichLines, } from '../knuthPlass';
 import { SOFT_HYPHEN } from './types';
 import { lineStartAt, lineWidthAt, lineWidthFunction, markInsetLines, uniformMeasureFrom } from './types';
 import { cleanSoftHyphens, measureTextWidth, normalSpaceWidthFor } from './canvas';
 import { isRuntLastLine } from './runts';
-import { computeJustifiedSpaceRatio, hasOverfullLine } from './plain';
+import { hasOverfullLine } from './plain';
+import { justifiedSpaceRatios } from './spaceRatios';
 import { quoteFamily } from './font';
 import { trimChipLineEdges } from './chipEdges';
 import { directChipRuns } from '../design/bidiText';
 import { cjkJoinBreaks, hasCJK } from './cjk';
 import { composeCjkParagraph, cjkWordBreaks, composesAsCjk, composesDashRow, spanMarks } from './cjkCompose';
+import { getCjkComposition } from './cjkPunctuation';
 import { graphemeCount, graphemesOf } from './graphemes';
 import { CENTRAL, sideMarkerRun } from './cjkAnnotate';
 import { fontEm, getMeasureRegion, getMeasureUprightDigits, getMeasureWritingMode, lineBaselineOffset, mayHoldVerticalCell, measuringVertically, verticalTextWidth, withMeasureWritingMode } from './vertical';
 import { latinReader, uprightDigitCandidates } from '../writingMode';
 import { sliceSpan } from '../parse/links';
-import { NO_BREAK_SPACES, WORDS_AND_SPACES_RE, isBlankText, isBreakingSpace, isBreakingSpaceRun } from './spaces';
+import { NO_BREAK_SPACES, WORDS_AND_SPACES_RE, isBlankText, isBreakingSpace, isBreakingSpaceRun, refLabelPieces } 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, getMeasureArabicNumbers, getMeasureDirection, spanLanguages } from './bidiLines';
 import { TATWEEL, justifyLinesWithKashida, kashidaCapacity } from './kashida';
 import { needsBidi, resolveParagraph, spanIsolates } from '../bidi';
+import { cutDoubledMarks, faceReadsScript, getMeasureScriptContext, isDoubledMark, isLetterless, pieceScriptContext, resolveScriptContext, rtlTextWidth, scriptAt, scriptContextUntracked, scriptTextWidth, wordPieceScript } from './script';
 /** 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. */
@@ -121,8 +124,48 @@ function scriptOf(t) {
         ...(t.smallCaps ? { smallCaps: true } : {}),
         ...(t.cjkMarks ? { cjkMarks: t.cjkMarks } : {}),
         ...(t.inserted ? { inserted: true } : {}),
+        // The pieces of a word with no letter are shaped in its script (#725).
+        ...(t.scriptContext ? { scriptContext: t.scriptContext } : {}),
+        ...(t.scriptRtl ? { scriptRtl: true } : {}),
     };
 }
+/** The script fields of the piece `[from, to)` of `token`, a head or a
+ *  tail of it: the token's own when it is a word with no letter, or one
+ *  measured right to left; else, for a word with a letter that may have
+ *  pieces with none (`RichToken.wordScript`), the script of the piece when
+ *  it holds no letter (it is then measured and painted in it), or the
+ *  script in force where it starts, for the pieces cut from it later. */
+function pieceScriptFields(token, from, to) {
+    if (token.wordScript === undefined)
+        return {};
+    const script = pieceScriptContext(token.text, from, to, token.wordScript);
+    if (script)
+        return { scriptContext: script };
+    const start = scriptAt(token.text, from, token.wordScript);
+    return start ? { wordScript: start } : {};
+}
+/** The width of a word of a joining script (Arabic…), always painted
+ *  right to left: measured so too in a face that draws its punctuation by
+ *  script (#725, `rtlTextWidth`), so the bracket or the stop at its edge
+ *  takes the forms it is painted in; as any text otherwise. */
+function rtlWordWidth(text, font) {
+    return getMeasureScriptContext().enabled && !measuringVertically() && faceReadsScript(font) ? rtlTextWidth(text, font) : textWidth(text, font, false);
+}
+/** How a token's text is measured: in its script when it is a word with
+ *  no letter given one (#725), else as any text (`textWidth`). */
+function tokenTextWidth(token, font) {
+    const script = token.scriptContext;
+    if (script)
+        return (text) => (text === '' ? 0 : scriptTextWidth(text, font, script, token.scriptRtl === true));
+    // A right-to-left word of a face that draws punctuation by script.
+    if (token.scriptRtl)
+        return (text) => (text === '' ? 0 : rtlTextWidth(text, font));
+    // What opens a word before its first letter is measured in its script.
+    const word = token.wordScript;
+    if (word)
+        return (text) => (isLetterless(text) ? scriptTextWidth(text, font, word, false) : textWidth(text, font, token.smallCaps));
+    return (text) => textWidth(text, font, token.smallCaps);
+}
 /** Small capitals are synthesised, the same way on every backend: a
  *  lowercase letter is set as its capital at this fraction of the text
  *  size, while capitals, digits and punctuation keep the full size — the
@@ -439,17 +482,19 @@ export function urlBreakIndices(text) {
 /**
  * A word as laid out (its soft hyphens removed) and the breaks its soft
  * hyphens mark: the dictionary's when `hyphenate` is on, and the author's
- * own — the U+00AD the source carries, which the dictionary leaves as they
- * are (it does not hyphenate a word that already has them). The zero-width
+ * own — the U+00AD the source carries between two letters or digits
+ * (`softHyphenBreaks`), which the dictionary leaves as they are (it does not
+ * hyphenate a word that already has them). The zero-width
  * space the dictionary puts after a slash is dropped: the rich breaker does
- * not break there, and it must not reach the line text.
+ * not break there, and it must not reach the line text. `byDictionary`
+ * leaves the document's rules out (#699): every point of the patterns.
  */
-function syllabify(word, hyphenate) {
+function syllabify(word, hyphenate, byDictionary = false) {
     // 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;
+    const hyphenated = hyphenate ? withoutSlashJoints(word, byDictionary ? hyphenateByDictionary(word) : hyphenateText(word)) : word;
     if (!hyphenated.includes(SOFT_HYPHEN))
         return { clean: hyphenated, soft: [] };
     let clean = '';
@@ -461,10 +506,12 @@ function syllabify(word, hyphenate) {
         const fromSource = j < word.length && ch === word[j];
         if (fromSource)
             j++;
-        if (ch === SOFT_HYPHEN)
-            soft.push({ index: clean.length, author: fromSource });
-        else
+        if (ch !== SOFT_HYPHEN)
             clean += ch;
+        // One the author typed at the word's edge or next to punctuation is no
+        // break (#700).
+        else if (!fromSource || softHyphenBreaks(word, j - 1))
+            soft.push({ index: clean.length, author: fromSource });
     }
     return { clean, soft };
 }
@@ -483,10 +530,13 @@ function syllabify(word, hyphenate) {
  *  - next to CJK characters, under the line-break rules of the document's
  *    `cjk.lineBreak` (`cjk`: the word's units, measured once each, whose
  *    running sums give the widths before its breaks). */
-function wordBreakPoints(clean, soft, font, letterSpacingPx, smallCaps, dashBreaks = false, touching, cjk) {
+function wordBreakPoints(clean, soft, font, letterSpacingPx, smallCaps, dashBreaks = false, touching, cjk, 
+/** How the word's pieces are measured when not as any text: in the
+ *  script of a word with no letter (#725). */
+measure) {
     const widthBefore = cjk
         ? cjk.widthBefore
-        : (idx) => textWidth(clean.slice(0, idx), font, smallCaps) + (letterSpacingPx === 0 ? 0 : letterSpacingPx * graphemeCount(clean.slice(0, idx)));
+        : (idx) => (measure ? measure(clean.slice(0, idx)) : textWidth(clean.slice(0, idx), font, smallCaps)) + (letterSpacingPx === 0 ? 0 : letterSpacingPx * graphemeCount(clean.slice(0, idx)));
     const byIndex = new Map();
     const add = (bp) => {
         if (bp.charIndex <= 0 || bp.charIndex >= clean.length)
@@ -548,9 +598,11 @@ export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, sylla
         return null;
     const joining = joiningScriptIn(text);
     // The word was measured untracked (`wordLetterSpacing`): its pieces too.
-    const spacing = joining ? 0 : letterSpacingPx;
+    // So was a word with no letter shaped in the Arabic script (#725).
+    const spacing = joining || scriptContextUntracked(token.scriptContext) ? 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 measure = tokenTextWidth(token, font);
+    const widthBefore = (idx) => measure(text.slice(0, idx)) + (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
@@ -562,8 +614,8 @@ export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, sylla
         if (headWidth > lineMaxWidth)
             continue;
         return {
-            head: { ...flags, text: text.slice(0, idx), kind: 'text', width: headWidth },
-            tail: { ...tailAfter(token, idx + 1, widthBefore(idx + 1)), ...flags },
+            head: { ...flags, ...pieceScriptFields(token, 0, idx), text: text.slice(0, idx), kind: 'text', width: headWidth },
+            tail: { ...tailAfter(token, idx + 1, widthBefore(idx + 1)), ...flags, ...pieceScriptFields(token, idx + 1, text.length) },
         };
     }
     // No hyphen where the cut falls next to an ideograph, or right after a
@@ -601,6 +653,18 @@ export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, sylla
                 at = s.index;
         }
     }
+    // A word the document keeps whole (`hyphenation.exceptions`, capitalised
+    // words, cited names) is still divided when it is wider than its measure:
+    // at its entry's points above, else at the dictionary's syllables (#699).
+    if (at === 0 && getHyphenationRulesKey() !== '') {
+        const whole = syllabify(text, true, true);
+        if (whole.clean === text) {
+            for (const s of whole.soft) {
+                if (s.index > 0 && s.index <= reach && fits(s.index))
+                    at = s.index;
+            }
+        }
+    }
     if (at === 0 && !syllablesOnly) {
         for (let idx = reach; idx >= 1; idx--) {
             // Not right before a hyphen of the text: the next line would open
@@ -624,8 +688,8 @@ export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, sylla
     return {
         head: geminate
             ? { ...flags, text: withLineEndHyphen(text.slice(0, at)), kind: 'text', width: widthBefore(at - 1) + markW(at) }
-            : { ...flags, text: text.slice(0, at) + mark, kind: 'text', width: widthBefore(at) + markW(at) },
-        tail: { ...tailAfter(token, at, widthBefore(at)), ...flags },
+            : { ...flags, ...pieceScriptFields(token, 0, at), text: text.slice(0, at) + mark, kind: 'text', width: widthBefore(at) + markW(at) },
+        tail: { ...tailAfter(token, at, widthBefore(at)), ...flags, ...pieceScriptFields(token, at, text.length) },
         ...(afterHyphen(at) ? { hard: true } : {}),
     };
 }
@@ -851,6 +915,42 @@ export function atomicSpanToken(span, normalFont, boldFont, italicFont, boldItal
     }
     return undefined;
 }
+/**
+ * The tokens of a reference whose label is words (`ref.breakable`, #702):
+ * one per piece of the label (`refLabelPieces`: a word, with the number that
+ * keeps to it, or a run of breaking spaces), or undefined for a label that
+ * is one token ({@link atomicSpanToken}). A word is built as the whole
+ * label is — the reference's font, no dictionary points, never divided —
+ * and a space is an ordinary space of the line: a legal break, stretched
+ * and shrunk with the others. Every piece carries the reference, so the
+ * link has no holes; every piece after the first is flagged
+ * `refContinues`, so the reference stays one position in the source. A
+ * no-break space inside the label glues, as anywhere.
+ */
+export function refLabelTokens(span, normalFont, boldFont, italicFont, boldItalicFont, letterSpacingPx) {
+    if (!span.ref?.breakable || span.footnote)
+        return undefined;
+    // A number, a Roman numeral or a single letter keeps to the word before
+    // it: `Fig. 1a` is one piece, its space set as text.
+    const parts = refLabelPieces(span.text);
+    if (!parts)
+        return undefined;
+    const tokens = [];
+    for (const part of parts) {
+        const token = atomicSpanToken({ ...span, text: part }, normalFont, boldFont, italicFont, boldItalicFont, letterSpacingPx);
+        if (!token)
+            return undefined;
+        if (isBreakingSpaceRun(part)) {
+            token.kind = 'space';
+            // A space has no capitals to shrink.
+            delete token.smallCaps;
+        }
+        if (tokens.length > 0)
+            token.refContinues = true;
+        tokens.push(token);
+    }
+    return tokens;
+}
 /**
  * A footnote marker set apart from the text (`footnotes.markerPosition`,
  * JLReq §4.2.3), at its size (`span.footnote.scale` of `font`, the text's):
@@ -896,7 +996,7 @@ export function tokenSegment(t) {
         ...(t.mathRender ? { mathRender: t.mathRender } : {}),
         ...(t.swatch ? { swatch: t.swatch } : {}),
         ...(t.chip ? { chip: t.chip } : {}),
-        ...(t.refResourceId !== undefined ? { refResourceId: t.refResourceId, ...(t.refAnchor ? { refAnchor: true } : {}), ...(t.refPageIndex !== undefined ? { refPageIndex: t.refPageIndex } : {}) } : {}),
+        ...(t.refResourceId !== undefined ? { refResourceId: t.refResourceId, ...(t.refAnchor ? { refAnchor: true } : {}), ...(t.refPageIndex !== undefined ? { refPageIndex: t.refPageIndex } : {}), ...(t.refContinues ? { refContinues: true } : {}) } : {}),
         ...(t.footnoteId !== undefined ? { footnoteId: t.footnoteId } : {}),
         ...(t.captionLabel ? { captionLabel: true } : {}),
         ...(t.labelTab || t.tab ? { labelTab: true } : {}),
@@ -919,6 +1019,8 @@ export function tokenSegment(t) {
         seg.inserted = true;
     if (t.runs)
         seg.runs = t.runs;
+    if (t.scriptContext)
+        seg.scriptContext = t.scriptContext;
     return seg;
 }
 /**
@@ -956,7 +1058,11 @@ cjkText = true,
  *  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) {
+bidi, 
+/** `keep-all` is in force for the block (its own `cjkWordBreak`, else
+ *  the document's `cjk.wordBreak`): a word that holds CJK characters does
+ *  not break between two letters (#705). */
+keepAll = false) {
     const tokens = [];
     // Which characters of the joined text sit in a compound, a word (across
     // runs: "*after*-dinner") with a hyphen between two letters.
@@ -981,6 +1087,58 @@ bidi) {
         return { script: span.script, scriptFont: m.font, baselineShift: m.baselineShift };
     };
     const spanFont = (span) => scriptFieldsOf(span).scriptFont ?? faceOf(span);
+    // A word with no letter takes the script of the text around it (#725),
+    // in a face that draws its punctuation by script; the paragraph's text
+    // and isolates are read when the first such word turns up.
+    const scriptState = getMeasureScriptContext();
+    let paragraphText;
+    let isolates;
+    // `script` undefined: a word with letters. Right to left, it is measured
+    // as it is painted (`rtlTextWidth`); left to right, the pieces of it
+    // that hold no letter are measured and painted in `pieces`, the script
+    // they have inside it (`wordPieceScript`).
+    const contextOf = !scriptState.enabled || measuringVertically()
+        ? undefined
+        : (word, at, length, font) => {
+            if (!faceReadsScript(font) || hasCJK(word))
+                return undefined;
+            const rtl = bidi !== undefined && (bidi.levels[at] & 1) === 1;
+            if (!isLetterless(word)) {
+                if (rtl)
+                    return { script: undefined, rtl };
+                const pieces = wordPieceScript(word);
+                return pieces ? { script: undefined, rtl, pieces } : undefined;
+            }
+            // The Chinese or Japanese document's own ellipsis and dash.
+            if (!rtl && scriptState.hanMarks && isDoubledMark(word))
+                return { script: 'Hani', rtl };
+            paragraphText ??= bidi?.text ?? spans.map((sp) => sp.text).join('');
+            isolates ??= spans.some((sp) => sp.direction) ? spanIsolates(spans) : [];
+            const script = resolveScriptContext(paragraphText, at, at + length, rtl, isolates, scriptState.script);
+            return script ? { script, rtl } : rtl ? { script: undefined, rtl } : undefined;
+        };
+    /** How a word in the context `contextOf` gave it is measured: whole
+     *  (`whole`, undefined: as any text) and up to one of its breaks
+     *  (`upTo`), the tracking it takes, and the fields its token carries. */
+    const scriptMeasure = (context, font, sc) => {
+        if (!context)
+            return { untracked: false, fields: {} };
+        const { script, rtl, pieces } = context;
+        const whole = script ? (text) => (text === '' ? 0 : scriptTextWidth(text, font, script, rtl))
+            : rtl ? (text) => (text === '' ? 0 : rtlTextWidth(text, font))
+                : undefined;
+        // What stands before the word's first letter is measured in its
+        // script; from that letter on, a shaper gives the text that script.
+        const upTo = pieces
+            ? (text) => (text === '' ? 0 : isLetterless(text) ? scriptTextWidth(text, font, pieces, false) : textWidth(text, font, sc))
+            : whole;
+        return {
+            ...(whole ? { whole } : {}),
+            ...(upTo ? { upTo } : {}),
+            untracked: scriptContextUntracked(script),
+            fields: { ...(script ? { scriptContext: script } : {}), ...(rtl ? { scriptRtl: true } : {}), ...(pieces ? { wordScript: pieces } : {}) },
+        };
+    };
     for (const span of spans) {
         const spanBase = spanStart;
         spanStart += span.text.length;
@@ -994,6 +1152,12 @@ bidi) {
             }
             continue;
         }
+        // A reference whose label is words: one token per word and space (#702).
+        const label = refLabelTokens(span, normalFont, boldFont, italicFont, boldItalicFont, letterSpacingPx);
+        if (label) {
+            tokens.push(...label);
+            continue;
+        }
         const atomic = atomicSpanToken(span, normalFont, boldFont, italicFont, boldItalicFont, letterSpacingPx);
         if (atomic) {
             tokens.push(atomic);
@@ -1026,7 +1190,13 @@ bidi) {
         const matched = span.text.match(WORDS_AND_SPACES_RE);
         if (!matched)
             continue;
-        const parts = bidi ? cutAtLevels(matched, spanBase, bidi) : matched;
+        const levelled = bidi ? cutAtLevels(matched, spanBase, bidi) : matched;
+        // In a Chinese or Japanese document a word with no letter is cut
+        // around its doubled ellipses and dashes: the document's own marks,
+        // set as Han text whatever sentence cites them (`cutDoubledMarks`).
+        const parts = contextOf && scriptState.hanMarks && faceReadsScript(font)
+            ? levelled.flatMap((part) => (isBreakingSpaceRun(part) ? undefined : cutDoubledMarks(part)) ?? [part])
+            : levelled;
         let partStart = spanBase;
         for (const part of parts) {
             const partAt = partStart;
@@ -1034,9 +1204,15 @@ bidi) {
             const isSpace = isBreakingSpaceRun(part);
             if (!isSpace && URL_LIKE_RE.test(part.replace(/\u00AD/g, '')) && !(letterSpacingPx !== 0 && joiningScriptIn(part))) {
                 const clean = part.replace(/\u00AD/g, '');
+                // An address is one script run: its pieces with no letter
+                // (`10.1006/`, `.2001`) are measured in the script they have in
+                // it, and an address with no letter at all in its context's (#725).
+                const inScript = scriptMeasure(contextOf?.(clean, partAt, part.length, font), font, sc);
+                const spacing = inScript.untracked ? 0 : letterSpacingPx;
+                const upTo = inScript.upTo ?? ((text) => textWidth(text, font, sc));
                 const breakPoints = urlBreakIndices(clean).map((charIndex) => ({
                     charIndex,
-                    widthBefore: textWidth(clean.slice(0, charIndex), font, sc) + (letterSpacingPx === 0 ? 0 : letterSpacingPx * graphemeCount(clean.slice(0, charIndex))),
+                    widthBefore: upTo(clean.slice(0, charIndex)) + (spacing === 0 ? 0 : spacing * graphemeCount(clean.slice(0, charIndex))),
                 }));
                 tokens.push({
                     text: clean,
@@ -1045,8 +1221,9 @@ bidi) {
                     captionLabel: span.captionLabel,
                     ...scriptFields,
                     ...scFields,
+                    ...inScript.fields,
                     kind: 'text',
-                    width: textWidth(clean, font, sc) + track(clean),
+                    width: (inScript.whole ? inScript.whole(clean) : textWidth(clean, font, sc)) + (inScript.untracked ? 0 : track(clean)),
                     ...(breakPoints.length > 0 ? { breakPoints, hyphenWidth: 0, bareBreaks: true } : {}),
                 });
                 continue;
@@ -1060,11 +1237,20 @@ bidi) {
                 ? before.text.slice(-2)
                 : 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 cjk = cjkText && !isSpace && hasCJK(clean) ? cjkWordBreaks(clean, font, sc, letterSpacingPx, undefined, keepAll) : undefined;
             // 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);
+            // A word with no letter: measured in the script of its context, its
+            // pieces at a break too (#725). In the Arabic script it takes no
+            // tracking, as the Arabic words around it take none.
+            // A word with a letter: its pieces with no letter (`COVID-` | `19`)
+            // in the script they have inside it.
+            const measured = scriptMeasure(contextOf && !isSpace && !cjk ? contextOf(clean, partAt, part.length, font) : undefined, font, sc);
+            const untracked = measured.untracked;
+            const wordSpacing = isSpace ? letterSpacingPx : untracked ? 0 : wordLetterSpacing(clean, letterSpacingPx);
+            const inScript = measured.whole;
+            const contextFields = measured.fields;
+            const breakPoints = isSpace ? [] : wordBreakPoints(clean, soft, font, wordSpacing, sc, dashBreaks, touching, cjk, measured.upTo);
             if (breakPoints.length > 0) {
                 tokens.push({
                     text: clean,
@@ -1073,8 +1259,9 @@ bidi) {
                     captionLabel: span.captionLabel,
                     ...scriptFields,
                     ...scFields,
+                    ...contextFields,
                     kind: 'text',
-                    width: cjk ? cjk.width : textWidth(clean, font, sc) + track(clean),
+                    width: cjk ? cjk.width : (inScript ? inScript(clean) : textWidth(clean, font, sc)) + (untracked ? 0 : track(clean)),
                     breakPoints,
                     hyphenWidth: measureTextWidth('-', font) + letterSpacingPx,
                 });
@@ -1090,8 +1277,9 @@ bidi) {
                     captionLabel: span.captionLabel,
                     ...scriptFields,
                     ...(isSpace ? {} : scFields),
+                    ...contextFields,
                     kind: isSpace ? 'space' : 'text',
-                    width: textWidth(word, font, sc && !isSpace) + track(word),
+                    width: (inScript ? inScript(word) : textWidth(word, font, sc && !isSpace)) + (untracked ? 0 : track(word)),
                 });
             }
         }
@@ -1176,7 +1364,7 @@ function joinStyledRuns(tokens, normalFont, boldFont, italicFont, boldItalicFont
             italic: dominant.italic,
             ...(parts[0].captionLabel ? { captionLabel: true } : {}),
             kind: 'text',
-            width: textWidth(text, tokenFont(dominant, normalFont, boldFont, italicFont, boldItalicFont), false),
+            width: rtlWordWidth(text, tokenFont(dominant, normalFont, boldFont, italicFont, boldItalicFont)),
             ...(dominant.faceFont ? { faceFont: dominant.faceFont } : {}),
             ...(runs.length > 1 ? { runs } : {}),
             ...(parts[parts.length - 1].dashJoin ? { dashJoin: true } : {}),
@@ -1296,9 +1484,10 @@ function splitToken(token, bp, mark, markWidth) {
     return {
         head: mark !== '' && bp.replacesWidth !== undefined
             ? { ...flags, text: withLineEndHyphen(token.text.slice(0, bp.charIndex)), kind: 'text', width: bp.widthBefore - bp.replacesWidth + markWidth }
-            : { ...flags, text: token.text.slice(0, bp.charIndex) + mark, kind: 'text', width: bp.widthBefore + markWidth },
+            : { ...flags, ...pieceScriptFields(token, 0, bp.charIndex), text: token.text.slice(0, bp.charIndex) + mark, kind: 'text', width: bp.widthBefore + markWidth },
         tail: {
             ...flags,
+            ...pieceScriptFields(token, bp.charIndex, token.text.length),
             text: token.text.slice(bp.charIndex),
             kind: 'text',
             width: token.width - bp.widthBefore,
@@ -1451,7 +1640,10 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
     // 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);
+    // `keep-all` holds in a Latin paragraph that quotes CJK characters as it
+    // does in one the composer sets (#705).
+    const keepAll = cjkText && (options?.cjkWordBreak !== undefined ? options.cjkWordBreak === 'keep-all' : (options?.cjkComposition ?? getCjkComposition()).keepAll === true);
+    const tokens = tokenizeSpans(spans, normalFont, boldFont, italicFont, boldItalicFont, shouldHyphenate, letterSpacingPx, options?.breakAfterDashes === true, options?.hyphenateCompounds === false, cjkText, bidi, keepAll);
     if (options?.labelColumnPx !== undefined)
         setLabelTabs(tokens, (t) => t.labelTab, options.labelColumnPx, (t, w) => { t.width = w; });
     const repeatHyphen = options?.repeatHyphen === true;
@@ -1470,7 +1662,7 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
             return;
         justifyLinesWithKashida(lines, (li) => {
             return lineWidthAt(maxWidthPx, options, li);
-        }, normalSpaceWidth, kashida, (seg, text) => textWidth(text, fontOf(seg), false));
+        }, normalSpaceWidth, kashida, (seg, text) => rtlWordWidth(text, fontOf(seg)));
     };
     // Knuth-Plass optimal line breaking path. A Latin paragraph quoting CJK
     // words takes it too: the breaks next to their characters are free
@@ -1817,7 +2009,7 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
         const lineText = lineTokens.map((t) => cleanSoftHyphens(t.text)).join('');
         const contentWidth = segments.reduce((sum, t) => sum + t.width, 0);
         // A tabbed line is set as measured: its widths are final.
-        const justifiedSpaceRatio = lineTabbed ? undefined : computeJustifiedSpaceRatio(segments, lineMaxWidth, normalSpaceWidth, textAlign, isLastLine);
+        const spaceRatios = lineTabbed || textAlign !== 'justify' || isLastLine ? {} : justifiedSpaceRatios(segments, lineMaxWidth, normalSpaceWidth);
         lines.push({
             text: lineText,
             bbox: createBoundingBox(lineIndent, y, contentWidth, lineHeightPx),
@@ -1827,7 +2019,7 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
             ...(lineRepeated && lineText.startsWith('-') ? { repeatedHyphen: true } : {}),
             segments,
             isLastLine,
-            ...(justifiedSpaceRatio !== undefined ? { justifiedSpaceRatio } : {}),
+            ...spaceRatios,
             ...(lineWordOverflow ? { wordOverflow: true } : {}),
             ...(lineTabbed ? { tabbed: true, ...(textAlign === 'justify' ? { ragged: true } : {}) } : {}),
         });