@openpresentation/opf-render 0.28.0 → 0.29.1

package/dist/fonts-browser.d.ts

@@ -73,6 +73,12 @@ export interface BrowserFontsHandle extends FontsHandle {
   ensure(presentation: unknown, options?: { signal?: AbortSignal } & Partial<ToSvgOptions>): Promise<EnsureResult>;
   /** Synchronous: the vendored files and script packages `ensure` would fetch. Empty means a render can start now. Throws what `toSvg` throws for a document that does not resolve. */
   pending(presentation: unknown, renderOptions?: Partial<ToSvgOptions>): string[];
+  /**
+   * Counters of the analysis behind `pending` and `ensure`, for tests and benchmarks: `decks` opened (resolved and checked),
+   * `slides` composed and drawn to find their faces, `designs` resolved for their families, and `strings` scanned for scripts.
+   * The analysis keeps what it found, so asking again about the same deck adds nothing and an edit adds only the changed slides.
+   */
+  readonly analysisStats: { decks: number; slides: number; designs: number; strings: number };
 }
 export declare function loadFonts(
   options?: FontRegistryOptions & {

package/dist/fonts-browser.js

@@ -1,11 +1,11 @@
 import { createFontRegistry, OPFFontError } from "./font-registry.js";
 import { lazyFontEntries, lazyFontList, normalizeExtraLazyFonts } from "./lazy-font-list.js";
-import { lazyFacesNeeded } from "./lazy-fonts.js";
+import { createFontAnalysis, lazyFacesNeeded } from "./lazy-fonts.js";
 import { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
 import { textOutlines } from "./text-paths.js";
 import { createSubsetter, fontSubsets } from "./font-subset.js";
 import { instantiateShaper } from "./hb-shape.js";
-import { analyzePresentationScripts, nextFallbackPackage, scriptFontPackages, scriptPackageEntries, scriptSelectionOf, uncoveredCjkCharacters } from "./script-font-pack.js";
+import { analyzePresentationScripts, createScriptAnalysis, nextFallbackPackage, scriptFontPackages, scriptPackageEntries, scriptSelectionOf, uncoveredCjkCharacters } from "./script-font-pack.js";
 export { autoScriptSelection, detectPresentationScripts, scriptFontEntries, scriptFontPackages } from "./script-font-pack.js";
 export { lazyFontEntries, lazyFontList, splitStartupFaces } from "./lazy-font-list.js";
 export { lazyFacesNeeded, lazyFontsFor, presentationFaces, presentationFamilies } from "./lazy-fonts.js";
@@ -102,6 +102,10 @@ async function loadRegistry(entries, options = {}, startup = {}) {
   };
   await registerBrowserFaces(faces, described);
 
+  // `pending` and `ensure` run before every render and edit, so the analyses keep what they found (the 0.28.0 startup regression):
+  // each slide's faces and families are analyzed again only when the slide changes, each drawn string is scanned once.
+  const fontAnalysis = createFontAnalysis(), scriptMemory = createScriptAnalysis({ fonts: fontAnalysis });
+  Object.defineProperty(registry, "analysisStats", { get: () => ({ ...fontAnalysis.stats, ...scriptMemory.stats }), enumerable: false });
   // Script faces (FF-19) are loaded lazily, once a document needs them, and only for the scripts it uses.
   const scriptPackages = new Set();
   let queue = Promise.resolve();
@@ -167,7 +171,7 @@ async function loadRegistry(entries, options = {}, startup = {}) {
      */
     async ensureScripts(presentation, callOptions) {
       if (disposed) throw gone();
-      const analysis = analyzePresentationScripts(presentation, undefined, renderOptionsFor(callOptions)), selection = scriptSelectionOf(analysis);
+      const analysis = analyzePresentationScripts(presentation, undefined, renderOptionsFor(callOptions), scriptMemory), selection = scriptSelectionOf(analysis);
       const loadedNow = [], failed = [];
       const attempt = async (item) => {
         try { loadedNow.push(...(await loadPackageList([item], callOptions))); }
@@ -186,7 +190,7 @@ async function loadRegistry(entries, options = {}, startup = {}) {
     },
     /** Synchronous: script-pack packages the presentation needs that are not loaded yet. Empty means `ensureScripts` would fetch nothing. `renderOptions` are the `toSvg` options the document resolves with (`catalogs`, ...). */
     pendingScripts(presentation, renderOptions) {
-      const analysis = analyzePresentationScripts(presentation, undefined, renderOptionsFor(renderOptions));
+      const analysis = analyzePresentationScripts(presentation, undefined, renderOptionsFor(renderOptions), scriptMemory);
       const primary = scriptFontPackages(scriptSelectionOf(analysis).scripts).map((item) => item.name).filter((name) => !scriptPackages.has(name));
       if (primary.length) return primary;
       const next = nextFallbackPackage(analysis, { covers, loaded: scriptPackages });
@@ -203,7 +207,7 @@ async function loadRegistry(entries, options = {}, startup = {}) {
   const aliasTargets = new Map(Object.entries(options.aliases ?? {}).map(([from, to]) => [from.toLowerCase(), to]));
   // Face level (FF-41): the faces the document draws, resolved as the registry resolves them with every vendored face loaded.
   // A document that does not resolve throws what `toSvg` throws for it.
-  const neededLazy = (presentation, callOptions) => lazyFacesNeeded(presentation, renderOptionsFor(callOptions), { lazy, held: registry.describeFaces(), loaded: lazyLoaded, policy, aliases: aliasTargets, fallbackFamily: options.fallbackFamily });
+  const neededLazy = (presentation, callOptions) => lazyFacesNeeded(presentation, renderOptionsFor(callOptions), { lazy, held: registry.describeFaces(), loaded: lazyLoaded, policy, aliases: aliasTargets, fallbackFamily: options.fallbackFamily, analysis: fontAnalysis });
   const lazyBaseUrl = () => {
     if (typeof options.lazyFontsBaseUrl !== "string" || !options.lazyFontsBaseUrl)
       throw new OPFFontError("invalid-font-source", "Loading vendored fonts requires lazyFontsBaseUrl, where the host serves the package's fonts directory.");
@@ -360,6 +364,8 @@ export async function loadFonts({ faces = [], subsetWasm, shapeWasm, ...options
     },
     /** Synchronous: the files and script packages `ensure` would fetch. Empty means a render can start now. Throws what `toSvg` throws for a document that does not resolve. */
     pending,
+    /** Counters of the font analysis behind `pending` and `ensure` (slides analyzed, strings scanned), for tests and benchmarks. */
+    get analysisStats() { return registry.analysisStats; },
     dispose: () => registry.dispose(),
   };
 }

package/dist/fonts-node.js

@@ -9,7 +9,7 @@ import { createSubsetter, fontSubsets } from "./font-subset.js";
 import { createShaper } from "./hb-shape.js";
 import { packageRoot, resolveInstalled } from "./node-resolve.js";
 export { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
-import { analyzePresentationScripts, autoScriptSelection, nextFallbackPackage, scriptFontPackages, scriptSelectionOf, uncoveredCjkCharacters } from "./script-font-pack.js";
+import { analyzePresentationScripts, autoScriptSelection, createScriptAnalysis, nextFallbackPackage, scriptFontPackages, scriptSelectionOf, uncoveredCjkCharacters } from "./script-font-pack.js";
 export { autoScriptSelection, detectPresentationScripts, scriptFontPackages } from "./script-font-pack.js";
 // Script faces are embedded in a standalone SVG only when the slide's text uses their family.
 const embedUsed = entries => entries.map(entry => ({...entry, embed: "used"}));
@@ -286,6 +286,8 @@ export async function loadFonts({pack = "base", embedScriptFonts = false, ...opt
   // Calls mutate one registry: serialize their reads/additions, while returning each
   // call's own result or error. A rejection must not poison later preparation.
   let ensureQueue = Promise.resolve();
+  // `pending` is asked before every render: each string is scanned once and each slide's families resolved once (see createScriptAnalysis).
+  const scriptMemory = createScriptAnalysis();
   const refresh = () => { embeddedFonts = undefined; fontFiles = [...registry.fontFiles]; };
   const [subsetter, shaper] = await Promise.all([nodeHarfbuzz("subsets"), nodeHarfbuzz("shaper")]);
   for (const [kind, engine] of [["subsets", subsetter], ["shaper", shaper]]) if (!engine) {
@@ -318,7 +320,7 @@ export async function loadFonts({pack = "base", embedScriptFonts = false, ...opt
     /** Synchronous: the script packages the presentation needs that are not loaded yet. Empty means `ensure` loads nothing. */
     pending(presentation, renderOptions) {
       const held = new Set([...loaded.packages, ...(loaded.selection?.notInstalled ?? [])]);
-      const analysis = analyzePresentationScripts(presentation, undefined, {...options.renderOptions, ...renderOptions});
+      const analysis = analyzePresentationScripts(presentation, undefined, {...options.renderOptions, ...renderOptions}, scriptMemory);
       const primary = scriptFontPackages(scriptSelectionOf(analysis).scripts).map(pkg => pkg.name).filter(name => !held.has(name));
       if (primary.length) return primary;
       const next = nextFallbackPackage(analysis, {covers: character => registry.scriptFacesCover(character), loaded: held});

package/dist/index.d.ts

@@ -295,7 +295,11 @@ export declare class OPFRenderError extends Error {
   constructor(code: string, message: string, details?: Record<string, unknown>);
 }
 
-export declare function resolvePresentation(input: unknown, options?: ToSvgOptions): ResolvedPresentation;
+/**
+ * Resolve a presentation for drawing. `select.slides` (0-based) binds only those slides (each slide is composed on its own); the other entries
+ * of `slides` are then undefined. Without it every slide is bound.
+ */
+export declare function resolvePresentation(input: unknown, options?: ToSvgOptions, select?: { slides?: number[] }): ResolvedPresentation;
 
 /** An SVG slide the renderer drew: its text, or its bytes. */
 export type SvgSlide = string | Uint8Array;

package/dist/lazy-fonts.js

@@ -1,6 +1,7 @@
 import { fontPolicyFor } from "@openpresentation/opf/font-policy";
 import { pickFace } from "./font-registry.js";
-import { resolvePresentation, toSvg } from "./svg.js";
+import { toSvg } from "./svg.js";
+import { deckInternals } from "./svg-internals.js";
 export { lazyFontEntries, lazyFontList } from "./lazy-font-list.js";
 
 /**
@@ -35,10 +36,7 @@ function resolveOptionsOf(options) {
  * `options.catalogs` needs those catalogs here too.
  */
 export function presentationFamilies(presentation, options = {}) {
-  const families = new Set();
-  const resolved = resolvePresentation(presentation, resolveOptionsOf(options));
-  for (const slide of resolved.slides) for (const family of Object.values(slide.design?.fonts ?? {})) if (typeof family === "string" && family) families.add(family);
-  return families;
+  return createFontAnalysis().families(presentation, options);
 }
 
 // A measurement that costs nothing to overflow: text is measured as very narrow, so layout never fails on text that
@@ -81,25 +79,206 @@ function registryView({ faces, policy = "none", aliases = new Map(), fallbackFam
  * @returns {{family: string, weight: number, italic: boolean}[]}
  */
 export function presentationFaces(presentation, options = {}, registry) {
-  const seen = new Map();
-  const resolve = registry ? registryView(registry) : undefined;
-  const settle = style => {
-    if (!resolve) return { ...style };
-    try { return resolve(style); } catch { return { ...style }; }
+  return createFontAnalysis().faces(presentation, options, registry);
+}
+
+const faceKey = (family, weight, italic) => `${lc(family)}\u0000${weight}\u0000${italic}`;
+const byFace = (a, b) => a.family < b.family ? -1 : a.family > b.family ? 1 : Number(a.italic) - Number(b.italic) || a.weight - b.weight;
+
+/**
+ * The measurement `presentationFaces` draws with: it records every style it is asked to measure (resolved through `settle`) into
+ * the map `record.into` holds (switch it to file what follows elsewhere).
+ */
+function recordingMeasurement(settle, into) {
+  const record = { into };
+  record.textMeasurement = {
+    measure(text, size, style) {
+      if (text !== "") {
+        const settled = settle(style), family = settled?.fontFamily;
+        if (typeof family === "string" && family.trim() && !family.startsWith("+")) {
+          const weight = Number.isFinite(settled.fontWeight) ? settled.fontWeight : 400, italic = settled.italic === true;
+          const key = faceKey(family, weight, italic);
+          if (!record.into.has(key)) record.into.set(key, { family, weight, italic });
+        }
+      }
+      return String(text).length * size * RECORDED_EM;
+    },
+    resolveStyle: settle,
   };
-  const record = style => {
-    const family = style?.fontFamily;
-    if (typeof family !== "string" || !family.trim() || family.startsWith("+")) return;
-    const weight = Number.isFinite(style.fontWeight) ? style.fontWeight : 400, italic = style.italic === true;
-    const key = `${lc(family)}\u0000${weight}\u0000${italic}`;
-    if (!seen.has(key)) seen.set(key, { family, weight, italic });
+  return record;
+}
+
+// Stable short tokens for option values: objects by identity (a host passes the same catalog objects on every call; the editor
+// freezes its catalog list), plain values and small plain objects by content.
+const objectTokens = new WeakMap();
+let nextObjectToken = 0;
+function optionToken(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return JSON.stringify(value ?? null);
+  if (Array.isArray(value)) return `[${value.map(optionToken).join(",")}]`;
+  let token = objectTokens.get(value);
+  if (token === undefined) { token = `#${nextObjectToken++}`; objectTokens.set(value, token); }
+  return token;
+}
+// The options a deck resolves with, as a key. `variables` is left out where it cannot change the deck (the editor's views pass `variables:
+// false` or nothing for the same plain deck, which must not analyze it twice).
+function optionsKey(options, presentation) {
+  return Object.keys(options).sort().filter(key => key !== "variables" || !deckInternals.variablesIdle(presentation, options.variables))
+    .map(key => `${JSON.stringify(key)}:${optionToken(options[key])}`).join(",");
+}
+
+/**
+ * Content keys of a deck for the per-slide caches: `context` is everything a slide's drawing reads besides the slide itself (the deck
+ * without its slides, and every slide's section, which furniture can show on other slides; the rule the editor's thumbnail cache
+ * uses), `slides[i]` the slide with its number and the slide count. Keys are taken from the content on every call, never from object
+ * identity, so a host that changes a deck in place is analyzed right. Undefined for input that is not a plain deck object (JSON
+ * text, bytes, a deck without a slide list or one JSON cannot write): such input is analyzed whole, as `toSvg` draws it.
+ */
+export function deckKeys(presentation) {
+  if (presentation === null || typeof presentation !== "object" || ArrayBuffer.isView(presentation) || !Array.isArray(presentation.slides)) return undefined;
+  try {
+    const { slides, ...metadata } = presentation;
+    return {
+      context: JSON.stringify([metadata, slides.map(slide => slide?.section ?? null)]),
+      slides: slides.map((slide, index) => `${index}/${slides.length}/${JSON.stringify(slide) ?? ""}`),
+    };
+  } catch { return undefined; }
+}
+
+/**
+ * Per-slide results kept between calls: a few contexts (least recently used first out) and, in each, the slides most recently asked
+ * for, up to twice the deck's slides (a host that alternates a document and a draft of it keeps both).
+ */
+function slideMemory(contexts = 8) {
+  const byContext = new Map();
+  return (context, slides) => {
+    let entries = byContext.get(context);
+    if (entries) byContext.delete(context);
+    else entries = new Map();
+    byContext.set(context, entries);
+    while (byContext.size > contexts) byContext.delete(byContext.keys().next().value);
+    const limit = 2 * slides + 16;
+    return {
+      get(key) {
+        const value = entries.get(key);
+        if (value !== undefined) { entries.delete(key); entries.set(key, value); }
+        return value;
+      },
+      set(key, value) {
+        entries.set(key, value);
+        while (entries.size > limit) entries.delete(entries.keys().next().value);
+      },
+    };
   };
-  const textMeasurement = {
-    measure(text, size, style) { if (text !== "") record(settle(style)); return String(text).length * size * RECORDED_EM; },
-    resolveStyle: settle,
+}
+
+/**
+ * `presentationFaces` and `presentationFamilies` with memory, for a fonts handle that is asked again and again (FF-41; the 0.28.0
+ * startup regression). Each slide's result is kept by the slide's content, and a call analyzes only the slides whose content,
+ * number or slide count changed: `faces` composes and draws just those slides with the recording measurement, `families` resolves
+ * just their designs. Everything else a slide's result depends on (the rest of the deck, every slide's section, the render
+ * options and, for faces, the registry view) is the cache's context: a change there analyzes every slide again. The results are
+ * the ones `presentationFaces` and `presentationFamilies` give, errors included: a deck not checked before is opened (resolved and
+ * checked) even when every slide is known, and a slide that fails throws what `toSvg` throws for it (only slides that succeed are
+ * kept).
+ *
+ * `stats` counts the work, for tests and benchmarks: `decks` (decks opened), `slides` (slides composed and drawn for faces) and
+ * `designs` (slide designs resolved for families).
+ */
+export function createFontAnalysis() {
+  const memory = slideMemory(), stats = { decks: 0, slides: 0, designs: 0 }, checked = new Set();
+  // The deck behind `keys`, opened (resolved and checked as `toSvg` does) when work is needed or this exact deck was never checked.
+  const opener = (presentation, resolveOptions, keys, optionsToken) => {
+    const whole = `${optionsToken}\u0001${keys.context}\u0001${keys.slides.join("\u0001")}`;
+    let deck;
+    const open = () => {
+      if (!deck) {
+        deck = deckInternals.openDeck(presentation, resolveOptions);
+        stats.decks++;
+        checked.delete(whole);
+        checked.add(whole);
+        while (checked.size > 8) checked.delete(checked.keys().next().value);
+      }
+      return deck;
+    };
+    return { open, check: () => { if (!checked.has(whole)) open(); } };
   };
-  toSvg(presentation, { ...resolveOptionsOf(options), fonts: { textMeasurement } });
-  return [...seen.values()].sort((a, b) => a.family < b.family ? -1 : a.family > b.family ? 1 : Number(a.italic) - Number(b.italic) || a.weight - b.weight);
+
+  function faces(presentation, options = {}, registry) {
+    const resolveOptions = resolveOptionsOf(options);
+    if (registry) registry = { ...registry, faces: [...registry.faces] };
+    const view = registry ? registryView(registry) : undefined;
+    const settle = style => {
+      if (!view) return { ...style };
+      try { return view(style); } catch { return { ...style }; }
+    };
+    const keys = deckKeys(presentation);
+    if (!keys) {
+      // Not a deck object: one whole-deck pass, kept nowhere.
+      const seen = new Map();
+      toSvg(presentation, { ...resolveOptions, fonts: { textMeasurement: recordingMeasurement(settle, seen).textMeasurement } });
+      stats.decks++;
+      return [...seen.values()].sort(byFace);
+    }
+    const optionsToken = optionsKey(resolveOptions, presentation);
+    const slides = memory(`faces\u0001${optionsToken}\u0001${registry ? registryKey(registry) : ""}\u0001${keys.context}`, keys.slides.length);
+    const deck = opener(presentation, resolveOptions, keys, optionsToken);
+    const entries = keys.slides.map(slides.get);
+    const missing = entries.flatMap((entry, index) => entry === undefined ? [index] : []);
+    if (missing.length) {
+      // Composition of the slides, then their drawing, as `toSvg` runs them.
+      const opened = deck.open();
+      const made = new Map(missing.map(index => [index, { composed: new Map(), drawn: new Map() }]));
+      const recorders = new Map(missing.map(index => [index, recordingMeasurement(settle, made.get(index).composed)]));
+      for (const index of missing) opened.bind(index, recorders.get(index).textMeasurement);
+      // A slide is drawn with the measurement it was composed with; what it measures from here on is its drawing. `skipHidden`
+      // leaves hidden slides undrawn (they are still composed), as in `toSvg`.
+      for (const index of missing) {
+        if (resolveOptions.skipHidden === true && opened.presentation.slides[index]?.hidden === true) continue;
+        recorders.get(index).into = made.get(index).drawn;
+        opened.render(index);
+      }
+      for (const [index, entry] of made) { slides.set(keys.slides[index], entry); entries[index] = entry; }
+      stats.slides += missing.length;
+    } else deck.check();
+    // In the order one `toSvg` records them: every slide's composition, then every slide's drawing.
+    const seen = new Map();
+    for (const phase of ["composed", "drawn"]) for (const entry of entries) for (const [key, face] of entry[phase]) if (!seen.has(key)) seen.set(key, face);
+    return [...seen.values()].sort(byFace).map(face => ({ ...face }));
+  }
+
+  function families(presentation, options = {}) {
+    const resolveOptions = resolveOptionsOf(options);
+    const familiesOf = design => Object.values(design?.fonts ?? {}).filter(family => typeof family === "string" && family);
+    const keys = deckKeys(presentation);
+    let entries;
+    if (!keys) {
+      const opened = deckInternals.openDeck(presentation, resolveOptions);
+      stats.decks++;
+      entries = opened.presentation.slides.map((_, index) => familiesOf(opened.design(index)));
+      stats.designs += entries.length;
+    } else {
+      const optionsToken = optionsKey(resolveOptions, presentation);
+      const slides = memory(`families\u0001${optionsToken}\u0001${keys.context}`, keys.slides.length);
+      const deck = opener(presentation, resolveOptions, keys, optionsToken);
+      entries = keys.slides.map(slides.get);
+      const missing = entries.flatMap((entry, index) => entry === undefined ? [index] : []);
+      if (missing.length) {
+        const opened = deck.open();
+        // The design as drawing binds it, without composing the slide (composing every slide with the default measurement made
+        // this the slowest step of a browser font check in 0.28.0).
+        for (const index of missing) { entries[index] = familiesOf(opened.design(index)); slides.set(keys.slides[index], entries[index]); }
+        stats.designs += missing.length;
+      } else deck.check();
+    }
+    return new Set(entries.flat());
+  }
+
+  return { faces, families, stats };
+}
+
+function registryKey({ faces, policy = "none", aliases = new Map(), fallbackFamily }) {
+  // Every field `pickFace` reads, as it reads them (`italic` is compared with ===, `fallbackOnly` and `scripts` by truth).
+  return JSON.stringify([faces.map(face => [face.family, face.familyGroup ?? face.family, face.weight ?? null, face.italic ?? null, !!face.fallbackOnly, !!face.scripts]), policy, [...aliases], fallbackFamily ?? null]);
 }
 
 /**
@@ -108,11 +287,13 @@ export function presentationFaces(presentation, options = {}, registry) {
  * (`registry.describeFaces()`), `loaded` the lazy files already loaded; `policy`, `aliases` and `fallbackFamily` are the
  * registry's. `renderOptions` are the `toSvg` options the document resolves with (`catalogs`, ...), and a document that
  * does not resolve throws what `toSvg` throws for it. Face level: a bold or italic run added by an edit adds just that face.
+ * Pass `analysis` (`createFontAnalysis()`) to keep each slide's faces between calls: then only slides that changed are analyzed.
  */
-export function lazyFacesNeeded(presentation, renderOptions, { lazy, held, loaded = new Set(), policy = "none", aliases = new Map(), fallbackFamily }) {
+export function lazyFacesNeeded(presentation, renderOptions, { lazy, held, loaded = new Set(), policy = "none", aliases = new Map(), fallbackFamily, analysis }) {
   const heldFaces = [...held], heldKeys = new Set(heldFaces.map(faceKeyOf));
   const missing = lazy.filter(face => !heldKeys.has(faceKeyOf(face)) && !loaded.has(face.file));
-  const drawn = new Set(presentationFaces(presentation, renderOptions, { faces: [...heldFaces, ...missing], policy, aliases, fallbackFamily }).map(faceKeyOf));
+  // `analysis` (from `createFontAnalysis`) keeps each slide's faces between calls, so a fonts handle redoes only changed slides.
+  const drawn = new Set((analysis ?? createFontAnalysis()).faces(presentation, renderOptions, { faces: [...heldFaces, ...missing], policy, aliases, fallbackFamily }).map(faceKeyOf));
   return missing.filter(face => drawn.has(faceKeyOf(face)));
 }
 function faceKeyOf(face) { return `${lc(face.family)}\u0000${face.weight}\u0000${!!face.italic}`; }

package/dist/script-font-pack.js

@@ -5,7 +5,7 @@ import { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
 import { OPFFontError } from "./font-registry.js";
 import { SCRIPT_FONT_REPLACEMENTS, glyphFallbackFamilies, scriptOfCharacter, scriptsOfText } from "./script-fonts.js";
 import { resolveScriptFonts } from "@openpresentation/opf/composition";
-import { presentationFamilies } from "./lazy-fonts.js";
+import { createFontAnalysis } from "./lazy-fonts.js";
 import { SYMBOL_SCRIPT, isSymbolEncodedFamily } from "./symbol-fonts.js";
 
 const SCRIPT_ALIASES = Object.freeze({Hira: "Jpan", Kana: "Jpan", Hrkt: "Jpan", Hang: "Kore", Hani: "Hans", Zyyy: "Latn"});
@@ -134,7 +134,7 @@ function scriptOfFamily(family) {
  * unchanged, and the families the renderer resolves per slide count too, so a scheme that exists only in the host's catalogs
  * and names a script font still loads that font.
  */
-function designScripts(presentation, profile, renderOptions) {
+function designScripts(presentation, profile, renderOptions, memory) {
   const scripts = new Set();
   let han;
   const note = resolved => {
@@ -153,7 +153,7 @@ function designScripts(presentation, profile, renderOptions) {
     });
   }
   if (renderOptions?.catalogs) {
-    for (const family of presentationFamilies(presentation, renderOptions)) note({ heading: { latin: family }, body: { latin: family } });
+    for (const family of memory.fonts.families(presentation, renderOptions)) note({ heading: { latin: family }, body: { latin: family } });
   }
   // FF-45: a run or design that names a symbol-encoded family (a Wingdings bullet run, a Symbol heading) needs the symbol faces.
   for (const family of namedFontFamilies(presentation)) if (isSymbolEncodedFamily(family)) scripts.add(SYMBOL_SCRIPT);
@@ -179,19 +179,62 @@ function* namedFontFamilies(value, key) {
  * `toSvg` options) matter only for font schemes the host supplies in `renderOptions.catalogs`, which then resolve
  * like the renderer resolves them; a document that then does not resolve throws what `toSvg` throws for it.
  */
-export function analyzePresentationScripts(presentation, profile, renderOptions) {
+export function analyzePresentationScripts(presentation, profile, renderOptions, memory = createScriptAnalysis()) {
   profile ??= presentationScriptProfile(presentation, renderOptions);
   const scripts = new Set(), cjk = new Set();
-  const design = designScripts(presentation, profile, renderOptions);
+  const design = designScripts(presentation, profile, renderOptions, memory);
   // Han-only text in a deck whose language is not CJK draws with the scheme's own CJK face when the scheme names one.
   const itemizing = design.han && !cjkKeys.includes(profile?.script) ? { ...profile, script: design.han } : profile;
+  const scan = memory.scanner(itemizing);
   for (const text of drawnStrings(presentation)) {
-    for (const script of scriptsOfText(text, itemizing)) scripts.add(script);
-    for (const character of text) if (character.codePointAt(0) > 0x2E7F && cjkCharacters.has(scriptOfCharacter(character))) cjk.add(character);
+    const found = scan(text);
+    for (const script of found.scripts) scripts.add(script);
+    for (const character of found.cjk) cjk.add(character);
   }
   return { profile, detected: [...scripts].sort(), design: design.scripts, cjk };
 }
 
+/** One string's scripts (`scriptsOfText`) and the Han, kana and Hangul characters it draws, in order. One pass over the characters. */
+function scanText(text, itemizing) {
+  const cjk = [];
+  for (const character of text) if (character.codePointAt(0) > 0x2E7F && cjkCharacters.has(scriptOfCharacter(character))) cjk.push(character);
+  return { scripts: scriptsOfText(text, itemizing), cjk };
+}
+
+const STRING_MEMORY_LIMIT = 65536;
+
+/**
+ * Memory for `analyzePresentationScripts`, for a fonts handle that analyzes the same deck again and again (the 0.28.0 startup
+ * regression): each drawn string is scanned once per itemizing profile (the document language decides how Han text and East
+ * Asian punctuation itemize), and the font families of the deck's slides come from a `createFontAnalysis` that redoes only
+ * changed slides. Pass the handle's own `fonts` analysis to share its slide memory. `stats.strings` counts the strings scanned.
+ */
+export function createScriptAnalysis({ fonts = createFontAnalysis() } = {}) {
+  const byProfile = new Map(), stats = { strings: 0 };
+  return {
+    fonts,
+    stats,
+    scanner(itemizing) {
+      const key = JSON.stringify(itemizing ?? null) ?? "null";
+      let seen = byProfile.get(key);
+      if (!seen) {
+        if (byProfile.size >= 4) byProfile.delete(byProfile.keys().next().value);
+        byProfile.set(key, seen = new Map());
+      }
+      return text => {
+        let found = seen.get(text);
+        if (found === undefined) {
+          found = scanText(text, itemizing);
+          stats.strings++;
+          if (seen.size >= STRING_MEMORY_LIMIT) seen.clear();
+          seen.set(text, found);
+        }
+        return found;
+      };
+    },
+  };
+}
+
 /**
  * Script keys (ISO 15924: `Jpan`, `Hans`, `Arab`, ...) whose faces a preview of this presentation needs.
  * Text decides, itemized exactly as drawing does: the document language only tells Han text apart

package/dist/script-fonts.js

@@ -181,9 +181,18 @@ const latinGroup = new Set(["Latn", "Cyrl", "Grek", "Zyyy", "Zinh", "Zzzz"]);
 
 const detected = ["Latn", "Cyrl", "Grek", "Hani", "Hira", "Kana", "Hang", "Bopo", "Yiii", "Arab", "Hebr", "Syrc", "Thaa", "Nkoo", "Adlm", "Rohg", "Mand", "Samr",
   "Deva", "Beng", "Guru", "Gujr", "Orya", "Taml", "Telu", "Knda", "Mlym", "Sinh", "Thai", "Laoo", "Tibt", "Mymr", "Khmr", "Mong", "Bali", "Java", "Lana",
-  "Tale", "Talu", "Cakm", "Olck", "Armn", "Geor", "Ethi", "Cher", "Tfng", "Vaii", "Zinh", "Zyyy"].map(code => [code, new RegExp(String.raw`^\p{Script=${code}}$`, "u")]);
+  "Tale", "Talu", "Cakm", "Olck", "Armn", "Geor", "Ethi", "Cher", "Tfng", "Vaii", "Zinh", "Zyyy"];
+// One precompiled pattern for every script, a capture group each, tried in the list's order (the first match wins, as with one
+// pattern per script): a character is classified by one match instead of up to 48 tests.
+const detectedPattern = new RegExp(`^(?:${detected.map(code => String.raw`(\p{Script=${code}})`).join("|")})$`, "u");
 const ignorable = /^\p{Default_Ignorable_Code_Point}$/u;
 const scriptCache = new Map();
+function classify(character) {
+  const match = detectedPattern.exec(character);
+  if (!match) return "Zzzz";
+  for (let group = 1; group < match.length; group++) if (match[group] !== undefined) return detected[group - 1];
+  return "Zzzz";
+}
 
 /** ISO 15924 script of one character: `Zyyy` common, `Zinh` inherited, `Zzzz` otherwise unknown. */
 export function scriptOfCharacter(character) {
@@ -192,7 +201,7 @@ export function scriptOfCharacter(character) {
     const code = character.codePointAt(0);
     script = code < 0x80 ? (/[A-Za-z]/.test(character) ? "Latn" : "Zyyy")
       : ignorable.test(character) ? "Zinh"
-        : (detected.find(([, pattern]) => pattern.test(character))?.[0] ?? "Zzzz");
+        : classify(character);
     if (scriptCache.size < 65536) scriptCache.set(character, script);
   }
   return script;
@@ -214,10 +223,10 @@ function hanScript(text, profile) {
   return "Hans";
 }
 
-function fontKey(script, text, profile) {
+function fontKey(script, text, profile, han = () => hanScript(text, profile)) {
   if (script === "Hira" || script === "Kana") return "Jpan";
   if (script === "Hang") return "Kore";
-  if (script === "Hani" || script === "Bopo") return hanScript(text, profile);
+  if (script === "Hani" || script === "Bopo") return han();
   return latinGroup.has(script) ? "Latn" : script;
 }
 
@@ -251,6 +260,9 @@ export function itemizeScripts(text, profile) {
   const runs = [];
   let pending = "";
   const eastAsian = eastAsianLanguage(profile);
+  // The Han key depends on the whole text and the profile only: work it out once per text, not once per Han character.
+  let han;
+  const hanOfText = () => han ??= hanScript(source, profile);
   const push = (character, key) => {
     const last = runs.at(-1);
     if (last && last.script === key) last.text += character;
@@ -268,7 +280,7 @@ export function itemizeScripts(text, profile) {
   for (const character of source) {
     const script = scriptOfCharacter(character);
     if (eastAsianCommon.test(character) || (eastAsian && eastAsianAmbiguous.test(character))) {
-      strong(character, script === "Hira" || script === "Kana" ? "Jpan" : hanScript(source, profile));
+      strong(character, script === "Hira" || script === "Kana" ? "Jpan" : hanOfText());
     } else if (script === "Zinh") {
       if (runs.length) runs.at(-1).text += character; else pending += character;
     } else if (script === "Zyyy") {
@@ -276,7 +288,7 @@ export function itemizeScripts(text, profile) {
       if (!last) pending += character;
       else if (character.codePointAt(0) < 0x80 && last.role === "eastAsian") push(character, "Latn");
       else last.text += character;
-    } else strong(character, fontKey(script, source, profile));
+    } else strong(character, fontKey(script, source, profile, hanOfText));
   }
   if (!runs.length) return [{text: pending, script: "Latn", role: "latin"}];
   return runs;

package/dist/svg-internals.js

@@ -0,0 +1,3 @@
+// Hooks svg.js fills in for the renderer's own modules (the font analysis in lazy-fonts.js). They are not part of the package API:
+// index.js re-exports svg.js, so internals live here instead of as exports there.
+export const deckInternals = {};

package/dist/svg.d.ts

@@ -190,7 +190,11 @@ export declare class OPFRenderError extends Error {
   constructor(code: string, message: string, details?: Record<string, unknown>);
 }
 
-export declare function resolvePresentation(input: unknown, options?: ToSvgOptions): ResolvedPresentation;
+/**
+ * Resolve a presentation for drawing. `select.slides` (0-based) binds only those slides (each slide is composed on its own); the other entries
+ * of `slides` are then undefined. Without it every slide is bound.
+ */
+export declare function resolvePresentation(input: unknown, options?: ToSvgOptions, select?: { slides?: number[] }): ResolvedPresentation;
 
 /** An SVG slide the renderer drew: its text, or its bytes. */
 export type SvgSlide = string | Uint8Array;

package/dist/svg.js

@@ -27,6 +27,7 @@ import { renderCaption, renderFootnotes } from "./annotations.js";
 import { drawnFaces } from "./drawn-faces.js";
 import { dataUrlFsType, embeddingAllowed } from "./font-fstype.js";
 import { rejectRenamedOptions, selectSlides } from "./slide-sources.js";
+import { deckInternals } from "./svg-internals.js";
 
 export const packageName = "@openpresentation/opf-render";
 
@@ -641,18 +642,21 @@ function normalizeOptions(options) {
  * Resolve a presentation for drawing: template variables filled, the boundary check passed, and every slide bound to its
  * layout, design, script fonts and composed geometry. `toSvg` draws from this.
  */
-export function resolvePresentation(input, options = {}) {
-  return resolveDeck(input, normalizeOptions(options));
+export function resolvePresentation(input, options = {}, { slides } = {}) {
+  return resolveDeck(input, normalizeOptions(options), Array.isArray(slides) ? () => new Set(slides) : undefined);
 }
 
-function resolveDeck(input, options) {
+// `wanted(count)` names the 0-based slides to bind (CE-20): a slide is composed on its own, so drawing one slide of a long deck binds that slide
+// only, and the others are left undefined. Without it every slide is bound.
+function resolveDeck(input, options, wanted) {
   const presentation = resolveTemplateInput(parseInput(input), options);
   if (options.validate !== false) {
     assertValidBoundary(presentation, options);
   }
 
   const context = { presentation, options };
-  const slides = presentation.slides.map((_, index) => bindSlide(presentation, index, context));
+  const only = wanted?.(presentation.slides.length);
+  const slides = presentation.slides.map((_, index) => (only && !only.has(index) ? undefined : bindSlide(presentation, index, context)));
 
   return {
     presentation,
@@ -670,7 +674,11 @@ function resolveDeck(input, options) {
 export function toSvg(input, slides, options) {
   if (slides !== null && typeof slides === "object" && !Array.isArray(slides)) { options = slides; slides = undefined; }
   const drawn = normalizeOptions(options ?? {});
-  const resolved = resolveDeck(input, drawn);
+  // Only the slides drawn are bound (the whole deck when every slide is drawn).
+  const resolved = resolveDeck(input, drawn, slides === undefined ? undefined : (count) => {
+    if (typeof slides === "number") return new Set([slides - 1]);
+    try { return new Set(selectSlides(slides, count).map((number) => number - 1)); } catch { return new Set(); }
+  });
   const count = resolved.slides.length;
   if (typeof slides === "number") {
     if (!Number.isInteger(slides) || slides < 1 || slides > count) throw new OPFRenderError("slide-out-of-range", `Slide ${slides} is not in the presentation, which has ${count} slide${count === 1 ? "" : "s"} (slides count from 1).`, { slide: slides, slideCount: count });
@@ -2280,3 +2288,34 @@ function tag(name, attrs = {}, children = "") {
   if (children === "") return `<${name}${serializedAttrs}/>`;
   return `<${name}${serializedAttrs}>${children}</${name}>`;
 }
+
+// For the renderer's own font analysis (lazy-fonts.js), not part of the package API (index.js re-exports this module): `openDeck`
+// opens the deck once (the parsing, template variables and boundary check of `toSvg`) and works on single slides on request, so an
+// analysis can redo only the slides that changed. Binding and drawing a slide read the deck and that slide only (its number and
+// the slide count included), never another slide's binding.
+// - `design(index)` is the slide's design as `bindSlide` resolves it, without composing the slide. Its font families do not depend
+//   on composition: without a measurement (the analysis passes none) the drawn families are the scheme's.
+// - `bind(index, textMeasurement)` composes the slide with that measurement, which `render(index)` then draws with too, exactly as
+//   `toSvg` measures each slide.
+// - `variablesIdle(deck, variables)`: the `variables` option leaves this deck as it is (a deck that is no template and has no content
+//   variables, with `variables` false, absent or empty; see `resolveTemplateInput`), so an analysis need not tell those options apart.
+deckInternals.variablesIdle = (input, variables) =>
+  isPlainObject(input) && (variables === undefined || variables === false || (isPlainObject(variables) && !Object.keys(variables).length)) && !isTemplate(input) && !hasContentVariables(input);
+deckInternals.openDeck = (input, options = {}) => {
+  const drawn = normalizeOptions(options);
+  const presentation = resolveTemplateInput(parseInput(input), drawn);
+  if (drawn.validate !== false) assertValidBoundary(presentation, drawn);
+  const resolved = { presentation, engineDefaults, slides: [] }, measurements = [];
+  return {
+    presentation,
+    design(index) {
+      const slideContext = resolveContext(presentation, index, { presentation, options: drawn });
+      return resolveDesign(presentation, slideContext.slide, slideContext);
+    },
+    bind(index, textMeasurement = drawn.textMeasurement) {
+      measurements[index] = textMeasurement;
+      resolved.slides[index] = bindSlide(presentation, index, { presentation, options: { ...drawn, textMeasurement } });
+    },
+    render(index) { return renderResolvedSlide(resolved, index, { ...drawn, textMeasurement: measurements[index] }); },
+  };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-render",
-  "version": "0.28.0",
+  "version": "0.29.1",
   "description": "Deterministic local OPF renderer for SVG, PNG, and PDF output.",
   "license": "MIT",
   "type": "module",
@@ -94,7 +94,7 @@
     "fontkit": "^2.0.4",
     "harfbuzzjs": "1.6.4",
     "pako": "3.0.2",
-    "@openpresentation/opf": "^0.28.0"
+    "@openpresentation/opf": "^0.29.1"
   },
   "peerDependencies": {
     "@expo-google-fonts/arimo": "0.4.3",
@@ -343,7 +343,7 @@
     "pdfjs-dist": "6.4.299",
     "playwright": "1.64.1",
     "sharp": "0.35.5",
-    "@openpresentation/gallery": "0.28.0"
+    "@openpresentation/gallery": "0.29.1"
   },
   "bin": {
     "opf-preview-fonts": "./dist/preview-fonts-cli.js"
@@ -399,5 +399,5 @@
     "test:preview-a11y-browser": "node test/preview-a11y-browser.mjs",
     "test:forced-colors-browser": "node test/forced-colors-browser.mjs artifacts/forced-colors"
   },
-  "gitHead": "abc56634a584db38a305a27edc3bc76b4116637b"
+  "gitHead": "e9f46c24606ce0f474347b984eacea5dce7fd839"
 }