slotdeck 0.1.1 → 0.2.0

package/dist/text/fonts.js

@@ -0,0 +1,59 @@
+// What measuring text needs from a font library, and which typeface a character is set in.
+/**
+ * The width of a piece of text at a font size, in points, as PowerPoint lays it out: on a grid of
+ * an eighth of a point, to which the advance of every glyph is rounded. At small sizes that
+ * rounding moves a line's width by a percent or two, enough to move a word to the next line.
+ */
+export function textWidth(face, text, size, kerning) {
+    let units = 0;
+    for (const advance of face.advances(text, kerning))
+        units += Math.round(advance * size * 8);
+    return units / 8;
+}
+const COMPLEX = /[\p{Script=Hebrew}\p{Script=Arabic}\p{Script=Syriac}\p{Script=Thaana}\p{Script=Thai}\p{Script=Lao}\p{Script=Khmer}\p{Script=Devanagari}\p{Script=Bengali}\p{Script=Gurmukhi}\p{Script=Gujarati}\p{Script=Tamil}\p{Script=Telugu}\p{Script=Kannada}\p{Script=Malayalam}\p{Script=Sinhala}\p{Script=Tibetan}\p{Script=Myanmar}]/u;
+const EAST_ASIAN = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Bopomofo}　-〿＀-￯]/u;
+const STRONG = /[\p{L}\p{M}]/u;
+const classes = new Map();
+/** The typeface class of a character, or `undefined` for one that takes its neighbour's (a space, a digit, punctuation). */
+export function scriptClass(char) {
+    if (classes.has(char))
+        return classes.get(char);
+    const found = COMPLEX.test(char) ? 'cs' : EAST_ASIAN.test(char) ? 'ea' : STRONG.test(char) ? 'latin' : undefined;
+    if (classes.size < 20000)
+        classes.set(char, found);
+    return found;
+}
+/** Whether a line may break before and after the character without a space, as between Chinese or Japanese characters. */
+export function breaksAnywhere(char) {
+    return /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Bopomofo}]/u.test(char);
+}
+/** The theme's name for the script of a complex-script or East Asian character, as in `<a:font script="Hebr">`. */
+export function themeScript(char) {
+    for (const [tag, test] of THEME_SCRIPTS)
+        if (test.test(char))
+            return tag;
+    return undefined;
+}
+const THEME_SCRIPTS = [
+    ['Hebr', /\p{Script=Hebrew}/u],
+    ['Arab', /\p{Script=Arabic}/u],
+    ['Syrc', /\p{Script=Syriac}/u],
+    ['Thaa', /\p{Script=Thaana}/u],
+    ['Thai', /\p{Script=Thai}/u],
+    ['Laoo', /\p{Script=Lao}/u],
+    ['Khmr', /\p{Script=Khmer}/u],
+    ['Deva', /\p{Script=Devanagari}/u],
+    ['Beng', /\p{Script=Bengali}/u],
+    ['Guru', /\p{Script=Gurmukhi}/u],
+    ['Gujr', /\p{Script=Gujarati}/u],
+    ['Taml', /\p{Script=Tamil}/u],
+    ['Telu', /\p{Script=Telugu}/u],
+    ['Knda', /\p{Script=Kannada}/u],
+    ['Mlym', /\p{Script=Malayalam}/u],
+    ['Sinh', /\p{Script=Sinhala}/u],
+    ['Tibt', /\p{Script=Tibetan}/u],
+    ['Hang', /\p{Script=Hangul}/u],
+    ['Jpan', /[\p{Script=Hiragana}\p{Script=Katakana}]/u],
+    ['Hans', /\p{Script=Han}/u],
+];
+//# sourceMappingURL=fonts.js.map

package/dist/text/fonts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fonts.js","sourceRoot":"","sources":["../../src/text/fonts.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAiC3F;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,IAAc,EAAE,IAAY,EAAE,IAAY,EAAE,OAAgB;IACpF,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;QAAE,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC;IAC5F,OAAO,KAAK,GAAG,CAAC,CAAC;AACnB,CAAC;AAQD,MAAM,OAAO,GACX,gUAAgU,CAAC;AACnU,MAAM,UAAU,GAAG,mGAAmG,CAAC;AACvH,MAAM,MAAM,GAAG,eAAe,CAAC;AAE/B,MAAM,OAAO,GAAG,IAAI,GAAG,EAAmC,CAAC;AAE3D,4HAA4H;AAC5H,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;QAAE,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAChD,MAAM,KAAK,GAA4B,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1I,IAAI,OAAO,CAAC,IAAI,GAAG,KAAK;QAAE,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACnD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,0HAA0H;AAC1H,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,OAAO,4EAA4E,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACjG,CAAC;AAED,mHAAmH;AACnH,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,aAAa;QAAE,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;YAAE,OAAO,GAAG,CAAC;IACzE,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,MAAM,aAAa,GAA4B;IAC7C,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAC9B,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAC9B,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAC9B,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAC9B,CAAC,MAAM,EAAE,kBAAkB,CAAC;IAC5B,CAAC,MAAM,EAAE,iBAAiB,CAAC;IAC3B,CAAC,MAAM,EAAE,mBAAmB,CAAC;IAC7B,CAAC,MAAM,EAAE,wBAAwB,CAAC;IAClC,CAAC,MAAM,EAAE,qBAAqB,CAAC;IAC/B,CAAC,MAAM,EAAE,sBAAsB,CAAC;IAChC,CAAC,MAAM,EAAE,sBAAsB,CAAC;IAChC,CAAC,MAAM,EAAE,mBAAmB,CAAC;IAC7B,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAC9B,CAAC,MAAM,EAAE,qBAAqB,CAAC;IAC/B,CAAC,MAAM,EAAE,uBAAuB,CAAC;IACjC,CAAC,MAAM,EAAE,qBAAqB,CAAC;IAC/B,CAAC,MAAM,EAAE,qBAAqB,CAAC;IAC/B,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAC9B,CAAC,MAAM,EAAE,2CAA2C,CAAC;IACrD,CAAC,MAAM,EAAE,iBAAiB,CAAC;CAC5B,CAAC"}

package/dist/text/layout.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Breaks one paragraph into lines. `first` and `rest` are the widths the first and the later
+ * lines may take; `measure` gives the width of a piece of text set on one line, in the same
+ * unit. Words go on a line while they fit; a word wider than a whole line is cut where the
+ * line ends. Spaces at the end of a line hang outside it and do not count.
+ *
+ * `inside` names the exception to that: it is asked whether the space after a line that would
+ * end with the given text, with the given word to follow, stays inside the line and so needs
+ * room. PowerPoint keeps it inside when the text on both sides of that space runs against the
+ * paragraph's direction.
+ */
+export declare function breakLines(text: string, first: number, rest: number, measure: (text: string) => number, inside?: (line: string, next: string) => boolean): string[];

package/dist/text/layout.js

@@ -0,0 +1,104 @@
+// Breaking a paragraph into lines the way PowerPoint does, given a way to measure a piece of text.
+import { breaksAnywhere } from './fonts.js';
+/** A line may break after a hyphen or a dash, as well as at a space. Not at a slash, a full stop or a colon. */
+const BREAK_AFTER = /[-‐–—]/;
+/** Chinese and Japanese closing punctuation, which never starts a line. */
+const CLOSING = /[、。，．！？」』）】ー]/;
+const SPACE = /[ \t  - 　]/;
+function units(text) {
+    const out = [];
+    let word = '';
+    const close = (gap = '') => {
+        if (word !== '' || gap !== '')
+            out.push({ word, gap });
+        word = '';
+    };
+    const chars = [...text];
+    for (let index = 0; index < chars.length; index++) {
+        const char = chars[index];
+        if (SPACE.test(char)) {
+            let gap = char;
+            while (index + 1 < chars.length && SPACE.test(chars[index + 1]))
+                gap += chars[++index];
+            close(gap);
+        }
+        else if (char === '​') {
+            close();
+        }
+        else if (breaksAnywhere(char)) {
+            if (CLOSING.test(char)) {
+                word += char;
+                continue;
+            }
+            close();
+            word = char;
+            const next = chars[index + 1];
+            if (next === undefined || !CLOSING.test(next))
+                close();
+        }
+        else {
+            word += char;
+            if (BREAK_AFTER.test(char) && index + 1 < chars.length && !SPACE.test(chars[index + 1]))
+                close();
+        }
+    }
+    close();
+    return out;
+}
+/**
+ * Breaks one paragraph into lines. `first` and `rest` are the widths the first and the later
+ * lines may take; `measure` gives the width of a piece of text set on one line, in the same
+ * unit. Words go on a line while they fit; a word wider than a whole line is cut where the
+ * line ends. Spaces at the end of a line hang outside it and do not count.
+ *
+ * `inside` names the exception to that: it is asked whether the space after a line that would
+ * end with the given text, with the given word to follow, stays inside the line and so needs
+ * room. PowerPoint keeps it inside when the text on both sides of that space runs against the
+ * paragraph's direction.
+ */
+export function breakLines(text, first, rest, measure, inside) {
+    const lines = [];
+    let line = '';
+    let width = 0;
+    let gap = '';
+    const limit = () => (lines.length === 0 ? first : rest);
+    const all = units(text);
+    for (let index = 0; index < all.length; index++) {
+        const unit = all[index];
+        let word = unit.word;
+        let wordWidth = word === '' ? 0 : measure(word);
+        const gapWidth = line !== '' && gap !== '' ? measure(gap) : 0;
+        const next = all[index + 1]?.word;
+        const tail = inside && line !== '' && unit.gap !== '' && next !== undefined && inside(line + gap + word, next) ? measure(unit.gap) : 0;
+        if (line !== '' && width + gapWidth + wordWidth + tail <= limit()) {
+            line += gap + word;
+            width += gapWidth + wordWidth;
+        }
+        else {
+            if (line !== '') {
+                lines.push(line + gap);
+                line = '';
+                width = 0;
+            }
+            // A word wider than a whole line is cut by characters.
+            while (wordWidth > limit()) {
+                const chars = [...word];
+                let count = 1;
+                while (count < chars.length && measure(chars.slice(0, count + 1).join('')) <= limit())
+                    count++;
+                lines.push(chars.slice(0, count).join(''));
+                word = chars.slice(count).join('');
+                wordWidth = word === '' ? 0 : measure(word);
+            }
+            line = word;
+            width = wordWidth;
+        }
+        gap = unit.gap;
+    }
+    if (line !== '' || lines.length === 0)
+        lines.push(line + gap);
+    else if (gap !== '')
+        lines[lines.length - 1] += gap;
+    return lines;
+}
+//# sourceMappingURL=layout.js.map

package/dist/text/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","sourceRoot":"","sources":["../../src/text/layout.ts"],"names":[],"mappings":"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"}

package/dist/text/measure.d.ts

@@ -0,0 +1,85 @@
+import type { Template } from '../render/render.ts';
+import type { PatternDef, TextSlotDef } from '../template/manifest.ts';
+import type { FontMetrics } from './fonts.ts';
+/** How far text may be reduced to make it fit. */
+export interface ShrinkLimit {
+    /** The smallest share of its size the text may be set at, e.g. 0.85. */
+    to: number;
+    /** A size in points under which text is never set, whatever `to` allows. */
+    minSize?: number;
+}
+export interface FitOptions {
+    /** The factor on body text the deck is rendered with: the template's times the deck's. Defaults to 1. */
+    textScale?: number;
+    /** Allow the text to be set smaller when it does not fit. */
+    shrink?: ShrinkLimit;
+    /** For a slot of a row of items: how many items the slide has, which can decide how wide an item is. */
+    items?: number;
+}
+/** How a text sits in a slot. */
+export interface TextFit {
+    /** Whether the text stays inside its box. */
+    fits: boolean;
+    /** Lines the text takes, over all its paragraphs. */
+    lines: number;
+    /** Lines of this text the box holds. */
+    capacity: number;
+    /** Lines that do not fit; 0 when the text fits. */
+    overflow: number;
+    /** Height the text takes, and the height the box gives it, in points. */
+    height: number;
+    room: number;
+    /** For a box that does not wrap: how much wider than the box the longest line is, as a factor. 1 or less fits. */
+    widthRatio: number;
+    /** Font size of the first paragraph as measured, in points. */
+    size: number;
+    /** The font size each paragraph is set at, in points: what the renderer writes when it shrinks the text. */
+    sizes: number[];
+    /** The factor the text was reduced by to make it fit; 1 when it was not reduced. */
+    scale: number;
+    /** About how many characters of text like this the box holds. */
+    fitsChars: number;
+    /** The lines of each paragraph, as they break. */
+    paragraphs: string[][];
+    /** The width of each of those lines in points, without the space that hangs at its end. */
+    widths: number[][];
+    /** The width a line of each paragraph may take, in points. */
+    lineRoom: number[];
+    /**
+     * Lines the template's own sample text takes in this slot: how full the designer drew it.
+     * 0 when the slot has no sample to compare with (a slot that moves its box or resets its size).
+     */
+    sampleLines: number;
+    /** A typeface or a weight was stood in for by another, so the figures are close but not exact. */
+    approximate: boolean;
+}
+/** A typeface in a weight and slant that the template's text is set in. */
+export interface TemplateFont {
+    typeface: string;
+    bold: boolean;
+    italic: boolean;
+}
+export interface TextMeasurer {
+    /**
+     * Measures a text in a slot of a pattern. `undefined` when it cannot be measured: the slot's
+     * shape holds no text, or a typeface it needs was not supplied.
+     */
+    fit(pattern: string | PatternDef, slot: string | TextSlotDef, text: string | string[], options?: FitOptions): TextFit | undefined;
+    /** The typefaces the template's text slots are set in for which no font was supplied. */
+    missingFonts(): TemplateFont[];
+}
+/**
+ * Builds a measurer for a template from font metrics. Pass the metrics here, or load the
+ * template with them (`loadTemplate(pptx, manifest, { fonts })`), which also makes validation,
+ * planning and rendering measure text.
+ */
+export declare function textMeasurer(template: Template, fonts?: FontMetrics | undefined): TextMeasurer;
+/** The measurer of a template that was loaded with fonts, or `undefined` for one that was not. */
+export declare function measurerFor(template: Template): TextMeasurer | undefined;
+/**
+ * The typefaces a template's text slots are set in, each with the weights and slants used: the
+ * font files to supply for measuring. `language` adds the typeface that text of that language is
+ * set in when it differs from the Latin one (Hebrew in a template whose theme sends it to
+ * another font); it defaults to the manifest's language.
+ */
+export declare function templateFonts(template: Template, language?: string | undefined): TemplateFont[];

package/dist/text/measure.js

@@ -0,0 +1,369 @@
+import { detectDirection } from '../render/text.js';
+import { inspectTemplate } from '../template/inspect.js';
+import { rowTextIds } from '../render/repeat.js';
+import { COPY_ID_STEP, effectiveSlots, itemCount, scalesWithText, widenFactor } from '../template/manifest.js';
+import { scriptClass, textWidth, themeScript } from './fonts.js';
+import { breakLines } from './layout.js';
+import { TextStyles } from './styles.js';
+/** A line that hangs under the box by less than this share of its height is counted as fitting. */
+const SLACK = 0.3;
+/** Width in points that a line of shrunk text must leave free: two steps of PowerPoint's layout grid. */
+const SPARE = 0.25;
+/** PowerPoint sets lines 1.2 times the font size apart, whatever the font's own metrics say. */
+const LINE = 1.2;
+/**
+ * A slot's box of the shape's own size, to within this share of the slide, moves the shape
+ * without resizing it. A manifest states boxes to four decimal places.
+ */
+const MOVED = 0.0005;
+const shared = new WeakMap();
+function sharedFor(pkg) {
+    let entry = shared.get(pkg);
+    if (!entry) {
+        entry = { styles: new TextStyles(pkg), info: inspectTemplate(pkg), shapes: new Map() };
+        shared.set(pkg, entry);
+    }
+    return entry;
+}
+class MissingFont extends Error {
+    font;
+    constructor(font) {
+        super(`no font was supplied for ${font.typeface}`);
+        this.font = font;
+    }
+}
+/** The theme's name for the script a language is written in, for the languages whose text takes a typeface of its own. */
+const LANGUAGE_SCRIPTS = { he: 'Hebr', iw: 'Hebr', yi: 'Hebr', ar: 'Arab', fa: 'Arab', ur: 'Arab', ps: 'Arab', ug: 'Arab', sd: 'Arab', ckb: 'Arab', syr: 'Syrc', dv: 'Thaa', th: 'Thai', hi: 'Deva' };
+function typefaceName(run, cls, char) {
+    const face = cls === 'cs' ? run.cs : cls === 'ea' ? run.ea : run.latin;
+    if (face.name)
+        return face.name;
+    const script = cls === 'latin' ? undefined : themeScript(char);
+    return (script && face.scripts?.get(script)) || run.latin.name;
+}
+const RTL_LANGUAGE = /^(he|iw|yi|ar|fa|ur|ps|ug|sd|ckb|syr|dv)(-|$)/i;
+const DIGIT = /\p{Nd}/u;
+const LAST_LETTER = /(\p{L})[^\p{L}]*$/u;
+/**
+ * Measures pieces of text in the typefaces of one run style, at one size. `rtl` says the run is
+ * marked with a right-to-left language, which decides the typeface of what is not a letter:
+ * PowerPoint then sets digits in the complex-script face and a space or a punctuation mark in
+ * the face of the character before it. In any other run they are all set in the Latin face.
+ */
+function runMeasure(fonts, run, size, rtl, flags) {
+    const style = { bold: run.bold, italic: run.italic };
+    const kerning = run.kern > 0 && size >= run.kern;
+    const faces = new Map();
+    const faceFor = (cls, char) => {
+        const name = typefaceName(run, cls, char);
+        let face = faces.get(name);
+        if (!face) {
+            face = name ? fonts.face(name, style) : undefined;
+            if (!face)
+                throw new MissingFont({ typeface: name || '(theme font)', ...style });
+            faces.set(name, face);
+        }
+        if (face.substitute)
+            flags.approximate = true;
+        return face;
+    };
+    const widths = new Map();
+    return (given) => {
+        const known = widths.get(given);
+        if (known !== undefined)
+            return known;
+        const text = run.caps ? given.toUpperCase() : given;
+        const chars = [...text];
+        let current = rtl ? 'cs' : 'latin';
+        let width = 0;
+        let piece = '';
+        let pieceFace;
+        let pieceClass = current;
+        let pieceLetters = false;
+        const flush = () => {
+            // Kerning, as PowerPoint applies it: complex-script letters are always kerned with each
+            // other, and never with the punctuation, digits or spaces next to them. Latin text is kerned
+            // when the run turns kerning on for its size, except in a run marked right-to-left.
+            const kerned = pieceClass === 'cs' ? pieceLetters : kerning && !rtl;
+            if (piece !== '' && pieceFace)
+                width += textWidth(pieceFace, piece, size, kerned);
+            piece = '';
+        };
+        for (const char of chars) {
+            const strong = scriptClass(char);
+            if (strong)
+                current = strong;
+            else if (!rtl)
+                current = 'latin';
+            else if (DIGIT.test(char))
+                current = 'cs';
+            let face = faceFor(current, char);
+            const codePoint = char.codePointAt(0);
+            if (!face.has(codePoint) && codePoint > 0x20) {
+                flags.approximate = true;
+                face = fonts.fallback?.(codePoint, style) ?? face;
+            }
+            // Complex-script letters are shaped apart from what stands between them.
+            const letters = strong !== undefined;
+            if (face !== pieceFace || current !== pieceClass || (current === 'cs' && letters !== pieceLetters))
+                flush();
+            pieceFace = face;
+            pieceClass = current;
+            pieceLetters = letters;
+            piece += char;
+        }
+        flush();
+        width += run.spacing * chars.length;
+        widths.set(given, width);
+        return width;
+    };
+}
+const spacing = (value, size) => ('points' in value ? value.points : value.percent * LINE * size);
+/**
+ * Builds a measurer for a template from font metrics. Pass the metrics here, or load the
+ * template with them (`loadTemplate(pptx, manifest, { fonts })`), which also makes validation,
+ * planning and rendering measure text.
+ */
+export function textMeasurer(template, fonts = template.fonts) {
+    if (!fonts)
+        throw new Error('textMeasurer needs font metrics: pass them, or load the template with fonts');
+    const metrics = fonts;
+    const { manifest, pkg } = template;
+    const { styles, info, shapes } = sharedFor(pkg);
+    const missing = new Map();
+    const shapeOf = (slide, id) => {
+        let byId = shapes.get(slide);
+        if (!byId) {
+            byId = new Map((info.slides[slide - 1]?.shapes ?? []).map((shape) => [shape.id, shape]));
+            shapes.set(slide, byId);
+        }
+        // A copied item's shapes exist only once the row is rendered; they are set like the shape they copy.
+        return byId.get(id) ?? byId.get(String(Number(id) % COPY_ID_STEP));
+    };
+    /**
+     * The frame a slot's text is measured in. This is the one place that decides the box: every
+     * check (validation, shrinking, the design checks) comes through here. `items` is the number
+     * of items on the slide: a row with `widen` makes its items wider when it holds fewer of them,
+     * and the text of such an item is measured in the box the renderer gives it.
+     */
+    const frameOf = (pattern, slot, items) => {
+        const shape = shapeOf(pattern.sourceSlide, slot.shapeId);
+        if (!shape)
+            return undefined;
+        // The shape's own size is read exactly from the slide; a slot that moves its box states another.
+        const box = slot.box;
+        const size = box && box.w > 0 && box.h > 0 ? { width: box.w * styles.slideWidth, height: box.h * styles.slideHeight } : undefined;
+        const repeat = pattern.repeat;
+        if (!size && repeat && items !== undefined) {
+            const count = itemCount(pattern, items);
+            const texts = rowTextIds(pattern);
+            if (texts?.has(slot.shapeId) && widenFactor(repeat, count) > 1) {
+                const widened = styles.rowFrame(pattern.sourceSlide, slot.shapeId, slot.styleRun ?? 'first', { key: pattern.id, repeat, count, texts });
+                if (widened)
+                    return widened;
+            }
+        }
+        return styles.frame(pattern.sourceSlide, shape.id, slot.styleRun ?? 'first', size);
+    };
+    /** Lays text out in a frame. `size` gives the font size of a paragraph style; `gap` overrides the space after paragraphs. */
+    const lay = (frame, paragraphs, size, gap, flags, spare = 0) => {
+        const inner = (frame.vertical ? frame.height - frame.insets.top - frame.insets.bottom : frame.width - frame.insets.left - frame.insets.right) / frame.columns - spare;
+        const laid = { lines: [], widths: [], lineRoom: [], height: 0, gaps: 0, lastPitch: 0, widest: 0, firstSize: 0 };
+        paragraphs.forEach((text, index) => {
+            const style = frame.paragraphs[Math.min(index, frame.paragraphs.length - 1)];
+            const points = size(style) * frame.fontScale;
+            if (index === 0)
+                laid.firstSize = points;
+            // The renderer marks a paragraph that starts with a right-to-left letter with such a language.
+            const direction = detectDirection(text);
+            const measure = runMeasure(metrics, style.run, points, direction === 'rtl' || RTL_LANGUAGE.test(style.run.lang), flags);
+            const rest = inner - style.marginStart - style.marginEnd;
+            const first = rest - (style.bullet && style.indent < 0 ? 0 : style.indent);
+            // The space after a line hangs outside it, unless it sits inside text that runs against the paragraph.
+            // A space between two words of one direction runs with them; between words of different
+            // directions it runs with the paragraph.
+            const against = (line, next) => {
+                const last = LAST_LETTER.exec(line)?.[1];
+                if (last === undefined || direction === undefined)
+                    return false;
+                const before = detectDirection(last);
+                return before !== direction && (detectDirection(next) ?? before) === before;
+            };
+            const lines = frame.wrap ? breakLines(text, Math.max(first, 1), Math.max(rest, 1), measure, against) : [text];
+            laid.lines.push(lines);
+            laid.lineRoom.push(Math.round(rest * 100) / 100);
+            const widths = lines.map((line) => measure(line.trimEnd()));
+            laid.widths.push(widths.map((width) => Math.round(width * 100) / 100));
+            for (const width of widths)
+                laid.widest = Math.max(laid.widest, width / Math.max(rest, 1));
+            const pitch = 'points' in style.lineSpacing ? style.lineSpacing.points : LINE * points * Math.max(0.1, style.lineSpacing.percent - frame.lineReduction);
+            laid.height += lines.length * pitch;
+            laid.lastPitch = pitch;
+            // The space before the first paragraph and after the last is not drawn.
+            const between = (index > 0 ? spacing(style.before, points) : 0) + (index < paragraphs.length - 1 ? (gap ?? spacing(style.after, points)) : 0);
+            laid.height += between;
+            laid.gaps += between;
+        });
+        return laid;
+    };
+    const note = (error) => {
+        if (!(error instanceof MissingFont))
+            throw error;
+        missing.set(`${error.font.typeface}|${error.font.bold}|${error.font.italic}`, error.font);
+        return undefined;
+    };
+    const fit = (patternRef, slotRef, text, options = {}) => {
+        const pattern = typeof patternRef === 'string' ? manifest.patterns.find((entry) => entry.id === patternRef) : patternRef;
+        if (!pattern)
+            return undefined;
+        let slot;
+        if (typeof slotRef === 'string') {
+            // A slot of a copied item is not in the pattern's own list, so the widest row is searched.
+            const found = effectiveSlots(pattern, pattern.repeat?.max).find((entry) => entry.name === slotRef) ?? pattern.slots.find((entry) => entry.name === slotRef);
+            if (found?.kind === 'text')
+                slot = found;
+        }
+        else {
+            slot = slotRef;
+        }
+        if (!slot)
+            return undefined;
+        const frame = frameOf(pattern, slot, options.items);
+        if (!frame)
+            return undefined;
+        // The box as the template draws it: the same frame unless the row widened this item.
+        const drawn = options.items === undefined ? frame : (frameOf(pattern, slot) ?? frame);
+        const paragraphs = (Array.isArray(text) ? text : text.split(/\r?\n/)).map((paragraph) => paragraph.trim()).filter((paragraph) => paragraph !== '');
+        if (paragraphs.length === 0)
+            return undefined;
+        const chosen = slot;
+        const flags = { approximate: frame.approximate };
+        // The size a paragraph is rendered at, mirroring the renderer: a deck's text size applies to
+        // body text, and only a run that states its size, or a slot that sets one, is rescaled.
+        const bodyScale = scalesWithText(chosen) ? (options.textScale ?? 1) : 1;
+        const sizeAt = (shrink) => (style) => {
+            const stated = chosen.fontSize ?? style.run.size;
+            const factor = chosen.fontSize !== undefined || style.run.ownSize || shrink !== 1 ? bodyScale * shrink : 1;
+            return factor !== 1 || chosen.fontSize !== undefined ? Math.round((stated * 100 * factor) / 50) / 2 : stated;
+        };
+        try {
+            const boxHeight = (frame.vertical ? frame.width - frame.insets.left - frame.insets.right : frame.height - frame.insets.top - frame.insets.bottom) * frame.columns;
+            let room = Math.max(0, boxHeight);
+            let roomWidth = 1;
+            let sampleLines = 0;
+            // A box drawn around its sample text holds at least what the sample takes. That does not
+            // carry over to a slot that resizes the box or resets the size: it uses the shape
+            // differently. A box that only moves the shape, as a mirrored pattern's does, keeps it.
+            const own = shapeOf(pattern.sourceSlide, chosen.shapeId)?.box;
+            const sameSize = chosen.box !== undefined && own !== undefined && Math.abs(chosen.box.w - own.w) <= MOVED && Math.abs(chosen.box.h - own.h) <= MOVED;
+            if ((chosen.box === undefined || sameSize) && chosen.fontSize === undefined) {
+                const sample = frame.sample.map((paragraph) => paragraph.trim()).filter((paragraph) => paragraph !== '');
+                if (sample.length > 0) {
+                    try {
+                        // An item that widens keeps its height, so the room below the first line, and how
+                        // full the designer drew the box, are those of the box as drawn.
+                        const laid = lay(drawn, sample, (style) => style.run.size, undefined, { approximate: false });
+                        room = Math.max(room, laid.height);
+                        sampleLines = laid.lines.reduce((sum, entry) => sum + entry.length, 0);
+                        const wide = frame === drawn ? laid : lay(frame, sample, (style) => style.run.size, undefined, { approximate: false });
+                        roomWidth = Math.max(roomWidth, wide.widest);
+                    }
+                    catch (error) {
+                        note(error);
+                    }
+                }
+            }
+            const measured = (shrink) => {
+                // A size chosen because the text just fits at it sits on the edge by construction, so a
+                // shrunk text is asked to fit with a little width to spare.
+                const laid = lay(frame, paragraphs, sizeAt(shrink), chosen.paragraphGap, flags, shrink === 1 ? 0 : SPARE);
+                const lines = laid.lines.reduce((sum, entry) => sum + entry.length, 0);
+                const slack = SLACK * laid.lastPitch;
+                const over = laid.height - room - slack;
+                const overflow = over > 0 ? Math.max(1, Math.ceil(over / laid.lastPitch - 1e-6)) : 0;
+                const spare = over > 0 ? 0 : Math.floor(-over / laid.lastPitch + 1e-6);
+                const widthRatio = frame.wrap ? 1 : laid.widest / roomWidth;
+                const chars = paragraphs.reduce((sum, paragraph) => sum + paragraph.length, 0);
+                const textHeight = Math.max(1, laid.height - laid.gaps);
+                const share = frame.wrap ? Math.max(0, room - laid.gaps) / textHeight : 1 / Math.max(widthRatio, 0.01);
+                return {
+                    fits: overflow === 0 && widthRatio <= 1.005,
+                    lines,
+                    capacity: Math.max(0, lines - overflow + spare),
+                    overflow,
+                    height: Math.round(laid.height * 100) / 100,
+                    room: Math.round(room * 100) / 100,
+                    widthRatio: Math.round(widthRatio * 1000) / 1000,
+                    size: laid.firstSize,
+                    sizes: paragraphs.map((_, index) => sizeAt(shrink)(frame.paragraphs[Math.min(index, frame.paragraphs.length - 1)])),
+                    scale: shrink,
+                    // Lines end at word boundaries, so a text cut to the box's share of its height needs a little margin.
+                    fitsChars: Math.max(1, Math.floor(chars * share * (share < 1 ? 0.95 : 1))),
+                    paragraphs: laid.lines,
+                    widths: laid.widths,
+                    lineRoom: laid.lineRoom,
+                    sampleLines,
+                    approximate: flags.approximate,
+                };
+            };
+            let result = measured(1);
+            if (!result.fits && options.shrink) {
+                const first = sizeAt(1)(frame.paragraphs[0]);
+                const floor = Math.max(options.shrink.to, options.shrink.minSize !== undefined && first > 0 ? options.shrink.minSize / first : 0);
+                // Sizes go in half points, so the scale steps down by half a point of the first paragraph at a time.
+                for (let size = Math.floor(first * 2 - 1) / 2; size > 0 && size / first >= floor - 1e-9; size -= 0.5) {
+                    result = measured(size / first);
+                    if (result.fits)
+                        break;
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            return note(error);
+        }
+    };
+    return {
+        fit,
+        missingFonts() {
+            const wanted = new Map(missing);
+            for (const font of templateFonts(template)) {
+                if (!metrics.face(font.typeface, font))
+                    wanted.set(`${font.typeface}|${font.bold}|${font.italic}`, font);
+            }
+            return [...wanted.values()].sort((a, b) => a.typeface.localeCompare(b.typeface) || Number(a.bold) - Number(b.bold) || Number(a.italic) - Number(b.italic));
+        },
+    };
+}
+/** The measurer of a template that was loaded with fonts, or `undefined` for one that was not. */
+export function measurerFor(template) {
+    return template.fonts ? textMeasurer(template, template.fonts) : undefined;
+}
+/**
+ * The typefaces a template's text slots are set in, each with the weights and slants used: the
+ * font files to supply for measuring. `language` adds the typeface that text of that language is
+ * set in when it differs from the Latin one (Hebrew in a template whose theme sends it to
+ * another font); it defaults to the manifest's language.
+ */
+export function templateFonts(template, language = template.manifest.language) {
+    const { styles } = sharedFor(template.pkg);
+    const script = LANGUAGE_SCRIPTS[(language ?? '').toLowerCase().split('-')[0] ?? ''];
+    const found = new Map();
+    const add = (typeface, run) => {
+        if (typeface)
+            found.set(`${typeface}|${run.bold}|${run.italic}`, { typeface, bold: run.bold, italic: run.italic });
+    };
+    for (const pattern of template.manifest.patterns) {
+        for (const slot of pattern.slots) {
+            if (slot.kind !== 'text' || slot.empty === 'drop' || slot.empty === 'keep')
+                continue;
+            const frame = styles.frame(pattern.sourceSlide, slot.shapeId, slot.styleRun ?? 'first');
+            for (const paragraph of frame?.paragraphs ?? []) {
+                add(paragraph.run.latin.name, paragraph.run);
+                add(paragraph.run.cs.name || (script ? (paragraph.run.cs.scripts?.get(script) ?? '') : ''), paragraph.run);
+            }
+        }
+    }
+    return [...found.values()].sort((a, b) => a.typeface.localeCompare(b.typeface) || Number(a.bold) - Number(b.bold) || Number(a.italic) - Number(b.italic));
+}
+//# sourceMappingURL=measure.js.map