@openpresentation/opf-render 0.17.1 → 0.18.1

package/dist/deck-runtime.js

@@ -1,9 +1,9 @@
 // RR-28: the part of the slideshow player and the <opf-deck> element that has no DOM of its own. It reads an OPF document,
-// decides which slides play (hidden ones do not), renders each slide once with the renderer's own SVG output (renderSlideSvg:
+// decides which slides play (hidden ones do not), renders each slide once with the renderer's own SVG output (toSvg:
 // there is no second layout engine) behind a face-level font gate, and synchronizes windows over a BroadcastChannel.
 // Nothing here fetches anything but the font files the host's font root serves.
 import { resolveSlideVariables } from "@openpresentation/opf";
-import { renderSlideSvg } from "./svg.js";
+import { toSvg } from "./svg.js";
 
 /** Error raised for a deck that cannot be read, rendered or loaded. */
 export class DeckError extends Error {
@@ -206,7 +206,7 @@ export function createFontGate(fonts) {
 
 /**
  * One deck's rendering, shared by the element, the full-screen player and the speaker view: font loading once, each slide
- * rendered once by `renderSlideSvg` and kept, so moving between slides never draws twice and every surface shows the same markup.
+ * rendered once by `toSvg` and kept, so moving between slides never draws twice and every surface shows the same markup.
  *
  * `fonts` is a browser fonts handle (or nothing: layout then uses estimated widths and the visitor's system sans-serif).
  */
@@ -237,7 +237,7 @@ export function createDeckStore({ document, fonts, renderOptions = {}, date } =
       let svg = cache.get(index);
       if (svg === undefined) {
         try {
-          svg = renderSlideSvg(deck, index, { ...options(), validate: !validated });
+          svg = toSvg(deck, index + 1, { ...options(), validate: !validated });
         } catch (cause) {
           if (cause instanceof DeckError) throw cause;
           // A document the schema rejects says where: the first finding's path and message.

package/dist/element.d.ts

@@ -1,6 +1,6 @@
 import type { BrowserFontsHandle } from "./fonts-browser.js";
 import type { RenderFonts } from "./fonts.js";
-import type { RenderSvgOptions } from "./svg.js";
+import type { SlideSelection, ToSvgOptions } from "./svg.js";
 import type { PlayerSession, PresentOptions, PlayerSlideChange } from "./player.js";
 export { DeckError } from "./player.js";
 export { loadPreviewFonts, previewBaseFaces, previewFontLayout } from "./preview-fonts.js";
@@ -43,8 +43,8 @@ export interface OpfDeckElement extends HTMLElement {
    * attribute's URL (an empty string without either).
    */
   fonts: string | BrowserFontsHandle;
-  /** Extra `renderSlideSvg` options (catalogs, imageResolver, date, ...). Set before the deck loads, or call `reload()`. */
-  renderOptions: Partial<RenderSvgOptions>;
+  /** Extra `toSvg` options (catalogs, imageResolver, date, ...). Set before the deck loads, or call `reload()`. */
+  renderOptions: Partial<ToSvgOptions>;
   includeHidden: boolean;
   thumbnails: boolean;
   readonly ready: Promise<void>;
@@ -66,10 +66,8 @@ export declare function getOpfDeckElement(): { new (): OpfDeckElement; readonly
 /** Register `<opf-deck>` (or another tag name). Safe to call twice and on a server, where it does nothing. */
 export declare function defineOpfDeck(tagName?: string): CustomElementConstructor | undefined;
 
-export interface RenderDeckHtmlOptions {
+export interface ToHtmlOptions {
   tagName?: string;
-  /** `"first"` (default: the first slide and a list of titles), `"all"`, or 1-based slide numbers. */
-  slides?: "first" | "all" | readonly number[];
   includeHidden?: boolean;
   src?: string;
   slide?: number;
@@ -86,11 +84,16 @@ export interface RenderDeckHtmlOptions {
   embed?: boolean;
   /** Today's date (ISO) for `date: true` furniture. */
   date?: string;
-  renderOptions?: Partial<RenderSvgOptions>;
+  renderOptions?: Partial<ToSvgOptions>;
 }
 
-/** Server-side markup: the deck's slides as inline SVG inside the tag, shown as is without JavaScript and replaced when the element upgrades. */
-export declare function renderDeckHtml(document: unknown, options?: RenderDeckHtmlOptions): string;
+/**
+ * Server-side markup (RR-73): the deck's slides as inline SVG inside the tag, shown as is without JavaScript and replaced when the
+ * element upgrades. `toHtml(deck)` draws the first slide and a list of titles; `toHtml(deck, 3)`, `toHtml(deck, "1-3")` (`"1-"` for
+ * every slide) or `toHtml(deck, [1, 3])` draw those slides of the presented sequence, counting from 1.
+ */
+export declare function toHtml(document: unknown, options?: ToHtmlOptions): string;
+export declare function toHtml(document: unknown, slides: SlideSelection, options?: ToHtmlOptions): string;
 
 declare global {
   interface HTMLElementTagNameMap { "opf-deck": OpfDeckElement }

package/dist/element.js

@@ -1,4 +1,4 @@
-// RR-28: <opf-deck>, a framework-free web component that embeds an OPF deck. It draws the renderer's own SVG (renderSvg), so
+// RR-28: <opf-deck>, a framework-free web component that embeds an OPF deck. It draws the renderer's own SVG (toSvg), so
 // the slide a page shows is the slide the preview, the editor and the PDF show. Importing this module touches no DOM, so it
 // is safe on a server (Next.js); `defineOpfDeck()` registers the tag in a browser.
 import {
@@ -6,8 +6,9 @@ import {
   prepareSlideSvg, sanitizeSvgTree, slideInfo, slideLabel, svgDimensions, plainText,
 } from "./deck-runtime.js";
 import { loadPreviewFonts } from "./preview-fonts.js";
-import { renderSlideSvg } from "./svg.js";
+import { toSvg } from "./svg.js";
 import { drawnFaces } from "./drawn-faces.js";
+import { selectSlides, slideArguments } from "./slide-sources.js";
 
 export { DeckError } from "./deck-runtime.js";
 export { loadPreviewFonts, previewBaseFaces, previewFontLayout } from "./preview-fonts.js";
@@ -36,17 +37,22 @@ button[aria-disabled="true"] { opacity: 0.45; cursor: default; }
 .counter { min-width: 4.5em; text-align: center; font-variant-numeric: tabular-nums; }
 .thumbs-wrap { min-width: 0; }
 .thumbs { position: relative; display: flex; gap: 8px; margin: 0; padding: 4px 2px; list-style: none; overflow-x: auto; scroll-snap-type: x proximity; }
-.thumbs li { flex: 0 0 auto; width: 132px; scroll-snap-align: center; }
-.thumb { display: block; width: 100%; padding: 0; min-height: 0; overflow: hidden; background: var(--opf-deck-stage, #f1f1f1); }
+.thumbs li { position: relative; flex: 0 0 auto; width: 132px; scroll-snap-align: center; }
+.thumbs .frame { display: block; box-sizing: content-box; aspect-ratio: var(--ratio, 16 / 9); overflow: hidden; border: 1px solid transparent; border-radius: var(--opf-deck-radius, 6px); background: var(--opf-deck-stage, #f1f1f1); }
+.thumbs .frame svg.opf-slide { display: block; width: 100%; height: 100%; pointer-events: none; }
+.thumb, .thumbs .thumb:hover { position: absolute; inset: 0; width: 100%; height: 100%; padding: 0; min-height: 0; background: transparent; }
 .thumb[aria-current="true"] { outline: 3px solid var(--opf-deck-accent, Highlight); outline-offset: 0; }
-.thumb .frame { display: block; width: 100%; aspect-ratio: var(--ratio, 16 / 9); }
-.thumb svg.opf-slide { display: block; width: 100%; height: 100%; pointer-events: none; }
 .sr-only { position: absolute; width: 1px; height: 1px; margin: -1px; padding: 0; overflow: hidden; clip-path: inset(50%); white-space: nowrap; border: 0; }
 .flip { display: inline-block; }
 .rtl .flip { transform: scaleX(-1); }
 .rtl .bar, .rtl .thumbs { direction: rtl; }
 @media (prefers-reduced-motion: no-preference) { button { transition: background-color 120ms; } }
-@media (forced-colors: active) { .viewport, button, .thumb[aria-current="true"] { border-color: CanvasText; } .thumb[aria-current="true"] { outline-color: Highlight; } }
+@media (forced-colors: active) {
+  .viewport, button, .thumb[aria-current="true"] { border-color: CanvasText; }
+  .thumb[aria-current="true"] { outline-color: Highlight; }
+  /* A disabled control is drawn in GrayText at full opacity: fading would blend its frame and its focus ring into Canvas. */
+  button[aria-disabled="true"] { opacity: 1; color: GrayText; border-color: GrayText; }
+}
 `;
 
 const supportsCustomElements = () => typeof customElements !== "undefined" && typeof HTMLElement !== "undefined";
@@ -140,7 +146,7 @@ function createElementClass() {
       if (had && before === this.getAttribute("fonts") && this.isConnected && this.#built) this.#start();
     }
 
-    /** Extra `renderSvg` options (catalogs, imageResolver, date, ...). Set before the deck loads, or call `reload()`. */
+    /** Extra `toSvg` options (catalogs, imageResolver, date, ...). Set before the deck loads, or call `reload()`. */
     get renderOptions() { return this.#renderOptions; }
     set renderOptions(value) { this.#renderOptions = value && typeof value === "object" ? value : {}; }
 
@@ -455,13 +461,15 @@ function createElementClass() {
         button.setAttribute("part", "thumbnail");
         button.setAttribute("aria-label", `Go to ${slideLabel(info, position + 1, sequence.length)}`);
         button.tabIndex = position === cursor.position ? 0 : -1;
+        // The drawing is a sibling under the button, not its content: the slide's own text is not the button's visible
+        // label (axe label-content-name-mismatch, WCAG 2.5.3), and the button's name is the slide's label. The button
+        // stays the first child (#markThumbnail) and covers the drawing (CSS), so it takes every click.
         const frame = doc.createElement("span");
         frame.className = "frame";
         frame.style.setProperty("--ratio", `${first.width} / ${first.height}`);
         frame.setAttribute("aria-hidden", "true");
-        button.append(frame);
         button.addEventListener("click", () => { this.#announce = true; this.#go(() => this.#cursor?.goto(position + 1)); });
-        li.append(button);
+        li.append(button, frame);
         li._frame = frame; li._index = index;
         return li;
       });
@@ -513,21 +521,22 @@ const escapeHtml = (value) => String(value).replace(/&/g, "&amp;").replace(/</g,
  * `/fonts-browser`, or one with a `textMeasurement` and `embeddedFonts`). A `fonts` string is the font root URL written to the
  * element's `fonts` attribute.
  *
- * `slides`: `"first"` (default: the first slide plus a list of titles), `"all"` or a list of 1-based slide numbers.
- * `embed` puts the document in an `application/opf+json` script child, so the element upgrades without a request.
+ * `toHtml(deck)` draws the first slide plus a list of titles; `toHtml(deck, 3)`, `toHtml(deck, "1-3")` (`"1-"` for every slide) or
+ * `toHtml(deck, [1, 3])` draw the selected slides of the presented sequence (counting from 1); the second argument may be the
+ * options instead, told apart by type (RR-73). `embed` puts the document in an `application/opf+json` script child, so the element upgrades without a request.
  * `fontMode`: `"standalone"` (default, embeds per slide), `"shared"` (one set of font rules in the returned tag), or
  * `"external"` (no font rules; the host must supply CSS with the exact pinned faces the handle measures).
  */
-export function renderDeckHtml(input, options = {}) {
+export function toHtml(input, slides, options) {
+  ({ slides, options } = slideArguments(slides, options));
   const deck = parseDeckDocument(input);
   const tag = options.tagName ?? OPF_DECK_TAG;
   const sequence = presentableIndexes(deck, { includeHidden: options.includeHidden });
-  const wanted = options.slides ?? "first";
-  const shown = wanted === "all" ? sequence.map((_, position) => position) : wanted === "first" ? [0] : wanted.map((number) => number - 1).filter((position) => position >= 0 && position < sequence.length);
+  const shown = slides === undefined ? [0] : selectSlides(slides, sequence.length).map((number) => number - 1);
   const handle = options.fonts !== null && typeof options.fonts === "object" ? options.fonts : undefined;
   const fontMode = options.fontMode ?? "standalone";
   if (!["standalone", "shared", "external"].includes(fontMode)) throw new DeckError("invalid-font-mode", "Choose standalone, shared or external SSR fonts.");
-  // Every mode measures with the same handle; external writes no @font-face data (RR-61 `embedFonts: false`).
+  // Every mode measures with the same handle; external writes no @font-face data (`text: "system"`).
   const renderFonts = handle ?? options.renderOptions?.fonts;
   const sharedRules = new Set(), sharedCharacters = new Map();
   const attributes = { src: options.src, slide: options.slide, fonts: handle ? undefined : options.fonts, label: options.label, ...options.attributes };
@@ -538,11 +547,11 @@ export function renderDeckHtml(input, options = {}) {
     const index = sequence[position];
     // Shared rules are deduplicated across slides, so the slides embed whole faces and the shared set is cut below to what
     // every slide draws (RR-65); per-slide subsets would differ and repeat each face once per slide.
-    let svg = renderSlideSvg(deck, index, { ...options.renderOptions, fonts: renderFonts, ...(fontMode === "external" ? { embedFonts: false } : {}), ...(fontMode === "shared" ? { subsetFonts: false } : {}), ...(date ? { date } : {}) });
+    let svg = toSvg(deck, index + 1, { ...options.renderOptions, fonts: renderFonts, ...(fontMode === "external" ? { text: "system" } : {}), ...(fontMode === "shared" ? { subsetFonts: false } : {}), ...(date ? { date } : {}) });
     if (fontMode === "shared") {
       drawnFaces(svg, sharedCharacters);
       svg = svg.replace(/<style>(@font-face[\s\S]*?)<\/style>/g, (_, css) => {
-        // These rules are produced by renderSlideSvg after its used-face selection and validation.
+        // These rules are produced by toSvg after its used-face selection and validation.
         for (const rule of css.split("\n")) sharedRules.add(rule);
         return "";
       });
@@ -552,7 +561,7 @@ export function renderDeckHtml(input, options = {}) {
     const label = slideLabel(slideInfo(deck, index), position + 1, sequence.length);
     return `<figure role="group" aria-roledescription="slide" aria-label="${escapeHtml(label)}" style="margin:0 0 8px">${prepared}</figure>`;
   });
-  const titles = wanted === "first" && sequence.length > 1
+  const titles = slides === undefined && sequence.length > 1
     ? `<nav aria-label="Slides"><ol>${sequence.map((index) => `<li>${escapeHtml(slideInfo(deck, index).title)}</li>`).join("")}</ol></nav>` : "";
   const embedded = options.embed ? `<script type="application/opf+json">${JSON.stringify(deck).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029")}</script>` : "";
   const subsets = options.renderOptions?.subsetFonts === false ? undefined : renderFonts?.subsets;

package/dist/export-browser.d.ts

@@ -1,8 +1,9 @@
-import type { PdfDiagnostic, PdfMetadata, SvgToPdfOptions } from "./index.js";
+import type { PdfDiagnostic, PdfMetadata, SlideSelection, SvgSlide, ToPdfOptions, ToSvgOptions } from "./index.js";
 import type { FontsHandle } from "./fonts.js";
 export type { PdfDiagnostic, PdfMetadata } from "./index.js";
 
-export interface BrowserSvgToPngOptions {
+/** The options of `toPng` in a browser: the canvas's own, and the `toSvg` options that draw a deck (`fonts` is the browser handle). */
+export interface BrowserToPngOptions extends ToSvgOptions {
   /** Multiplies the SVG's own size (default 1). The result is limited to 40 megapixels. */
   scale?: number;
   /** A CSS colour painted first (default white); `"transparent"` keeps the alpha channel. */
@@ -10,18 +11,19 @@ export interface BrowserSvgToPngOptions {
   signal?: AbortSignal;
 }
 
-export interface BrowserSvgToPdfOptions extends Pick<SvgToPdfOptions, "mode" | "background" | "serifFamily" | "metadata" | "tagged" | "compress" | "strict" | "rasterFallbackScale" | "defaultFontFamily" | "sansSerifFamily" | "monospaceFamily" | "onDiagnostic"> {
-  /** Raster mode: pixel density of each page image (default 2). */
+/** The options of `toPdf` in a browser: the PDF's own, and the `toSvg` options that draw a deck. */
+export interface BrowserToPdfOptions extends Omit<ToSvgOptions, "fonts" | "onDiagnostic">, Pick<ToPdfOptions, "raster" | "background" | "serifFamily" | "metadata" | "tagged" | "compress" | "strict" | "rasterFallbackScale" | "defaultFontFamily" | "sansSerifFamily" | "monospaceFamily" | "onDiagnostic"> {
+  /** `raster: true`: pixel density of each page image (default 2). */
   scale?: number;
   /**
-   * Raster mode only: the pdf-lib module (`import * as pdfLib from "pdf-lib"`), an optional peer of the renderer that this entry never imports itself, so a
-   * bundle of it holds no PDF library. Without it raster mode tries to import "pdf-lib" by name and rejects with `OPFRenderError` `converter-missing`
-   * when the page cannot. The default vector mode needs no option.
+   * `raster: true` only: the pdf-lib module (`import * as pdfLib from "pdf-lib"`), an optional peer of the renderer that this entry never imports itself, so a
+   * bundle of it holds no PDF library. Without it a raster PDF tries to import "pdf-lib" by name and rejects with `OPFRenderError` `converter-missing`
+   * when the page cannot. The default vector PDF needs no option.
    */
   pdfLib?: { PDFDocument: { create(options?: { updateMetadata?: boolean }): Promise<any> } };
   /**
-   * The browser fonts handle (`loadFonts` from `/fonts-browser`): every face it holds can be embedded in the PDF, including script faces
-   * a standalone SVG does not carry. Faces an SVG embeds as `@font-face` data (the `embeddedFonts` of the handle `renderSvg` was given) need no entry.
+   * The browser fonts handle (`loadFonts` from `/fonts-browser`): it draws a deck, and every face it holds can be embedded in the PDF, including
+   * script faces a standalone SVG does not carry. Faces an SVG embeds as `@font-face` data (the `embeddedFonts` of the handle `toSvg` was given) need no entry.
    */
   fonts?: FontsHandle;
   /** Extra font faces as bytes (TrueType outlines) when there is no handle. */
@@ -32,7 +34,15 @@ export interface BrowserSvgToPdfOptions extends Pick<SvgToPdfOptions, "mode" | "
   onProgress?: (progress: { page: number; pages: number }) => void;
 }
 
-export declare function svgToPng(svg: string | Uint8Array, options?: BrowserSvgToPngOptions): Promise<Uint8Array>;
-export declare function svgToPdf(svgs: string | Uint8Array | Array<string | Uint8Array>, options?: BrowserSvgToPdfOptions): Promise<Uint8Array>;
+/** PNG with a canvas (RR-73): the arguments and results of the Node `toPng`. */
+export declare function toPng(svg: Uint8Array | `<${string}`, options?: BrowserToPngOptions): Promise<Uint8Array>;
+export declare function toPng(svgs: readonly SvgSlide[], options?: BrowserToPngOptions): Promise<Uint8Array[]>;
+export declare function toPng(deck: unknown, slide: number, options?: BrowserToPngOptions): Promise<Uint8Array>;
+export declare function toPng(deck: unknown, slides: Exclude<SlideSelection, number>, options?: BrowserToPngOptions): Promise<Uint8Array[]>;
+export declare function toPng(deck: object, options?: BrowserToPngOptions): Promise<Uint8Array[]>;
+export declare function toPng(source: string, options?: BrowserToPngOptions): Promise<Uint8Array | Uint8Array[]>;
+/** One PDF (RR-73), a page per slide, of a deck drawn with `toSvg` (every slide or a selection) or of SVG slides. */
+export declare function toPdf(source: unknown, options?: BrowserToPdfOptions): Promise<Uint8Array>;
+export declare function toPdf(deck: unknown, slides: SlideSelection, options?: BrowserToPdfOptions): Promise<Uint8Array>;
 /** Format of an embedded picture and, for a JPEG, its size, component count and EXIF orientation. */
 export declare function sniffImage(bytes: Uint8Array): { format: "png" | "webp" | "gif" | "jpeg" | undefined; width?: number; height?: number; channels?: number; orientation?: number; space?: string };

package/dist/export-browser.js

@@ -1,22 +1,35 @@
 import { svgsToVectorPdf } from "./pdf-vector.js";
-import { OPFRenderError, packageName } from "./svg.js";
+import { OPFRenderError, packageName, toSvg } from "./svg.js";
+import { slideArguments, slideSources } from "./slide-sources.js";
 
-// RR-23: PNG and PDF output in a browser. `svgToPng` and `svgToPdf` of the root entry need Node (resvg, sharp); this entry
+// RR-23: PNG and PDF output in a browser. `toPng` and `toPdf` of the root entry need Node (resvg, sharp); this entry
 // has the same two names for a page. It uses the same vector PDF converter as Node (fontkit, bidi-js and pako, all pure
 // JavaScript) over the SVG the preview draws, so the text stays real text in the same embedded subsets. What differs from
 // Node is only how pixels are made: a canvas decodes pictures and draws PNGs. No system font is read (a browser has no way
 // to hand one over) and nothing is fetched: faces come from the SVG's own @font-face data (the `embeddedFonts` of the fonts handle
-// `renderSvg` was given), from the faces the `fonts` handle holds (`loadFonts` from `/fonts-browser`, so script faces the SVG does not
+// `toSvg` was given), from the faces the `fonts` handle holds (`loadFonts` from `/fonts-browser`, so script faces the SVG does not
 // embed reach the PDF too), or from `fontData`.
 //
-// RR-63: this entry imports no converter. The one optional piece is pdf-lib, for `mode: "raster"` only (the default vector PDF
+// RR-63: this entry imports no converter. The one optional piece is pdf-lib, for `raster: true` only (the default vector PDF
 // needs nothing): the host imports it and passes it as `options.pdfLib`, so a bundler never has to resolve it.
 
 const DEFAULT_DIMENSIONS = { width: 1280, height: 720 };
 const MAX_PIXELS = 40_000_000;
 
-/** Convert one SVG to PNG bytes with a canvas. `scale` multiplies the SVG's own size; `background` is a CSS colour (default white, `"transparent"` for none). */
-export async function svgToPng(svg, options = {}) {
+/**
+ * PNG with a canvas (RR-73): a deck drawn with `toSvg` (all slides, a slide number or a selection, as for the Node `toPng`) or SVG
+ * the renderer drew; one PNG for a slide number or one SVG, a list otherwise. `scale` multiplies the SVG's own size; `background`
+ * is a CSS colour (default white, `"transparent"` for none).
+ */
+export async function toPng(source, slides, options) {
+  ({ slides, options } = slideArguments(slides, options));
+  const { svgs, one } = slideSources(source, slides, options, toSvg);
+  const pngs = [];
+  for (const svg of svgs) pngs.push(await svgPng(svg, options));
+  return one ? pngs[0] : pngs;
+}
+
+async function svgPng(svg, options = {}) {
   const text = svgText(svg);
   const size = pageSize(text);
   const scale = positive(options.scale, "scale", 1);
@@ -32,24 +45,26 @@ export async function svgToPng(svg, options = {}) {
 }
 
 /**
- * Convert SVG slides to a PDF, one slide per page (1 SVG pixel is 1 PDF point, as in Node). `mode: "vector"` (default) writes
- * real text, paths, gradients and images; `"raster"` draws each slide as an image (`scale`, default 2). Takes the options of
- * the Node `svgToPdf` that make sense here (`metadata`, `tagged`, `strict`, `compress`, `onDiagnostic`, the generic family
- * names, `rasterFallbackScale`), `pdfLib` (raster mode only: `import * as pdfLib from "pdf-lib"`), `fonts` (the handle `loadFonts()` returns: every face it holds can be embedded), `fontData`
+ * One PDF (RR-73) of a deck drawn with `toSvg` (all slides or a selection) or of SVG slides, one slide per page (1 SVG pixel is 1
+ * PDF point, as in Node). Vector by default (real text, paths, gradients and images); `raster: true` draws each slide as an image
+ * (`scale`, default 2). Takes the options of the Node `toPdf` that make sense here (`metadata`, `tagged`, `strict`, `compress`,
+ * `onDiagnostic`, the generic family names, `rasterFallbackScale`), `pdfLib` (`raster: true` only: `import * as pdfLib from "pdf-lib"`), `fonts` (the handle `loadFonts()` returns: every face it holds can be embedded), `fontData`
  * (`[{ data, family? }]`, extra face bytes without a handle), `signal` (an AbortSignal, checked between pages) and
  * `onProgress({ page, pages })`.
  */
-export async function svgToPdf(svgs, options = {}) {
-  const inputs = (Array.isArray(svgs) ? svgs : [svgs]).map(svgText);
-  if (!inputs.length) throw new OPFRenderError("empty-pdf", "svgToPdf requires at least one SVG slide.");
-  const mode = options.mode ?? "vector";
-  if (mode !== "vector" && mode !== "raster") throw new OPFRenderError("invalid-conversion-option", 'mode must be "vector" or "raster".', { option: "mode", value: mode });
-  if (mode === "raster") return rasterPdf(inputs, options);
+export async function toPdf(source, slides, options) {
+  ({ slides, options } = slideArguments(slides, options));
+  const inputs = slideSources(source, slides, options, toSvg).svgs.map(svgText);
+  if (!inputs.length) throw new OPFRenderError("empty-pdf", "toPdf needs at least one slide.");
+  if (options.raster !== undefined && typeof options.raster !== "boolean") throw new OPFRenderError("invalid-conversion-option", "raster must be true or false.", { option: "raster", value: options.raster });
+  if (options.raster === true) return rasterPdf(inputs, options);
   const scale = positive(options.rasterFallbackScale, "rasterFallbackScale", 2);
   const fontCss = fontFaceCss(inputs);
   return svgsToVectorPdf(inputs, {
     fontFiles: [], fontDirs: [],
     fontData: [...(options.fonts?.registry?.exportFaces?.() ?? []), ...(Array.isArray(options.fontData) ? options.fontData : [])],
+    // opf-render#188: shaped by HarfBuzz when the handle has the shaper (`shapeWasm`); fontkit otherwise.
+    shape: options.fonts?.outlines?.shape,
     imageCodec: canvasImageCodec(),
     defaultFontFamily: options.defaultFontFamily ?? "Roboto",
     sansSerifFamily: options.sansSerifFamily ?? options.defaultFontFamily ?? "Roboto",
@@ -68,7 +83,7 @@ export async function svgToPdf(svgs, options = {}) {
     producer: packageName,
     ErrorClass: OPFRenderError,
     // The element's own text has no fonts in a standalone SVG image: give it the faces the slides embed.
-    rasterize: async (svg, factor) => ({ png: await svgToPng(fontCss && /<text[\s>]/.test(svg) ? svg.replace(/(<svg\b[^>]*>)/, `$1<style>${fontCss}</style>`) : svg, { scale: factor, background: "transparent", signal: options.signal }) }),
+    rasterize: async (svg, factor) => ({ png: await svgPng(fontCss && /<text[\s>]/.test(svg) ? svg.replace(/(<svg\b[^>]*>)/, `$1<style>${fontCss}</style>`) : svg, { scale: factor, background: "transparent", signal: options.signal }) }),
   });
 }
 
@@ -81,7 +96,7 @@ async function rasterPdf(inputs, options) {
   for (const [index, svg] of inputs.entries()) {
     options.signal?.throwIfAborted?.();
     const size = pageSize(svg);
-    const png = await svgToPng(svg, { scale, background: options.background ?? "#FFFFFF", signal: options.signal });
+    const png = await svgPng(svg, { scale, background: options.background ?? "#FFFFFF", signal: options.signal });
     const image = await pdf.embedPng(png);
     pdf.addPage([size.width, size.height]).drawImage(image, { x: 0, y: 0, width: size.width, height: size.height });
     options.onProgress?.({ page: index + 1, pages: inputs.length });
@@ -90,14 +105,14 @@ async function rasterPdf(inputs, options) {
   return pdf.save({ addDefaultPage: false, useObjectStreams: false });
 }
 
-// pdf-lib for raster mode when the host did not pass it. The specifier is not a literal, so a browser bundler leaves it alone (and
+// pdf-lib for `raster: true` when the host did not pass it. The specifier is not a literal, so a browser bundler leaves it alone (and
 // never fails for a host that does not install pdf-lib); it resolves where the page can import it by name, for example with an import map.
 async function importPdfLib() {
   const name = "pdf-lib";
   try {
     return await import(/* webpackIgnore: true */ /* @vite-ignore */ name);
   } catch (error) {
-    throw new OPFRenderError("converter-missing", 'Raster-mode PDF output needs pdf-lib, an optional peer dependency of @openpresentation/opf-render: run `npm install pdf-lib@^1.17.1` and pass it as the pdfLib option (import * as pdfLib from "pdf-lib"). The default vector mode needs nothing.', { package: "pdf-lib", range: "^1.17.1", install: "npm install pdf-lib@^1.17.1", cause: error instanceof Error ? error.message : String(error) });
+    throw new OPFRenderError("converter-missing", 'A raster PDF (raster: true) needs pdf-lib, an optional peer dependency of @openpresentation/opf-render: run `npm install pdf-lib@^1.17.1` and pass it as the pdfLib option (import * as pdfLib from "pdf-lib"). The default vector PDF needs nothing.', { package: "pdf-lib", range: "^1.17.1", install: "npm install pdf-lib@^1.17.1", cause: error instanceof Error ? error.message : String(error) });
   }
 }
 

package/dist/font-manifest.js

@@ -1620,12 +1620,12 @@ export const BUNDLED_FONT_MANIFEST=freeze({
     },
     {
       "name": "@expo-google-fonts/noto-sans-jp",
-      "version": "0.4.3",
+      "version": "0.4.4",
       "pack": "scripts",
       "scripts": [
         "Jpan"
       ],
-      "source": "https://www.npmjs.com/package/@expo-google-fonts/noto-sans-jp/v/0.4.3",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/noto-sans-jp/v/0.4.4",
       "license": "OFL-1.1",
       "licenseFile": "LICENSE_FONT",
       "licenseSha256": "1c05c68c34f9708415aada51f17e1b0092d2cea709bf4a94cd38114f9e73d7d9",
@@ -1640,25 +1640,25 @@ export const BUNDLED_FONT_MANIFEST=freeze({
           "family": "Noto Sans JP",
           "weight": 400,
           "italic": false,
-          "sha256": "d930d5d52d15231c283089760f84584272ad5e37e14607ba0d19c798e7a9caec"
+          "sha256": "6255ea4692e97ef27330304fb96fd650f9111f868cd585fcf2802d42823930e5"
         },
         {
           "file": "700Bold/NotoSansJP_700Bold.ttf",
           "family": "Noto Sans JP",
           "weight": 700,
           "italic": false,
-          "sha256": "c5b7b9d6a6eb682b0d4e6bbb38509575fd2759a28f147daa74714d1359a7909e"
+          "sha256": "7c03e14d8a03e8f5181dbd130712d51e4ae01ac648cbd59442ae8b16c0951835"
         }
       ]
     },
     {
       "name": "@expo-google-fonts/noto-sans-sc",
-      "version": "0.4.3",
+      "version": "0.4.4",
       "pack": "scripts",
       "scripts": [
         "Hans"
       ],
-      "source": "https://www.npmjs.com/package/@expo-google-fonts/noto-sans-sc/v/0.4.3",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/noto-sans-sc/v/0.4.4",
       "license": "OFL-1.1",
       "licenseFile": "LICENSE_FONT",
       "licenseSha256": "1c05c68c34f9708415aada51f17e1b0092d2cea709bf4a94cd38114f9e73d7d9",
@@ -1686,12 +1686,12 @@ export const BUNDLED_FONT_MANIFEST=freeze({
     },
     {
       "name": "@expo-google-fonts/noto-sans-tc",
-      "version": "0.4.3",
+      "version": "0.4.4",
       "pack": "scripts",
       "scripts": [
         "Hant"
       ],
-      "source": "https://www.npmjs.com/package/@expo-google-fonts/noto-sans-tc/v/0.4.3",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/noto-sans-tc/v/0.4.4",
       "license": "OFL-1.1",
       "licenseFile": "LICENSE_FONT",
       "licenseSha256": "1c05c68c34f9708415aada51f17e1b0092d2cea709bf4a94cd38114f9e73d7d9",
@@ -1719,12 +1719,12 @@ export const BUNDLED_FONT_MANIFEST=freeze({
     },
     {
       "name": "@expo-google-fonts/noto-sans-kr",
-      "version": "0.4.3",
+      "version": "0.4.4",
       "pack": "scripts",
       "scripts": [
         "Kore"
       ],
-      "source": "https://www.npmjs.com/package/@expo-google-fonts/noto-sans-kr/v/0.4.3",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/noto-sans-kr/v/0.4.4",
       "license": "OFL-1.1",
       "licenseFile": "LICENSE_FONT",
       "licenseSha256": "1c05c68c34f9708415aada51f17e1b0092d2cea709bf4a94cd38114f9e73d7d9",
@@ -1739,14 +1739,14 @@ export const BUNDLED_FONT_MANIFEST=freeze({
           "family": "Noto Sans KR",
           "weight": 400,
           "italic": false,
-          "sha256": "8cbc9b353bb9ce848fd69bb6a507319dfacc659cf5fd643db5d88f3c4970e1dd"
+          "sha256": "b4a747e78805bc25b610dcfc3003cb5fb2e2ec034763774b24216ed15889eef4"
         },
         {
           "file": "700Bold/NotoSansKR_700Bold.ttf",
           "family": "Noto Sans KR",
           "weight": 700,
           "italic": false,
-          "sha256": "4ffa20c272ae6d689f7c8d34ff9c8039a326e9c334d9fc8852b2a7396227d077"
+          "sha256": "c76f806dc46b8e7981410cb083801f7f124b7f8bc0d181cdae80e78f16d0e9cc"
         }
       ]
     },
@@ -2551,7 +2551,7 @@ export const BUNDLED_FONT_MANIFEST=freeze({
     },
     {
       "name": "@expo-google-fonts/noto-color-emoji",
-      "version": "0.4.6",
+      "version": "0.4.7",
       "pack": "scripts",
       "scripts": [
         "Zsye"
@@ -2560,7 +2560,7 @@ export const BUNDLED_FONT_MANIFEST=freeze({
         "format": "COLRv1, SVG",
         "rasterFamily": "Noto Emoji"
       },
-      "source": "https://www.npmjs.com/package/@expo-google-fonts/noto-color-emoji/v/0.4.6",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/noto-color-emoji/v/0.4.7",
       "license": "OFL-1.1",
       "licenseFile": "LICENSE_FONT",
       "licenseSha256": "ac564676d10054a8445923dfc2dfb13c042d97888bd27c1b6ec6dfe89a9d8d62",
@@ -2573,18 +2573,18 @@ export const BUNDLED_FONT_MANIFEST=freeze({
           "family": "Noto Color Emoji",
           "weight": 400,
           "italic": false,
-          "sha256": "7fb39738ab18f10612d6f4595e2e8e47a0afdf34738460442d99cd0c344a4d90"
+          "sha256": "ad4a3478943b88660a194d1434793bc02c8007819f2d1e7da9ede289e78f9ca7"
         }
       ]
     },
     {
       "name": "@expo-google-fonts/noto-emoji",
-      "version": "0.4.7",
+      "version": "0.4.8",
       "pack": "scripts",
       "scripts": [
         "Zsye"
       ],
-      "source": "https://www.npmjs.com/package/@expo-google-fonts/noto-emoji/v/0.4.7",
+      "source": "https://www.npmjs.com/package/@expo-google-fonts/noto-emoji/v/0.4.8",
       "license": "OFL-1.1",
       "licenseFile": "LICENSE_FONT",
       "licenseSha256": "500bb1ccf43df7bbb522112f9133a52b16e1c35e809632f5d8609b179152de5b",

package/dist/font-registry.js

@@ -68,6 +68,32 @@ export function skipUndecodableLookups(font) {
   return guarded;
 }
 
+// opf-render#125: fontkit 2.0.4 caches one Glyph per glyph id (font._glyphs) with the code points of the call that created it, and
+// its layout reads the input's code points back from that cache (glyphsForString -> getGlyph(id, [codePoint]) -> GlyphInfo). A glyph
+// first reached another way keeps other code points: a composite outline (run.bbox for outlineBounds, glyph.path) reaches its
+// components with none, and a substitution's output carries its input's. Noto Sans Bengali draws ra (U+09B0) with the nukta glyph
+// (U+09BC) as a component, so once any outline with ra was bounded, a later run with a nukta shaped the nukta as an unknown
+// character, the Indic shaper broke its cluster and inserted a dotted circle (0.51 em each): the measured width of a string
+// depended on what the process had measured before. Every request for a glyph with code points now gets a glyph that carries
+// exactly those (a view of the cached glyph when they differ), so shaping is a function of the text alone. The PDF writer's own
+// faces do the same (pdf-fonts.js parseFace).
+const codePointsPinned = new WeakSet();
+export function pinGlyphCodePoints(font) {
+  if (codePointsPinned.has(font) || typeof font?.getGlyph !== "function") return font;
+  codePointsPinned.add(font);
+  const getGlyph = font.getGlyph.bind(font);
+  font.getGlyph = (id, codePoints = []) => {
+    const glyph = getGlyph(id, codePoints);
+    if (!glyph || !codePoints.length) return glyph;
+    const cached = glyph.codePoints;
+    if (cached?.length === codePoints.length && codePoints.every((codePoint, index) => cached[index] === codePoint)) return glyph;
+    const view = Object.create(glyph);
+    view.codePoints = [...codePoints];
+    return view;
+  };
+  return font;
+}
+
 /**
  * The face a registry draws for `family` (a validated concrete family: theme tokens are already resolved) in `style`, chosen
  * from `faces` ({family, familyGroup, weight, italic, fallbackOnly?, scripts?}) under the substitution policy, aliases and
@@ -143,6 +169,7 @@ export function createFontRegistry(entries, options = {}) {
     let font;
     try { font = create(data, entry.postscriptName); } catch (error) { throw new OPFFontError("invalid-font-data", error.message); }
     if (!font?.layout || !font.unitsPerEm) throw new OPFFontError("font-collection", "Select one font from a collection with postscriptName.");
+    pinGlyphCodePoints(font);
     const family = validFamily(entry.family ?? font.familyName);
     // OpenType groups Medium/SemiBold/ExtraBold under a preferred family, while
     // retaining separate legacy families for four-style native font selectors.
@@ -227,6 +254,10 @@ export function createFontRegistry(entries, options = {}) {
     if(face.fontFace) resolved.fontFace={...face.fontFace};
     // FF-45: the planner maps a symbol-encoded family's codes (symbol-fonts.js); the face only lends its glyphs.
     if(resolution.symbolEncoding) resolved.symbolEncoding=resolution.symbolEncoding;
+    // render#220: resolving a resolved style again keeps its encoding. Core composes each list paragraph from its block's resolved
+    // style, so the item asks for the open symbol face (Noto Sans Symbols 2) by name; that face is the encoding's own, so the codes
+    // still map. Any other family drops a stale encoding.
+    else if(style.symbolEncoding && symbolPreviewFaces(style.symbolEncoding).some(name=>name.toLowerCase()===face.family.toLowerCase())) resolved.symbolEncoding=symbolEncodingFamily(style.symbolEncoding);
     return resolved;
   };
   const metrics = (text,size,style,includeOutline=false) => {

package/dist/font-subset.js

@@ -2,7 +2,7 @@
 // `harfbuzz-subset.wasm` of the pinned harfbuzzjs package, MIT) keeps the glyphs a slide's characters reach through the
 // font's layout tables (every GSUB and GPOS feature is kept, so the browser shapes the subset exactly as the whole face),
 // renumbers them and trims cmap, hmtx, GPOS and the rest to them. The module has no imports, so it is instantiated
-// synchronously from its bytes and `renderSvg` stays synchronous; the same input always gives the same bytes.
+// synchronously from its bytes and `toSvg` stays synchronous; the same input always gives the same bytes.
 //
 // Only a face whose license allows it is subset: a bundled face (matched by the sha256 of its bytes against the pinned
 // manifest) under an allowed license, whose family and file names do not contain one of its package's Reserved Font Names