postext 1.8.6 → 1.9.0

package/dist/measure/cjkCompose.js

@@ -0,0 +1,2022 @@
+/**
+ * The CJK line composer: Chinese (and Japanese, Korean) paragraphs, on both
+ * the plain and the formatted path, broken between characters under the
+ * clreq prohibitions of the document's `cjk.lineBreak` and, when justified,
+ * spread between characters.
+ *
+ * Linear in the paragraph: every unit (one grapheme, a Western run a line
+ * never breaks inside, a 2-em dash or ellipsis, an atomic box) is measured
+ * once — the width cache holds single characters, not prefixes — and the
+ * breaker walks the units once with a running width. A line that would
+ * start with a prohibited mark gives up characters to the next line
+ * (push-out), back to the last break the rules allow.
+ *
+ * Justification (clreq §6.2.2.4): a justified line that is not its
+ * paragraph's last is stretched to the measure — word spaces first, up to
+ * ½ em each, then every gap between characters equally, never inside a
+ * Western run (a word, a number with its signs), a 2-em dash or ellipsis,
+ * and never next to a connector or a solidus. The spread is carried as
+ * segment `tracking` (px after each grapheme, in the segment's width); a
+ * Western run or a dash pair that a gap follows gives its last grapheme a
+ * segment of its own. A line that needs more than the cap (½ em, or
+ * `bodyText.maxJustifyTracking` when set) is set with the cap and flagged
+ * `cjkLoose` and `ragged`; a line with no CJK character on it (the head of
+ * a long web address) is set `ragged` without the flag.
+ *
+ * Segments: a Western run keeps one of its own, and single characters
+ * share one only when they have one style, link and spacing and advance
+ * alike, so a caret spread evenly over a segment lands on its characters
+ * and a Markdown link covers only its own.
+ */
+import { createBoundingBox } from '../vdt';
+import { lineMeasure } from './types';
+import { measureInkBox, measureInkExtent, measureTextWidth, normalSpaceWidthFor } from './canvas';
+import { atomicSpanToken, emergencySplit, expandSmallCaps, pickSpanFont, scriptMetrics, setsObject, spanScriptFields, stackedScriptPairs, textWidth, tokenSegment, URL_LIKE_RE, urlBreakIndices, } from './rich';
+import { cjkBreakAllowed, cjkClassOf, getCjkLineBreak, isCjkGrapheme, isFullwidthAlnum, isFullwidthDigit, isLineEndProhibited, isLineStartProhibited, isWordInnerMark, } from './cjkClasses';
+import { hasCJK } from './cjk';
+import { graphemeCount, graphemesOf, lastGrapheme } from './graphemes';
+import { isBreakingSpace } from './spaces';
+import { trimChipLineEdges } from './chipEdges';
+import { cellAdvance, fontEm, fontFamilyOf, getMeasureRegion, getMeasureUprightDigits, getMeasureWritingMode, lineBaselineOffset, measureCentralBaseline, verticalTrackCount, withMeasureWritingMode } from './vertical';
+import { verticalRuns } from '../writingMode';
+import { foldWidth, isZhuyin, noteRowBaselines, readingAdvance, rubyGeometry, splitNote, withFontSize, ZHUYIN_SIZE_RATIO } from './cjkAnnotate';
+import { applyLineEdges, boxCut, carryStopBlank, compositionFor, compressPair, getCjkComposition, isLatinSpacingHan, isLatinSpacingLatin, isPlainComposition, latinSpacingPx, lineEdgeCut, mayHang, punctuationBox, punctuationShrink, routesSharedMarks, shrinkPunctuation, shrinkStep, } from './cjkPunctuation';
+/** Fit tolerance of the breaker (px): running sums of many widths may
+ *  land a hair past a measure they fill exactly. */
+const FIT_EPS = 1e-6;
+const FONT_SIZE_RE = /(\d*\.?\d+)px/;
+/** Letters of the scripts set without spaces (Han, kana, bopomofo, hangul),
+ *  as {@link isCjkParagraph} counts them. */
+const CJK_LETTER_RE = /[\u3005-\u3007\u3040-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3100-\u312F\u31A0-\u31BF\u3400-\u4DBF\u4E00-\u9FFF\uAC00-\uD7AF\uF900-\uFAFF\uFF66-\uFF9F\u{20000}-\u{3FFFF}]/u;
+/** Combining marks and variation selectors: they belong to the character
+ *  before them. */
+const MARK_RE = /\p{M}/u;
+/**
+ * Whether a paragraph is set by the CJK composer: it holds more CJK letters
+ * than word spaces. A word space is a run of spaces between two characters
+ * that are not CJK. A space that touches a CJK character or mark is the
+ * one web text types at each boundary (`2026 年 9 月 28 日`, `安装 Node.js
+ * 和 Git`), which the composer replaces with the Han–Latin space.
+ * A Latin paragraph that quotes a Chinese title or name ("the novel 紅樓夢
+ * was …") has more word spaces, stays with Knuth–Plass and breaks next to
+ * the characters it quotes; a Chinese paragraph with Latin words in it
+ * ("用 iPhone 拍照") is composed, with its typed spaces or without them.
+ */
+export function isCjkParagraph(text) {
+    let letters = 0;
+    let spaces = 0;
+    let inSpace = false;
+    // Whether the character before the run of spaces is CJK.
+    let spaceAfterCjk = false;
+    let lastCjk = false;
+    for (const ch of text) {
+        if (isBreakingSpace(ch)) {
+            if (!inSpace)
+                spaceAfterCjk = lastCjk;
+            inSpace = true;
+            continue;
+        }
+        if (MARK_RE.test(ch))
+            continue;
+        const cjk = hasCJK(ch);
+        if (inSpace && !spaceAfterCjk && !cjk)
+            spaces++;
+        inSpace = false;
+        lastCjk = cjk;
+        if (CJK_LETTER_RE.test(ch))
+            letters++;
+    }
+    if (inSpace && !spaceAfterCjk)
+        spaces++;
+    return letters > spaces;
+}
+/** Whether the CJK composer sets a paragraph of this text: it holds CJK
+ *  text (not only unit squares or marks Latin shares with Chinese) and more
+ *  CJK letters than word spaces (see {@link isCjkParagraph}). Both
+ *  measuring paths ask this, so they agree. */
+export function composesAsCjk(text) {
+    return hasCJK(text) && isCjkParagraph(text);
+}
+/** The marks a span sets on its characters (#193), the emphasis dots'
+ *  defaults filled in: a filled dot (an open circle), under the text, or
+ *  right of it in vertical text. */
+export function spanMarks(span, vertical) {
+    if (!span.emphasisMark && span.properName === undefined && !span.bookTitle)
+        return undefined;
+    const marks = {};
+    if (span.emphasisMark) {
+        const style = span.emphasisMark.style ?? 'dot';
+        marks.dots = {
+            style,
+            fill: span.emphasisMark.fill ?? (style === 'circle' ? 'open' : 'filled'),
+            position: span.emphasisMark.position ?? (vertical ? 'over' : 'under'),
+        };
+    }
+    if (span.properName !== undefined)
+        marks.properName = span.properName;
+    if (span.bookTitle)
+        marks.bookTitle = span.bookTitle.id;
+    return marks;
+}
+/** The part of a style key the marks and added characters make. */
+function marksKey(marks, inserted) {
+    if (!marks && !inserted)
+        return '';
+    const d = marks?.dots;
+    return `|m:${d ? `${d.style}${d.fill}${d.position}` : ''}:${marks?.properName ?? ''}:${marks?.bookTitle ?? ''}${inserted ? ':ins' : ''}`;
+}
+function styleOf(span, fonts, vertical = false) {
+    const script = spanScriptFields(span, fonts.normal, fonts.bold, fonts.italic, fonts.boldItalic);
+    const font = script.scriptFont ?? pickSpanFont(span.bold, span.italic, fonts.normal, fonts.bold, fonts.italic, fonts.boldItalic);
+    const marks = spanMarks(span, vertical);
+    return {
+        key: `${span.bold ? 'b' : ''}${span.italic ? 'i' : ''}${span.captionLabel ? 'c' : ''}${span.smallCaps ? 's' : ''}|${script.script ?? ''}|${font}|${script.baselineShift ?? ''}${marksKey(marks, span.inserted)}`,
+        bold: span.bold,
+        italic: span.italic,
+        ...(span.captionLabel ? { captionLabel: true } : {}),
+        ...script,
+        ...(span.smallCaps ? { smallCaps: true } : {}),
+        font,
+        ...(marks ? { marks } : {}),
+        ...(span.inserted ? { inserted: true } : {}),
+    };
+}
+/** A grapheme set as a Chinese character here: a CJK grapheme, unless it
+ *  is the apostrophe or the interpunct of a Latin word ("don’t", "l·l"). */
+function isCjkHere(g, prev, next) {
+    return isCjkGrapheme(g) && !isWordInnerMark(g, prev, next);
+}
+/** Marks that pair up into one 2-em unit (破折号, 省略号). */
+function pairable(g) {
+    return g === '\u2014' || g === '\u2015' || g === '\u2026' || g === '\u22EF'; // — ― … ⋯
+}
+/** Whether a vertical Western run opens and ends with a short number set
+ *  in one upright cell (`cjk.uprightDigits`, see `verticalRuns`);
+ *  undefined when neither. */
+function numberCellEdges(run) {
+    const digits = getMeasureUprightDigits();
+    if (digits === 0 || !run.some((g) => g >= '0' && g <= '9' && g.length === 1))
+        return undefined;
+    const runs = verticalRuns(run, getMeasureRegion(), digits);
+    const start = runs[0]?.glyph.orient === 'tcy';
+    const end = runs[runs.length - 1]?.glyph.orient === 'tcy';
+    return start || end ? { start, end } : undefined;
+}
+/**
+ * The units of a span the author set apart in vertical text (see
+ * `Unit.orient`): `:tcy[…]` one upright cell of one em, `:upright[…]` one
+ * cell per character (a line never breaks between them), `:sideways[…]`
+ * one Western run at its horizontal width. The cells break and spread like
+ * Chinese characters and take no Han–Latin space; the block's tracking
+ * follows each cell once.
+ */
+function orientedUnits(span, style, letterSpacingPx, zwsp, units) {
+    const track = (n) => (letterSpacingPx === 0 ? 0 : letterSpacingPx * n);
+    const em = fontEm(style.font);
+    const base = { style, at: 0, ...(zwsp ? { zwspBefore: true } : {}) };
+    if (span.orientation === 'sideways' && !span.combineUpright) {
+        const graphemes = graphemesOf(span.text);
+        units.push({
+            ...base,
+            kind: 'text',
+            text: span.text,
+            width: measureTextWidth(span.text, style.font) + track(graphemes.length),
+            graphemes: graphemes.length,
+            first: 'western',
+            last: 'western',
+            firstCjk: false,
+            lastCjk: false,
+            run: true,
+            orient: 'sideways',
+        });
+        return;
+    }
+    if (span.combineUpright) {
+        units.push({
+            ...base,
+            kind: 'text',
+            text: span.text,
+            width: em + track(1),
+            graphemes: 1,
+            first: 'ideograph',
+            last: 'ideograph',
+            firstCjk: true,
+            lastCjk: true,
+            orient: 'tcy',
+        });
+        return;
+    }
+    let offset = 0;
+    graphemesOf(span.text).forEach((g, i) => {
+        units.push({
+            ...base,
+            ...(i > 0 ? { glueBefore: true, zwspBefore: undefined } : {}),
+            kind: 'text',
+            text: g,
+            width: em + track(1),
+            graphemes: 1,
+            first: 'ideograph',
+            last: 'ideograph',
+            firstCjk: true,
+            lastCjk: true,
+            at: offset,
+            orient: 'upright',
+        });
+        offset += g.length;
+    });
+}
+/** The unit of a ruby base (#194): its characters as one box, measured as
+ *  the composer measures them (cells down a vertical line), the reading
+ *  laid out later (`sizeRubies`). Where the reading goes: `pos`, else
+ *  zhuyin right of each character and anything else over; in vertical text
+ *  `right` is the over side. */
+function rubyBaseUnit(span, fonts, letterSpacingPx, vertical) {
+    const ruby = span.ruby;
+    const style = styleOf(span, fonts, vertical);
+    const graphemes = graphemesOf(span.text);
+    let width = 0;
+    for (const g of graphemes) {
+        width += isCjkGrapheme(g) ? cellAdvance(g, style.font, vertical, cjkClassOf(g)) : textWidth(g, style.font, style.smallCaps);
+    }
+    width += letterSpacingPx * graphemes.length;
+    const firstG = graphemes[0] ?? '';
+    const lastG = graphemes[graphemes.length - 1] ?? '';
+    let position = ruby.position ?? (isZhuyin(ruby.text) ? 'right' : 'over');
+    if (vertical && position === 'right')
+        position = 'over';
+    return {
+        kind: 'text',
+        text: span.text,
+        width,
+        graphemes: graphemes.length,
+        first: cjkClassOf(firstG),
+        last: cjkClassOf(lastG),
+        firstCjk: isCjkGrapheme(firstG),
+        lastCjk: isCjkGrapheme(lastG),
+        style,
+        at: 0,
+        ruby: { span: ruby, position },
+    };
+}
+/**
+ * Lay out each ruby base's reading (see `cjkAnnotate.ts`): its box grows
+ * to the reading less what the reading may pass it by — a quarter of the
+ * ruby em onto a neighbour without ruby, and it keeps as much from a
+ * neighbour's reading on the same side (two zhuyin readings: a quarter of
+ * the symbols' em). Run once the units are final.
+ */
+function sizeRubies(units) {
+    for (let k = 0; k < units.length; k++) {
+        const u = units[k];
+        if (!u.ruby || u.ruby.geometry)
+            continue;
+        const fontOf = (v) => v.ruby.span.fontString ?? withFontSize(v.style.font, emOfFont(v.style.font) / 2);
+        const font = fontOf(u);
+        const q = fontEm(font) / 4;
+        const zhuyin = isZhuyin(u.ruby.span.text);
+        // How far the reading may pass its box towards a neighbour: a quarter
+        // of the ruby em onto one without a reading; next to a reading on the
+        // same side, what keeps the two a quarter em apart (the neighbour's
+        // box is at least its base). Zhuyin is set at 60 % of the ruby size,
+        // so two zhuyin readings keep a quarter of that em apart: three
+        // symbols beside each of two characters stay in their cells (clreq
+        // §5.5.3 centres each column on its own character).
+        const allow = (v) => {
+            if (!v || v.kind !== 'text' || v.note)
+                return 0;
+            if (!v.ruby)
+                return q;
+            if (v.ruby.position !== u.ruby.position || v.ruby.position === 'right')
+                return q;
+            const theirs = v.ruby.geometry?.rtWidth ?? readingAdvance(v.ruby.span.text, fontOf(v), v.ruby.position);
+            const gap = zhuyin && isZhuyin(v.ruby.span.text) ? (fontEm(font) * ZHUYIN_SIZE_RATIO) / 4 : q;
+            return Math.min(q, (v.width - theirs) / 2 - gap);
+        };
+        const geometry = rubyGeometry({
+            reading: u.ruby.span.text,
+            fontString: font,
+            position: u.ruby.position,
+            baseWidth: u.width,
+            em: emOfFont(u.style.font),
+            allowLeft: allow(units[k - 1]),
+            allowRight: allow(units[k + 1]),
+        });
+        u.ruby.geometry = geometry;
+        u.width = geometry.width;
+    }
+}
+/** The units of a paragraph's spans, the characters of each warichu note
+ *  (#195) measured at the note's size and flagged with it, between the
+ *  note's brackets (added text at the body size, in the note's colour). */
+function buildAllUnits(spans, fonts, letterSpacingPx, vertical, route) {
+    if (!spans.some((s) => s.warichu))
+        return buildUnits(spans, fonts, letterSpacingPx, vertical, route);
+    const out = [];
+    let i = 0;
+    while (i < spans.length) {
+        const note = spans[i].warichu;
+        let j = i + 1;
+        while (j < spans.length && spans[j].warichu === note)
+            j++;
+        const group = spans.slice(i, j);
+        if (!note)
+            out.push(...buildUnits(group, fonts, letterSpacingPx, vertical, route));
+        else
+            out.push(...noteUnits(group, note, fonts, vertical));
+        i = j;
+    }
+    return out;
+}
+/** The units of one warichu note: its characters at the note's size (a
+ *  word space inside it is a character of the note), its brackets. */
+function noteUnits(spans, note, fonts, vertical) {
+    const size = note.fontString ? fontEm(note.fontString) : emOfFont(fonts.normal) / 2;
+    const noteFonts = {
+        normal: withFontSize(fonts.normal, size),
+        bold: withFontSize(fonts.bold, size),
+        italic: withFontSize(fonts.italic, size),
+        boldItalic: withFontSize(fonts.boldItalic, size),
+    };
+    const inner = buildUnits(spans, noteFonts, 0, vertical, false);
+    for (const u of inner) {
+        u.note = note;
+        if (u.kind === 'space') {
+            u.kind = 'text';
+            u.firstCjk = u.lastCjk = false;
+            u.noteSpace = true;
+        }
+    }
+    const bracket = (text) => {
+        const g = graphemesOf(text);
+        const cls = cjkClassOf(g[0] ?? '');
+        const style = {
+            key: `ins|${note.color ?? ''}|${fonts.normal}`,
+            bold: false,
+            italic: false,
+            font: fonts.normal,
+            inserted: true,
+            ...(note.color ? { color: note.color } : {}),
+        };
+        let width = 0;
+        for (const c of g)
+            width += cellAdvance(c, fonts.normal, vertical, cjkClassOf(c));
+        return {
+            kind: 'text',
+            text,
+            width,
+            graphemes: g.length,
+            first: cls,
+            last: cjkClassOf(g[g.length - 1] ?? ''),
+            firstCjk: isCjkGrapheme(g[0] ?? ''),
+            lastCjk: isCjkGrapheme(g[g.length - 1] ?? ''),
+            style,
+            at: 0,
+        };
+    };
+    return [...(note.open ? [bracket(note.open)] : []), ...inner, ...(note.close ? [bracket(note.close)] : [])];
+}
+/**
+ * The units of a paragraph's spans, in order. `letterSpacingPx` (the
+ * block's tracking) is measured into every width, per grapheme. In
+ * `vertical` text a CJK character advances by its cell (`cellAdvance`).
+ */
+function buildUnits(spans, fonts, letterSpacingPx, vertical = false, route = false) {
+    const units = [];
+    const track = (n) => (letterSpacingPx === 0 ? 0 : letterSpacingPx * n);
+    let zwsp = false;
+    // A word joiner (U+2060) before the next unit: no break there, in one
+    // span or across two (`**①**⁠文`). It takes no room and is left out.
+    let wj = false;
+    const glue = () => {
+        const g = wj;
+        wj = false;
+        return g ? { glueBefore: true } : {};
+    };
+    // Which units open a span and hold all of it (the candidates for stacked
+    // scripts), by index.
+    const wholeSpan = new Set();
+    for (let si = 0; si < spans.length; si++) {
+        const span = spans[si];
+        // A ruby base: one unit, sized with its reading once its neighbours
+        // are known (`sizeRubies`).
+        if (span.ruby && span.text.length > 0) {
+            units.push({ ...rubyBaseUnit(span, fonts, letterSpacingPx, vertical), ...(zwsp ? { zwspBefore: true } : {}), ...glue() });
+            zwsp = false;
+            continue;
+        }
+        if (vertical && (span.combineUpright || span.orientation) && span.text.length > 0 && !setsObject(span)) {
+            const first = units.length;
+            orientedUnits(span, styleOf(span, fonts, vertical), letterSpacingPx, zwsp, units);
+            if (units.length > first)
+                Object.assign(units[first], glue());
+            zwsp = false;
+            continue;
+        }
+        const atomic = atomicSpanToken(span, fonts.normal, fonts.bold, fonts.italic, fonts.boldItalic, letterSpacingPx);
+        if (atomic) {
+            const style = styleOf(span, fonts, vertical);
+            const graphemes = graphemesOf(atomic.text);
+            const object = atomic.chip !== undefined || atomic.mathRender !== undefined || atomic.swatch !== undefined;
+            const firstG = graphemes[0] ?? '';
+            const lastG = graphemes[graphemes.length - 1] ?? '';
+            units.push({
+                kind: 'atomic',
+                text: atomic.text,
+                width: atomic.width,
+                graphemes: graphemes.length,
+                first: object ? 'ideograph' : cjkClassOf(firstG),
+                last: object ? 'ideograph' : cjkClassOf(lastG),
+                firstCjk: object || isCjkGrapheme(firstG),
+                lastCjk: object || isCjkGrapheme(lastG),
+                style,
+                at: 0,
+                token: atomic,
+                ...(atomic.refResourceId !== undefined || atomic.footnoteId !== undefined ? { glueBefore: true } : {}),
+                ...(zwsp ? { zwspBefore: true } : {}),
+                ...glue(),
+            });
+            zwsp = false;
+            continue;
+        }
+        if (span.text.length === 0)
+            continue;
+        const style = styleOf(span, fonts, vertical);
+        const graphemes = graphemesOf(span.text);
+        const spanFirst = units.length;
+        let run = [];
+        let runAt = 0;
+        let runLink;
+        let space = '';
+        let spaceAt = 0;
+        // A lone mark that may pair with the next one (—, …), by unit index.
+        let pairOpen = -1;
+        let at = 0;
+        // The link a character at `offset` of the span is part of: its span and
+        // range, so two links to one target stay apart.
+        const links = span.links;
+        const linkAt = (offset) => {
+            if (!links || links.length === 0)
+                return undefined;
+            for (let li = 0; li < links.length; li++) {
+                const l = links[li];
+                if (offset >= l.start && offset < l.end)
+                    return `${si}:${li}`;
+            }
+            return undefined;
+        };
+        const push = (u) => {
+            units.push({
+                ...u,
+                style,
+                ...(zwsp ? { zwspBefore: true } : {}),
+                ...(style.script && units.length === spanFirst ? { glueBefore: true } : {}),
+                ...glue(),
+            });
+            zwsp = false;
+        };
+        const flushRun = () => {
+            if (run.length === 0)
+                return;
+            const text = run.join('');
+            const firstG = run[0];
+            const lastG = run[run.length - 1];
+            // Vertical text: a short number at either end stands in one upright
+            // cell (`cjk.uprightDigits`), and the run is Chinese on that side;
+            // tracking follows the cell once.
+            const cells = vertical ? numberCellEdges(run) : undefined;
+            push({
+                kind: 'text',
+                text,
+                width: textWidth(text, style.font, style.smallCaps) + track(vertical && letterSpacingPx !== 0 ? verticalTrackCount(text) : run.length),
+                graphemes: run.length,
+                first: cells?.start ? 'ideograph' : cjkClassOf(firstG),
+                last: cells?.end ? 'ideograph' : cjkClassOf(lastG),
+                firstCjk: cells?.start === true,
+                lastCjk: cells?.end === true,
+                at: runAt,
+                run: true,
+                ...(cells?.start ? { cellStart: true } : {}),
+                ...(cells?.end ? { cellEnd: true } : {}),
+                ...(URL_LIKE_RE.test(text) ? { url: true } : {}),
+                ...(runLink !== undefined ? { link: runLink } : {}),
+            });
+            run = [];
+            pairOpen = -1;
+        };
+        const flushSpace = () => {
+            if (space === '')
+                return;
+            units.push({
+                kind: 'space',
+                text: space,
+                width: measureTextWidth(space, style.font) + track(graphemeCount(space)),
+                graphemes: graphemeCount(space),
+                first: 'western',
+                last: 'western',
+                firstCjk: false,
+                lastCjk: false,
+                style,
+                at: spaceAt,
+            });
+            space = '';
+            pairOpen = -1;
+        };
+        for (let i = 0; i < graphemes.length; i++) {
+            const g = graphemes[i];
+            const gAt = at;
+            at += g.length;
+            if (isBreakingSpace(g[0])) {
+                flushRun();
+                wj = false;
+                if (space === '')
+                    spaceAt = gAt;
+                space += g;
+                continue;
+            }
+            flushSpace();
+            if (g === '\u200B') {
+                flushRun();
+                zwsp = true;
+                pairOpen = -1;
+                continue;
+            }
+            if (g === '\u2060') {
+                flushRun();
+                wj = true;
+                pairOpen = -1;
+                continue;
+            }
+            // A soft hyphen: the composer breaks Western words only when they are
+            // wider than the line, so it is left out, and the word stays whole.
+            if (g === '\u00AD')
+                continue;
+            const link = linkAt(gAt);
+            if (!isCjkHere(g, graphemes[i - 1], graphemes[i + 1])) {
+                // A link that starts or ends inside a run cuts it: the two parts
+                // still never part (neither is CJK) and take no space between them.
+                if (run.length > 0 && link !== runLink)
+                    flushRun();
+                if (run.length === 0) {
+                    runAt = gAt;
+                    runLink = link;
+                }
+                run.push(g);
+                continue;
+            }
+            flushRun();
+            // —— and …… are one unit of two ems; a third mark opens another.
+            if (pairOpen >= 0 && units[pairOpen].text === g && !zwsp && units[pairOpen].link === link) {
+                const u = units[pairOpen];
+                u.text += g;
+                u.width += cellAdvance(g, style.font, vertical, u.first) + track(1);
+                u.graphemes = 2;
+                u.first = u.last = g === '\u2026' || g === '\u22EF' ? 'ellipsis' : 'dash';
+                pairOpen = -1;
+                continue;
+            }
+            let cls = cjkClassOf(g);
+            // A single em dash (or horizontal bar) joins two words as a connector
+            // (clreq §6.1.1): never at a line start.
+            if (g === '\u2014' || g === '\u2015')
+                cls = 'connector';
+            push({
+                kind: 'text',
+                text: g,
+                width: (style.smallCaps && !vertical ? textWidth(g, style.font, true) : cellAdvance(g, style.font, vertical, cls)) + track(1),
+                graphemes: 1,
+                first: cls,
+                last: cls,
+                firstCjk: true,
+                lastCjk: true,
+                at: gAt,
+                ...(link !== undefined ? { link } : {}),
+            });
+            pairOpen = pairable(g) ? units.length - 1 : -1;
+        }
+        flushRun();
+        flushSpace();
+        if (units.length === spanFirst + 1 && units[spanFirst].kind === 'text')
+            wholeSpan.add(spanFirst);
+    }
+    // A subscript and a superscript that touch are set one over the other
+    // (EF-80): the first advances nothing, the second the pair's advance, and
+    // the two never part.
+    if (units.some((u) => u.style.script)) {
+        const scripts = units.map((u, i) => (wholeSpan.has(i) && u.style.script && !u.style.smallCaps ? u.style.script : undefined));
+        for (const i of stackedScriptPairs(scripts)) {
+            const a = units[i];
+            const b = units[i + 1];
+            const sub = a.style.script === 'sub' ? a : b;
+            sub.style = {
+                ...sub.style,
+                key: `${sub.style.key}|stacked`,
+                baselineShift: scriptMetrics(pickSpanFont(sub.style.bold, sub.style.italic, fonts.normal, fonts.bold, fonts.italic, fonts.boldItalic), 'sub', true).baselineShift,
+            };
+            b.width = Math.max(a.width, b.width);
+            a.width = 0;
+            a.stacked = 'first';
+            b.stacked = 'second';
+            b.glueBefore = true;
+        }
+    }
+    if (route)
+        routeSharedMarks(units, letterSpacingPx, vertical);
+    return units;
+}
+/** The marks Latin text shares with Chinese (East Asian Width ambiguous):
+ *  quotes, the ellipsis, the em dash and horizontal bar, interpuncts. */
+const SHARED_MARKS = new Set(['\u201C', '\u201D', '\u2018', '\u2019', '\u2026', '\u22EF', '\u2014', '\u2015', '\u00B7', '\u2027']);
+/** Whether a unit is one shared mark, or a pair of them (—— ……). */
+function isSharedMarkUnit(u) {
+    if (u.kind !== 'text' || u.run || u.stacked || u.style.script || u.style.smallCaps)
+        return false;
+    if (u.graphemes === 1)
+        return SHARED_MARKS.has(u.text);
+    return u.graphemes === 2 && SHARED_MARKS.has(u.text[0]) && u.text[0] === u.text[1];
+}
+/** The script a unit sets for the shared marks next to it: Chinese (a CJK
+ *  character or mark), Western (a Latin run or a word space), or none for
+ *  one that is transparent to them (another shared mark, an inline box). */
+function unitScript(v) {
+    if (v.kind === 'space')
+        return 'western';
+    if (v.kind === 'atomic' || isSharedMarkUnit(v))
+        return undefined;
+    return !v.run && v.firstCjk ? 'cjk' : 'western';
+}
+/**
+ * The marks Latin text shares with Chinese (“ ” ‘ ’ … — ·, East Asian
+ * Width ambiguous) take the box of a Chinese mark when they stand in
+ * Chinese text (clreq §3.1; research note on context routing): a text on
+ * either side is Chinese, or none is Western. A font whose glyphs for them
+ * are proportional (LXGW WenKai sets “ ” at 0.35 em, Noto Serif SC the em
+ * dash at 0.89 em and · at a third) would otherwise crowd them against the
+ * characters they belong to. Each grapheme advances one em (with the
+ * block's tracking) whatever its font's advance, and its glyph sits where
+ * a Chinese font puts it: an opening quote at the end of its box, a
+ * closing one at its start, an interpunct, an ellipsis and a single dash
+ * centred; an ellipsis pair (……) is set as the font sets the two
+ * together and centred in its two ems, so its six dots keep one spacing,
+ * and a 破折号 (——) is stretched into one rule over its two ems
+ * (`dashRule`). The composition then adjusts the box as
+ * it does any mark's (`cjk.punctuationWidth`). A glyph one em wide already changes
+ * nothing. Next to Western text on both sides (`He said “yes”`) they keep
+ * their own advance, and so do they in Japanese and Korean text (the
+ * composer calls this for Chinese text only, `routesSharedMarks`).
+ *
+ * Down a vertical line (`vertical`) every mark stands in a cell of its own
+ * already; only the 破折号 is set here: the font's vertical form of a dash
+ * leaves blank at both ends of its cell (Noto CJK's, 0.07 em), so the pair
+ * would print as two strokes. Its dashes are stretched into one rule as in
+ * horizontal text, and the renderers paint them turned with the page's
+ * frame (sideways), the stretch running down the column
+ * (`VDTLineSegment.inkScale`).
+ */
+function routeSharedMarks(units, letterSpacingPx, vertical = false) {
+    if (!units.some(isSharedMarkUnit))
+        return;
+    // The script of the nearest unit on each side that is not transparent
+    // (`unitScript`), past runs of shared marks and inline boxes: two
+    // linear passes, so a long run of marks costs no more than its length.
+    const n = units.length;
+    const before = new Array(n);
+    const after = new Array(n);
+    let seen;
+    for (let k = 0; k < n; k++) {
+        before[k] = seen;
+        seen = unitScript(units[k]) ?? seen;
+    }
+    seen = undefined;
+    for (let k = n - 1; k >= 0; k--) {
+        after[k] = seen;
+        seen = unitScript(units[k]) ?? seen;
+    }
+    for (let k = 0; k < n; k++) {
+        const u = units[k];
+        if (!isSharedMarkUnit(u))
+            continue;
+        const dash = u.graphemes === 2 && (u.text[0] === '\u2014' || u.text[0] === '\u2015');
+        // Vertical text: a 破折号 only, and not one whose orientation the
+        // author set (`:upright[…]`, `:sideways[…]`).
+        if (vertical && (!dash || u.orient))
+            continue;
+        const b = before[k];
+        const a = after[k];
+        if (b !== 'cjk' && a !== 'cjk' && (b !== undefined || a !== undefined))
+            continue;
+        const em = emOfFont(u.style.font);
+        const font = u.style.font;
+        let place;
+        const rule = dash ? dashRule(u.text[0], font, em, em + letterSpacingPx, vertical) : undefined;
+        if (rule) {
+            place = rule.place;
+            if (rule.scale !== undefined)
+                u.scale = rule.scale;
+            if (rule.shift !== undefined)
+                u.shift = rule.shift;
+            if (vertical) {
+                // The cells keep their length down the line.
+                u.place = place;
+                continue;
+            }
+        }
+        else if (vertical) {
+            // No ink metrics: each dash in its vertical form, as it was.
+            continue;
+        }
+        else if (u.graphemes === 2) {
+            // ……, or —— when the measurer gives no ink metrics: the pair as the
+            // font sets it (a face may kern the dashes into one line), centred
+            // in its two ems.
+            const g = u.text[0];
+            const adv = measureTextWidth(g, font);
+            const pair = measureTextWidth(u.text, font);
+            if (Math.abs(adv - em) < 1e-6 && Math.abs(pair - 2 * em) < 1e-6)
+                continue;
+            const start = em - pair / 2;
+            place = [start, start + pair - adv - em];
+        }
+        else {
+            const adv = measureTextWidth(u.text, font);
+            if (Math.abs(adv - em) < 1e-6)
+                continue;
+            const slack = em - adv;
+            const cls = cjkClassOf(u.text);
+            place = [cls === 'opening' ? slack : cls === 'closing' ? 0 : slack / 2];
+        }
+        u.width = u.graphemes * (em + letterSpacingPx);
+        u.place = place;
+    }
+}
+/** How far past the join each dash of a 破折号 runs, em: the two strokes
+ *  overlap, so no seam shows between them at any resolution. */
+const DASH_JOIN_EM = 0.02;
+/**
+ * A 破折号 (——) in Chinese text is one unbroken rule two ems long, on the
+ * characters' centre line (GB/T 15834). Faces whose em dash is a
+ * proportional Latin stroke (Noto Serif SC: 0.89 em advance, ink from 0.04
+ * to 0.85 em, at the height of a Latin dash) print the pair as a short
+ * rule with blank on both sides, and low. Each dash is stretched over its
+ * cell (`cell`, px: an em and the block's tracking): the rule starts and
+ * ends the face's own side bearing inside the pair's two cells (at most a
+ * tenth of an em) and each stroke runs `DASH_JOIN_EM` past the join. Its
+ * glyphs move to the centre of the ideographic em box
+ * (`measureCentralBaseline`). Undefined when the measurer gives no ink
+ * metrics, or when the dash already fills its em (a face whose two dashes
+ * join by themselves). Down a vertical line (`vertical`) the scale is set
+ * even when it is 1: it tells the renderers to paint the dash turned.
+ */
+function dashRule(g, font, em, cell, vertical = false) {
+    const ink = measureInkExtent(g, font);
+    // No ink metrics, or a dash already drawn edge to edge across its em.
+    if (!ink || (ink.start <= 0.01 * em && ink.end >= cell - 0.01 * em))
+        return undefined;
+    const side = Math.min(Math.max(ink.start, 0), 0.1 * em);
+    const join = DASH_JOIN_EM * em;
+    const scale = (cell - side + join) / (ink.end - ink.start);
+    const place = [side - ink.start * scale, -join - ink.start * scale];
+    const box = measureInkBox(g, font);
+    const shift = box ? (box.ascent - box.descent) / 2 - measureCentralBaseline(fontFamilyOf(font)) * em : 0;
+    return {
+        place,
+        ...(vertical || Math.abs(scale - 1) > 1e-3 ? { scale } : {}),
+        ...(Math.abs(shift) > 0.01 * em ? { shift } : {}),
+    };
+}
+/** The em (px) of a font shorthand: its size. */
+function emOfFont(font) {
+    const m = FONT_SIZE_RE.exec(font);
+    return m ? parseFloat(m[1]) : 16;
+}
+/** Whether a unit is a single CJK mark (a bracket, a pause, stop or
+ *  interpunct mark, a dash or an ellipsis): two of them in a row never
+ *  hang. */
+function isMarkUnit(u) {
+    if (!u || u.kind !== 'text' || u.run || !u.firstCjk)
+        return false;
+    switch (u.first) {
+        case 'opening':
+        case 'closing':
+        case 'pause':
+        case 'stop':
+        case 'interpunct':
+        case 'dash':
+        case 'ellipsis':
+            return true;
+        default:
+            return false;
+    }
+}
+/**
+ * The punctuation widths and Han–Latin spaces of a paragraph's units, as
+ * the composition sets them (see `cjkPunctuation.ts`): each full-width mark
+ * takes the width its style gives it (`Unit.punct`), two marks that meet
+ * give up the blank between them (`compressAdjacent`), and a space unit
+ * (`Unit.auto`) goes between each Han character and a Latin letter or digit
+ * it touches — the space the author typed there turns into one. The line
+ * edges (and the reduction a line makes to take one more character) are
+ * the breaker's and the line's business. A plain composition changes
+ * nothing but the mainland interpunct, half an em under every style
+ * (`punctuationBox`), as its cell is in vertical text.
+ */
+function prepareUnits(units, c, letterSpacingPx) {
+    const plain = isPlainComposition(c);
+    // Down the line the mainland interpunct's cell is half an em already.
+    if (plain && (c.region !== 'mainland' || c.vertical))
+        return units;
+    const full = new Map();
+    for (const u of units) {
+        if (u.kind !== 'text' || u.run || u.graphemes !== 1 || !u.firstCjk || u.style.script || u.stacked || u.orient || u.ruby || u.note)
+            continue;
+        if (plain && u.first !== 'interpunct')
+            continue;
+        const box = punctuationBox(u.text, u.first, u.width - letterSpacingPx, emOfFont(u.style.font), c);
+        if (!box)
+            continue;
+        full.set(u, u.width);
+        u.punct = box;
+        u.width -= boxCut(box);
+    }
+    if (plain)
+        return units;
+    // Kaiming sets a stop's blank after the closing mark that follows it (。”␣).
+    const carry = c.punctuationWidth === 'kaiming';
+    if ((c.compressAdjacent || carry) && full.size > 1) {
+        for (let k = 1; k < units.length; k++) {
+            const a = units[k - 1];
+            const b = units[k];
+            if (!a.punct || !b.punct || b.zwspBefore)
+                continue;
+            if (c.compressAdjacent)
+                compressPair(a.punct, b.punct);
+            if (carry)
+                carryStopBlank(a.punct, b.punct);
+            a.width = full.get(a) - boxCut(a.punct);
+            b.width = full.get(b) - boxCut(b.punct);
+        }
+    }
+    if ((c.latinSpacing.px ?? c.latinSpacing.em ?? 0) <= 0)
+        return units;
+    const out = [];
+    const han = (u, edge) => !!u && u.kind === 'text' && !u.run && !u.note && u.firstCjk && u[edge] === 'ideograph' && !u.style.script && isLatinSpacingHan(u.text);
+    // A run whose edge is a number set in one upright cell (vertical text)
+    // takes no Han–Latin space on that side; neither does a unit the author
+    // set upright or in one cell.
+    const latin = (u, edge) => !!u && u.kind === 'text' && !!u.run && !u.note && !u.style.script && !(edge === 'first' ? u.cellStart : u.cellEnd)
+        && isLatinSpacingLatin(edge === 'first' ? String.fromCodePoint(u.text.codePointAt(0)) : lastGrapheme(u.text));
+    const spaceOf = (h) => latinSpacingPx(c, emOfFont(h.style.font));
+    for (let k = 0; k < units.length; k++) {
+        const u = units[k];
+        const prev = out[out.length - 1];
+        if (u.kind === 'space' && /^ +$/.test(u.text)) {
+            // A space typed between Han and Latin is replaced by the Han–Latin
+            // space (CSS `text-autospace: replace`).
+            const next = units[k + 1];
+            const h = han(prev, 'last') && latin(next, 'first') && !next.glueBefore ? prev
+                : latin(prev, 'last') && han(next, 'first') && !next.glueBefore ? next : undefined;
+            if (h) {
+                out.push({ ...u, width: spaceOf(h), auto: true });
+                continue;
+            }
+        }
+        else if (prev && !u.glueBefore && ((han(prev, 'last') && latin(u, 'first')) || (latin(prev, 'last') && han(u, 'first')))) {
+            const h = han(prev, 'last') ? prev : u;
+            out.push({
+                kind: 'space',
+                text: '',
+                width: spaceOf(h),
+                graphemes: 0,
+                first: 'western',
+                last: 'western',
+                firstCjk: false,
+                lastCjk: false,
+                style: h.style,
+                at: u.at,
+                auto: true,
+            });
+        }
+        out.push(u);
+    }
+    return out;
+}
+const isDigitCode = (c) => (c >= 0x30 && c <= 0x39) || isFullwidthDigit(c);
+/** Whether a number keeps to the sign or unit next to it (`50 %`, `50％`,
+ *  `￥５９９`, `−3 ℃`): a unit ending in a digit before a unit sign, or a
+ *  currency or plus-minus sign before a digit. At every level. */
+function numberGlue(a, b) {
+    if (a.kind !== 'text' || b.kind !== 'text')
+        return false;
+    if (b.first === 'postfix' && isDigitCode(a.text.charCodeAt(a.text.length - 1)))
+        return true;
+    return a.last === 'prefix' && isDigitCode(b.text.charCodeAt(0));
+}
+/** A fullwidth character unit (one grapheme, not a Western run) whose code
+ *  point passes `test`. */
+function fullwidthUnit(u, test) {
+    return u !== undefined && u.kind === 'text' && !u.run && u.graphemes === 1 && test(u.text.charCodeAt(0));
+}
+/** Marks that join fullwidth digits into one number: a decimal point, a
+ *  thousands separator, the colon of a time, the solidus of a fraction
+ *  (３．１４, １２：３０, １／２). */
+const isFullwidthNumberJoin = (cp) => cp === 0xFF0E || cp === 0xFF0C || cp === 0xFF1A || cp === 0xFF0F;
+/** Whether units `k - 1` and `k` belong to one fullwidth number or word
+ *  (１２３, ＡＢＣ, ３．１４): each character is a unit of its own, spread
+ *  like Han when the line is justified, but the line never breaks inside. */
+function fullwidthGlue(units, k) {
+    const a = units[k - 1];
+    const b = units[k];
+    if (fullwidthUnit(a, isFullwidthAlnum) && fullwidthUnit(b, isFullwidthAlnum))
+        return true;
+    if (fullwidthUnit(a, isFullwidthDigit) && fullwidthUnit(b, isFullwidthNumberJoin) && fullwidthUnit(units[k + 1], isFullwidthDigit))
+        return true;
+    return fullwidthUnit(a, isFullwidthNumberJoin) && fullwidthUnit(b, isFullwidthDigit) && fullwidthUnit(units[k - 2], isFullwidthDigit);
+}
+/** Whether a line may break before each unit (index 0 is never a break).
+ *  A word space is a break unless the unit after it may not open a line,
+ *  the last one before it may not close one, or they are a number and its
+ *  sign; a zero-width space is a break at every level. */
+function breakOpportunities(units, level) {
+    const out = new Uint8Array(units.length);
+    // The last unit before `k` that is not a space.
+    let ink = -1;
+    for (let k = 1; k < units.length; k++) {
+        const a = units[k - 1];
+        const b = units[k];
+        if (a.kind !== 'space')
+            ink = k - 1;
+        if (b.kind === 'space')
+            continue;
+        // A line never opens with a warichu note's word space.
+        if (b.noteSpace)
+            continue;
+        if (b.zwspBefore) {
+            out[k] = 1;
+            continue;
+        }
+        if (a.kind === 'space') {
+            const p = ink >= 0 ? units[ink] : undefined;
+            if (!p || (!numberGlue(p, b) && !isLineStartProhibited(b.first, level) && !isLineEndProhibited(p.last, level)))
+                out[k] = 1;
+            continue;
+        }
+        if (a.noteSpace) {
+            // A word space inside a warichu note: the note's words part there.
+            let q = k - 1;
+            while (q > 0 && units[q].noteSpace)
+                q--;
+            const p = units[q];
+            if (!p.noteSpace && !numberGlue(p, b) && !isLineStartProhibited(b.first, level) && !isLineEndProhibited(p.last, level))
+                out[k] = 1;
+            continue;
+        }
+        if (b.glueBefore)
+            continue;
+        if (numberGlue(a, b) || fullwidthGlue(units, k))
+            continue;
+        if (cjkBreakAllowed(a.last, a.lastCjk, b.first, b.firstCjk, level))
+            out[k] = 1;
+    }
+    return out;
+}
+/** Whether justification may add space between two units that touch on a
+ *  line: between characters, never inside a Western run or a 2-em mark
+ *  (those are single units), never between two Western runs, next to a
+ *  connector or a solidus, after an atomic box, or before a mark that
+ *  keeps to the text before it. Spaces take their own share. */
+function gapStretches(a, b) {
+    if (a.kind !== 'text' || b.kind === 'space')
+        return false;
+    if (b.glueBefore || a.stacked)
+        return false;
+    if (a.last === 'connector' || a.last === 'solidus' || b.first === 'connector' || b.first === 'solidus')
+        return false;
+    if (!a.lastCjk && !b.firstCjk)
+        return false;
+    if (a.last === b.first && (a.last === 'dash' || a.last === 'ellipsis'))
+        return false;
+    return true;
+}
+function lineFitOf(c) {
+    if (isPlainComposition(c))
+        return undefined;
+    return {
+        lead: (u) => (u.punct ? lineEdgeCut(u.punct, c, true, false) : 0),
+        tail: (u) => (u.punct ? lineEdgeCut(u.punct, c, false, true) : 0),
+        give(u, atStart, atEnd) {
+            if (u.kind === 'space') {
+                const em = emOfFont(u.style.font);
+                return Math.max(0, u.width - (u.auto ? em / 8 : em / 4));
+            }
+            if (!u.punct)
+                return 0;
+            if (!atStart && !atEnd)
+                return punctuationShrink(u.punct, c);
+            const box = { ...u.punct };
+            applyLineEdges(box, c, atStart, atEnd);
+            return punctuationShrink(box, c);
+        },
+        edge: (u, start, end) => (u.punct ? applyLineEdges(u.punct, c, start, end) : 0),
+        hangs(units, k, unitAt) {
+            const u = unitAt(k);
+            if (u.kind !== 'text' || u.run || u.graphemes !== 1 || u.note || u.ruby || !mayHang(u.text, u.first, c))
+                return false;
+            if (k > 0 && isMarkUnit(unitAt(k - 1)))
+                return false;
+            return k + 1 >= units.length || !isMarkUnit(units[k + 1]);
+        },
+        hanging: c.hangingPunctuation,
+    };
+}
+/** The last unit that must share a line with unit `k` when `k` ends one:
+ *  the units after it up to the next break (a closing quote after a
+ *  full stop). -1 when that is more than a few units away or crosses a
+ *  space the line may not break after. */
+function groupEnd(units, breaks, k) {
+    const n = units.length;
+    for (let q = k; q < k + 6; q++) {
+        if (q + 1 >= n)
+            return q;
+        if (units[q + 1].kind === 'space') {
+            let r = q + 1;
+            while (r < n && units[r].kind === 'space')
+                r++;
+            return r >= n || breaks[r] ? q : -1;
+        }
+        if (breaks[q + 1])
+            return q;
+    }
+    return -1;
+}
+/** The advance of the first `idx` UTF-16 units of a Western run, the
+ *  block's tracking included. */
+function prefixWidth(u, idx, letterSpacingPx) {
+    const head = u.text.slice(0, idx);
+    return textWidth(head, u.style.font, u.style.smallCaps) + (letterSpacingPx === 0 ? 0 : letterSpacingPx * graphemeCount(head));
+}
+/** Characters of a run kept past the first that does not fit when it is
+ *  cut: enough for the dictionary and the joints of a web address to read
+ *  the text around every cut that fits as they read the whole run. */
+const CUT_CONTEXT = 32;
+/** The shortest prefix of a Western run (in UTF-16 units) wider than
+ *  `room`, or its length when all of it fits: found by doubling, then
+ *  halving, so a run many lines long costs what one line of it does. */
+function overflowAt(u, room, letterSpacingPx) {
+    const len = u.text.length;
+    let fit = 0;
+    let over = len;
+    for (let step = 1; fit + step < len; step *= 2) {
+        if (prefixWidth(u, fit + step, letterSpacingPx) > room + FIT_EPS) {
+            over = fit + step;
+            break;
+        }
+        fit += step;
+    }
+    if (over === len && u.width <= room + FIT_EPS)
+        return len;
+    while (over - fit > 1) {
+        const mid = (fit + over) >> 1;
+        if (prefixWidth(u, mid, letterSpacingPx) > room + FIT_EPS)
+            over = mid;
+        else
+            fit = mid;
+    }
+    return over;
+}
+/** The rest of a run after its first `from` UTF-16 units (`cutWidth` px). */
+function runTail(u, from, cutWidth) {
+    const tail = u.text.slice(from);
+    return {
+        ...u,
+        text: tail,
+        width: u.width - cutWidth,
+        graphemes: u.graphemes - graphemeCount(u.text.slice(0, from)),
+        first: cjkClassOf(tail),
+        at: u.at + from,
+        glueBefore: false,
+        zwspBefore: false,
+    };
+}
+/** Cut a web address at its last joint (after a slash, before a dot…)
+ *  whose head fits `room`: nothing is added at the break. Only the joints
+ *  before the first character that does not fit are tried. */
+function cutAtJoint(u, room, letterSpacingPx) {
+    const over = overflowAt(u, room, letterSpacingPx);
+    const joints = urlBreakIndices(u.text.slice(0, Math.min(u.text.length, over + CUT_CONTEXT)));
+    for (let j = joints.length - 1; j >= 0; j--) {
+        const idx = joints[j];
+        if (idx >= over)
+            continue;
+        const head = u.text.slice(0, idx);
+        const w = prefixWidth(u, idx, letterSpacingPx);
+        if (w > room + FIT_EPS)
+            continue;
+        return {
+            head: { ...u, text: head, width: w, graphemes: graphemeCount(head), last: cjkClassOf(lastGrapheme(head)), url: false },
+            tail: runTail(u, idx, w),
+        };
+    }
+    return null;
+}
+/** Divide a Western run wider than the whole line (see `emergencySplit`):
+ *  at a dictionary syllable with a hyphen, else at the last character that
+ *  fits. Only the run up to a little past the first character that does not
+ *  fit is handed to the divider, so each line of a long run costs what the
+ *  line holds. */
+function divideRun(u, room, letterSpacingPx) {
+    const end = Math.min(u.text.length, overflowAt(u, room, letterSpacingPx) + CUT_CONTEXT);
+    const text = end === u.text.length ? u.text : u.text.slice(0, end);
+    const width = end === u.text.length ? u.width : prefixWidth(u, end, letterSpacingPx);
+    const token = {
+        text,
+        bold: u.style.bold,
+        italic: u.style.italic,
+        kind: 'text',
+        width,
+        ...(u.style.smallCaps ? { smallCaps: true } : {}),
+    };
+    const split = emergencySplit(token, u.style.font, letterSpacingPx, room);
+    if (!split)
+        return null;
+    const headText = split.head.text;
+    const hyphen = headText.length > 0 && headText.endsWith('-') && !u.text.startsWith(headText);
+    // Where the rest starts (past a no-break space the divider parted at)
+    // and the advance of what comes before it.
+    const from = text.length - split.tail.text.length;
+    return {
+        head: { ...u, text: headText, width: split.head.width, graphemes: graphemeCount(headText), last: cjkClassOf(lastGrapheme(headText)), url: false },
+        tail: runTail(u, from, width - split.tail.width),
+        hyphen,
+        hard: split.hard === true,
+    };
+}
+/**
+ * Break the units into lines, first fit with push-out: a line takes units
+ * while they fit its measure less `reserve`; the unit that does not fit
+ * opens the next line when a break before it is allowed, else (when the
+ * composition cannot push it in or hang it) the line ends
+ * at the last allowed break (the characters after it go down with the
+ * unit). A space never overflows: the line ends before it, when the line
+ * may break after it. A unit wider
+ * than the whole line is divided when it is a Western run (a web address
+ * at a joint first), else set on a line of its own.
+ */
+function breakUnits(units, breaks, measureOf, reserve, letterSpacingPx, fit, level = getCjkLineBreak(), 
+/** End line `line` before unit `at` (a break), whatever else fits. */
+stop) {
+    const out = [];
+    const n = units.length;
+    let i = 0;
+    let carried;
+    let carriedAt = -1;
+    const unitAt = (k) => (k === carriedAt && carried ? carried : units[k]);
+    // A warichu note's characters on the line take the advance of their two
+    // rows (`foldWidth`), not their sum: where the note's part on this line
+    // starts, and the line's width before it.
+    let noteFrom = -1;
+    let noteBase = 0;
+    const foldOf = (from, to) => {
+        const widths = [];
+        const startProhibited = [];
+        const endProhibited = [];
+        for (let q = from; q <= to; q++) {
+            const uq = unitAt(q);
+            widths.push(uq.width);
+            startProhibited.push(noteRowStartProhibited(uq, level));
+            endProhibited.push(isLineEndProhibited(uq.last, level));
+        }
+        return foldWidth(widths, splitNote(widths, startProhibited, endProhibited));
+    };
+    for (let li = 0;; li++) {
+        while (i < n && unitAt(i).kind === 'space')
+            i++;
+        if (i >= n)
+            break;
+        const max = measureOf(li) - reserve;
+        let w = 0;
+        let lastBreak = -1;
+        let end = -1;
+        let head;
+        let tail;
+        let hyphenated = false;
+        let hardHyphen = false;
+        let hang = false;
+        // What the line could give up to take one more character (push-in).
+        let give = 0;
+        for (let k = i; k < n; k++) {
+            if (stop && stop.line === li && k >= stop.at) {
+                end = k;
+                break;
+            }
+            const u = unitAt(k);
+            if (k > i && breaks[k])
+                lastBreak = k;
+            if (u.note) {
+                if (k === i || unitAt(k - 1).note !== u.note) {
+                    noteFrom = k;
+                    noteBase = w;
+                }
+                const folded = noteBase + foldOf(noteFrom, k);
+                if (folded <= max + FIT_EPS) {
+                    w = folded;
+                    continue;
+                }
+                // The part no longer folds into the line: the line ends here or at
+                // the last break before, never taking the character at its own
+                // advance (the fold of a part is not monotonic, so every part the
+                // line may end with was one that folded).
+            }
+            const lead = fit && k === i ? fit.lead(u) : 0;
+            if (!u.note && w + u.width - lead - (fit ? fit.tail(u) : 0) <= max + FIT_EPS) {
+                w += u.width - lead;
+                if (fit)
+                    give += fit.give(u, k === i, false);
+                continue;
+            }
+            if (fit && k > i && u.kind !== 'space' && !u.note) {
+                // A pause or stop mark that does not fit hangs past the measure:
+                // at once under 'force', after compressing the line failed under
+                // 'allow'. Else, when the unit may not open the next line (no
+                // break before it), the line gives up blank to take it and what
+                // must stay with it (push-in, clreq §6.2.2.3), before it would
+                // push characters down. A unit that may open a line goes down and
+                // the line is spread: compressing marks to take one more
+                // character there would narrow Kaiming's stop marks inside the
+                // line.
+                const canHang = fit.hanging !== 'none' && groupEnd(units, breaks, k) === k && fit.hangs(units, k, unitAt);
+                if (canHang && fit.hanging === 'force') {
+                    end = k + 1;
+                    hang = true;
+                    break;
+                }
+                const m = breaks[k] ? -1 : groupEnd(units, breaks, k);
+                if (m >= k) {
+                    let width = w;
+                    let room = give;
+                    for (let q = k; q <= m; q++) {
+                        const uq = unitAt(q);
+                        const t = q === m ? fit.tail(uq) : 0;
+                        width += uq.width - t;
+                        room += fit.give(uq, false, q === m);
+                    }
+                    if (width - room <= max + FIT_EPS) {
+                        end = m + 1;
+                        break;
+                    }
+                }
+                if (canHang) {
+                    end = k + 1;
+                    hang = true;
+                    break;
+                }
+            }
+            if (u.kind === 'space') {
+                // The line ends before the space when it may break after it; else
+                // it gives up characters to the next line, as for any other unit.
+                let m = k + 1;
+                while (m < n && units[m].kind === 'space')
+                    m++;
+                if (m >= n || breaks[m]) {
+                    end = k;
+                    break;
+                }
+            }
+            if (u.url) {
+                const cut = cutAtJoint(u, max - w, letterSpacingPx);
+                if (cut) {
+                    end = k;
+                    head = cut.head;
+                    tail = cut.tail;
+                    hyphenated = true;
+                    hardHyphen = false;
+                    break;
+                }
+            }
+            if (k > i && breaks[k]) {
+                end = k;
+                break;
+            }
+            if (lastBreak > i) {
+                end = lastBreak;
+                break;
+            }
+            if (k === i) {
+                if (u.run) {
+                    const split = divideRun(u, max, letterSpacingPx);
+                    if (split) {
+                        end = k;
+                        head = split.head;
+                        tail = split.tail;
+                        hyphenated = true;
+                        hardHyphen = split.hard;
+                        break;
+                    }
+                }
+                end = k + 1;
+                break;
+            }
+            // Nothing on the line may end it: break before the unit anyway.
+            end = k;
+            break;
+        }
+        if (end < 0)
+            end = n;
+        out.push({
+            start: i,
+            end,
+            ...(carriedAt === i && carried ? { first: carried } : {}),
+            ...(head ? { head } : {}),
+            hyphenated,
+            ...(hardHyphen ? { hardHyphen: true } : {}),
+            ...(hang ? { hang: true } : {}),
+        });
+        if (tail) {
+            carried = tail;
+            carriedAt = end;
+        }
+        else if (carriedAt < end) {
+            carried = undefined;
+            carriedAt = -1;
+        }
+        i = end;
+    }
+    return out;
+}
+/** Whether a note's unit may not open its lower row: a mark that may not
+ *  start a line, or a word space (it ends the upper row instead). */
+function noteRowStartProhibited(u, level) {
+    return u.noteSpace === true || isLineStartProhibited(u.first, level);
+}
+/** Replace each run of a warichu note's characters on a line by the part
+ *  folded into its two rows (see `cjkAnnotate.ts`). `us` is changed in
+ *  place. */
+function foldNotes(us, level, em) {
+    const out = [];
+    for (let j = 0; j < us.length;) {
+        const u = us[j];
+        if (!u.note) {
+            out.push(u);
+            j++;
+            continue;
+        }
+        let e = j + 1;
+        while (e < us.length && us[e].note === u.note)
+            e++;
+        out.push(noteFragment(us.slice(j, e), level, em));
+        j = e;
+    }
+    us.splice(0, us.length, ...out);
+}
+/** A line's part of a warichu note: its characters split into an upper and
+ *  a lower row, each painted in runs of one font; the part's advance is the
+ *  wider row's. */
+function noteFragment(part, level, em) {
+    const note = part[0].note;
+    const widths = part.map((u) => u.width);
+    const at = splitNote(widths, part.map((u) => noteRowStartProhibited(u, level)), part.map((u) => isLineEndProhibited(u.last, level)));
+    const noteFont = note.fontString ?? part[0].style.font;
+    const rows = noteRowBaselines(em, fontEm(noteFont));
+    const runs = [];
+    const row = (units, dy) => {
+        let dx = 0;
+        let text = '';
+        let run;
+        for (const u of units) {
+            if (run && run.fontString === u.style.font)
+                run.text += u.text;
+            else {
+                run = { text: u.text, dx, dy, fontString: u.style.font };
+                runs.push(run);
+            }
+            dx += u.width;
+            text += u.text;
+        }
+        return { text, width: dx };
+    };
+    const upper = row(part.slice(0, at), rows.upper);
+    const lower = row(part.slice(at), rows.lower);
+    const first = part[0];
+    const last = part[part.length - 1];
+    let graphemes = 0;
+    for (const u of part)
+        graphemes += u.graphemes;
+    return {
+        kind: 'text',
+        text: upper.text + lower.text,
+        width: Math.max(upper.width, lower.width),
+        graphemes,
+        first: first.first,
+        last: last.last,
+        firstCjk: first.firstCjk,
+        lastCjk: last.lastCjk,
+        style: first.style,
+        at: first.at,
+        warichu: {
+            upper: upper.text,
+            lower: lower.text,
+            fontString: noteFont,
+            upperDy: rows.upper,
+            lowerDy: rows.lower,
+            ...(note.color ? { color: note.color } : {}),
+            runs,
+        },
+    };
+}
+/**
+ * A ruby base that opens or closes a line (clreq §5.5.4): base and reading
+ * align to that edge. The base gives up its inset on that side, and the
+ * box keeps only what the reading needs past its other side (less what it
+ * may pass the box by there), never more than it was, so the line the
+ * breaker set never grows. A base alone on its line stays centred.
+ * Units that change are replaced by copies in `us`.
+ */
+function alignEdgeRubies(us) {
+    if (us.length < 2)
+        return;
+    const align = (j, start) => {
+        const u = us[j];
+        const g = u.ruby?.geometry;
+        if (!g || u.ruby.position === 'right' || g.runs.length === 0)
+            return;
+        const base = u.width - 2 * g.inset;
+        const rt = g.rtWidth;
+        const wide = rt > base;
+        // How far the reading reaches from the edge: its advance, or to the
+        // far side of the base it is centred on.
+        const reach = wide ? rt : (base + rt) / 2;
+        const width = Math.min(u.width, Math.max(base, reach - (start ? g.allowRight : g.allowLeft)));
+        const inset = start ? 0 : width - base;
+        const readingAt = wide ? (start ? 0 : width - rt) : inset + (base - rt) / 2;
+        const shift = readingAt - g.runs[0].dx;
+        if (Math.abs(width - u.width) < 1e-9 && Math.abs(inset - g.inset) < 1e-9 && Math.abs(shift) < 1e-9)
+            return;
+        us[j] = {
+            ...u,
+            width,
+            ruby: { ...u.ruby, geometry: { ...g, width, inset, runs: g.runs.map((r) => ({ ...r, dx: r.dx + shift })) } },
+        };
+    };
+    align(0, true);
+    align(us.length - 1, false);
+}
+/** Keep the readings of a line's ruby bases inside the line: a reading
+ *  that would pass the line's start or end is moved back to it (clreq
+ *  §5.5.4: at a line edge base and ruby align to the edge). */
+function clampReadings(segments) {
+    if (!segments.some((s) => s.ruby))
+        return;
+    let lineWidth = 0;
+    for (const s of segments)
+        if (!s.hangs)
+            lineWidth += s.width;
+    let x = 0;
+    for (const s of segments) {
+        const ruby = s.ruby;
+        if (ruby && ruby.position !== 'right' && ruby.runs.length > 0) {
+            const lo = ruby.runs[0].dx;
+            const hi = lo + ruby.rtWidth;
+            let shift = 0;
+            if (x + lo < 0)
+                shift = -(x + lo);
+            else if (x + hi > lineWidth + 1e-6)
+                shift = lineWidth - (x + hi);
+            if (shift !== 0)
+                ruby.runs = ruby.runs.map((r) => ({ ...r, dx: r.dx + shift }));
+        }
+        x += s.width;
+    }
+}
+/** Share `amount` among `caps` equally, none past its cap: what each
+ *  takes. */
+function spread(amount, caps) {
+    const takes = caps.map(() => 0);
+    const order = caps.map((_, i) => i).sort((a, b) => caps[a] - caps[b]);
+    let rest = amount;
+    for (let o = 0; o < order.length && rest > 1e-12; o++) {
+        const i = order[o];
+        const take = Math.min(caps[i], rest / (order.length - o));
+        takes[i] = take;
+        rest -= take;
+    }
+    return takes;
+}
+/**
+ * A line's units as its edges and its measure set them (see
+ * `cjkPunctuation.ts`): the first mark gives up its lead and the last its
+ * tail, each taking back the blank it gave to a mark on the other side of
+ * the break (the two no longer meet); a mark that hangs is taken out and
+ * returned apart; and a line wider than its measure (it took one more
+ * character that may not open a line, clreq §6.2.2.3) gives up
+ * blank in clreq's order — word spaces to a quarter em, interpuncts,
+ * brackets, pause marks, Han–Latin spaces to an eighth of an em, stop marks
+ * last — each step shared equally, until it fits. `us` holds the line's
+ * units and is changed in place; a unit that changes is replaced by a copy,
+ * since the paragraph's units serve every attempt at breaking it.
+ */
+function fitLine(us, units, range, lastK, isLast, measure, fit) {
+    const copy = (j) => {
+        const u = us[j];
+        const c = { ...u, ...(u.punct ? { punct: { ...u.punct } } : {}) };
+        us[j] = c;
+        return c;
+    };
+    let hang;
+    if (us.length > 1) {
+        const unitAt = (k) => (k === range.start && range.first ? range.first : units[k]);
+        const forced = fit.hanging === 'force' && !isLast && !range.head && fit.hangs(units, lastK, unitAt);
+        if (range.hang || forced) {
+            hang = copy(us.length - 1);
+            us.pop();
+            hang.width -= fit.edge(hang, false, true);
+            while (us.length > 0 && us[us.length - 1].kind === 'space')
+                us.pop();
+        }
+    }
+    if (us.length === 0)
+        return hang;
+    // The marks at the edges: what they gave to a mark across the break
+    // comes back, then the edge trims.
+    if (fit.lead(us[0]) !== 0) {
+        const c = copy(0);
+        c.width -= fit.edge(c, true, false);
+    }
+    if (fit.tail(us[us.length - 1]) !== 0) {
+        const c = copy(us.length - 1);
+        c.width -= fit.edge(c, false, true);
+    }
+    let over = -measure;
+    for (const u of us)
+        over += u.width;
+    if (over <= FIT_EPS)
+        return hang;
+    // Steps of the reduction order: word spaces (1), interpuncts (2),
+    // brackets (3), pause marks (4), Han–Latin spaces (5), stop marks (6).
+    const stepOf = (u) => (u.kind === 'space' ? (u.auto ? 5 : 1) : u.punct ? shrinkStep(u.punct) : 0);
+    for (let step = 1; step <= 6 && over > FIT_EPS; step++) {
+        const members = [];
+        const caps = [];
+        for (let j = 0; j < us.length; j++) {
+            const u = us[j];
+            if (stepOf(u) !== step)
+                continue;
+            // The marks at the edges already gave up their lead and tail.
+            const cap = fit.give(u, false, false);
+            if (cap <= 0)
+                continue;
+            members.push(j);
+            caps.push(cap);
+        }
+        if (members.length === 0)
+            continue;
+        const takes = spread(over, caps);
+        for (let m = 0; m < members.length; m++) {
+            const take = takes[m];
+            if (take <= 0)
+                continue;
+            const c = copy(members[m]);
+            const given = c.punct ? shrinkPunctuation(c.punct, take) : take;
+            c.width -= given;
+            over -= given;
+        }
+    }
+    return hang;
+}
+/** Where a unit's glyph (its `grapheme`th) is painted from its segment's
+ *  start, px (`VDTLineSegment.inkOffset`): a shared mark's place in its
+ *  box, less the blank its box gave up before it. Undefined for a unit
+ *  painted at its own advances. */
+function inkOffsetOf(u, grapheme = 0) {
+    const cutStart = u.punct?.cutStart ?? 0;
+    if (u.place)
+        return u.place[grapheme] - cutStart;
+    if (u.punct && boxCut(u.punct) > 0)
+        return cutStart > 0 ? -cutStart : 0;
+    return undefined;
+}
+/** The segments, text and flags of one line (see the module comment for
+ *  the spreading). */
+function composeLine(units, range, li, isLast, ctx) {
+    const us = [];
+    for (let k = range.start; k < range.end; k++)
+        us.push(k === range.start && range.first ? range.first : units[k]);
+    if (range.head)
+        us.push(range.head);
+    let lastK = range.end - 1;
+    while (us.length > 0 && us[us.length - 1].kind === 'space') {
+        us.pop();
+        lastK--;
+    }
+    const measure = ctx.measureOf(li);
+    // A warichu note's characters fold into their two rows (#195).
+    if (us.some((u) => u.note))
+        foldNotes(us, ctx.level, ctx.em);
+    // A ruby base at either edge aligns to it with its reading (#194).
+    alignEdgeRubies(us);
+    const hang = ctx.fit ? fitLine(us, units, range, lastK, isLast, measure, ctx.fit) : undefined;
+    const justify = ctx.textAlign === 'justify' && !isLast;
+    let spaceWidth;
+    let tracking = 0;
+    let loose = false;
+    let spaceRatio;
+    let ragged = false;
+    const stretches = [];
+    if (justify) {
+        let content = 0;
+        let spaces = 0;
+        let natural = 0;
+        let widest = 0;
+        let gaps = 0;
+        // Han–Latin spaces (`cjk.latinSpacing`): they flex apart from word
+        // spaces, and the renderers leave them as set.
+        const autos = [];
+        for (let j = 0; j < us.length; j++) {
+            const u = us[j];
+            content += u.width;
+            if (u.kind === 'space' && u.auto)
+                autos.push(j);
+            else if (u.kind === 'space') {
+                spaces++;
+                natural += u.width;
+                widest = Math.max(widest, u.width);
+            }
+            const s = j < us.length - 1 && gapStretches(u, us[j + 1]);
+            stretches.push(s);
+            if (s)
+                gaps++;
+        }
+        let slack = measure - content;
+        if (slack > FIT_EPS) {
+            if (gaps > 0 || autos.length > 0) {
+                if (spaces > 0) {
+                    // Word spaces first, up to half an em each, all set alike.
+                    spaceWidth = Math.max(widest, Math.min((natural + slack) / spaces, Math.max(ctx.em / 2, widest)));
+                    slack -= spaceWidth * spaces - natural;
+                    if (ctx.normalSpace > 0)
+                        spaceRatio = spaceWidth / ctx.normalSpace;
+                }
+                if (autos.length > 0 && slack > FIT_EPS) {
+                    // Then the Han–Latin spaces, up to half an em each (clreq
+                    // §6.2.2.4).
+                    const caps = autos.map((j) => Math.max(0, emOfFont(us[j].style.font) / 2 - us[j].width));
+                    const takes = spread(slack, caps);
+                    autos.forEach((j, m) => {
+                        if (takes[m] <= 0)
+                            return;
+                        us[j] = { ...us[j], width: us[j].width + takes[m] };
+                        slack -= takes[m];
+                    });
+                }
+                if (slack > FIT_EPS) {
+                    // Then every gap between characters, the Han–Latin spaces too.
+                    tracking = slack / (gaps + autos.length);
+                    if (tracking > ctx.cap + 1e-9) {
+                        tracking = ctx.cap;
+                        loose = true;
+                    }
+                    for (const j of autos)
+                        us[j] = { ...us[j], width: us[j].width + tracking };
+                }
+            }
+            else if (spaces > 0) {
+                // No gap between characters: the spaces take it all, as in a Latin
+                // line (the renderers stretch them).
+                if (ctx.normalSpace > 0)
+                    spaceRatio = (natural + slack) / spaces / ctx.normalSpace;
+            }
+            else if (us.some((u) => u.kind === 'text' && (u.firstCjk || u.lastCjk))) {
+                // A CJK character with nothing to spread against.
+                loose = true;
+            }
+            else {
+                // Western text only (the head of a web address, a divided word): set
+                // ragged, as a Latin line of one word is, and not reported.
+                ragged = true;
+            }
+        }
+    }
+    const pieces = [];
+    const addText = (u, text, width, t) => {
+        // Single characters (not Western runs, which keep a segment each) of
+        // one style, link and spacing that advance alike share a segment.
+        // A mark that gave up blank is a segment of its own: its glyph may be
+        // painted before its box (`inkOffset`), and the caret spreads a
+        // segment's width evenly over its characters.
+        const cut = u.punct ? boxCut(u.punct) : 0;
+        // Upright letters (`:upright[…]`) share a segment with each other only.
+        const key = u.stacked || u.run || u.graphemes !== 1 || cut > 0 || u.place || u.orient === 'tcy' ? undefined : `${u.style.key}|${u.link ?? ''}|${t ?? ''}${u.orient ? `|${u.orient}` : ''}`;
+        const last = pieces[pieces.length - 1];
+        if (key !== undefined && last && last.key === key && last.cell !== undefined && Math.abs(last.cell - width) < 1e-3) {
+            last.parts.push(text);
+            last.seg.width += width;
+            return;
+        }
+        pieces.push({ seg: segmentOf(u, width, t), parts: [text], key, ...(key !== undefined ? { cell: width } : {}) });
+    };
+    const segmentOf = (u, width, t, grapheme = 0) => {
+        const s = u.style;
+        const ink = inkOffsetOf(u, grapheme);
+        return {
+            kind: 'text',
+            text: '',
+            width,
+            bold: s.bold || undefined,
+            italic: s.italic || undefined,
+            ...(s.captionLabel ? { captionLabel: true } : {}),
+            ...(s.script ? { script: s.script, fontString: s.scriptFont, baselineShift: s.baselineShift } : {}),
+            ...(u.stacked === 'first' ? { stacked: true } : {}),
+            ...(s.smallCaps ? { smallCaps: true } : {}),
+            ...(s.marks ? { cjkMarks: s.marks } : {}),
+            ...(s.inserted ? { inserted: true } : {}),
+            ...(s.color ? { color: s.color } : {}),
+            ...(t !== undefined ? { tracking: t } : {}),
+            // Every mark that gave up blank carries its ink offset (0 when only
+            // the blank after its glyph went), and so does a shared mark set in
+            // a Chinese box, so no renderer paints its line in one run at the
+            // glyphs' own advances.
+            ...(ink !== undefined ? { inkOffset: ink } : {}),
+            ...(u.orient === 'tcy' ? { tcy: true } : u.orient ? { orientation: u.orient } : {}),
+            ...(u.scale !== undefined ? { inkScale: u.scale } : {}),
+            ...(u.shift !== undefined ? { baselineShift: u.shift } : {}),
+        };
+    };
+    for (let j = 0; j < us.length; j++) {
+        const u = us[j];
+        if (u.kind === 'space' && u.auto) {
+            pieces.push({ seg: { kind: 'space', text: u.text, width: u.width, autospace: true }, parts: [u.text], key: undefined });
+            continue;
+        }
+        if (u.kind === 'space') {
+            pieces.push({ seg: { kind: 'space', text: u.text, width: spaceWidth ?? u.width }, parts: [u.text], key: undefined });
+            continue;
+        }
+        if (u.kind === 'atomic') {
+            const seg = tokenSegment(u.token);
+            pieces.push({ seg, parts: [seg.text], key: undefined });
+            continue;
+        }
+        const gap = tracking > 0 && stretches[j] ? tracking : 0;
+        if (u.warichu) {
+            // A warichu note's part: the rows are painted, not the text.
+            pieces.push({ seg: { kind: 'text', text: u.text, width: u.width + gap, warichu: u.warichu }, parts: [u.text], key: undefined });
+            continue;
+        }
+        if (u.ruby?.geometry) {
+            // A ruby base: centred in its box, its reading placed from the box's
+            // start (#194). One character takes the gap after it as tracking; a
+            // base of several keeps its natural spacing, centred under its
+            // reading, and the gap follows the box as a space of its own (its
+            // width final, as a Han–Latin space's is): tracking would be added
+            // after each of its characters.
+            const g = u.ruby.geometry;
+            const gapAfter = gap > 0 && u.graphemes > 1;
+            const seg = {
+                ...segmentOf(u, gapAfter ? u.width : u.width + gap, gap > 0 && !gapAfter ? gap : undefined),
+                text: u.text,
+                ...(g.inset > 1e-9 ? { inkOffset: g.inset } : {}),
+                ruby: {
+                    text: u.ruby.span.text,
+                    fontString: u.ruby.span.fontString ?? g.runs[0]?.fontString ?? u.style.font,
+                    baseWidth: u.width - g.inset * 2 - (u.ruby.position === 'right' ? g.rtWidth : 0),
+                    rtWidth: g.rtWidth,
+                    position: u.ruby.position,
+                    ...(u.ruby.span.group ? { group: true } : {}),
+                    ...(u.ruby.span.color ? { color: u.ruby.span.color } : {}),
+                    runs: g.runs,
+                },
+            };
+            pieces.push({ seg, parts: [u.text], key: undefined });
+            if (gapAfter)
+                pieces.push({ seg: { kind: 'space', text: '', width: gap, autospace: true }, parts: [''], key: undefined });
+            continue;
+        }
+        if (u.place && u.graphemes === 2) {
+            // A pair (—— ……) set in Chinese boxes: one segment per grapheme,
+            // each glyph placed in its own em.
+            const cell = u.width / 2;
+            pieces.push({ seg: { ...segmentOf(u, cell, undefined, 0), text: u.text[0] }, parts: [u.text[0]], key: undefined });
+            pieces.push({ seg: { ...segmentOf(u, cell + gap, gap > 0 ? gap : undefined, 1), text: u.text[1] }, parts: [u.text[1]], key: undefined });
+        }
+        else if (gap === 0) {
+            addText(u, u.text, u.width, undefined);
+        }
+        else if (ctx.vertical && u.run) {
+            // In vertical text a run is painted whole, its cells and sideways
+            // letters as it was measured: the gap after it is advance only, and
+            // cutting its last letter off would lose the neighbour an apostrophe
+            // or an interpunct inside it is read with (`verticalRuns`).
+            addText(u, u.text, u.width + gap, undefined);
+        }
+        else if (u.graphemes <= 1) {
+            addText(u, u.text, u.width + gap, gap);
+        }
+        else {
+            // A run the gap follows: its last grapheme carries the gap, the rest
+            // keeps its natural spacing.
+            const lastG = lastGrapheme(u.text);
+            const head = u.text.slice(0, u.text.length - lastG.length);
+            const headWidth = textWidth(head, u.style.font, u.style.smallCaps) + (ctx.letterSpacingPx === 0 ? 0 : ctx.letterSpacingPx * (u.graphemes - 1));
+            addText(u, head, headWidth, undefined);
+            addText(u, lastG, u.width - headWidth + gap, gap);
+        }
+    }
+    const segments = [];
+    for (const p of pieces) {
+        if (p.parts.length > 1 || p.seg.text === '')
+            p.seg.text = p.parts.join('');
+        segments.push(p.seg);
+    }
+    const trimmed = trimChipLineEdges(segments);
+    clampReadings(trimmed);
+    let width = 0;
+    for (const s of trimmed)
+        width += s.width;
+    if (hang) {
+        // The hung mark follows the line, outside its measure and its width.
+        trimmed.push({ ...segmentOf(hang, hang.width, undefined), text: hang.text, hangs: true });
+    }
+    const text = trimmed.map((s) => s.text).join('');
+    const y = li * ctx.lineHeightPx;
+    return {
+        text,
+        bbox: createBoundingBox(ctx.indentOf(li), y, width, ctx.lineHeightPx),
+        baseline: y + ctx.baselineOffset,
+        hyphenated: range.hyphenated,
+        ...(range.hyphenated && range.hardHyphen ? { hardHyphen: true } : {}),
+        segments: trimmed,
+        isLastLine: isLast,
+        ...(spaceRatio !== undefined && !loose ? { justifiedSpaceRatio: spaceRatio } : {}),
+        ...(loose ? { ragged: true, cjkLoose: true } : ragged ? { ragged: true } : {}),
+        cjkComposed: true,
+    };
+}
+/**
+ * Set a Chinese, Japanese or Korean paragraph (see the module comment):
+ * `options.cjkLineBreak` (else the document's level) decides where lines
+ * may break; `textAlign: 'justify'` spreads every line but the last to the
+ * measure. First-line and hanging indents, the block's tracking
+ * (`letterSpacingPx`), other measures for later lines (`restWidths`) and a
+ * positive `looseness` (one line more, for column balancing: the lines are
+ * broken a little short of the measure and spread to it) are honoured;
+ * Knuth–Plass options are not used.
+ */
+export function composeCjkParagraph(spans, normalFont, boldFont, italicFont, boldItalicFont, maxWidthPx, lineHeightPx, options) {
+    // A writing mode asked for this paragraph alone: the Latin runs' widths
+    // (`textWidth`) read it too.
+    if (options?.writingMode !== undefined && options.writingMode !== getMeasureWritingMode()) {
+        const opts = options;
+        return withMeasureWritingMode(opts.writingMode, () => composeCjkParagraph(spans, normalFont, boldFont, italicFont, boldItalicFont, maxWidthPx, lineHeightPx, opts));
+    }
+    const fonts = { normal: normalFont, bold: boldFont, italic: italicFont, boldItalic: boldItalicFont };
+    const letterSpacingPx = options?.letterSpacingPx ?? 0;
+    const vertical = getMeasureWritingMode() === 'vertical-rl';
+    // The composition works along the line in either writing mode; vertical
+    // text keeps ：；？！ at one em (`CjkComposition.vertical`).
+    const composition = compositionFor(options?.cjkComposition ?? getCjkComposition(), vertical);
+    // The marks Latin text shares with Chinese take Chinese boxes in Chinese
+    // text only (`routesSharedMarks`).
+    const route = routesSharedMarks(composition, spans.map((s) => s.text).join(''));
+    const units = prepareUnits(buildAllUnits(spans, fonts, letterSpacingPx, vertical, route), composition, letterSpacingPx);
+    // Ruby readings (#194), laid out once their neighbours are known.
+    if (units.some((u) => u.ruby))
+        sizeRubies(units);
+    if (!units.some((u) => u.kind !== 'space'))
+        return { lines: [], totalHeight: 0 };
+    const fit = lineFitOf(composition);
+    const level = options?.cjkLineBreak ?? getCjkLineBreak();
+    const breaks = breakOpportunities(units, level);
+    const indentPx = options?.firstLineIndentPx ?? 0;
+    const hanging = options?.hangingIndent ?? false;
+    const indentOf = (li) => (indentPx > 0 ? (hanging ? (li === 0 ? 0 : indentPx) : (li === 0 ? indentPx : 0)) : 0);
+    const measureOf = (li) => lineMeasure(maxWidthPx, options?.restWidths, li) - indentOf(li);
+    const sizeMatch = FONT_SIZE_RE.exec(normalFont);
+    const em = sizeMatch ? parseFloat(sizeMatch[1]) : 16;
+    const trackingCap = options?.justifyTrackingPx && options.justifyTrackingPx > 0 ? Math.min(em / 2, options.justifyTrackingPx) : em / 2;
+    const textAlign = options?.textAlign ?? 'left';
+    const ctx = {
+        fonts,
+        textAlign,
+        letterSpacingPx,
+        em,
+        cap: trackingCap,
+        normalSpace: textAlign === 'justify' ? normalSpaceWidthFor(normalFont) + letterSpacingPx : 0,
+        lineHeightPx,
+        baselineOffset: lineBaselineOffset(lineHeightPx, normalFont),
+        indentOf,
+        measureOf,
+        ...(vertical ? { vertical: true } : {}),
+        ...(fit ? { fit } : {}),
+        level,
+    };
+    const compose = (ranges) => ranges.map((r, li) => composeLine(units, r, li, li === ranges.length - 1, ctx));
+    const ranges = breakUnits(units, breaks, measureOf, 0, letterSpacingPx, fit, level);
+    let lines = compose(ranges);
+    // 孤字 (clreq §7.2), where the paragraph avoids runts (`bodyText.avoidRunts`
+    // gives it a runt penalty): a last line that holds one character, alone
+    // or with its closing marks, takes the last character the line above may
+    // give up (push-out), and that line is spread to the measure. When it
+    // would need more than the tracking cap, the runt stays.
+    if ((options?.runtPenalty ?? 0) > 0 && endsOnOneCharacter(lines)) {
+        const li = ranges.length - 2;
+        const above = ranges[li];
+        let at = above.end - 1;
+        while (at > above.start && !breaks[at])
+            at--;
+        if (!above.head && !above.hyphenated && !ranges[li + 1].first && at > above.start) {
+            const pushed = breakUnits(units, breaks, measureOf, 0, letterSpacingPx, fit, level, { line: li, at });
+            if (pushed.length === ranges.length) {
+                const set = compose(pushed);
+                if (!set[li].cjkLoose && !endsOnOneCharacter(set))
+                    lines = set;
+            }
+        }
+    }
+    // Column balancing asks for a paragraph one line longer: break each line
+    // a little short of its measure, in eighths of an em, until the paragraph
+    // gains the lines without a line past the tracking cap. The first step
+    // that gains them usually carries a single character down; a setting
+    // whose last line is one character, alone or with its marks (孤字), is
+    // passed over for the next step's, which carries more.
+    const looseness = options?.looseness ?? 0;
+    if (looseness > 0) {
+        const target = lines.length + looseness;
+        for (let step = 1; step <= 16; step++) {
+            const ranges = breakUnits(units, breaks, measureOf, (step * em) / 8, letterSpacingPx, fit, level);
+            if (ranges.length < target)
+                continue;
+            if (ranges.length > target)
+                break;
+            const loose = compose(ranges);
+            if (!loose.some((l) => l.cjkLoose) && !endsOnOneCharacter(loose)) {
+                lines = loose;
+                break;
+            }
+        }
+    }
+    if (lines.some((l) => l.segments?.some((s) => s.smallCaps))) {
+        expandSmallCaps(lines, normalFont, boldFont, italicFont, boldItalicFont, letterSpacingPx);
+    }
+    return { lines, totalHeight: lines.length * lineHeightPx };
+}
+/** Whether a paragraph of two lines or more ends on a line that holds one
+ *  CJK character, alone or followed by the marks that may not open a line
+ *  (`图`, `版。`, `说。”`): the 孤字 Chinese typesetting avoids. */
+function endsOnOneCharacter(lines) {
+    if (lines.length < 2)
+        return false;
+    const gs = graphemesOf(lines[lines.length - 1].text.trim());
+    let n = gs.length;
+    while (n > 1 && isLineStartProhibited(cjkClassOf(gs[n - 1]), 'basic'))
+        n--;
+    return n === 1 && isCjkGrapheme(gs[0]) && cjkClassOf(gs[0]) === 'ideograph';
+}
+/**
+ * The breaks of one word (no breaking space inside) that holds CJK
+ * characters, in a paragraph set by the word-by-word breaker (a Latin
+ * paragraph quoting CJK): next to its CJK characters, under the document's
+ * line-break rules. Each unit is measured once and the widths before a
+ * break come from their running sums, so a long run of ideographs costs
+ * linear time.
+ */
+export function cjkWordBreaks(word, font, smallCaps, letterSpacingPx, level = getCjkLineBreak()) {
+    const span = { text: word, bold: false, italic: false, ...(smallCaps ? { smallCaps: true } : {}) };
+    const units = buildUnits([span], { normal: font, bold: font, italic: font, boldItalic: font }, letterSpacingPx, getMeasureWritingMode() === 'vertical-rl');
+    const opportunities = breakOpportunities(units, level);
+    const starts = [];
+    const sums = [0];
+    const breaks = [];
+    let total = 0;
+    for (let k = 0; k < units.length; k++) {
+        const u = units[k];
+        starts.push(u.at);
+        if (k > 0 && opportunities[k])
+            breaks.push(u.at);
+        total += u.width;
+        sums.push(total);
+    }
+    const widthBefore = (idx) => {
+        // The last unit that starts at or before `idx`.
+        let lo = 0;
+        let hi = starts.length - 1;
+        let found = -1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            if (starts[mid] <= idx) {
+                found = mid;
+                lo = mid + 1;
+            }
+            else
+                hi = mid - 1;
+        }
+        if (found < 0)
+            return 0;
+        const u = units[found];
+        const inside = idx - u.at;
+        if (inside <= 0)
+            return sums[found];
+        if (inside >= u.text.length)
+            return sums[found + 1];
+        const part = u.text.slice(0, inside);
+        return sums[found] + textWidth(part, font, smallCaps) + (letterSpacingPx === 0 ? 0 : letterSpacingPx * graphemeCount(part));
+    };
+    return { breaks, width: total, widthBefore };
+}
+//# sourceMappingURL=cjkCompose.js.map