postext 1.51.1 → 1.53.0

package/dist/measure/rich.js

@@ -1,43 +1,53 @@
-import { FORCED_BREAK, measureForcedBreaks } from './hardBreaks';
-import { placeTab } from './tabs';
-import { measureInlineIcon } from './inlineIcon';
-import { uprightArabicSpans, uprightFace } from '../uprightArabic';
-import { createBoundingBox } from '../vdt';
-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, getMeasureLanguage, measureTextWidth, normalSpaceWidthFor, setMeasureLanguage, withMeasureLanguage } from './canvas';
-import { spanShapingLanguage } from './spanLanguage';
-import { isRuntLastLine } from './runts';
-import { hasOverfullLine } from './plain';
-import { justifiedSpaceRatios } from './spaceRatios';
-import { quoteFamily } from './font';
-import { findPxSize, splitAtFontSize, withPxSize } from './fontString';
-import { trimChipLineEdges } from './chipEdges';
-import { directChipRuns, measuresRunsAsPainted, paintedRunWidth } 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, 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';
+import { FORCED_BREAK, measureForcedBreaks } from './hardBreaks.js';
+import { placeTab } from './tabs.js';
+import { measureInlineIcon } from './inlineIcon.js';
+import { uprightArabicSpans, uprightFace } from '../uprightArabic.js';
+import { createBoundingBox } from '../vdt.js';
+import { getHyphenationRulesKey, hyphenateByDictionary, hyphenateText, softHyphenBreaks, withoutSlashJoints } from '../hyphenate.js';
+import { richTokensToItems, computeBreakpoints, reconstructRichLines, } from '../knuthPlass/index.js';
+import { SOFT_HYPHEN } from './types.js';
+import { lineStartAt, lineWidthAt, lineWidthFunction, markInsetLines, uniformMeasureFrom } from './types.js';
+import { cleanSoftHyphens, getMeasureLanguage, measureTextWidth, normalSpaceWidthFor, setMeasureLanguage, withMeasureLanguage } from './canvas.js';
+import { spanShapingLanguage } from './spanLanguage.js';
+import { isRuntLastLine } from './runts.js';
+import { hasOverfullLine } from './plain.js';
+import { justifiedSpaceRatios } from './spaceRatios.js';
+import { quoteFamily } from './font.js';
+import { findPxSize, splitAtFontSize, withPxSize } from './fontString.js';
+import { trimChipLineEdges } from './chipEdges.js';
+import { directChipRuns, measuresRunsAsPainted, paintedRunWidth } from '../design/bidiText.js';
+import { cjkJoinBreaks, hasCJK } from './cjk.js';
+import { composeCjkParagraph, cjkWordBreaks, composesAsCjk, composesDashRow, spanMarks } from './cjkCompose.js';
+import { getCjkComposition } from './cjkPunctuation.js';
+import { graphemeCount, graphemesOf } from './graphemes.js';
+import { CENTRAL, sideMarkerRun } from './cjkAnnotate.js';
+import { fontEm, getMeasureRegion, getMeasureUprightDigits, getMeasureWritingMode, lineBaselineOffset, mayHoldVerticalCell, measuringVertically, verticalTextWidth, withMeasureWritingMode } from './vertical.js';
+import { latinReader, uprightDigitCandidates } from '../writingMode.js';
+import { sliceSpan } from '../parse/links.js';
+import { NO_BREAK_SPACES, WORDS_AND_SPACES_RE, isBlankText, isBreakingSpace, isBreakingSpaceRun, refLabelPieces } from './spaces.js';
+import { ZERO_WIDTH_SPACE, breaksAfterDash, breaksAfterHardHyphen, getSlashBreaks, hasCompound, isDash, raggedStretchPx, slashBreakIndices, withoutZeroWidthSpaces } from './breakRules.js';
+import { GEMINATE_DOT, endsInsideGeminate, withLineEndHyphen } from './geminate.js';
+import { insideJoiningWord, joiningScriptIn, wordLetterSpacing } from './joining.js';
+import { applyLineDirections, applySegmentLanguages, getMeasureArabicNumbers, getMeasureDirection, spanLanguages } from './bidiLines.js';
+import { TATWEEL, justifyLinesWithKashida, kashidaCapacity } from './kashida.js';
+import { needsBidi, resolveParagraph, spanIsolates } from '../bidi.js';
+import { cutDoubledMarks, faceReadsScript, getMeasureScriptContext, isDoubledMark, isLetterless, pieceScriptContext, resolveScriptContext, rtlTextWidth, scriptAt, scriptContextUntracked, scriptTextWidth, wordPieceScript } from './script.js';
 /** 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. */
 export function isSwatchFill(color) {
     return /^#(?:[0-9a-f]{6}|[0-9a-f]{8})$/i.test(color) || /^rgba?\([^()]*\)$/i.test(color);
 }
+/** The shape fields of a swatch segment (#1104, see `VDTSwatch`): only
+ *  those its attributes set, so a plain swatch keeps today's segment. */
+function swatchShapeOf(box, side, width) {
+    return {
+        ...(box.sidePx !== undefined || width !== side ? { side } : {}),
+        ...(box.borderWidthPx !== undefined ? { borderWidth: box.borderWidthPx } : {}),
+        ...(box.borderColor !== undefined ? { borderColor: box.borderColor } : {}),
+        ...(box.radiusPx !== undefined ? { radius: Math.min(box.radiusPx, side / 2) } : {}),
+    };
+}
 /** Side of an inline colour swatch: three quarters of the font size (the
  *  height of a capital), read from the `px` size of the CSS font string. */
 export function swatchSidePx(font) {
@@ -632,6 +642,26 @@ function syllabify(word, hyphenate, byDictionary = false) {
     }
     return { clean, soft };
 }
+/** {@link withoutZeroWidthSpaces} of a syllabified word: its soft breaks
+ *  moved to the text left. */
+function dropZeroWidthSpaces(clean, soft) {
+    const dropped = withoutZeroWidthSpaces(clean);
+    if (dropped.text === clean)
+        return { clean, soft, zeroWidth: [] };
+    // How many zero-width spaces stand before each offset of `clean`.
+    const before = [];
+    let n = 0;
+    for (let i = 0; i <= clean.length; i++) {
+        before.push(n);
+        if (clean[i] === ZERO_WIDTH_SPACE)
+            n++;
+    }
+    return {
+        clean: dropped.text,
+        soft: soft.map((s) => ({ ...s, index: s.index - before[s.index] })),
+        zeroWidth: dropped.breaks,
+    };
+}
 /** Break opportunities inside a word (`clean`, the text as laid out):
  *  - after each soft hyphen, the dictionary's or the author's (`soft`); a
  *    hyphen is added when the line ends there;
@@ -646,7 +676,12 @@ function syllabify(word, hyphenate, byDictionary = false) {
  *    plain paragraph there;
  *  - 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). */
+ *    running sums give the widths before its breaks);
+ *  - in a word with no CJK character, after a slash between two words
+ *    ("and/or", "ACC/AHA", see `slashBreakIndices`) and where the author
+ *    typed a zero-width space (`zeroWidthBreaks`, offsets into `clean`,
+ *    which no longer holds the character), #1164: the line ends as it is
+ *    and nothing is added. */
 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). */
@@ -657,7 +692,7 @@ measure,
  *  draws the two together: Lora ligates `l·`, and left `col-` 1.32 px
  *  narrower than painted at 20 px (36.14 px for 37.46); Fira Sans,
  *  0.2 px. */
-ownHeads = false) {
+ownHeads = false, zeroWidthBreaks = []) {
     const widthBefore = cjk
         ? cjk.widthBefore
         : (idx) => (measure ? measure(clean.slice(0, idx)) : textWidth(clean.slice(0, idx), font, smallCaps)) + (letterSpacingPx === 0 ? 0 : letterSpacingPx * graphemeCount(clean.slice(0, idx)));
@@ -695,6 +730,12 @@ ownHeads = false) {
     if (cjk)
         for (const idx of cjk.breaks)
             add({ charIndex: idx, free: true, cjk: true });
+    else {
+        for (const idx of slashBreakIndices(clean))
+            add({ charIndex: idx, free: true });
+        for (const idx of zeroWidthBreaks)
+            add({ charIndex: idx, free: true });
+    }
     return [...byIndex.values()].sort((a, b) => a.charIndex - b.charIndex);
 }
 /**
@@ -712,6 +753,14 @@ ownHeads = false) {
  * touches a run of another script (`ABCكتاب`), with nothing added. Null
  * when no such place fits: the word then runs past the measure, and the
  * line says so (`VDTLine.wordOverflow`).
+ *
+ * Before a syllable, it is divided after a slash or at a zero-width space
+ * the author typed, nothing added (#1164).
+ *
+ * `divided` says how a word was cut (#1150): at a syllable (`'syllable'`)
+ * or between two characters (`'character'`); absent for a cut at a
+ * no-break space, after a slash, at a zero-width space, at the edge of a run of another script, or next to an
+ * ideograph, which divide no word.
  */
 export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, syllablesOnly = false) {
     const text = token.text;
@@ -747,6 +796,33 @@ export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, sylla
             tail: { ...restFrom(idx + 1), ...flags, ...pieceScriptFields(token, idx + 1, text.length) },
         };
     }
+    // After a slash ("ACC/" | "AHA/AAPA"), any slash but the `//` of an
+    // address (with `bodyText.breakAfterSlashes`), or at a free break of the
+    // token's (a zero-width space the author typed, a dash): no word is
+    // divided and nothing is added (#1164). The
+    // last one that leaves a head that fits wins over a syllable and over a
+    // cut between letters.
+    const joints = new Set();
+    if (getSlashBreaks())
+        for (let idx = 2; idx < text.length; idx++) {
+            if (text[idx - 1] === '/' && text[idx] !== '/' && text[idx - 2] !== '/')
+                joints.add(idx);
+        }
+    for (const bp of token.breakPoints ?? [])
+        if (bp.free && !bp.cjk && !token.bareBreaks)
+            joints.add(bp.charIndex);
+    if (joints.size > 0 && !hasCJK(text)) {
+        const sorted = [...joints].filter((idx) => idx > 0 && idx < text.length).sort((a, b) => b - a);
+        for (const idx of sorted) {
+            const headWidth = widthBefore(idx);
+            if (headWidth > lineMaxWidth)
+                continue;
+            return {
+                head: { ...flags, ...pieceScriptFields(token, 0, idx), text: text.slice(0, idx), kind: 'text', width: headWidth },
+                tail: { ...restFrom(idx), ...flags, ...pieceScriptFields(token, idx, text.length) },
+            };
+        }
+    }
     // No hyphen where the cut falls next to an ideograph, or right after a
     // hyphen of the text.
     const afterHyphen = (idx) => text[idx - 1] === '-';
@@ -773,6 +849,7 @@ export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, sylla
             over = mid;
     }
     let at = 0;
+    let divided;
     // The dictionary's syllables, as offsets into the text: `syllabify` maps
     // them past anything else the dictionary might put in.
     const { clean, soft } = syllabify(text, true);
@@ -782,6 +859,8 @@ export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, sylla
                 at = s.index;
         }
     }
+    if (at > 0)
+        divided = 'syllable';
     // 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).
@@ -793,6 +872,8 @@ export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, sylla
                     at = s.index;
             }
         }
+        if (at > 0)
+            divided = 'syllable';
     }
     if (at === 0 && !syllablesOnly) {
         for (let idx = reach; idx >= 1; idx--) {
@@ -808,6 +889,10 @@ export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, sylla
                 break;
             }
         }
+        // Between two letters of one word: not where a word of a joining script
+        // meets another run, nor beside an ideograph, nor after a hyphen.
+        if (at > 0 && !joining && !afterHyphen(at) && !hasCJK(text.slice(at - 1, at + 1)))
+            divided = 'character';
     }
     if (at === 0)
         return null;
@@ -820,6 +905,7 @@ export function emergencySplit(token, font, letterSpacingPx, lineMaxWidth, sylla
             : { ...flags, ...pieceScriptFields(token, 0, at), text: text.slice(0, at) + mark, kind: 'text', width: widthBefore(at) + markW(at) },
         tail: { ...restFrom(at), ...flags, ...pieceScriptFields(token, at, text.length) },
         ...(afterHyphen(at) ? { hard: true } : {}),
+        ...(divided && !afterHyphen(at) ? { divided } : {}),
     };
 }
 /** What is left of `token` after a cut at `at` (`cutWidth` px in): its text
@@ -1033,14 +1119,18 @@ export function atomicSpanToken(span, normalFont, boldFont, italicFont, boldItal
             const icon = measureInlineIcon(span.swatch.icon, span.swatch.color, normalFont);
             return { text: span.text, bold: span.bold, italic: span.italic, captionLabel: span.captionLabel, kind: 'text', width: icon.widthPx, swatch: { icon } };
         }
+        const fill = isSwatchFill(span.swatch.color) ? { color: span.swatch.color } : {};
+        const box = span.swatch.box;
+        const side = box?.sidePx ?? swatchSidePx(swatchFont);
+        const width = side + (box?.gapPx ?? 0);
         return {
             text: span.text,
             bold: span.bold,
             italic: span.italic,
             captionLabel: span.captionLabel,
             kind: 'text',
-            width: swatchSidePx(swatchFont),
-            swatch: isSwatchFill(span.swatch.color) ? { color: span.swatch.color } : {},
+            width,
+            swatch: box ? { ...fill, ...swatchShapeOf(box, side, width) } : fill,
         };
     }
     if (span.math && span.mathRender) {
@@ -1401,7 +1491,9 @@ keepAll = false) {
                     });
                     continue;
                 }
-                const { clean, soft } = isSpace ? { clean: part, soft: [] } : syllabify(part, shouldHyphenate && inCompound?.[partAt] !== true);
+                const syllabified = isSpace ? { clean: part, soft: [] } : syllabify(part, shouldHyphenate && inCompound?.[partAt] !== true);
+                // The author's zero-width spaces: breaks, out of the text (#1164).
+                const { clean, soft, zeroWidth } = isSpace || !syllabified.clean.includes(ZERO_WIDTH_SPACE) || hasCJK(syllabified.clean) ? { ...syllabified, zeroWidth: [] } : dropZeroWidthSpaces(syllabified.clean, syllabified.soft);
                 // The characters this word touches, for a dash that opens it
                 // ("**riddles.**—I", "*\"no\"*—and"): the end of a word run just
                 // before, no space in between.
@@ -1423,7 +1515,7 @@ keepAll = false) {
                 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, ownPieces && !cjk);
+                const breakPoints = isSpace ? [] : wordBreakPoints(clean, soft, font, wordSpacing, sc, dashBreaks, touching, cjk, measured.upTo, ownPieces && !cjk, zeroWidth);
                 if (breakPoints.length > 0) {
                     tokens.push({
                         text: clean,
@@ -1970,6 +2062,7 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
         let lineHardHyphen = false;
         // A word of a joining script wider than the line runs past it.
         let lineWordOverflow = false;
+        let lineWordDivided;
         // The line holds a tab placed at a stop (#622).
         let lineTabbed = false;
         // Consume leading spaces at line start (skip them)
@@ -2091,6 +2184,7 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
                 const font = tokenFont(token, normalFont, boldFont, italicFont, boldItalicFont);
                 const split = emergencySplit(token, font, letterSpacingPx, lineMaxWidth);
                 if (split) {
+                    lineWordDivided = split.divided;
                     lineTokens.push(split.head);
                     lineWidth += split.head.width;
                     lineHyphenated = true;
@@ -2151,6 +2245,7 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
                 if (isDivisible(token)) {
                     const split = emergencySplit(token, font, letterSpacingPx, lineMaxWidth - lineWidth, true);
                     if (split) {
+                        lineWordDivided = split.divided;
                         lineTokens.push(split.head);
                         lineWidth += split.head.width;
                         lineHyphenated = true;
@@ -2241,6 +2336,7 @@ function measureRichText(spans, plainText, normalFont, boldFont, italicFont, bol
             isLastLine,
             ...spaceRatios,
             ...(lineWordOverflow ? { wordOverflow: true } : {}),
+            ...(lineWordDivided ? { wordDivided: lineWordDivided } : {}),
             ...(lineTabbed ? { tabbed: true, ...(textAlign === 'justify' ? { ragged: true } : {}) } : {}),
         });
         y += lineHeightPx;