@openpresentation/opf-render 0.17.1 → 0.18.1

package/dist/raster.js

@@ -1,5 +1,6 @@
 import {prepareRasterImages} from './raster-images.js';
-import {OPFRenderError,packageName} from './svg.js';
+import {OPFRenderError,packageName,toSvg} from './svg.js';
+import {slideArguments,slideSources} from './slide-sources.js';
 import {separateLigatures} from './font-compatibility.js';
 import {monochromeColorFonts,rasterFontFiles} from './color-fonts.js';
 import {pinScriptClusters} from './raster-text.js';
@@ -7,38 +8,47 @@ import {loadConverter} from './converters.js';
 const DEFAULT_DIMENSIONS = { width: 1280, height: 720 };
 const DEFAULT_RASTER_SCALE = 1;
 const DEFAULT_RASTER_BACKGROUND = "#FFFFFF";
-// RR-12: PDF output is vector (selectable text, vector drawing) unless a caller asks for the raster-backed compatibility mode.
-const DEFAULT_PDF_MODE = "vector";
-let bundledFontFilesCache=null;
+let bundledFontsCache=null;
 
-// The faces a raster or PDF conversion draws with, from the fonts handle (`loadFonts()` from `/fonts-node`): its `fontFiles`, and
-// whether the bundled base faces are added (`useBundledFonts`, default true; a Node handle already holds its own, so it says false) and
-// whether system fonts load (`loadSystemFonts`, default false). Without a handle the bundled base faces draw.
+// The faces a raster or PDF conversion draws with (RR-74: one `fonts`). The fonts handle (`loadFonts()` from `/fonts-node`) gives its
+// `fontFiles`, whether the bundled base faces are added (`useBundledFonts`, default true; a Node handle already holds its own, so it
+// says false) and whether system fonts load (`loadSystemFonts`, default false). Font folders (a path or a list of paths) add every
+// face in them to the bundled base faces. Without either the bundled base faces draw.
 function fontSettings(options) {
   const fonts = options.fonts ?? {};
-  return { fontFiles: stringArray(fonts.fontFiles), useBundledFonts: fonts.useBundledFonts !== false, loadSystemFonts: fonts.loadSystemFonts === true };
+  if (typeof fonts === "string" || Array.isArray(fonts)) return { fontFiles: [], fontDirs: stringArray([fonts].flat()), useBundledFonts: true, loadSystemFonts: false };
+  return { fontFiles: stringArray(fonts.fontFiles), fontDirs: [], useBundledFonts: fonts.useBundledFonts !== false, loadSystemFonts: fonts.loadSystemFonts === true };
 }
 
 /**
- * Convert one SVG (the output of `renderSvg` or `renderSlideSvg`) to PNG bytes. `fonts` is the handle `loadFonts()` returns: the raster draws
- * with its font files, so the preview and the PNG use the same faces. Without it the bundled base faces draw.
+ * PNG (RR-73): a deck drawn with `toSvg` (`toPng(deck)` gives one PNG per slide, `toPng(deck, 3)` the third slide's PNG,
+ * `toPng(deck, "1-3")` those slides'), or SVG the renderer drew (one SVG gives one PNG, a list a list). `fonts` is the handle
+ * `loadFonts()` returns, so the preview and the PNG draw with the same faces, or font folders for SVG input. Without either the
+ * bundled base faces draw.
  */
-export async function svgToPng(svg, options = {}) {
-  const rendered = await rasterizeSvg(svg, options);
-  return rendered.png;
+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 rasterizeSvg(svg, options)).png);
+  return one ? pngs[0] : pngs;
 }
 
-/** Convert SVG slides (the output of `renderSvg`) to a PDF, one page each. `fonts` is as for `svgToPng`; `mode` is `"vector"` (default) or `"raster"`. */
-export async function svgToPdf(svgs, options = {}) {
-  const pdfInputs = normalizeSvgList(svgs);
+/**
+ * One PDF (RR-73), a page per slide, of a deck drawn with `toSvg` (all slides, or a selection: `toPdf(deck, "2-4")`) or of SVG
+ * slides the renderer drew. Vector by default (selectable text in embedded subsets); `raster: true` draws each slide as an image.
+ * `fonts` is as for `toPng`.
+ */
+export async function toPdf(source, slides, options) {
+  ({ slides, options } = slideArguments(slides, options));
+  const pdfInputs = slideSources(source, slides, options, toSvg).svgs;
   if (!pdfInputs.length) {
-    throw new OPFRenderError("empty-pdf", "svgToPdf requires at least one SVG slide.");
+    throw new OPFRenderError("empty-pdf", "toPdf needs at least one slide.");
   }
-  const mode = options.mode ?? DEFAULT_PDF_MODE;
-  if (mode !== "vector" && mode !== "raster") {
-    throw new OPFRenderError("invalid-conversion-option", 'mode must be "vector" or "raster".', { option: "mode", value: mode });
+  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 (mode === "vector") return vectorPdf(pdfInputs, options);
+  if (options.raster !== true) return vectorPdf(pdfInputs, options);
 
   const { PDFDocument } = await loadPdfLib();
   const pdf = await PDFDocument.create({ updateMetadata: false });
@@ -65,19 +75,23 @@ export async function svgToPdf(svgs, options = {}) {
 async function vectorPdf(inputs, options) {
   const settings = fontSettings(options);
   if (settings.loadSystemFonts) {
-    throw new OPFRenderError("pdf-system-fonts-unsupported", 'Vector PDF output embeds only the font files you supply: fonts.loadSystemFonts is not supported with mode "vector". Pass a fonts handle with fontFiles (and fontDirs), or use mode "raster".', { option: "fonts.loadSystemFonts" });
+    throw new OPFRenderError("pdf-system-fonts-unsupported", 'Vector PDF output embeds only the font files you supply: so fonts.loadSystemFonts does not apply. Pass a fonts handle with fontFiles, or font folders, or use raster: true.', { option: "fonts.loadSystemFonts" });
   }
   const scale = positiveNumber(options.rasterFallbackScale, "rasterFallbackScale", 2);
   const fontFiles = [
     ...(settings.useBundledFonts ? await bundledFontFiles() : []),
     ...settings.fontFiles
   ];
+  // opf-render#188: the runs are shaped by HarfBuzz, as the browser shapes them, through the fonts handle's shaper (or that of
+  // the bundled handle the conversion draws with); fontkit shapes them when neither has one.
+  const shape = options.fonts?.outlines?.shape ?? (settings.useBundledFonts ? (await bundledFonts()).outlines?.shape : undefined);
   const svgs = [];
   for (const input of inputs) svgs.push(await prepareRasterImages(normalizeSvgInput(input)));
   const {svgsToVectorPdf} = await import("./pdf-vector.js");
   return svgsToVectorPdf(svgs, {
     fontFiles,
-    fontDirs: stringArray(options.fontDirs),
+    fontDirs: settings.fontDirs,
+    shape,
     defaultFontFamily: options.defaultFontFamily ?? "Roboto",
     sansSerifFamily: options.sansSerifFamily ?? options.defaultFontFamily ?? "Roboto",
     monospaceFamily: options.monospaceFamily ?? "Roboto Mono",
@@ -123,7 +137,7 @@ async function rasterizeSvg(svgInput, options) {
   const font = {
     loadSystemFonts: settings.loadSystemFonts,
     fontFiles,
-    fontDirs: stringArray(options.fontDirs),
+    fontDirs: settings.fontDirs,
     defaultFontFamily: options.defaultFontFamily ?? "Roboto",
     sansSerifFamily: options.sansSerifFamily ?? options.defaultFontFamily ?? "Roboto",
     monospaceFamily: options.monospaceFamily ?? "Roboto Mono"
@@ -167,23 +181,18 @@ const loadResvg = () => loadConverter("@resvg/resvg-js");
 const loadPdfLib = () => loadConverter("pdf-lib");
 
 async function bundledFontFiles() {
-  if (!bundledFontFilesCache) {
-    bundledFontFilesCache = resolveBundledFontFiles().catch(error => {
-      bundledFontFilesCache = null;
+  return (await bundledFonts()).fontFiles;
+}
+
+// The bundled base handle (`loadFonts()`), loaded once: its font files, and its shaper for the vector PDF.
+function bundledFonts() {
+  if (!bundledFontsCache) {
+    bundledFontsCache = import('./fonts-node.js').then(({loadFonts}) => loadFonts()).catch(error => {
+      bundledFontsCache = null;
       throw error;
     });
   }
-  return bundledFontFilesCache;
-}
-
-async function resolveBundledFontFiles() {
-  const {loadFonts} = await import('./fonts-node.js');
-  return (await loadFonts()).fontFiles;
-}
-
-function normalizeSvgList(value) {
-  if (Array.isArray(value)) return value;
-  return [value];
+  return bundledFontsCache;
 }
 
 function normalizeSvgInput(value) {

package/dist/script-font-pack.js

@@ -65,7 +65,7 @@ const UNDRAWN_VALUE = /^(?:https?|data|blob|pkg|file|mailto):\S*$/i;
 
 // The built-in variables that copy a document value into drawn text: the inline token and the whole-field reference
 // (a logo or photo reference draws a picture, not text).
-const ORGANIZATION_TOKEN = /\{\{\s*organization\.|var:organization\.(?!logo\b)/;
+const ORGANIZATION_TOKEN = /\{\{\s*organization\.|var:organization\.(?!(?:[^.\s]+\.)?logo\b)/;
 const SPEAKER_TOKEN = /\{\{\s*speaker\.|var:speaker\.(?!photo\b|image\b|avatar\b)/;
 const SECTION_TOKEN = /\{\{\s*slide\.section\s*[|}]/;
 
@@ -130,7 +130,7 @@ function scriptOfFamily(family) {
  * scheme (`slide.design`), so each such slide is resolved too. `han` is the CJK script the scheme names, which tells
  * Han-only text apart when the language does not (a Yu Gothic deck whose language is English).
  *
- * `renderOptions` are the host's `renderSvg` options: their `catalogs` (core `Catalog[]`) go to core's `resolveScriptFonts`
+ * `renderOptions` are the host's `toSvg` options: their `catalogs` (core `Catalog[]`) go to core's `resolveScriptFonts`
  * 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.
  */
@@ -176,8 +176,8 @@ function* namedFontFamilies(value, key) {
  * itemization, so language-dependent punctuation counts), the scripts its font schemes need (`design`, for example
  * Jpan for a Yu Gothic scheme) and the CJK characters that a glyph fallback might have to draw with another CJK face.
  * The text decides, so a document is analyzed without resolving its layouts and catalogs; `renderOptions` (the host's
- * `renderSvg` 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 `renderSvg` throws for it.
+ * `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) {
   profile ??= presentationScriptProfile(presentation, renderOptions);
@@ -198,7 +198,7 @@ export function analyzePresentationScripts(presentation, profile, renderOptions)
  * (Japanese, Korean, Simplified or Traditional Chinese) and makes curly quotes, dashes and the ellipsis
  * East Asian. Text the preview never draws (ids, alt text, sources, assets, catalogs, notes) is ignored.
  * Greek and Cyrillic add nothing: the office registry always carries Noto Sans (the glyph-fallback face) and Roboto covers them.
- * Pass `profile` to reuse a resolved profile. Other options are the host's `renderSvg` options (`catalogs`, see `analyzePresentationScripts`).
+ * Pass `profile` to reuse a resolved profile. Other options are the host's `toSvg` options (`catalogs`, see `analyzePresentationScripts`).
  */
 export function detectPresentationScripts(presentation, { profile, ...renderOptions } = {}) {
   return analyzePresentationScripts(presentation, profile, renderOptions).detected;

package/dist/script-fonts.js

@@ -46,7 +46,9 @@ export const SCRIPT_FONT_FAMILIES = freeze({
   // text, not scripts a character carries: emoji and math characters are Common, so they stay in their
   // neighbours' run and reach these faces through the glyph fallback chain (emoji-presentation clusters
   // take the emoji face first). The keys are last so the chain tries every real script face before them.
-  Zsye: {sans: "Noto Color Emoji"},
+  // `fallback` is a further designated face, tried after the colour face: a host that installed only the monochrome Noto Emoji package
+  // still previews and exports emoji. The colour face stays first wherever it is loaded.
+  Zsye: {sans: "Noto Color Emoji", fallback: "Noto Emoji"},
   Zmth: {serif: "STIX Two Math", sans: "Noto Sans Math"},
 });
 
@@ -315,7 +317,7 @@ export function detectScripts(value, profile, { includeLanguage = true, ignoreKe
 export function designatedFamilies(script, serif = false) {
   const entry = SCRIPT_FONT_FAMILIES[script];
   if (!entry) return [];
-  return (serif ? [entry.serif, entry.sans] : [entry.sans, entry.serif]).filter(Boolean);
+  return (serif ? [entry.serif, entry.sans, entry.fallback] : [entry.sans, entry.serif, entry.fallback]).filter(Boolean);
 }
 
 const hanKeys = ["Jpan", "Hans", "Hant", "Kore"];

package/dist/slide-sources.js

@@ -0,0 +1,47 @@
+// RR-73: what `toPng` and `toPdf` draw. They take a deck (an object, or JSON text) and draw it with `toSvg`, or SVG the renderer
+// already drew (a string or bytes starting with `<`, or a list of them). The second argument is a slide selection for a deck (`3`
+// or `"1-3"`, slides counting from 1) or the options, told apart by type, as for `toSvg`.
+import { parseSlideSelection } from "@openpresentation/opf";
+import { OPFRenderError } from "./svg.js";
+
+/** The slide numbers (from 1) a selection names: a list of numbers or text such as "1,3-5"; core's parser, with the renderer's error. */
+export function selectSlides(slides, count) {
+  try {
+    return parseSlideSelection(slides, count, "slides");
+  } catch (error) {
+    throw new OPFRenderError("invalid-slide-selection", error.message, { option: "slides", slideCount: count, cause: error });
+  }
+}
+
+// The 0.17 option names (RR-73, RR-74): pre-v1 there is no alias, but a call that still passes one fails with the new name.
+const RENAMED = { embedFonts: "text: \"system\" (embedFonts: false)", textAsPaths: "text: \"paths\"", mode: "raster: true (vector is the default)", fontDirs: "fonts: a font folder or a list of them" };
+
+/** Throws for an option of 0.17 that 0.18 renamed, naming its replacement. */
+export function rejectRenamedOptions(options, code) {
+  for (const name of Object.keys(RENAMED)) {
+    if (options?.[name] !== undefined) throw new OPFRenderError(code, `The ${name} option was replaced by ${RENAMED[name]}.`, { option: name });
+  }
+}
+
+/** `(slides, options)` with the options moved into place when the second argument is the options object. */
+export function slideArguments(slides, options) {
+  if (slides !== null && typeof slides === "object" && !Array.isArray(slides)) return { slides: undefined, options: slides };
+  return { slides, options: options ?? {} };
+}
+
+const isSvg = (value) => value instanceof Uint8Array || (typeof value === "string" && /^\s*</.test(value));
+
+/**
+ * The SVG slides to convert, and whether the caller asked for one (a slide number, or one SVG): `draw` is `toSvg`, called with the
+ * conversion options for a deck (they carry the fonts handle and the drawing options).
+ */
+export function slideSources(source, slides, options, draw) {
+  rejectRenamedOptions(options, "invalid-conversion-option");
+  if (Array.isArray(source) || isSvg(source)) {
+    if (slides !== undefined) throw new OPFRenderError("invalid-conversion-option", "A slide selection applies to a deck; SVG input is already drawn, so pass the slides you want.", { option: "slides" });
+    if (Array.isArray(source) && !source.every(isSvg)) throw new OPFRenderError("invalid-svg-input", "A list must hold SVG slides (strings or bytes starting with <).");
+    return { svgs: Array.isArray(source) ? source : [source], one: !Array.isArray(source) };
+  }
+  const drawn = draw(source, slides, options);
+  return typeof drawn === "string" ? { svgs: [drawn], one: true } : { svgs: drawn, one: false };
+}

package/dist/svg.d.ts

@@ -1,5 +1,6 @@
 import type { RenderFonts, ScriptFonts } from "./fonts.js";
-import type { Catalog, Finding, UnresolvedReferenceDiagnostic } from "@openpresentation/opf";
+import type { Catalog, Finding, SlideSelection, UnresolvedReferenceDiagnostic } from "@openpresentation/opf";
+export type { SlideSelection } from "@openpresentation/opf";
 import type { SlideComposition, LayoutDiagnostic, TextMeasurement } from "@openpresentation/opf/composition";
 export declare const packageName = "@openpresentation/opf-render";
 
@@ -49,8 +50,8 @@ export type RenderDiagnostic = LayoutDiagnostic | {
   placeholder: "label" | "icon";
 };
 
-export interface RenderSvgOptions {
-  /** Leave out slides marked `hidden: true`, as the player does. Default false: one SVG per slide. With true the result holds only the visible slides, in order, so an index no longer names the slide at that index. Read by the deck-level `renderSvg`; `renderSlideSvg` draws the slide it is given. */
+export interface ToSvgOptions {
+  /** Leave out slides marked `hidden: true` when drawing the whole deck, as the player does. Default false: one SVG per slide. A slide number or selection draws exactly the slides it names. */
   skipHidden?: boolean;
   /**
    * The fonts the deck is laid out and drawn with: the handle `loadFonts()` returns (from `@openpresentation/opf-render/fonts-node` or
@@ -58,10 +59,12 @@ export interface RenderSvgOptions {
    * core's portable width estimate and the SVG names the design fonts without embedding them.
    */
   fonts?: RenderFonts;
-  /** `false` writes no `@font-face` data into the SVG (RR-61): the fonts handle still measures and the SVG still names the families, for a host whose page already has the faces (a browser `loadFonts` handle adds them to the document). Default true: each SVG embeds the faces of `fonts.embeddedFonts` its own text draws. */
-  embedFonts?: boolean;
   /**
-   * `true` draws every `<text>` as glyph outlines (RR-64): `<use>` of outlines kept once per slide in `<defs>`, so the SVG needs
+   * How the SVG draws text (RR-74). `"fonts"` (default): each SVG embeds, as `@font-face` data, the faces of `fonts.embeddedFonts` its
+   * own text draws (RR-61). `"system"`: no `@font-face` data; the fonts handle still measures and the SVG still names the families,
+   * for a host whose page already has the faces (a browser `loadFonts` handle adds them to the document).
+   *
+   * `"paths"`: every `<text>` drawn as glyph outlines (RR-64): `<use>` of outlines kept once per slide in `<defs>`, so the SVG needs
    * no font and looks the same in every viewer (about 40 KB a slide over the core example decks, against 0.5 to 4 MB of embedded
    * faces). Needs the fonts handle `loadFonts()` returns (`text-as-paths-needs-fonts` otherwise). The text is no longer text: it
    * cannot be edited in place. The glyphs are shaped by HarfBuzz (the browser's shaper; the Node handle always, a browser handle
@@ -70,9 +73,9 @@ export interface RenderSvgOptions {
    * A run stays text, reported as `text-as-paths-fallback` with a `reason`, when its font is a colour or bitmap font
    * (`"colour-font"`), its face's fsType restricts embedding (`"restricted"`), or it has no pinned width and HarfBuzz and the
    * layout's measurement disagree on it (`"shaping"`). Use it for thumbnails, previews and portable SVG files, not for an editing
-   * surface or the vector PDF (which keeps real text from `<text>` SVG). Default false.
+   * surface or the vector PDF (which keeps real text from `<text>` SVG).
    */
-  textAsPaths?: boolean;
+  text?: "fonts" | "system" | "paths";
   /**
    * `false` embeds whole faces (RR-65). By default, with a fonts handle that carries `subsets` (the Node `loadFonts` handle, a browser
    * handle given `subsetWasm`), each face an SVG embeds is cut to the characters the slide draws, keeping every layout feature, so the
@@ -119,20 +122,8 @@ export interface RenderSvgOptions {
   strictReferences?: boolean;
 }
 
-export interface SvgToPngOptions {
-  /** The fonts the conversion draws with (Node): see `SvgToPngOptions` in the main entry. */
-  fonts?: RenderFonts;
-  scale?: number;
-  background?: string;
-  dpi?: number;
-  /** Extra directories of font files to draw with. */
-  fontDirs?: string[];
-  defaultFontFamily?: string;
-  sansSerifFamily?: string;
-  monospaceFamily?: string;
-}
-
-export interface SvgToPdfOptions extends SvgToPngOptions {}
+/** The Node conversion options (types only: `toPng` and `toPdf` run in Node, or from `/export-browser`). */
+export type { ToPngOptions, ToPdfOptions } from "./index.js";
 
 export interface ResolvedPresentation {
   presentation: unknown;
@@ -185,12 +176,16 @@ export declare class OPFRenderError extends Error {
   constructor(code: string, message: string, details?: Record<string, unknown>);
 }
 
-export declare function resolvePresentation(input: unknown, options?: RenderSvgOptions): ResolvedPresentation;
-
-/** The SVG of every slide of the deck, in order. */
-export declare function renderSvg(input: unknown, options?: RenderSvgOptions): string[];
-
-/** The SVG of one slide of the deck (`index` is zero-based; out of range throws `slide-index-out-of-range`). */
-export declare function renderSlideSvg(input: unknown, index: number, options?: RenderSvgOptions): string;
+export declare function resolvePresentation(input: unknown, options?: ToSvgOptions): ResolvedPresentation;
 
+/** An SVG slide the renderer drew: its text, or its bytes. */
+export type SvgSlide = string | Uint8Array;
 
+/**
+ * The deck as SVG (RR-73). `toSvg(deck)`: every slide, in order (without the hidden ones under `skipHidden`). `toSvg(deck, 3)`: the
+ * third slide (slides count from 1; out of range throws `slide-out-of-range`). `toSvg(deck, "1-3")` or `toSvg(deck, [1, 3])`: the
+ * selected slides (a malformed selection throws `invalid-slide-selection`). The second argument may be the options instead.
+ */
+export declare function toSvg(input: unknown, options?: ToSvgOptions): string[];
+export declare function toSvg(input: unknown, slide: number, options?: ToSvgOptions): string;
+export declare function toSvg(input: unknown, slides: Exclude<SlideSelection, number>, options?: ToSvgOptions): string[];

package/dist/svg.js

@@ -19,11 +19,13 @@ import {
 } from "@openpresentation/opf";
 import { adjustedFontSize, baselineShift, createScriptFonts } from "./script-fonts.js";
 import { disabledFeaturesStyle } from "./font-compatibility.js";
+import { isSymbolEncodedFamily } from "./symbol-fonts.js";
 import { fontPolicyFor } from "@openpresentation/opf/font-policy";
 import { isDatasetChart, isDatasetTable, renderCatalogChart } from "./charts.js";
 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";
 
 export const packageName = "@openpresentation/opf-render";
 
@@ -615,9 +617,12 @@ function bindSlide(presentation, index, context) {
   // RR-17 (FF-41): a family that names its weight (Arial Black, Segoe UI Semibold and Light) keeps its own name through composition, so each run
   // resolves it again and draws the replacement's encoded weight (Montserrat 900, Red Hat Display 600 and 300); resolving the role to the
   // replacement family first would draw every run at 400 or 700 and measure it that way. Every other family resolves once, here.
+  // A symbol-encoded family (Symbol, Wingdings, Webdings; FF-45) keeps its name too: each run resolves it again and the script-font planner
+  // maps the run's private-use codes through the symbol table (symbol-fonts.js), as it does for a symbol run. Resolving the role to the open
+  // symbol face here would drop the encoding, and the codes would reach a face with no glyph for them (missing-glyph).
   for (const role of ["heading","body","code","accent"]) if (design.fonts[role] !== undefined) {
     const named = design.fonts[role], resolved = resolveTextStyle({fontFamily:named,fontWeight:role === "heading" ? 700 : 400},textMeasurement).fontFamily;
-    design.fonts[role] = fontPolicyFor(named)?.replacement?.weight !== undefined && resolved.toLowerCase() !== named.toLowerCase() ? named : resolved;
+    design.fonts[role] = isSymbolEncodedFamily(named) || fontPolicyFor(named)?.replacement?.weight !== undefined && resolved.toLowerCase() !== named.toLowerCase() ? named : resolved;
   }
   const geometry = composeSlide(slide, { ...slideContext.options, fontFamilies: design.fonts, textRasterPadding:context.options.textRasterPadding, textMeasurement });
   return {
@@ -640,22 +645,24 @@ function bindSlide(presentation, index, context) {
 }
 
 // `options.fonts` is the handle `loadFonts()` returns (or any object with a `textMeasurement` and, to embed faces in the SVG, an
-// `embeddedFonts` list). The renderer reads the two as plain options from here on. `embedFonts: false` (RR-61) keeps the
-// measurement and drops the faces, for a host whose page already holds them.
-// `textAsPaths: true` (RR-64) draws text as glyph outlines with the handle's `outlines` engine (a `loadFonts` handle carries one).
-// `subsetFonts: false` (RR-65) embeds whole faces; by default a handle with a subset engine (`fonts.subsets`) cuts each embedded
-// face to the characters the slide draws.
+// `embeddedFonts` list). The renderer reads the two as plain options from here on. `text` (RR-74) says how the SVG draws text:
+// `"fonts"` (default) embeds the faces the slide draws, cut to its glyphs when the handle carries `subsets` (RR-61, RR-65);
+// `"system"` embeds no face and names the families, for a host whose page already holds them; `"paths"` draws glyph outlines with
+// the handle's `outlines` engine, so the SVG needs no font (RR-64). `subsetFonts: false` embeds whole faces.
+const TEXT_MODES = ["fonts", "system", "paths"];
 function normalizeOptions(options) {
-  const { fonts, embedFonts, textAsPaths, subsetFonts, ...rest } = options ?? {};
+  rejectRenamedOptions(options, "invalid-render-options");
+  const { fonts, text = "fonts", subsetFonts, ...rest } = options ?? {};
+  if (!TEXT_MODES.includes(text)) throw new OPFRenderError("invalid-render-options", 'text must be "fonts", "system" or "paths".', { option: "text", value: text });
   if (subsetFonts !== undefined && typeof subsetFonts !== "boolean") throw new OPFRenderError("invalid-render-options", "subsetFonts must be true or false.", { option: "subsetFonts" });
-  if (textAsPaths !== undefined && typeof textAsPaths !== "boolean") throw new OPFRenderError("invalid-render-options", "textAsPaths must be true or false.", { option: "textAsPaths" });
-  if (textAsPaths && typeof fonts?.outlines?.outlineSlideText !== "function") throw new OPFRenderError("text-as-paths-needs-fonts", "textAsPaths needs the fonts handle loadFonts() returns (from /fonts-node or /fonts-browser), passed as `fonts`.", { option: "textAsPaths" });
-  return { ...rest, textMeasurement: fonts?.textMeasurement, embeddedFonts: embedFonts === false ? undefined : fonts?.embeddedFonts, ...(textAsPaths ? { outlines: fonts.outlines } : {}), ...(subsetFonts !== false && fonts?.subsets ? { subsets: fonts.subsets } : {}) };
+  if (typeof fonts === "string" || Array.isArray(fonts)) throw new OPFRenderError("invalid-render-options", "Drawing a deck needs the fonts handle loadFonts() returns (from /fonts-node or /fonts-browser): it measures the text. Font folders are read by toPng and toPdf for SVG input.", { option: "fonts" });
+  if (text === "paths" && typeof fonts?.outlines?.outlineSlideText !== "function") throw new OPFRenderError("text-as-paths-needs-fonts", 'text: "paths" needs the fonts handle loadFonts() returns (from /fonts-node or /fonts-browser), passed as `fonts`.', { option: "text" });
+  return { ...rest, textMeasurement: fonts?.textMeasurement, embeddedFonts: text === "system" ? undefined : fonts?.embeddedFonts, ...(text === "paths" ? { outlines: fonts.outlines } : {}), ...(subsetFonts !== false && fonts?.subsets ? { subsets: fonts.subsets } : {}) };
 }
 
 /**
  * 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. `renderSvg` and `renderSlideSvg` draw from this.
+ * layout, design, script fonts and composed geometry. `toSvg` draws from this.
  */
 export function resolvePresentation(input, options = {}) {
   return resolveDeck(input, normalizeOptions(options));
@@ -678,27 +685,24 @@ function resolveDeck(input, options) {
 }
 
 /**
- * The SVG of every slide of the deck, in order. `skipHidden: true` leaves out slides marked `hidden` (the sequence the player
- * presents); the result is then shorter than the deck, so an index no longer names the slide at that index.
+ * The deck as SVG (RR-73): `toSvg(deck)` gives every slide, in order, as an array; `toSvg(deck, 3)` the third slide as one string
+ * (slides count from 1); `toSvg(deck, "1-3")` (`"2,4"`, `"5-"`, the CLI's --slides syntax, or a list such as `[1, 3]`) the selected slides as an array. The
+ * second argument may be the options instead, told apart by type. `skipHidden: true` leaves slides marked `hidden` out of the
+ * whole deck (the sequence the player presents); a selection draws exactly the slides it names.
  */
-export function renderSvg(input, options = {}) {
-  const drawn = normalizeOptions(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);
-  const indexes = resolved.slides.map((_, index) => index).filter(index => !(options.skipHidden === true && resolved.presentation.slides[index]?.hidden === true));
-  return indexes.map(index => renderResolvedSlide(resolved, index, drawn));
-}
-
-/** The SVG of one slide of the deck (a zero-based index). */
-export function renderSlideSvg(input, index, options = {}) {
-  const drawn = normalizeOptions(options);
-  const resolved = resolveDeck(input, drawn);
-  if (!Number.isInteger(index) || index < 0 || index >= resolved.slides.length) {
-    throw new OPFRenderError("slide-index-out-of-range", `Slide index ${index} is out of range.`, {
-      slideIndex: index,
-      slideCount: resolved.slides.length
-    });
+  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 });
+    return renderResolvedSlide(resolved, slides - 1, drawn);
   }
-  return renderResolvedSlide(resolved, index, drawn);
+  const numbers = slides === undefined
+    ? resolved.slides.map((_, index) => index + 1).filter(number => !(options?.skipHidden === true && resolved.presentation.slides[number - 1]?.hidden === true))
+    : selectSlides(slides, count);
+  return numbers.map(number => renderResolvedSlide(resolved, number - 1, drawn));
 }
 
 function renderResolvedSlide(resolved, slideIndex, options) {
@@ -1697,12 +1701,27 @@ function renderBranding(bound,presentation,width,height,options) {
     // The group keeps its bare opacity attribute (opf-pptx's watermark parity test reads it); the picture itself is hidden.
     pieces.push(tag('g',{opacity:typeof design.watermark==='object'?design.watermark.opacity??.08:.08},renderImage({value:design.watermark,path:rootFor('watermark')},{x:width*.3,y:height*.3,width:width*.4,height:height*.4},bound,{...options,imageFit:'contain',imageDecorative:true})));
   }
-  // Cover and section slides: the deck logo core composed at the top-left of the free area, anchored left.
+  // Cover and section slides: the logo core composed (the primary organization's full logo, or the design.logo override, in the
+  // variant for this slide's background) at the top-left of the free area, anchored left. RR-71: the picture is named by its
+  // asset's alt text, else by the organization it belongs to ("Acme Corp logo"); an unnamed organization still says "Logo".
   const logo=bound.geometry.logo;
-  if(logo)pieces.push(renderImage({value:logo.source,path:logo.path},logo.box,bound,{...options,imageAnchor:logo.anchor??'left',imageLabel:'Logo',imageGenerated:true}));
+  if(logo)pieces.push(renderImage({value:logo.source,path:logo.path},logo.box,bound,{...options,imageAnchor:logo.anchor??'left',imageLabel:logoLabel(presentation,logo.path),imageGenerated:true}));
   return pieces.join('');
 }
 
+// The organization a logo path (`organization.logo.full`, `organization.1.logo.icon.onDark`) belongs to: the record at the index the path
+// names, else the single organization object.
+function logoOrganization(presentation,path){
+  const match=/^organization(?:\.(\d+))?\.logo(?:\.|$)/.exec(path??'');
+  if(!match)return undefined;
+  const organization=presentation?.organization;
+  return Array.isArray(organization)?organization[Number(match[1])]:match[1]===undefined?organization:undefined;
+}
+function logoLabel(presentation,path){
+  const name=logoOrganization(presentation,path)?.name;
+  return typeof name==='string'&&name.trim()?`${name.trim()} logo`:'Logo';
+}
+
 // A family name is written unquoted only when it is a valid sequence of CSS identifiers; a word that starts with a digit
 // ("Source Sans 3", "Noto Sans Symbols 2") or any other non-identifier character makes an unquoted name invalid CSS, which
 // drops the whole font-family in a browser (FF-45). Such names are single-quoted (the attribute is double-quoted).

package/dist/text-paths.js

@@ -1,4 +1,4 @@
-// RR-64: `textAsPaths: true` draws every <text> of a slide as glyph outlines, so the SVG needs no font. The renderer has
+// RR-64: `text: "paths"` draws every <text> of a slide as glyph outlines, so the SVG needs no font. The renderer has
 // already decided every line, position and width (x, y, text-anchor, textLength); the vector PDF export's SVG text layout
 // (layoutText: text chunks, bidirectional runs, per-character fallback, fontkit shaping, textLength) turns that into positioned
 // glyph runs, and this module writes each glyph as a <use> of its outline. Outlines are kept once per slide in <defs>, in font
@@ -96,7 +96,7 @@ export function outlineSlideText(content, { library, shaper, rootStyle = {}, rep
     defaults: [],
     splitByOwner: true,
     // HarfBuzz, the browser's shaper, when the handle carries one (RR-64 phase 2); fontkit otherwise.
-    ...(shaper ? { shape: (face, text, options) => shaper.shape(face.hash, face.data, text, { ...options, language: options.lang }) } : {}),
+    ...(shaper ? { shape: harfBuzzShape(shaper) } : {}),
     // The renderer reports its own font substitutions and missing glyphs while it lays the slide out.
     diagnostic: () => {},
     missing: () => {},
@@ -316,15 +316,27 @@ function precise(value) { return String(Number(Number(value).toPrecision(6))); }
 
 
 /**
- * The outline engine a fonts handle carries as `outlines` (RR-64): `renderSvg(deck, { fonts, textAsPaths: true })` draws each
+ * The outline engine a fonts handle carries as `outlines` (RR-64): `toSvg(deck, { fonts, text: "paths" })` draws each
  * slide's text with it. The faces are read from the handle when a slide is outlined, so faces it loads later are used too.
  */
 export function textOutlines(fonts) {
   return Object.freeze({
     outlineSlideText: (content, options) => {
       const library = outlineLibrary(fonts);
-      if (!library) throw options.fail("text-as-paths-needs-fonts", "textAsPaths needs font faces to outline: pass the handle loadFonts() returns as `fonts`.");
+      if (!library) throw options.fail("text-as-paths-needs-fonts", 'text: "paths" needs font faces to outline: pass the handle loadFonts() returns as `fonts`.');
       return outlineSlideText(content, { ...options, library, shaper: fonts.shaper });
     },
+    // opf-render#188: the vector PDF shapes its runs with the same HarfBuzz. Each character stays with the glyph it became (cluster
+    // level 2: a mark, a reordered vowel sign), so the PDF's glyph-to-Unicode map and /ActualText spans give the text as before;
+    // the glyphs and positions are the outlines'.
+    ...(fonts.shaper ? { shape: harfBuzzShape(fonts.shaper, { clusterLevel: 2 }) } : {}),
   });
 }
+
+/**
+ * A layoutText `env.shape` over a HarfBuzz shaper (hb-shape.js), for faces of a FontLibrary (keyed by their content hash).
+ * HarfBuzz takes the BCP 47 tag (`lang`); fontkit the OpenType language system (`language`).
+ */
+function harfBuzzShape(shaper, { clusterLevel } = {}) {
+  return (face, text, options) => shaper.shape(face.hash, face.data, text, { ...options, language: options.lang, clusterLevel });
+}