@openpresentation/opf-render 0.17.1 → 0.18.0

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";
@@ -140,7 +141,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 : {}; }
 
@@ -513,21 +514,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 +540,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 +554,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,19 +45,19 @@ 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, {
@@ -68,7 +81,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 +94,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 +103,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-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

package/dist/fonts-browser.d.ts

@@ -6,7 +6,7 @@ import type {
   FontsHandle,
 } from "./fonts.js";
 import type { AutoScriptSelection, BundledFontPackage, LazyFont, ScriptSelection } from "./fonts-node.js";
-import type { RenderSvgOptions } from "./svg.js";
+import type { ToSvgOptions } from "./svg.js";
 export type { LazyFont } from "./fonts-node.js";
 export type { AutoScriptSelection } from "./fonts-node.js";
 export { detectPresentationScripts, autoScriptSelection } from "./fonts-node.js";
@@ -26,17 +26,17 @@ export interface BrowserFontRegistry extends FontRegistry {
    * family the policy would not resolve, nor for a weight or style nothing draws), once each, from `lazyFontsBaseUrl`.
    * Fetches and verifies every file, then adds the faces to the document and the registry together; on failure nothing
    * changes and the call can be retried. Call it before measuring a document, and again after edits: an edit that adds a
-   * bold or italic run loads just that face. Besides `signal`, the call takes the `renderSvg` options the document resolves
+   * bold or italic run loads just that face. Besides `signal`, the call takes the `toSvg` options the document resolves
    * with (`catalogs`, ...) over the loader's `renderOptions`. A document that does not resolve rejects with the error
-   * `renderSvg` throws for it. After `dispose()` it rejects with `font-registry-disposed`.
+   * `toSvg` throws for it. After `dispose()` it rejects with `font-registry-disposed`.
    */
-  ensureLazyFonts(presentation: unknown, options?: { signal?: AbortSignal } & Partial<RenderSvgOptions>): Promise<LazyFont[]>;
+  ensureLazyFonts(presentation: unknown, options?: { signal?: AbortSignal } & Partial<ToSvgOptions>): Promise<LazyFont[]>;
   /**
    * Synchronous: the vendored faces the presentation draws under the registry's policy that are not loaded yet. Empty means
-   * `ensureLazyFonts` fetches nothing. `renderOptions` are the `renderSvg` options the document resolves with (`catalogs`, ...)
-   * over the loader's `renderOptions`. Throws what `renderSvg` throws for a document that does not resolve.
+   * `ensureLazyFonts` fetches nothing. `renderOptions` are the `toSvg` options the document resolves with (`catalogs`, ...)
+   * over the loader's `renderOptions`. Throws what `toSvg` throws for a document that does not resolve.
    */
-  pendingLazyFonts(presentation: unknown, renderOptions?: Partial<RenderSvgOptions>): LazyFont[];
+  pendingLazyFonts(presentation: unknown, renderOptions?: Partial<ToSvgOptions>): LazyFont[];
 
   /** Load script faces for ISO 15924 codes (or "all") from `scriptBaseUrl`. Resolves with the newly loaded package names. */
   loadScripts(scripts: ScriptSelection, options?: { signal?: AbortSignal }): Promise<string[]>;
@@ -49,15 +49,15 @@ export interface BrowserFontRegistry extends FontRegistry {
    * OPFFontError whose `details` are `{ loaded: string[]; failed: {package, code, message}[] }`. A failed call (fetch, hash, FontFace load) leaves nothing loaded and can be retried; after
    * `dispose()` it rejects with `font-registry-disposed`.
    */
-  ensureScripts(presentation: unknown, options?: { signal?: AbortSignal } & Partial<RenderSvgOptions>): Promise<AutoScriptSelection & { loaded: string[]; uncovered: string[] }>;
+  ensureScripts(presentation: unknown, options?: { signal?: AbortSignal } & Partial<ToSvgOptions>): Promise<AutoScriptSelection & { loaded: string[]; uncovered: string[] }>;
   /** Synchronous: package names the presentation needs that are not loaded yet. Empty means `ensureScripts` fetches nothing, so a host can render immediately. Text decides, so a document is analyzed without resolving its layouts; `renderOptions.catalogs` matter for font schemes only the host's catalogs have (FF-41). */
-  pendingScripts(presentation: unknown, renderOptions?: Partial<RenderSvgOptions>): string[];
+  pendingScripts(presentation: unknown, renderOptions?: Partial<ToSvgOptions>): string[];
   /** Names of the script-pack packages loaded so far. */
   readonly loadedScriptPackages: string[];
 }
 /**
  * The fonts handle of a browser: the faces you list, registered with the document, and on demand the script and vendored faces a deck
- * draws. Pass it as `{ fonts }` to `renderSvg`, `renderSlideSvg`, `<opf-deck>` and the player, core `paginate` and `validate`, and the editor.
+ * draws. Pass it as `{ fonts }` to `toSvg`, `<opf-deck>` and the player, core `paginate` and `validate`, and the editor.
  * The registry behind it keeps the lower-level loaders (`ensureLazyFonts`, `ensureScripts`, `loadScripts`, `pendingLazyFonts`, `pendingScripts`).
  */
 export interface BrowserFontsHandle extends FontsHandle {
@@ -66,13 +66,13 @@ export interface BrowserFontsHandle extends FontsHandle {
   dispose(): void;
   /**
    * Load the vendored and script faces the presentation draws (each hash-verified, all or nothing), repeating while loading changes what
-   * is needed. Cheap when nothing is needed. Besides `signal`, the call takes the `renderSvg` options the document resolves with
-   * (`catalogs`, ...) over the loader's `renderOptions`. A document that does not resolve rejects with what `renderSvg` throws for it; after
+   * is needed. Cheap when nothing is needed. Besides `signal`, the call takes the `toSvg` options the document resolves with
+   * (`catalogs`, ...) over the loader's `renderOptions`. A document that does not resolve rejects with what `toSvg` throws for it; after
    * `dispose()` it rejects with `font-registry-disposed`.
    */
-  ensure(presentation: unknown, options?: { signal?: AbortSignal } & Partial<RenderSvgOptions>): Promise<EnsureResult>;
-  /** Synchronous: the vendored files and script packages `ensure` would fetch. Empty means a render can start now. Throws what `renderSvg` throws for a document that does not resolve. */
-  pending(presentation: unknown, renderOptions?: Partial<RenderSvgOptions>): string[];
+  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[];
 }
 export declare function loadFonts(
   options?: FontRegistryOptions & {
@@ -83,12 +83,12 @@ export declare function loadFonts(
     signal?: AbortSignal;
     /**
      * RR-65: harfbuzzjs's `harfbuzz-subset.wasm` (the URL the host serves it from, its bytes or a compiled WebAssembly.Module). With
-     * it the handle carries `subsets`, and every SVG `renderSvg` draws with this handle embeds each face cut to the characters the
+     * it the handle carries `subsets`, and every SVG `toSvg` draws with this handle embeds each face cut to the characters the
      * slide draws. Without it a browser handle embeds whole faces (the Node handle always subsets).
      */
     subsetWasm?: string | URL | ArrayBuffer | ArrayBufferView | WebAssembly.Module;
     /**
-     * RR-64: harfbuzzjs's `harfbuzz.wasm` (its URL, bytes or a compiled WebAssembly.Module). With it `textAsPaths` shapes outlines with
+     * RR-64: harfbuzzjs's `harfbuzz.wasm` (its URL, bytes or a compiled WebAssembly.Module). With it `text: "paths"` shapes outlines with
      * HarfBuzz, as the browser shapes text; without it a browser handle shapes them with fontkit (the Node handle always uses HarfBuzz).
      */
     shapeWasm?: string | URL | ArrayBuffer | ArrayBufferView | WebAssembly.Module;
@@ -111,11 +111,11 @@ export declare function loadFonts(
      */
     extraLazyFonts?: readonly ExtraLazyFont[];
     /**
-     * FF-41: the `renderSvg` options the documents resolve with (`catalogs` above all), the default for `pendingLazyFonts`,
+     * FF-41: the `toSvg` options the documents resolve with (`catalogs` above all), the default for `pendingLazyFonts`,
      * `ensureLazyFonts`, `pendingScripts` and `ensureScripts`. A layout or font scheme id that only the host's catalogs have
      * resolves the same way here as it does when the host renders. A call's own options win.
      */
-    renderOptions?: Partial<RenderSvgOptions>;
+    renderOptions?: Partial<ToSvgOptions>;
   },
 ): Promise<BrowserFontsHandle>;
 export declare function scriptFontPackages(scripts: ScriptSelection): BundledFontPackage[];
@@ -138,10 +138,10 @@ export interface ExtraLazyFont { family: string; weight: number; italic?: boolea
 export declare function splitStartupFaces<T extends { family: string; weight: number; italic?: boolean }>(faces: readonly T[], options?: { startup?: (face: T) => boolean }): { startup: T[]; rest: T[] };
 /**
  * The font families a presentation's slides resolve (heading, body and code roles of every slide). `options` are the
- * `renderSvg` options the document resolves with (`catalogs`, ...). A document that does not resolve throws what `renderSvg`
+ * `toSvg` options the document resolves with (`catalogs`, ...). A document that does not resolve throws what `toSvg`
  * throws for it (FF-41: it no longer returns an empty set). This is the role families, not what is drawn: see `presentationFaces`.
  */
-export declare function presentationFamilies(presentation: unknown, options?: Partial<RenderSvgOptions>): Set<string>;
+export declare function presentationFamilies(presentation: unknown, options?: Partial<ToSvgOptions>): Set<string>;
 /** A face request or a drawn face: a family, a weight and a style. */
 export interface FaceRequest { family: string; weight: number; italic: boolean }
 /**
@@ -151,16 +151,16 @@ export interface FaceRequest { family: string; weight: number; italic: boolean }
  * faces are the styles as the document names them. With `registry` (`{faces, policy, aliases, fallbackFamily}`: the faces a
  * registry holds or could hold and its substitution options) every style resolves as that registry resolves it, in the two
  * steps drawing takes (role family, then weight within it), and the result is the faces the registry paints.
- * `options` are the `renderSvg` options the document resolves with; a document that does not resolve throws what `renderSvg`
+ * `options` are the `toSvg` options the document resolves with; a document that does not resolve throws what `toSvg`
  * throws for it.
  */
-export declare function presentationFaces(presentation: unknown, options?: Partial<RenderSvgOptions>, registry?: { faces: Iterable<FaceRequest>; policy?: "none" | "metric" | "visual"; aliases?: ReadonlyMap<string, string>; fallbackFamily?: string }): FaceRequest[];
+export declare function presentationFaces(presentation: unknown, options?: Partial<ToSvgOptions>, registry?: { faces: Iterable<FaceRequest>; policy?: "none" | "metric" | "visual"; aliases?: ReadonlyMap<string, string>; fallbackFamily?: string }): FaceRequest[];
 /**
  * The vendored faces (of `lazy`) a presentation draws that the registry does not hold. `held` is `registry.describeFaces()`,
  * `loaded` the lazy files already loaded; `policy`, `aliases` and `fallbackFamily` are the registry's. Face level: only the
  * drawn faces, so an edit adding a bold run adds one face.
  */
-export declare function lazyFacesNeeded(presentation: unknown, renderOptions: Partial<RenderSvgOptions> | undefined, context: { lazy: readonly LazyFont[]; held: Iterable<FaceRequest>; loaded?: ReadonlySet<string>; policy?: "none" | "metric" | "visual"; aliases?: ReadonlyMap<string, string>; fallbackFamily?: string }): LazyFont[];
+export declare function lazyFacesNeeded(presentation: unknown, renderOptions: Partial<ToSvgOptions> | undefined, context: { lazy: readonly LazyFont[]; held: Iterable<FaceRequest>; loaded?: ReadonlySet<string>; policy?: "none" | "metric" | "visual"; aliases?: ReadonlyMap<string, string>; fallbackFamily?: string }): LazyFont[];
 /**
  * The vendored faces a list of requests needs that the registry does not hold, following the registry's own order and
  * `policy` (default "visual"): the family itself, an alias target, the declared replacement, then its alternates.

package/dist/fonts-browser.js

@@ -97,7 +97,7 @@ async function loadRegistry(entries, options = {}) {
   // 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(), disposed = false;
-  // FF-41: the `renderSvg` options a document resolves with (`catalogs`, ...). `options.renderOptions` are the defaults; a call's own
+  // FF-41: the `toSvg` options a document resolves with (`catalogs`, ...). `options.renderOptions` are the defaults; a call's own
   // options (everything but `signal`) are added over them, so a host that passes its canvas options gets the same resolution here.
   const renderOptionsFor = (callOptions) => { const { signal: _signal, ...own } = callOptions ?? {}; return { ...options.renderOptions, ...own }; };
   const gone = () => new OPFFontError("font-registry-disposed", "The font registry was disposed.");
@@ -151,7 +151,7 @@ async function loadRegistry(entries, options = {}) {
      * fallback needs for characters the loaded faces lack. Cheap when nothing new is needed; call it after edits and
      * render again afterwards. Resolves with the detected scripts, the packages loaded by this call, the scripts no
      * pinned font serves and `uncovered`, drawn CJK characters no loaded face covers (the renderer reports
-     * `missing-glyph` for them). Besides `signal`, the call takes the `renderSvg` options the document resolves with
+     * `missing-glyph` for them). Besides `signal`, the call takes the `toSvg` options the document resolves with
      * (`catalogs`, ...) over the loader's `renderOptions`. Each package loads all or nothing. If some package fails, the others still load: the
      * call then rejects with an OPFFontError (the first failure's code) whose `details` hold `loaded` (packages this
      * call did load) and `failed` (`{package, code, message}` per failed package); nothing is lost and a later call
@@ -176,7 +176,7 @@ async function loadRegistry(entries, options = {}) {
       }
       return { ...selection, loaded: loadedNow, uncovered: uncoveredCjkCharacters(analysis, { covers }) };
     },
-    /** Synchronous: script-pack packages the presentation needs that are not loaded yet. Empty means `ensureScripts` would fetch nothing. `renderOptions` are the `renderSvg` options the document resolves with (`catalogs`, ...). */
+    /** 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 primary = scriptFontPackages(scriptSelectionOf(analysis).scripts).map((item) => item.name).filter((name) => !scriptPackages.has(name));
@@ -194,7 +194,7 @@ async function loadRegistry(entries, options = {}) {
   const policy = options.substitutionPolicy ?? "none";
   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 `renderSvg` throws for it.
+  // 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 lazyBaseUrl = () => {
     if (typeof options.lazyFontsBaseUrl !== "string" || !options.lazyFontsBaseUrl)
@@ -210,8 +210,8 @@ async function loadRegistry(entries, options = {}) {
      * policy (nothing is downloaded for a family the policy would not resolve), once each. All or nothing: on any failure
      * (fetch, hash, FontFace.load, registry) the document and registry are unchanged and the call can be retried. Cheap when
      * nothing is needed. Call it before measuring a document, and again after edits that change fonts. Resolves with the faces
-     * added. Besides `signal`, the call takes the `renderSvg` options the document resolves with (`catalogs`, ...) over the
-     * loader's `renderOptions`; a document that does not resolve rejects with what `renderSvg` throws for it.
+     * added. Besides `signal`, the call takes the `toSvg` options the document resolves with (`catalogs`, ...) over the
+     * loader's `renderOptions`; a document that does not resolve rejects with what `toSvg` throws for it.
      */
     ensureLazyFonts(presentation, callOptions = {}) {
       const result = queue.then(async () => {
@@ -247,7 +247,7 @@ async function loadRegistry(entries, options = {}) {
       queue = result.catch(() => {});
       return result;
     },
-    /** Synchronous: the vendored faces the presentation draws under the registry's policy that are not loaded yet. Empty means `ensureLazyFonts` fetches nothing. `renderOptions` are the `renderSvg` options the document resolves with (`catalogs`, ...). */
+    /** Synchronous: the vendored faces the presentation draws under the registry's policy that are not loaded yet. Empty means `ensureLazyFonts` fetches nothing. `renderOptions` are the `toSvg` options the document resolves with (`catalogs`, ...). */
     pendingLazyFonts: (presentation, renderOptions) => neededLazy(presentation, renderOptions),
   });
   /** Names of the script-pack packages loaded so far. */
@@ -277,7 +277,7 @@ const MAX_ENSURE_ROUNDS = 4;
 /**
  * The fonts handle for a browser: the faces you list (`faces`, each `{ url | data, family, weight, italic, sha256 }`, fetched and
  * hash-verified, then registered with the document) and, on demand, the script and vendored faces a deck draws. Pass it as `{ fonts }` to
- * `renderSvg`, `renderSlideSvg`, `<opf-deck>` and the player, core `paginate` and `validate`, and the editor. `scripts`, `scriptBaseUrl`,
+ * `toSvg`, `<opf-deck>` and the player, core `paginate` and `validate`, and the editor. `scripts`, `scriptBaseUrl`,
  * `lazyFontsBaseUrl`, `extraLazyFonts`, `renderOptions`, `signal`, `document`, `fetch`, `crypto` and the registry options
  * (`substitutionPolicy`, `aliases`, `fallbackFamily`, `themeFonts`, `strictGlyphs`) are as for the registry (see `fonts-browser.d.ts`).
  * `dispose()` removes every face from the document.
@@ -320,7 +320,7 @@ export async function loadFonts({ faces = [], subsetWasm, shapeWasm, ...options
     textMeasurement: registry.textMeasurement,
     get embeddedFonts() { if (stale) { embedded = registry.embeddedFonts; stale = false; } return embedded; },
     registry,
-    // RR-64: the outline engine `renderSvg(deck, { fonts, textAsPaths: true })` draws text with, over this registry's faces.
+    // RR-64: the outline engine `toSvg(deck, { fonts, text: "paths" })` draws text with, over this registry's faces.
     outlines: textOutlines({ registry, shaper }),
     // RR-65: with `subsetWasm`, the subset engine that cuts each face an SVG embeds to the characters the slide draws.
     ...(subsetter ? { subsets: fontSubsets(registry, subsetter) } : {}),
@@ -329,8 +329,8 @@ export async function loadFonts({ faces = [], subsetWasm, shapeWasm, ...options
     /**
      * Load the vendored and script faces the presentation draws, each hash-verified, all or nothing, and repeat while loading
      * changes what is needed (a script face can need a vendored one). Cheap when nothing is needed. Besides `signal`, the call
-     * takes the `renderSvg` options the document resolves with (`catalogs`, ...) over the loader's `renderOptions`. A document that
-     * does not resolve rejects with what `renderSvg` throws for it. After `dispose()` it rejects with `font-registry-disposed`.
+     * takes the `toSvg` options the document resolves with (`catalogs`, ...) over the loader's `renderOptions`. A document that
+     * does not resolve rejects with what `toSvg` throws for it. After `dispose()` it rejects with `font-registry-disposed`.
      */
     async ensure(presentation, callOptions = {}) {
       const lazy = [], scripts = [];
@@ -344,7 +344,7 @@ export async function loadFonts({ faces = [], subsetWasm, shapeWasm, ...options
       }
       return { scripts, lazy, uncovered };
     },
-    /** Synchronous: the files and script packages `ensure` would fetch. Empty means a render can start now. Throws what `renderSvg` throws for a document that does not resolve. */
+    /** 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,
     dispose: () => registry.dispose(),
   };

package/dist/fonts-node.d.ts

@@ -1,5 +1,5 @@
 import type {FontRegistry,FontRegistryOptions,FontFaceInput,FontsHandle,EnsureResult,ScriptFontProfile} from "./fonts.js";
-import type {RenderSvgOptions} from "./svg.js";
+import type {ToSvgOptions} from "./svg.js";
 /** A caller-supplied face (FF-31), for example a licensed copy of the real font. Node callers may pass a file path. */
 export type CallerFontFace = FontFaceInput | (Omit<FontFaceInput, "data"> & {path: string});
 /** "all" or ISO 15924 codes (`Jpan`, `Hans`, `Hant`, `Kore`, `Arab`, `Hebr`, `Deva`, `Thai`, ...). */
@@ -16,9 +16,9 @@ export interface AutoScriptSelection {
 /** Script-pack packages that `scripts: "auto"` loaded or found not installed. */
 export interface AppliedScriptSelection extends AutoScriptSelection { packages: string[]; notInstalled: string[]; /** Drawn CJK characters no loaded face covers (glyph fallback stopped at its cap). */ uncovered?: string[] }
 /** Script keys whose faces a preview of the presentation needs: text decides, the document language only tells Han scripts apart. */
-/** `options` may also carry the `renderSvg` options the document resolves with (`catalogs`): a font scheme that exists only in the host's catalogs and names a script font selects that font's script (FF-41). */
-export declare function detectPresentationScripts(presentation: unknown, options?: { profile?: ScriptFontProfile } & Partial<RenderSvgOptions>): string[];
-export declare function autoScriptSelection(presentation: unknown, options?: { profile?: ScriptFontProfile } & Partial<RenderSvgOptions>): AutoScriptSelection;
+/** `options` may also carry the `toSvg` options the document resolves with (`catalogs`): a font scheme that exists only in the host's catalogs and names a script font selects that font's script (FF-41). */
+export declare function detectPresentationScripts(presentation: unknown, options?: { profile?: ScriptFontProfile } & Partial<ToSvgOptions>): string[];
+export declare function autoScriptSelection(presentation: unknown, options?: { profile?: ScriptFontProfile } & Partial<ToSvgOptions>): AutoScriptSelection;
 export interface ScriptPackOptions {
   /** Caller-supplied faces, loaded first so a licensed real font resolves as an exact face (FF-31). */
   faces?: readonly CallerFontFace[];
@@ -30,8 +30,8 @@ export interface ScriptPackOptions {
   scripts?: ScriptSelection | "auto";
   /** The presentation whose text decides `scripts: "auto"`. */
   presentation?: unknown;
-  /** The `renderSvg` options the presentation resolves with (`catalogs`, ...), for the font schemes `scripts: "auto"` reads (FF-41). */
-  renderOptions?: Partial<RenderSvgOptions>;
+  /** The `toSvg` options the presentation resolves with (`catalogs`, ...), for the font schemes `scripts: "auto"` reads (FF-41). */
+  renderOptions?: Partial<ToSvgOptions>;
   /** Receives `script-font-unavailable` and `script-font-not-installed` for `scripts: "auto"`. */
   onDiagnostic?: (diagnostic: {code: string; message: string; script?: string; package?: string; scripts?: string[]}) => void;
 }
@@ -74,7 +74,7 @@ export declare function scriptFontPackages(scripts: ScriptSelection): BundledFon
 export interface NodeFontsHandle extends FontsHandle {
   readonly registry: NodeFontRegistry;
   readonly manifest: BundledFontManifest;
-  /** Every font file the handle holds, for `svgToPng` and `svgToPdf`; includes the script faces `ensure` loaded. */
+  /** Every font file the handle holds, for `toPng` and `toPdf`; includes the script faces `ensure` loaded. */
   readonly fontFiles: string[];
   /** The files are already in `fontFiles`, so a conversion adds no bundled faces. */
   readonly useBundledFonts: false;
@@ -86,9 +86,9 @@ export interface NodeFontsHandle extends FontsHandle {
    * the new faces. A package that is not installed or a script no pinned font serves is reported once through `onDiagnostic`.
    * Resolves with the packages this call added (`scripts`; `lazy` is empty: Node loads every vendored face with its pack).
    */
-  ensure(presentation: unknown, options?: { onDiagnostic?: ScriptPackOptions["onDiagnostic"]; renderOptions?: Partial<RenderSvgOptions> }): Promise<EnsureResult>;
+  ensure(presentation: unknown, options?: { onDiagnostic?: ScriptPackOptions["onDiagnostic"]; renderOptions?: Partial<ToSvgOptions> }): Promise<EnsureResult>;
   /** Synchronous: the script packages the presentation needs that are not loaded yet. */
-  pending(presentation: unknown, renderOptions?: Partial<RenderSvgOptions>): string[];
+  pending(presentation: unknown, renderOptions?: Partial<ToSvgOptions>): string[];
 }
 export interface LoadFontsOptions extends FontRegistryOptions, ScriptPackOptions {
   /** `base` (default): the bundled Roboto faces. `office`: the metric and visual substitutes for the Office families plus the open families font schemes select. `none`: only the `faces` you supply. */

package/dist/fonts-node.js

@@ -95,7 +95,7 @@ const loadPack = pack => loadPackages(BUNDLED_FONT_MANIFEST.packages.filter(item
 /**
  * Adds the script pack. `scripts` is 'all', ISO 15924 codes, or 'auto' (FF-19): detect the scripts the
  * `presentation` draws and load only their faces. Auto never fails on a missing optional package or a
- * script no pinned font serves; it reports them through `onDiagnostic` and `selection`. `renderOptions` are the host's `renderSvg`
+ * script no pinned font serves; it reports them through `onDiagnostic` and `selection`. `renderOptions` are the host's `toSvg`
  * options (see `analyzePresentationScripts`).
  */
 async function withScripts(loaded, scripts, {presentation, onDiagnostic, renderOptions} = {}) {
@@ -250,7 +250,7 @@ async function ensureFonts(registry, loaded, presentation, {onDiagnostic, render
 }
 
 // RR-65: hb-subset from the pinned harfbuzzjs package (MIT), compiled once per process. The module has no imports, so it is
-// instantiated synchronously and renderSvg stays synchronous. A copy that cannot be loaded leaves the handle without `subsets`
+// instantiated synchronously and toSvg stays synchronous. A copy that cannot be loaded leaves the handle without `subsets`
 // (whole faces, as before RR-65): a byte saving never stops fonts from loading.
 let subsetterPromise;
 function nodeSubsetter() {
@@ -268,7 +268,7 @@ function nodeShaper() {
 
 /**
  * The fonts handle: one set of verified font inputs for layout, SVG, editor, PPTX and Node raster export. Pass it as `{ fonts }` to
- * `renderSvg`, `renderSlideSvg`, `svgToPng`, `svgToPdf`, core `paginate` and `validate`, and `toPptx`.
+ * `toSvg`, `toPng`, `toPdf`, core `paginate` and `validate`, and `toPptx`.
  *
  * Bundled, openly licensed faces only: no system font discovery and no network requests. `pack`: `base` (default, Roboto),
  * `office` (the Office substitutes and the open families) or `none` (only the `faces` you supply). Everything else
@@ -293,7 +293,7 @@ export async function loadFonts({pack = "base", embedScriptFonts = false, ...opt
     useBundledFonts: false,
     loadSystemFonts: false,
     registry,
-    // RR-64: the outline engine `renderSvg(deck, { fonts, textAsPaths: true })` draws text with, over this registry's faces.
+    // RR-64: the outline engine `toSvg(deck, { fonts, text: "paths" })` draws text with, over this registry's faces.
     outlines: textOutlines({ registry, shaper }),
     // RR-65: the subset engine that cuts each face an SVG embeds to the characters the slide draws.
     ...(subsetter ? { subsets: fontSubsets(registry, subsetter) } : {}),