@openpresentation/opf-render 0.11.8 → 0.12.0

package/dist/script-fonts.js

@@ -16,6 +16,9 @@
 // is reported as a note. `glyphFallback: "none"` (strict mode) keeps the exact
 // faces and lets a missing glyph raise `missing-glyph`.
 
+import { fontPolicyFor } from "./font-policy.js";
+import { SYMBOL_PLACEHOLDER, SYMBOL_SCRIPT, mapSymbolText, symbolEncodingFor, symbolPreviewFaces } from "./symbol-fonts.js";
+
 const freeze = value => { if (value && typeof value === "object") { for (const child of Object.values(value)) freeze(child); Object.freeze(value); } return value; };
 
 /** Designated open replacement families per ISO 15924 script, by style. */
@@ -37,8 +40,33 @@ export const SCRIPT_FONT_FAMILIES = freeze({
   Ethi: {sans: "Noto Sans Ethiopic"}, Armn: {sans: "Noto Sans Armenian"}, Geor: {sans: "Noto Sans Georgian"},
   Mong: {sans: "Noto Sans Mongolian"}, Thaa: {sans: "Noto Sans Thaana"}, Syrc: {sans: "Noto Sans Syriac"},
   Tibt: {serif: "Noto Serif Tibetan"},
+  // FF-45 special families. Zsye (emoji symbols) and Zmth (mathematical notation) are ISO 15924 keys for
+  // text, not scripts a character carries: emoji and math characters are Common, so they stay in their
+  // neighbours' run and reach these faces through the glyph fallback chain (emoji-presentation clusters
+  // take the emoji face first). The keys are last so the chain tries every real script face before them.
+  Zsye: {sans: "Noto Color Emoji"},
+  Zmth: {serif: "STIX Two Math", sans: "Noto Sans Math"},
 });
 
+/**
+ * Emoji presentation (FF-45): a grapheme cluster that a browser or PowerPoint draws with the emoji font. Characters
+ * whose default presentation is emoji (Emoji_Presentation), any cluster with VS16 (U+FE0F), a skin tone modifier
+ * (U+1F3FB-1F3FF), a regional indicator (flags), a keycap (U+20E3) or an emoji tag (U+E0020-E007F). Digits, #, *
+ * and text-default pictographs (U+2764 heart, U+263A) count only with VS16; VS15 (U+FE0E) asks for text.
+ */
+const emojiPresentation = /\p{Emoji_Presentation}|\p{Emoji_Modifier}|\p{Regional_Indicator}|️|⃣|[\u{E0020}-\u{E007F}]/u;
+/** True when the text holds an emoji-presentation cluster (planned in the emoji face, in measurement and drawing). */
+export function hasEmojiPresentation(text) {
+  return typeof text === "string" && emojiPresentation.test(text);
+}
+const textPresentation = /︎/u;
+/** Characters that need a math face rather than a text face: math alphanumerics, letterlike math sets and the rarer operator blocks. */
+const mathNotation = /[\u{1D400}-\u{1D7FF}⟀-⟯⦀-⧿⨀-⫿ℂℇℊ-ℓℕℙ-ℝℤℨℬℭℯ-ℱℳ-ℸ]/u;
+/** True when the text holds mathematical notation that ordinary text faces lack (loads the math pack under `scripts: 'auto'`). */
+export function hasMathNotation(text) {
+  return typeof text === "string" && mathNotation.test(text);
+}
+
 const replacement = (script, substitutes, requestedFamilies) => requestedFamilies.map(requestedFamily => ({
   requestedFamily, script, substitutes, compatibility: "visual",
   note: "Designated open replacement for preview only; the PPTX keeps the requested family. Appearance and advances differ.",
@@ -85,8 +113,64 @@ export const SCRIPT_FONT_REPLACEMENTS = freeze([
   ...replacement("Thaa", sansThenSerif("Thaa"), ["MV Boli"]),
   ...replacement("Syrc", sansThenSerif("Syrc"), ["Estrangelo Edessa"]),
   ...replacement("Tibt", serifThenSans("Tibt"), ["Microsoft Himalaya"]),
+  // FF-45: Segoe UI Emoji previews with Noto Color Emoji (COLRv1 and SVG colour glyphs; Noto Emoji is the monochrome
+  // face the raster path draws), Cambria Math with STIX Two Math (serif math face with a MATH table; Noto Sans Math
+  // is the sans alternative). Both are visual: advances differ from the Microsoft fonts (see the policy rows).
+  ...replacement("Zsye", ["Noto Color Emoji", "Noto Emoji"], ["Segoe UI Emoji"]),
+  ...replacement("Zmth", ["STIX Two Math", "Noto Sans Math"], ["Cambria Math"]),
 ]);
 
+/**
+ * RR-38: the preview size multiplier of a policy row (`replacement.sizeAdjust`) when `drawnFamily` is its replacement, the face the
+ * multiplier was measured on; otherwise undefined. `row` is a policy row, or the requested family name. A renderer scales the
+ * replacement's font size by it in measurement and drawing alike, so a replacement much wider than the real font (Noto Naskh Arabic
+ * for Arabic Typesetting: 1/0.64) draws lines of the length PowerPoint draws. The exported size and core's geometry never change.
+ */
+export function sizeAdjustFor(row, drawnFamily) {
+  const policy = typeof row === "string" ? fontPolicyFor(row) : row;
+  const replacement = policy?.replacement, adjust = replacement?.sizeAdjust;
+  return typeof adjust === "number" && adjust !== 1 && typeof replacement.family === "string" && replacement.family.toLowerCase() === String(drawnFamily).toLowerCase() ? adjust : undefined;
+}
+
+/**
+ * RR-38: where PowerPoint puts the baseline of a line below its top, in em, for the policy row's replacement drawn as `drawnFamily`
+ * (`{lineAscent, lineAscentMixed}`: a line in the real font alone, and a line that also holds other fonts), or undefined. Measured in
+ * a native PowerPoint probe (Arabic Typesetting 0.70 and 0.78); core places baselines one em below the line top.
+ */
+export function lineAscentFor(row, drawnFamily) {
+  const policy = typeof row === "string" ? fontPolicyFor(row) : row;
+  const replacement = policy?.replacement;
+  if (!sizeAdjustFor(policy, drawnFamily) || typeof replacement.lineAscent !== "number") return undefined;
+  return {lineAscent: replacement.lineAscent, lineAscentMixed: typeof replacement.lineAscentMixed === "number" ? replacement.lineAscentMixed : replacement.lineAscent};
+}
+
+/**
+ * RR-38: how far (em of the composed font size) the baseline of a line moves up so runs drawn in a policy replacement sit where PowerPoint
+ * puts the real font's baseline. `lines` is the planned runs of one line (one array per fragment). A line whose runs all carry a
+ * `lineAscent` takes it; a line that also holds other runs takes `lineAscentMixed`; a line with none is untouched (0).
+ */
+export function baselineShift(...lines) {
+  const runs = lines.flat().filter(run => run.text !== "");
+  const adjusted = runs.filter(run => typeof run.lineAscent === "number");
+  if (!adjusted.length) return 0;
+  const ascent = adjusted.length === runs.length ? Math.min(...adjusted.map(run => run.lineAscent)) : Math.min(...adjusted.map(run => run.lineAscentMixed ?? run.lineAscent));
+  return Math.max(0, 1 - ascent);
+}
+
+/**
+ * RR-38: the font size a run with a policy size multiplier is measured and drawn at: `size x adjust` on a quarter-pixel grid. Chromium on
+ * Linux quantizes a fractional font size (a scan of Noto Naskh Arabic against fontkit: every multiple of 0.25 px within 0.09 px over
+ * 340 px lines, other fractions up to 0.27 px), so a size off that grid would break the 0.1 px browser-versus-measured advance gate.
+ * Measurement and drawing both go through this function, so they agree on the size whatever the grid.
+ */
+export function adjustedFontSize(size, adjust) {
+  return typeof adjust === "number" && adjust > 0 ? Math.max(0.25, Math.round(size * adjust * 4) / 4) : size;
+}
+
+/** The emoji faces (FF-45): they draw emoji-presentation clusters only, never a run's Latin text or digits. */
+export const EMOJI_FONT_FAMILIES = SCRIPT_FONT_REPLACEMENTS.find(rule => rule.script === "Zsye").substitutes;
+const emojiFaces = new Set(EMOJI_FONT_FAMILIES);
+
 const eastAsianScripts = new Set(["Hani", "Hans", "Hant", "Hanb", "Jpan", "Kore", "Hang", "Jamo", "Hira", "Kana", "Hrkt", "Bopo", "Yiii"]);
 const complexScripts = new Set([
   "Arab", "Hebr", "Syrc", "Thaa", "Nkoo", "Adlm", "Rohg", "Mand", "Samr",
@@ -214,8 +298,11 @@ export function itemizeScripts(text, profile) {
  */
 export function scriptsOfText(text, profile) {
   const source = String(text ?? "");
-  if (latinOnly.test(source) && !(eastAsianLanguage(profile) && eastAsianAmbiguous.test(source))) return [];
-  return itemizeScripts(source, profile).filter(run => run.script !== "Latn").map(run => run.script);
+  // FF-45: emoji-presentation clusters and mathematical notation are Common characters inside a Latin (or other) run; their
+  // faces are needed all the same, so they are reported as the pseudo-scripts Zsye and Zmth, which the emoji and math packs serve.
+  const special = [...(hasEmojiPresentation(source) ? ["Zsye"] : []), ...(hasMathNotation(source) ? ["Zmth"] : [])];
+  if (latinOnly.test(source) && !(eastAsianLanguage(profile) && eastAsianAmbiguous.test(source))) return special;
+  return [...itemizeScripts(source, profile).filter(run => run.script !== "Latn").map(run => run.script), ...special];
 }
 
 /**
@@ -268,8 +355,11 @@ export function glyphFallbackFamilies(character, profile = {}, serif = profile?.
   // otherwise every CJK face is tried in turn (Japanese, Simplified, Traditional, Korean).
   const own = script === "Hani" ? (hanKeys.includes(language) ? language : "Zzzz") : fontKey(script, character, profile);
   const keys = [own, language, "Latn", ...hanKeys, ...Object.keys(SCRIPT_FONT_FAMILIES)];
-  return [...new Set([...new Set(keys)].flatMap(key => designatedFamilies(key, serif)))];
+  // 6. the open symbol faces (FF-45), when a host loaded them: mathematical operators, arrows, dingbats and pictographs.
+  return [...new Set([...new Set(keys)].flatMap(key => designatedFamilies(key, serif)).concat(SYMBOL_FALLBACK_FACES))];
 }
+/** The symbol faces at the end of the glyph fallback chain, in order: pictographs, then the mathematical operators. */
+const SYMBOL_FALLBACK_FACES = ["Noto Sans Symbols 2", "Noto Sans Symbols", "Noto Sans Math"];
 
 /**
  * Aliases from proprietary script fonts to the first loaded designated
@@ -433,22 +523,94 @@ export function createScriptFonts(profile = {}, measurement, options = {}) {
   const candidatesFor = (run, slots) => {
     const list = [run.role === "eastAsian" ? slots.eastAsian : run.role === "complexScript" ? slots.complexScript : slots.latin];
     if (run.script !== "Latn") {
+      // RR-38: a slot family whose policy replacement carries a size multiplier (Arabic Typesetting -> Noto Naskh Arabic, 0.64) names that
+      // replacement next: the multiplier was measured on it, and it is the face a registry resolves the family to, so a preview without a
+      // measurement provider draws the same face and size as a measured one (it drew the sans face, Noto Sans Arabic, at full size). Other
+      // proprietary script families keep the designated order below until they carry a measured multiplier of their own.
+      const scriptRule = list[0] ? SCRIPT_FONT_REPLACEMENTS.find(rule => rule.script === run.script && rule.requestedFamily.toLowerCase() === String(list[0]).toLowerCase()) : undefined;
+      if (scriptRule && sizeAdjustFor(list[0], scriptRule.substitutes[0])) list.push(scriptRule.substitutes[0]);
       if (slots.supplement && slots.supplement.script === run.script) list.push(slots.supplement.family);
       list.push(...designatedFamilies(run.script, serif));
     }
     return [...new Set(list.filter(Boolean))];
   };
 
+  /**
+   * FF-45: runs for text in a symbol-encoded family (Symbol, Wingdings, Wingdings 2, Wingdings 3, Webdings). Each
+   * character's code (U+F0xx private use or its Windows-1252 character) maps to its Unicode equivalent, drawn with the
+   * first loaded face of the family's preview chain that has it (`symbolPreviewFaces`), one run per glyph so the
+   * preview can place each at the verified font's advance (`run.symbol.advance`, em). A code with no equivalent, or
+   * whose equivalent no loaded face has, draws the placeholder U+25A1 and says so (`run.symbol.placeholder`, the
+   * fallback note carries `codes`). Characters that are not codes (a CJK letter, an emoji) are planned as ordinary text.
+   * Without a measurement provider every symbol run names the whole chain as its stack.
+   */
+  const planSymbols = (text, style, encoding) => {
+    const cacheKey = `${SYMBOL_SCRIPT}\u0000${encoding}\u0000${style.fontFamily}\u0000${style.fontWeight ?? 400}\u0000${!!style.italic}\u0000${textRole(style) ?? ""}\u0000${style.path ?? ""}\u0000${text}`;
+    const cached = plans.get(cacheKey);
+    if (cached) return cached;
+    const chain = symbolPreviewFaces(encoding);
+    const resolvedChain = measured ? chain.map(name => resolveName(name, style)).filter((name, index, all) => name && all.indexOf(name) === index) : chain;
+    const out = [], notes = new Map();
+    let foreign = "";
+    const flushForeign = () => {
+      if (!foreign) return;
+      for (const run of plan(foreign, {...style, symbolEncoding: null})) out.push(run);
+      foreign = "";
+    };
+    const note = (family, item, drawn, placeholder) => {
+      const key = `${family}\u0000${placeholder ? "placeholder" : "glyph"}`;
+      let entry = notes.get(key);
+      if (!entry) notes.set(key, entry = {fontFamily: encoding, fallbackFamily: family, scripts: [SYMBOL_SCRIPT], characters: [], codes: [], ...(placeholder ? {placeholder: drawn || "none"} : {}), ...(style.path ? {path: style.path} : {})});
+      const hex = item.code.toString(16).toUpperCase().padStart(2, "0");
+      if (!entry.codes.includes(hex) && entry.codes.length < 32) { entry.codes.push(hex); if (entry.characters.length < 16) entry.characters.push(item.source); }
+    };
+    for (const item of mapSymbolText(encoding, text)) {
+      if (item.code === null) { foreign += item.source; continue; }
+      flushForeign();
+      let drawn = item.unicode, family = null, placeholder = false;
+      if (!measured) { out.push({text: drawn ?? SYMBOL_PLACEHOLDER, family: chain[0], own: false, stack: chain, symbol: {family: encoding, code: item.code, source: item.source, advance: item.advance, ...(drawn === null ? {placeholder: true, reason: item.reason} : {})}}); continue; }
+      if (drawn !== null) family = resolvedChain.find(name => covers(name, drawn, style)) ?? null;
+      if (family === null) {
+        placeholder = true;
+        const reason = drawn === null ? item.reason : `no loaded face has U+${drawn.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}; load the symbol faces (scripts: ['${SYMBOL_SCRIPT}'])`;
+        // The placeholder is U+25A1 WHITE SQUARE from a loaded symbol face; without one, U+FFFD from the style's face (Noto Sans,
+        // Roboto and the office faces have it); a registry with neither draws nothing at the code's advance.
+        const own = resolveName(style.fontFamily, style) ?? style.fontFamily;
+        const choice = [[SYMBOL_PLACEHOLDER, resolvedChain.find(name => covers(name, SYMBOL_PLACEHOLDER, style))], ["�", [own, ...resolvedChain].find(name => covers(name, "�", style))]].find(([, name]) => name);
+        drawn = choice ? choice[0] : "";
+        family = choice ? choice[1] : own;
+        out.push({text: drawn, family, own: false, symbol: {family: encoding, code: item.code, source: item.source, advance: item.advance, placeholder: true, reason}});
+      } else out.push({text: drawn, family, own: false, symbol: {family: encoding, code: item.code, source: item.source, advance: item.advance}});
+      note(family, item, drawn, placeholder);
+    }
+    flushForeign();
+    for (const entry of notes.values()) {
+      const key = `${entry.fontFamily}\u0000${entry.fallbackFamily}\u0000${entry.placeholder ?? ""}\u0000${style.path ?? ""}`;
+      if (fallbackNotes.has(key)) continue;
+      fallbackNotes.set(key, entry);
+      options.onFallback?.(entry);
+    }
+    if (plans.size >= 4096) plans.delete(plans.keys().next().value);
+    plans.set(cacheKey, out);
+    return out;
+  };
+
   /** Font runs for text drawn in `style` (the resolved latin style). `own` runs use the style's family. */
   const plan = (text, style) => {
     text = String(text ?? "");
-    if (latinOnly.test(text) && !(eastAsianText && eastAsianAmbiguous.test(text))) {
+    // A symbol-encoded family (resolved styles carry `symbolEncoding`; an unresolved style names the family itself) is mapped code by
+    // code; `symbolEncoding: null` is the planner's own request for ordinary runs (characters that are not codes).
+    const encoding = style.symbolEncoding === null ? undefined : style.symbolEncoding ?? symbolEncodingFor(style.fontFamily)?.family;
+    if (encoding) return text ? planSymbols(text, style, encoding) : [{text, family: style.fontFamily, own: true}];
+    // An emoji face (Noto Color Emoji for a Segoe UI Emoji run) draws emoji-presentation clusters only: its Latin text and digits
+    // are planned per cluster below, where they take a text face (FF-45).
+    const ownFace = measured && fallbackEnabled ? resolveName(style.fontFamily, style) : undefined;
+    if (latinOnly.test(text) && !(eastAsianText && eastAsianAmbiguous.test(text)) && !(ownFace && emojiFaces.has(ownFace))) {
       // Latin-group text is one run in the latin slot's face, unless that face lacks a character
       // (Cyrillic or Greek beyond a Latin replacement): then it is planned per character below.
       if (!fallbackEnabled || !nonAscii.test(text)) return [{text, family: style.fontFamily, own: true}];
       if (!measured) return cyrillicOrGreek.test(text) ? [{text, family: style.fontFamily, own: false, stack: [style.fontFamily, ...designatedFamilies("Latn", serif)]}] : [{text, family: style.fontFamily, own: true}];
-      const own = resolveName(style.fontFamily, style);
-      if (own === null || covers(own, text, style)) return [{text, family: style.fontFamily, own: true}];
+      if (ownFace === null || covers(ownFace, text, style)) return [{text, family: style.fontFamily, own: true}];
     }
     const cacheKey = `${style.fontFamily}\u0000${style.fontWeight ?? 400}\u0000${!!style.italic}\u0000${textRole(style) ?? ""}\u0000${style.path ?? ""}\u0000${text}`;
     const cached = plans.get(cacheKey);
@@ -459,19 +621,32 @@ export function createScriptFonts(profile = {}, measurement, options = {}) {
     const global = [...new Set([...runs.flatMap(run => run.candidates), ...designatedFamilies(fontKey(profile.script ?? "Zzzz", text, profile), serif), ...designatedFamilies("Latn", serif)])];
     const unique = names => names.map(name => resolveName(name, style)).filter((name, index, all) => name && all.indexOf(name) === index);
     const out = [];
-    const push = (text, family, stack) => {
+    const push = (text, family, stack, sizeAdjust, ascent) => {
       const own = family === style.fontFamily && (!stack || stack.length === 1);
       const last = out.at(-1);
-      if (last && last.family === family && JSON.stringify(last.stack) === JSON.stringify(stack)) last.text += text;
-      else out.push({text, family, own, ...(stack && !own ? {stack} : {})});
+      if (last && last.family === family && last.sizeAdjust === sizeAdjust && last.lineAscent === ascent?.lineAscent && JSON.stringify(last.stack) === JSON.stringify(stack)) last.text += text;
+      else out.push({text, family, own, ...(stack && !own ? {stack} : {}), ...(sizeAdjust ? {sizeAdjust} : {}), ...(ascent ?? {})});
     };
     for (const run of runs) {
-      if (!measured) { push(run.text, run.candidates[0], run.candidates); continue; }
+      // RR-38: the slot family's replacement draws at the policy's size multiplier. Unmeasured, the replacement is the first face
+      // the stack names after the requested family; the requested name leaves the stack so a host that has the real font installed
+      // (a browser on Windows) cannot draw it at the reduced size.
+      const adjustOf = family => sizeAdjustFor(run.candidates[0], family);
+      const ascentOf = family => lineAscentFor(run.candidates[0], family);
+      if (!measured) {
+        const adjust = adjustOf(run.candidates[1]);
+        push(run.text, adjust ? run.candidates[1] : run.candidates[0], adjust ? run.candidates.slice(1) : run.candidates, adjust, ascentOf(run.candidates[1]));
+        continue;
+      }
       const chosen = resolveName(run.candidates[0], style);
-      const whole = run.candidates.map(family => resolveName(family, style)).find(name => name && covers(name, run.text, style));
+      // FF-45: a run with an emoji-presentation cluster, or whose face is an emoji face, is always planned per cluster: VS16 and
+      // emoji-default clusters take the emoji face even when the text face has a monochrome glyph for the base character, and the
+      // emoji face never draws the run's Latin text or digits.
+      const emojiRun = emojiFaces.has(chosen) || hasEmojiPresentation(run.text);
+      const whole = emojiRun ? undefined : run.candidates.map(family => resolveName(family, style)).find(name => name && covers(name, run.text, style));
       if (whole) {
         if (whole !== chosen) noteFallback(pending, chosen, whole, [...run.text].filter(character => !covers(chosen ?? whole, character, style)));
-        push(run.text, whole);
+        push(run.text, whole, undefined, adjustOf(whole), ascentOf(whole));
         continue;
       }
       // No single candidate covers the run. Split it into grapheme clusters (a base character with
@@ -486,7 +661,14 @@ export function createScriptFonts(profile = {}, measurement, options = {}) {
       let sticky = null;
       // The note lists what the chosen face lacks (a mark, not its covered base letter); a cluster it only lacks as a whole lists all.
       const missingFrom = (face, text) => { const lacking = [...text].filter(character => !covers(face, character, style)); return lacking.length ? lacking : [...text]; };
-      const choose = (subject, sample) => unique([run.candidates[0], ...(sticky ? [sticky] : []), ...run.candidates, ...global, ...(fallbackEnabled ? chainFor(sample) : [])]).find(name => covers(name, subject, style));
+      // An emoji-presentation cluster tries the emoji faces first (Noto Color Emoji, loaded with the emoji pack), then the text
+      // faces; any other cluster tries them last, so a run's digits and Latin text (which the emoji face draws emoji-sized) take a
+      // text face, while a text-presentation symbol only the emoji face has (U+2764 with VS15) is still drawn rather than missing.
+      const choose = (subject, sample, emoji = false) => {
+        const names = unique([run.candidates[0], ...(sticky ? [sticky] : []), ...run.candidates, ...global, ...(fallbackEnabled ? chainFor(sample) : [])]);
+        const emojiNames = names.filter(name => emojiFaces.has(name)), textNames = names.filter(name => !emojiFaces.has(name));
+        return (emoji ? [...emojiNames, ...textNames] : [...textNames, ...emojiNames]).find(name => covers(name, subject, style));
+      };
       const segments = [];
       for (const character of run.text) {
         const script = scriptOfCharacter(character), last = segments.at(-1)?.clusters.at(-1);
@@ -504,10 +686,11 @@ export function createScriptFonts(profile = {}, measurement, options = {}) {
         const strong = segment.clusters.filter(cluster => !cluster.weak);
         const face = strong.length ? choose(strong.map(cluster => cluster.text).join(""), strong[0].base) : undefined;
         for (const cluster of segment.clusters) {
-          const family = face && covers(face, cluster.text, style) ? face : choose(cluster.text, cluster.base) ?? choose(cluster.base, cluster.base) ?? primary;
+          const emoji = hasEmojiPresentation(cluster.text);
+          const family = !emoji && face && covers(face, cluster.text, style) ? face : choose(cluster.text, cluster.base, emoji) ?? choose(cluster.base, cluster.base, emoji) ?? primary;
           if (family !== primary && family !== chosen) sticky = family;
           if (chosen !== null && family !== chosen && covers(family, cluster.text, style)) noteFallback(pending, chosen, family, missingFrom(chosen, cluster.text));
-          push(cluster.text, family);
+          push(cluster.text, family, undefined, adjustOf(family), ascentOf(family));
         }
       }
     }
@@ -517,32 +700,40 @@ export function createScriptFonts(profile = {}, measurement, options = {}) {
     return out;
   };
 
-  const styleFor = (run, style) => styled(run.own ? style : {...style, fontFamily: run.family});
-  /** Measured advance of each planned run, in order; undefined without a measurement provider. */
-  const runWidths = (runs, size, style) => measured ? runs.map(run => inner.measure(run.text, size, styleFor(run, style))) : undefined;
+  // A run drawn for another family drops the encoding: the open face's own glyphs are measured.
+  const styleFor = (run, style) => styled(run.own ? style : {...style, fontFamily: run.family, symbolEncoding: null});
+  /**
+   * The advance a planned run occupies: the open face's measured advance, except that a symbol run (FF-45) occupies the
+   * verified symbol font's advance for its code, so lines break and bullets sit where PowerPoint puts them; `natural`
+   * asks for the open face's advance of that run instead (the SVG compresses a wider glyph to fit, never stretches one).
+   */
+  const runWidth = (run, size, style, natural = false) => run.symbol && !natural && run.symbol.advance !== null ? run.symbol.advance * size : inner.measure(run.text, adjustedFontSize(size, run.sizeAdjust), styleFor(run, style));
+  /** Advance of each planned run, in order (see `runWidth`); undefined without a measurement provider. */
+  const runWidths = (runs, size, style, {natural = false} = {}) => measured ? runs.map(run => runWidth(run, size, style, natural)) : undefined;
   let textMeasurement;
   if (measured) {
     textMeasurement = {
       ...inner,
       measure(text, size, style) {
         const runs = plan(text, style);
-        if (runs.length === 1 && runs[0].own) return inner.measure(text, size, styled(style));
-        return runs.reduce((total, run) => total + inner.measure(run.text, size, styleFor(run, style)), 0);
+        // RR-38: a run drawn at the policy's size multiplier is not the style's own face at its own size: it takes the run path below.
+        if (runs.length === 1 && runs[0].own && !runs[0].sizeAdjust) return inner.measure(text, size, styled(style));
+        return runs.reduce((total, run) => total + runWidth(run, size, style), 0);
       },
       [scriptMeasurement]: {inner, profile, options},
     };
     if (typeof inner.outlineBounds === "function") {
       textMeasurement.outlineBounds = (text, size, style) => {
         const runs = plan(text, style);
-        if (runs.length === 1 && runs[0].own) return inner.outlineBounds(text, size, styled(style));
+        if (runs.length === 1 && runs[0].own && !runs[0].sizeAdjust) return inner.outlineBounds(text, size, styled(style));
         let x = 0, box = null;
         for (const run of runs) {
-          const runStyle = styleFor(run, style), bounds = inner.outlineBounds(run.text, size, runStyle);
+          const runStyle = styleFor(run, style), bounds = inner.outlineBounds(run.text, adjustedFontSize(size, run.sizeAdjust), runStyle);
           if (bounds) {
             const left = x + bounds.x, top = bounds.y, right = left + bounds.width, bottom = top + bounds.height;
             box = box ? {left: Math.min(box.left, left), top: Math.min(box.top, top), right: Math.max(box.right, right), bottom: Math.max(box.bottom, bottom)} : {left, top, right, bottom};
           }
-          x += inner.measure(run.text, size, runStyle);
+          x += runWidth(run, size, style);
         }
         return box && {x: box.left, y: box.top, width: box.right - box.left, height: box.bottom - box.top};
       };

package/dist/sha256.js

@@ -0,0 +1,47 @@
+// SHA-256 in plain JavaScript (FIPS 180-4), so the vector PDF writer needs neither node:crypto nor Web Crypto (which is
+// asynchronous) and runs the same in Node and in a browser. Returns the 32-byte digest.
+
+const K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+
+export function sha256Bytes(input) {
+  const data = input instanceof Uint8Array ? input : new Uint8Array(input);
+  const length = data.length;
+  const padded = new Uint8Array(((length + 9 + 63) >> 6) << 6);
+  padded.set(data);
+  padded[length] = 0x80;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(length / 0x20000000), false);
+  view.setUint32(padded.length - 4, (length << 3) >>> 0, false);
+  const h = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let index = 0; index < 16; index++) w[index] = view.getUint32(offset + index * 4, false);
+    for (let index = 16; index < 64; index++) {
+      const a = w[index - 15], b = w[index - 2];
+      const s0 = ((a >>> 7) | (a << 25)) ^ ((a >>> 18) | (a << 14)) ^ (a >>> 3);
+      const s1 = ((b >>> 17) | (b << 15)) ^ ((b >>> 19) | (b << 13)) ^ (b >>> 10);
+      w[index] = (w[index - 16] + s0 + w[index - 7] + s1) | 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h;
+    for (let index = 0; index < 64; index++) {
+      const s1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+      const ch = (e & f) ^ (~e & g);
+      const t1 = (hh + s1 + ch + K[index] + w[index]) | 0;
+      const s0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+      const maj = (a & b) ^ (a & c) ^ (b & c);
+      const t2 = (s0 + maj) | 0;
+      hh = g; g = f; f = e; e = (d + t1) | 0; d = c; c = b; b = a; a = (t1 + t2) | 0;
+    }
+    h[0] = (h[0] + a) | 0; h[1] = (h[1] + b) | 0; h[2] = (h[2] + c) | 0; h[3] = (h[3] + d) | 0;
+    h[4] = (h[4] + e) | 0; h[5] = (h[5] + f) | 0; h[6] = (h[6] + g) | 0; h[7] = (h[7] + hh) | 0;
+  }
+  const out = new Uint8Array(32);
+  const outView = new DataView(out.buffer);
+  for (let index = 0; index < 8; index++) outView.setUint32(index * 4, h[index], false);
+  return out;
+}

package/dist/svg.d.ts

@@ -41,7 +41,7 @@ export type RenderDiagnostic = LayoutDiagnostic | {
   scripts: string[];
   characters: string[];
 } | {
-  code: "unsupported-pattern" | "date-needs-value" | "language-preview-unavailable" | "language-preview-unresolved" | "paragraph-direction-unavailable";
+  code: "unsupported-pattern" | "variable-example-used" | "date-needs-value" | "language-preview-unavailable" | "language-preview-unresolved" | "paragraph-direction-unavailable";
   path: string;
   message: string;
 } | {
@@ -74,6 +74,14 @@ export interface RenderSvgOptions {
   onDiagnostic?: (diagnostic: RenderDiagnostic) => void;
   /** When false, skip AJV boundary validation. Default true. */
   validate?: boolean;
+  /**
+   * Values for the deck's template variables, keyed by variable id (core `resolveVariables`). A deck that uses
+   * content variables, or is marked `template: true`, is resolved to a concrete deck first. A template previews with
+   * each unfilled variable's example (reported as `variable-example-used`); a normal deck with an unfilled required
+   * variable throws `unfilled-variables`. `false` draws the document as authored, with `{{id}}` tokens and
+   * `var:id` references visible and nothing resolved: the view an editor uses while the template itself is edited.
+   */
+  variables?: Record<string, unknown> | false;
   slideIndex?: number;
   /**
    * Today's calendar date (ISO YYYY-MM-DD) for `date: true` header/footer furniture. The renderer
@@ -82,6 +90,11 @@ export interface RenderSvgOptions {
   date?: string;
   trace?: boolean;
   catalogs?: Record<string, { records?: unknown[] } | unknown[]>;
+  /**
+   * Records for catalog sources the host has already fetched, keyed by the source string a document's
+   * `catalogs.<kind>.source` names (a single source or an ordered array; first match wins, the bundled
+   * default catalog is appended). The renderer never fetches a source itself.
+   */
   catalogSources?: Record<string, { records?: unknown[] } | unknown[]>;
 }