postext 1.28.6 → 1.29.0

package/dist/measure/rich.js

@@ -6,7 +6,8 @@ import { getHyphenationRulesKey, hyphenateByDictionary, hyphenateText, softHyphe
 import { richTokensToItems, computeBreakpoints, reconstructRichLines, } from '../knuthPlass';
 import { SOFT_HYPHEN } from './types';
 import { lineStartAt, lineWidthAt, lineWidthFunction, markInsetLines, uniformMeasureFrom } from './types';
-import { cleanSoftHyphens, measureTextWidth, normalSpaceWidthFor } from './canvas';
+import { cleanSoftHyphens, getMeasureLanguage, measureTextWidth, normalSpaceWidthFor, setMeasureLanguage, withMeasureLanguage } from './canvas';
+import { spanShapingLanguage } from './spanLanguage';
 import { isRuntLastLine } from './runts';
 import { hasOverfullLine } from './plain';
 import { justifiedSpaceRatios } from './spaceRatios';
@@ -127,6 +128,8 @@ function scriptOf(t) {
         // The pieces of a word with no letter are shaped in its script (#725).
         ...(t.scriptContext ? { scriptContext: t.scriptContext } : {}),
         ...(t.scriptRtl ? { scriptRtl: true } : {}),
+        // And the pieces of a word of a run in another language in it (#764).
+        ...(t.lang !== undefined ? { lang: t.lang } : {}),
     };
 }
 /** The script fields of the piece `[from, to)` of `token`, a head or a
@@ -154,6 +157,12 @@ function rtlWordWidth(text, font) {
 /** How a token's text is measured: in its script when it is a word with
  *  no letter given one (#725), else as any text (`textWidth`). */
 function tokenTextWidth(token, font) {
+    // A word of a run in another language is measured in it (#764).
+    if (token.lang !== undefined) {
+        const { lang, ...rest } = token;
+        const inner = tokenTextWidth(rest, font);
+        return (text) => withMeasureLanguage(lang, () => inner(text));
+    }
     const script = token.scriptContext;
     if (script)
         return (text) => (text === '' ? 0 : scriptTextWidth(text, font, script, token.scriptRtl === true));
@@ -1140,147 +1149,165 @@ keepAll = false) {
         };
     };
     for (const span of spans) {
-        const spanBase = spanStart;
-        spanStart += span.text.length;
-        // A tab (#622): its width is set where its line gets to it.
-        // Tab characters in a row are one character of the text that goes on
-        // that many stops: the later ones have no text.
-        if (span.tab) {
-            const tab = span.tab.px ? { stop: span.tab.px } : {};
-            for (let k = 0; k < Math.max(1, span.tab.count ?? 1); k++) {
-                tokens.push({ text: k === 0 ? span.text : '', bold: span.bold, italic: span.italic, kind: 'space', width: 0, tab });
+        // A run that names its language (`:ltr[…]{lang=en}`) is measured in it,
+        // in a document shaped in its own (#764); its tokens say so, for what
+        // is measured of them later (a cut, a piece).
+        const ownLanguage = spanShapingLanguage(span);
+        const spanTokensFrom = tokens.length;
+        const languageBefore = getMeasureLanguage();
+        if (ownLanguage !== undefined)
+            setMeasureLanguage(ownLanguage);
+        try {
+            const spanBase = spanStart;
+            spanStart += span.text.length;
+            // A tab (#622): its width is set where its line gets to it.
+            // Tab characters in a row are one character of the text that goes on
+            // that many stops: the later ones have no text.
+            if (span.tab) {
+                const tab = span.tab.px ? { stop: span.tab.px } : {};
+                for (let k = 0; k < Math.max(1, span.tab.count ?? 1); k++) {
+                    tokens.push({ text: k === 0 ? span.text : '', bold: span.bold, italic: span.italic, kind: 'space', width: 0, tab });
+                }
+                continue;
             }
-            continue;
-        }
-        // A reference whose label is words: one token per word and space (#702).
-        const label = refLabelTokens(span, normalFont, boldFont, italicFont, boldItalicFont, letterSpacingPx);
-        if (label) {
-            tokens.push(...label);
-            continue;
-        }
-        const atomic = atomicSpanToken(span, normalFont, boldFont, italicFont, boldItalicFont, letterSpacingPx);
-        if (atomic) {
-            tokens.push(atomic);
-            continue;
-        }
-        const font = spanFont(span);
-        // A fixed space is set as text: no break, no justification glue.
-        if (span.fixedSpace) {
-            if (span.text.length > 0) {
-                tokens.push({ text: span.text, bold: span.bold, italic: span.italic, kind: 'text', width: textWidth(span.text, font, false) + track(span.text) });
+            // A reference whose label is words: one token per word and space (#702).
+            const label = refLabelTokens(span, normalFont, boldFont, italicFont, boldItalicFont, letterSpacingPx);
+            if (label) {
+                tokens.push(...label);
+                continue;
             }
-            continue;
-        }
-        // Chinese marks (#193) ride on the span's words like its script.
-        const marks = spanMarks(span, getMeasureWritingMode() === 'vertical-rl');
-        const scriptFields = {
-            ...scriptFieldsOf(span),
-            ...(marks ? { cjkMarks: marks } : {}),
-            ...(span.inserted ? { inserted: true } : {}),
-        };
-        // Small capitals: the words keep their case (hyphenation reads it) and
-        // measure as they will be painted.
-        const sc = !!span.smallCaps;
-        const scFields = sc ? { smallCaps: true } : {};
-        // Split on word boundaries while preserving spaces. Each word is
-        // hyphenated on its own (the dictionary works word by word anyway), so
-        // its soft hyphens can be told apart from the ones the source carries.
-        // A no-break space is no boundary: it stays inside the word it glues
-        // ("37 °C"), which the line then never breaks at (EF-66).
-        const matched = span.text.match(WORDS_AND_SPACES_RE);
-        if (!matched)
-            continue;
-        const levelled = bidi ? cutAtLevels(matched, spanBase, bidi) : matched;
-        // In a Chinese or Japanese document a word with no letter is cut
-        // around its doubled ellipses and dashes: the document's own marks,
-        // set as Han text whatever sentence cites them (`cutDoubledMarks`).
-        const parts = contextOf && scriptState.hanMarks && faceReadsScript(font)
-            ? levelled.flatMap((part) => (isBreakingSpaceRun(part) ? undefined : cutDoubledMarks(part)) ?? [part])
-            : levelled;
-        let partStart = spanBase;
-        for (const part of parts) {
-            const partAt = partStart;
-            partStart += part.length;
-            const isSpace = isBreakingSpaceRun(part);
-            if (!isSpace && URL_LIKE_RE.test(part.replace(/\u00AD/g, '')) && !(letterSpacingPx !== 0 && joiningScriptIn(part))) {
-                const clean = part.replace(/\u00AD/g, '');
-                // An address is one script run: its pieces with no letter
-                // (`10.1006/`, `.2001`) are measured in the script they have in
-                // it, and an address with no letter at all in its context's (#725).
-                const inScript = scriptMeasure(contextOf?.(clean, partAt, part.length, font), font, sc);
-                const spacing = inScript.untracked ? 0 : letterSpacingPx;
-                const upTo = inScript.upTo ?? ((text) => textWidth(text, font, sc));
-                const breakPoints = urlBreakIndices(clean).map((charIndex) => ({
-                    charIndex,
-                    widthBefore: upTo(clean.slice(0, charIndex)) + (spacing === 0 ? 0 : spacing * graphemeCount(clean.slice(0, charIndex))),
-                }));
-                tokens.push({
-                    text: clean,
-                    bold: span.bold,
-                    italic: span.italic,
-                    captionLabel: span.captionLabel,
-                    ...scriptFields,
-                    ...scFields,
-                    ...inScript.fields,
-                    kind: 'text',
-                    width: (inScript.whole ? inScript.whole(clean) : textWidth(clean, font, sc)) + (inScript.untracked ? 0 : track(clean)),
-                    ...(breakPoints.length > 0 ? { breakPoints, hyphenWidth: 0, bareBreaks: true } : {}),
-                });
+            const atomic = atomicSpanToken(span, normalFont, boldFont, italicFont, boldItalicFont, letterSpacingPx);
+            if (atomic) {
+                tokens.push(atomic);
                 continue;
             }
-            const { clean, soft } = isSpace ? { clean: part, soft: [] } : syllabify(part, shouldHyphenate && inCompound?.[partAt] !== true);
-            // 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.
-            const before = tokens[tokens.length - 1];
-            const touching = dashBreaks && before && before.kind === 'text' && !before.mathRender && !before.swatch && !before.chip
-                ? before.text.slice(-2)
-                : undefined;
-            // A word that holds CJK characters: measured unit by unit, once each.
-            const cjk = cjkText && !isSpace && hasCJK(clean) ? cjkWordBreaks(clean, font, sc, letterSpacingPx, undefined, keepAll) : undefined;
-            // A word of a joining script is measured untracked, its break points
-            // (after a hyphen or a dash it carries) too.
-            // A word with no letter: measured in the script of its context, its
-            // pieces at a break too (#725). In the Arabic script it takes no
-            // tracking, as the Arabic words around it take none.
-            // A word with a letter: its pieces with no letter (`COVID-` | `19`)
-            // in the script they have inside it.
-            const measured = scriptMeasure(contextOf && !isSpace && !cjk ? contextOf(clean, partAt, part.length, font) : undefined, font, sc);
-            const untracked = measured.untracked;
-            const wordSpacing = isSpace ? letterSpacingPx : untracked ? 0 : wordLetterSpacing(clean, letterSpacingPx);
-            const inScript = measured.whole;
-            const contextFields = measured.fields;
-            const breakPoints = isSpace ? [] : wordBreakPoints(clean, soft, font, wordSpacing, sc, dashBreaks, touching, cjk, measured.upTo);
-            if (breakPoints.length > 0) {
-                tokens.push({
-                    text: clean,
-                    bold: span.bold,
-                    italic: span.italic,
-                    captionLabel: span.captionLabel,
-                    ...scriptFields,
-                    ...scFields,
-                    ...contextFields,
-                    kind: 'text',
-                    width: cjk ? cjk.width : (inScript ? inScript(clean) : textWidth(clean, font, sc)) + (untracked ? 0 : track(clean)),
-                    breakPoints,
-                    hyphenWidth: measureTextWidth('-', font) + letterSpacingPx,
-                });
+            const font = spanFont(span);
+            // A fixed space is set as text: no break, no justification glue.
+            if (span.fixedSpace) {
+                if (span.text.length > 0) {
+                    tokens.push({ text: span.text, bold: span.bold, italic: span.italic, kind: 'text', width: textWidth(span.text, font, false) + track(span.text) });
+                }
+                continue;
+            }
+            // Chinese marks (#193) ride on the span's words like its script.
+            const marks = spanMarks(span, getMeasureWritingMode() === 'vertical-rl');
+            const scriptFields = {
+                ...scriptFieldsOf(span),
+                ...(marks ? { cjkMarks: marks } : {}),
+                ...(span.inserted ? { inserted: true } : {}),
+            };
+            // Small capitals: the words keep their case (hyphenation reads it) and
+            // measure as they will be painted.
+            const sc = !!span.smallCaps;
+            const scFields = sc ? { smallCaps: true } : {};
+            // Split on word boundaries while preserving spaces. Each word is
+            // hyphenated on its own (the dictionary works word by word anyway), so
+            // its soft hyphens can be told apart from the ones the source carries.
+            // A no-break space is no boundary: it stays inside the word it glues
+            // ("37 °C"), which the line then never breaks at (EF-66).
+            const matched = span.text.match(WORDS_AND_SPACES_RE);
+            if (!matched)
+                continue;
+            const levelled = bidi ? cutAtLevels(matched, spanBase, bidi) : matched;
+            // In a Chinese or Japanese document a word with no letter is cut
+            // around its doubled ellipses and dashes: the document's own marks,
+            // set as Han text whatever sentence cites them (`cutDoubledMarks`).
+            const parts = contextOf && scriptState.hanMarks && faceReadsScript(font)
+                ? levelled.flatMap((part) => (isBreakingSpaceRun(part) ? undefined : cutDoubledMarks(part)) ?? [part])
+                : levelled;
+            let partStart = spanBase;
+            for (const part of parts) {
+                const partAt = partStart;
+                partStart += part.length;
+                const isSpace = isBreakingSpaceRun(part);
+                if (!isSpace && URL_LIKE_RE.test(part.replace(/\u00AD/g, '')) && !(letterSpacingPx !== 0 && joiningScriptIn(part))) {
+                    const clean = part.replace(/\u00AD/g, '');
+                    // An address is one script run: its pieces with no letter
+                    // (`10.1006/`, `.2001`) are measured in the script they have in
+                    // it, and an address with no letter at all in its context's (#725).
+                    const inScript = scriptMeasure(contextOf?.(clean, partAt, part.length, font), font, sc);
+                    const spacing = inScript.untracked ? 0 : letterSpacingPx;
+                    const upTo = inScript.upTo ?? ((text) => textWidth(text, font, sc));
+                    const breakPoints = urlBreakIndices(clean).map((charIndex) => ({
+                        charIndex,
+                        widthBefore: upTo(clean.slice(0, charIndex)) + (spacing === 0 ? 0 : spacing * graphemeCount(clean.slice(0, charIndex))),
+                    }));
+                    tokens.push({
+                        text: clean,
+                        bold: span.bold,
+                        italic: span.italic,
+                        captionLabel: span.captionLabel,
+                        ...scriptFields,
+                        ...scFields,
+                        ...inScript.fields,
+                        kind: 'text',
+                        width: (inScript.whole ? inScript.whole(clean) : textWidth(clean, font, sc)) + (inScript.untracked ? 0 : track(clean)),
+                        ...(breakPoints.length > 0 ? { breakPoints, hyphenWidth: 0, bareBreaks: true } : {}),
+                    });
+                    continue;
+                }
+                const { clean, soft } = isSpace ? { clean: part, soft: [] } : syllabify(part, shouldHyphenate && inCompound?.[partAt] !== true);
+                // 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.
+                const before = tokens[tokens.length - 1];
+                const touching = dashBreaks && before && before.kind === 'text' && !before.mathRender && !before.swatch && !before.chip
+                    ? before.text.slice(-2)
+                    : undefined;
+                // A word that holds CJK characters: measured unit by unit, once each.
+                const cjk = cjkText && !isSpace && hasCJK(clean) ? cjkWordBreaks(clean, font, sc, letterSpacingPx, undefined, keepAll) : undefined;
+                // A word of a joining script is measured untracked, its break points
+                // (after a hyphen or a dash it carries) too.
+                // A word with no letter: measured in the script of its context, its
+                // pieces at a break too (#725). In the Arabic script it takes no
+                // tracking, as the Arabic words around it take none.
+                // A word with a letter: its pieces with no letter (`COVID-` | `19`)
+                // in the script they have inside it.
+                const measured = scriptMeasure(contextOf && !isSpace && !cjk ? contextOf(clean, partAt, part.length, font) : undefined, font, sc);
+                const untracked = measured.untracked;
+                const wordSpacing = isSpace ? letterSpacingPx : untracked ? 0 : wordLetterSpacing(clean, letterSpacingPx);
+                const inScript = measured.whole;
+                const contextFields = measured.fields;
+                const breakPoints = isSpace ? [] : wordBreakPoints(clean, soft, font, wordSpacing, sc, dashBreaks, touching, cjk, measured.upTo);
+                if (breakPoints.length > 0) {
+                    tokens.push({
+                        text: clean,
+                        bold: span.bold,
+                        italic: span.italic,
+                        captionLabel: span.captionLabel,
+                        ...scriptFields,
+                        ...scFields,
+                        ...contextFields,
+                        kind: 'text',
+                        width: cjk ? cjk.width : (inScript ? inScript(clean) : textWidth(clean, font, sc)) + (untracked ? 0 : track(clean)),
+                        breakPoints,
+                        hyphenWidth: measureTextWidth('-', font) + letterSpacingPx,
+                    });
+                }
+                else {
+                    // A word of a joining script loses the soft hyphens it may not
+                    // break at (`syllabify`); any other keeps its text as written.
+                    const word = clean !== part && !isSpace && joiningScriptIn(part) ? clean : part;
+                    tokens.push({
+                        text: word,
+                        bold: span.bold,
+                        italic: span.italic,
+                        captionLabel: span.captionLabel,
+                        ...scriptFields,
+                        ...(isSpace ? {} : scFields),
+                        ...contextFields,
+                        kind: isSpace ? 'space' : 'text',
+                        width: (inScript ? inScript(word) : textWidth(word, font, sc && !isSpace)) + (untracked ? 0 : track(word)),
+                    });
+                }
             }
-            else {
-                // A word of a joining script loses the soft hyphens it may not
-                // break at (`syllabify`); any other keeps its text as written.
-                const word = clean !== part && !isSpace && joiningScriptIn(part) ? clean : part;
-                tokens.push({
-                    text: word,
-                    bold: span.bold,
-                    italic: span.italic,
-                    captionLabel: span.captionLabel,
-                    ...scriptFields,
-                    ...(isSpace ? {} : scFields),
-                    ...contextFields,
-                    kind: isSpace ? 'space' : 'text',
-                    width: (inScript ? inScript(word) : textWidth(word, font, sc && !isSpace)) + (untracked ? 0 : track(word)),
-                });
+        }
+        finally {
+            if (ownLanguage !== undefined) {
+                setMeasureLanguage(languageBefore);
+                if (ownLanguage !== languageBefore)
+                    for (let k = spanTokensFrom; k < tokens.length; k++)
+                        tokens[k].lang = ownLanguage;
             }
         }
     }