@openpresentation/opf-render 0.17.1 → 0.18.1

package/dist/index.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
@@ -118,18 +121,18 @@ export interface RenderSvgOptions {
   strictReferences?: boolean;
 }
 
-export interface SvgToPngOptions {
+/** The options of `toPng`: the conversion's own, and the `toSvg` options that draw a deck. */
+export interface ToPngOptions extends Omit<ToSvgOptions, "fonts"> {
   /**
-   * The fonts the conversion draws with: the handle `loadFonts()` returns from `/fonts-node` (its `fontFiles`; `useBundledFonts` and
-   * `loadSystemFonts` say whether the bundled base faces are added, default true, and whether system fonts load, default false). Without
-   * it the bundled base faces draw. The same handle goes to `renderSvg`, so the preview and the PNG use the same faces.
+   * The fonts the deck is laid out and drawn with: the handle `loadFonts()` returns from `/fonts-node` (it measures the deck, and its
+   * `fontFiles` draw; `useBundledFonts` and `loadSystemFonts` say whether the bundled base faces are added, default true, and whether
+   * system fonts load, default false), so the preview and the PNG use the same faces. For SVG input it may instead be font folders
+   * (a path or a list of paths), whose faces are added to the bundled base faces. Without it the bundled base faces draw.
    */
-  fonts?: RenderFonts;
+  fonts?: RenderFonts | string | readonly string[];
   scale?: number;
   background?: string;
   dpi?: number;
-  /** Extra directories of font files to draw with. */
-  fontDirs?: string[];
   defaultFontFamily?: string;
   sansSerifFamily?: string;
   monospaceFamily?: string;
@@ -198,14 +201,14 @@ export interface PdfMetadata {
   modificationDate?: Date | string;
 }
 
-export interface SvgToPdfOptions extends SvgToPngOptions {
+export interface ToPdfOptions extends Omit<ToPngOptions, "onDiagnostic"> {
   /**
-   * `"vector"` (default): shapes, gradients and patterns as PDF vector graphics, pictures as images, text as real text
-   * with embedded font subsets (selectable, searchable, correct copy and paste); the fonts are the bundled files, the `fonts` handle's
-   * `fontFiles` and the `fontDirs` you supply, never system fonts. `"raster"`: each slide an image, as before.
+   * `true` draws each slide as an image (`scale`). Default false, a vector PDF: shapes, gradients and patterns as PDF vector graphics,
+   * pictures as images, text as real text with embedded font subsets (selectable, searchable, correct copy and paste); the fonts are
+   * the bundled files, the `fonts` handle's `fontFiles` and the font folders you supply, never system fonts.
    */
-  mode?: "vector" | "raster";
-  /** Vector mode paints the page this colour first (default white, as raster mode composites on white); `"none"` leaves it unpainted. */
+  raster?: boolean;
+  /** A vector PDF paints the page this colour first (default white, as a raster PDF composites on white); `"none"` leaves it unpainted. */
   background?: string;
   /** Vector only. Family drawn for the generic `serif`; default `defaultFontFamily`. */
   serifFamily?: string;
@@ -219,8 +222,8 @@ export interface SvgToPdfOptions extends SvgToPngOptions {
   strict?: boolean;
   /** Vector only. Pixel density of the rare element rasterized because it has no vector form; default 2. */
   rasterFallbackScale?: number;
-  /** Vector only. Receives font embedding reports, substitutions, fallbacks and unsupported features. */
-  onDiagnostic?: (diagnostic: PdfDiagnostic) => void;
+  /** Vector only: font embedding reports, substitutions, fallbacks and unsupported features; given a deck, also the diagnostics of drawing it. */
+  onDiagnostic?: (diagnostic: PdfDiagnostic | RenderDiagnostic) => void;
   /** Vector only. Checked between pages; an abort rejects with the signal's reason. */
   signal?: AbortSignal;
   /** Vector only. Called after each page is written. */
@@ -278,14 +281,32 @@ export declare class OPFRenderError extends Error {
   constructor(code: string, message: string, details?: Record<string, unknown>);
 }
 
-export declare function resolvePresentation(input: unknown, options?: RenderSvgOptions): ResolvedPresentation;
+export declare function resolvePresentation(input: unknown, options?: ToSvgOptions): ResolvedPresentation;
 
-/** The SVG of every slide of the deck, in order. */
-export declare function renderSvg(input: unknown, options?: RenderSvgOptions): string[];
+/** An SVG slide the renderer drew: its text, or its bytes. */
+export type SvgSlide = string | Uint8Array;
 
-/** 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;
+/**
+ * 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[];
 
-export declare function svgToPng(svg: string | Uint8Array, options?: SvgToPngOptions): Promise<Uint8Array>;
+/**
+ * PNG (RR-73) of a deck, drawn with `toSvg` (the slide arguments are `toSvg`'s: one PNG for a slide number, a list otherwise), or of
+ * SVG the renderer drew (one SVG gives one PNG, a list a list). A slide selection with SVG input throws `invalid-conversion-option`.
+ */
+export declare function toPng(svg: Uint8Array | `<${string}`, options?: ToPngOptions): Promise<Uint8Array>;
+export declare function toPng(svgs: readonly SvgSlide[], options?: ToPngOptions): Promise<Uint8Array[]>;
+export declare function toPng(deck: unknown, slide: number, options?: ToPngOptions): Promise<Uint8Array>;
+export declare function toPng(deck: unknown, slides: Exclude<SlideSelection, number>, options?: ToPngOptions): Promise<Uint8Array[]>;
+export declare function toPng(deck: object, options?: ToPngOptions): Promise<Uint8Array[]>;
+/** A string is SVG when it starts with `<`, and the deck's JSON text otherwise. */
+export declare function toPng(source: string, options?: ToPngOptions): Promise<Uint8Array | Uint8Array[]>;
 
-export declare function svgToPdf(svgs: string | Uint8Array | Array<string | Uint8Array>, options?: SvgToPdfOptions): Promise<Uint8Array>;
+/** One PDF (RR-73), a page per slide: of a deck drawn with `toSvg` (every slide, or a selection: `toPdf(deck, "2-4")`), or of SVG slides. */
+export declare function toPdf(source: unknown, options?: ToPdfOptions): Promise<Uint8Array>;
+export declare function toPdf(deck: unknown, slides: SlideSelection, options?: ToPdfOptions): Promise<Uint8Array>;

package/dist/index.js

@@ -1,2 +1,2 @@
 export * from './svg.js';
-export {svgToPng,svgToPdf} from './raster.js';
+export {toPng,toPdf} from './raster.js';

package/dist/lazy-fonts.js

@@ -1,6 +1,6 @@
 import { fontPolicyFor } from "@openpresentation/opf/font-policy";
 import { pickFace } from "./font-registry.js";
-import { renderSvg, resolvePresentation } from "./svg.js";
+import { resolvePresentation, toSvg } from "./svg.js";
 export { lazyFontEntries, lazyFontList } from "./lazy-font-list.js";
 
 /**
@@ -17,7 +17,7 @@ const lc = value => String(value).trim().toLowerCase();
 
 /**
  * Render options that decide how a document resolves (catalogs, validate, date, ...) are forwarded from the host's
- * `renderSvg` options. The analysis supplies its own measurement and reports nothing: callbacks, the host's fonts handle
+ * `toSvg` options. The analysis supplies its own measurement and reports nothing: callbacks, the host's fonts handle
  * (measurement and embedded fonts), asset resolution and tracing are dropped.
  */
 const NOT_RESOLVE_OPTIONS = new Set(["fonts", "onDiagnostic", "trace", "glyphFallback", "imageResolver", "strictAssets", "signal"]);
@@ -27,10 +27,10 @@ function resolveOptionsOf(options) {
 
 /**
  * The font families a presentation's slides resolve (heading, body and code roles of every slide, including per-slide
- * design overrides), as `renderSvg` resolves them with the same `options` (`catalogs`, ...). This is the role families,
+ * design overrides), as `toSvg` resolves them with the same `options` (`catalogs`, ...). This is the role families,
  * not what is drawn: use `presentationFaces` for that.
  *
- * A document that does not resolve throws the error `renderSvg` throws for it (an OPFRenderError such as
+ * A document that does not resolve throws the error `toSvg` throws for it (an OPFRenderError such as
  * `catalog-resolution-failed` for a layout id no catalog has, or `invalid-opf`), never an empty set: a document whose layout comes only from
  * `options.catalogs` needs those catalogs here too.
  */
@@ -57,7 +57,7 @@ function registryView({ faces, policy = "none", aliases = new Map(), fallbackFam
 
 /**
  * The faces a preview of the presentation draws, as `[{family, weight, italic}]`, sorted by family, style and weight. It is
- * the renderer's own layout and painting run with a recording measurement, so it follows exactly what `renderSvg` measures
+ * the renderer's own layout and painting run with a recording measurement, so it follows exactly what `toSvg` measures
  * and draws: the heading and body roles of every slide that draws them, bold and italic runs of rich text, table and cell
  * styles, header and footer furniture, chart labels, metrics, quotes and timelines, the code role only where code is
  * drawn, per-slide design overrides, font scheme and theme resolution, and script slots (a script run is requested in its
@@ -73,8 +73,8 @@ function registryView({ faces, policy = "none", aliases = new Map(), fallbackFam
  * family found. The result is the faces the registry paints, for example `Intos 700` for a 600-weight label of an Aptos
  * deck. A style the registry cannot resolve is left as named (drawing reports it).
  *
- * `options` are the `renderSvg` options the document resolves with (`catalogs`, `date`, `validate`, ...). A document that
- * does not resolve throws what `renderSvg` throws for it.
+ * `options` are the `toSvg` options the document resolves with (`catalogs`, `date`, `validate`, ...). A document that
+ * does not resolve throws what `toSvg` throws for it.
  * @param {unknown} presentation
  * @param {object} [options]
  * @param {{faces: Iterable<{family: string, weight: number, italic: boolean}>, policy?: "none"|"metric"|"visual", aliases?: ReadonlyMap<string, string>, fallbackFamily?: string}} [registry]
@@ -98,7 +98,7 @@ export function presentationFaces(presentation, options = {}, registry) {
     measure(text, size, style) { if (text !== "") record(settle(style)); return String(text).length * size * RECORDED_EM; },
     resolveStyle: settle,
   };
-  renderSvg(presentation, { ...resolveOptionsOf(options), fonts: { textMeasurement } });
+  toSvg(presentation, { ...resolveOptionsOf(options), fonts: { textMeasurement } });
   return [...seen.values()].sort((a, b) => a.family < b.family ? -1 : a.family > b.family ? 1 : Number(a.italic) - Number(b.italic) || a.weight - b.weight);
 }
 
@@ -106,8 +106,8 @@ export function presentationFaces(presentation, options = {}, registry) {
  * The vendored faces (of `lazy`) a presentation draws that the registry does not hold: what a registry loads before it can
  * paint the document as Node paints it with every vendored face loaded. `held` lists the registry's faces
  * (`registry.describeFaces()`), `loaded` the lazy files already loaded; `policy`, `aliases` and `fallbackFamily` are the
- * registry's. `renderOptions` are the `renderSvg` options the document resolves with (`catalogs`, ...), and a document that
- * does not resolve throws what `renderSvg` throws for it. Face level: a bold or italic run added by an edit adds just that face.
+ * registry's. `renderOptions` are the `toSvg` options the document resolves with (`catalogs`, ...), and a document that
+ * does not resolve throws what `toSvg` throws for it. Face level: a bold or italic run added by an edit adds just that face.
  */
 export function lazyFacesNeeded(presentation, renderOptions, { lazy, held, loaded = new Set(), policy = "none", aliases = new Map(), fallbackFamily }) {
   const heldFaces = [...held], heldKeys = new Set(heldFaces.map(faceKeyOf));

package/dist/node-resolve.js

@@ -0,0 +1,24 @@
+// render#199: the files the Node entries read from disk (harfbuzzjs's .wasm, the installed `@expo-google-fonts/*` packages and this
+// package's vendored `fonts/` directory) are located at run time, by Node's own resolution from this file, in a form bundlers leave
+// alone. A bundler (Next.js Turbopack, webpack) treats `require.resolve` on `createRequire(import.meta.url)` as a module import: a
+// literal .wasm specifier is compiled as a WebAssembly module (which fails `next build`), a computed one (`${name}/package.json`)
+// becomes a stub that always throws, and `new URL(`../${dir}/`, import.meta.url)` becomes the URL of an unrelated emitted asset.
+// Here `createRequire` is reached through the module namespace and the specifier is a variable behind the bundlers' ignore comments,
+// so neither is traced, and the package root is computed from this file's path. Plain Node resolves exactly as before.
+import * as nodeModule from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** This package's root directory (the parent of `dist/`). */
+export const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+const requireHere = nodeModule.createRequire(import.meta.url);
+
+/**
+ * The absolute path of an installed file (`harfbuzzjs/dist/harfbuzz.wasm`, `@expo-google-fonts/roboto/package.json`), resolved as
+ * `require.resolve` resolves it from this package, or from `directory` when given. Throws `MODULE_NOT_FOUND` like `require.resolve`.
+ */
+export function resolveInstalled(specifier, directory) {
+  const resolver = directory === undefined ? requireHere : nodeModule.createRequire(path.join(directory, "package.json"));
+  return resolver.resolve(/* webpackIgnore: true */ /* turbopackIgnore: true */ specifier);
+}

package/dist/pdf-fonts.js

@@ -4,7 +4,7 @@ import { isTrueTypeOutlines, subsetTrueType } from "./pdf-subset.js";
 import { hex, name, num, sha256, textString, utf16Hex } from "./pdf-writer.js";
 
 // Font selection, shaping and embedding for the vector PDF export (RR-12). Fonts come only from the faces the
-// caller supplies (the same bundled font files, `fontFiles` and `fontDirs` the PNG preview draws with, and the
+// caller supplies (the same bundled font files, fonts handle or font folders the PNG preview draws with, and the
 // `@font-face` data of the SVG itself); nothing is read from the system and nothing is fetched. A face whose
 // OS/2 embedding bits forbid embedding is never embedded.
 

package/dist/pdf-text.js

@@ -7,8 +7,8 @@ import { attributesOf, inheritStyle, parseFontFamilies, parseFontWeight, parseLe
 // SVG text layout for the vector PDF export (RR-12): the renderer has already decided every line, position and
 // width (x, y, text-anchor, textLength), so this module only turns that into positioned glyph runs: text chunks,
 // the Unicode bidirectional algorithm (the SVG carries directional isolates around right-to-left paragraphs),
-// per-character font fallback, OpenType shaping with fontkit and textLength adjustment. It never wraps, shrinks
-// or truncates text.
+// per-character font fallback, OpenType shaping (HarfBuzz through `env.shape` when the fonts handle has it, fontkit
+// otherwise) and textLength adjustment. It never wraps, shrinks or truncates text.
 
 const bidi = bidiFactory();
 const IGNORED = /[⁦-⁩‎‏‪-‮؜]/u;
@@ -245,8 +245,8 @@ function shapeRun(run, env) {
   const size = parseFloat(style["font-size"]) || 16;
   const direction = run.level % 2 === 1 ? "rtl" : "ltr";
   const language = openTypeLanguage(style.lang ?? style["xml:lang"]);
-  // RR-64: outlined text is shaped by HarfBuzz (env.shape), the browser's shaper; the vector PDF keeps fontkit.
-  // HarfBuzz takes the BCP 47 tag (`lang`); fontkit the OpenType language system (`language`).
+  // RR-64, opf-render#188: outlined text and the vector PDF are shaped by HarfBuzz (env.shape), the browser's shaper, when the
+  // fonts handle carries it; fontkit otherwise. HarfBuzz takes the BCP 47 tag (`lang`); fontkit the OpenType language system (`language`).
   const glyphs = (env.shape ?? shape)(run.face, run.text, { features: featuresOf(style), language, lang: style.lang ?? style["xml:lang"], direction });
   const scale = size / run.face.upem;
   const letterSpacing = parseLength(style["letter-spacing"], { fontSize: size }) ?? 0;

package/dist/pdf-vector.js

@@ -81,6 +81,8 @@ class Converter {
     this.env = {
       fonts: this.fonts,
       defaults: this.defaults,
+      // opf-render#188: HarfBuzz, the browser's shaper, from the fonts handle (`fonts.outlines.shape`); fontkit without one.
+      ...(typeof options.shape === "function" ? { shape: options.shape } : {}),
       diagnostic: (d) => this.diagnostic(d),
       // A feature the PDF cannot give: reported once per character and family, fatal under `strict`.
       missing: (d) => {
@@ -89,7 +91,7 @@ class Converter {
         this.reported.add(key);
         this.unsupported(d.code, d.message, { fontFamily: d.fontFamily, codePoint: d.codePoint });
       },
-      unavailable: (families) => this.error("pdf-font-unavailable", `No embeddable font face is available for ${families.length ? `'${families.join("', '")}'` : "the requested text"}. Supply font files (fontFiles/fontDirs) or keep useBundledFonts enabled.`, {}),
+      unavailable: (families) => this.error("pdf-font-unavailable", `No embeddable font face is available for ${families.length ? `'${families.join("', '")}'` : "the requested text"}. Pass the fonts handle or font folders as fonts, or keep useBundledFonts enabled.`, {}),
     };
   }
 
@@ -797,16 +799,24 @@ class Converter {
         // The text object starts at the glyph's natural position (PDFium merges an /ActualText span across adjacent objects only),
         // and the font's horizontal placement is a leading adjustment inside it.
         const shift = glyph.xOffset ? [num(-glyph.xOffset * 1000 / upem, 3)] : [];
-        operations.push({ at: [run.x + run.scaleX * penBefore, run.y - glyph.yOffset * scale], items: [...shift, `<${code}>`] });
+        // A glyph shown alone only because it follows a placed one keeps the baseline (the glyphs after it continue on its line).
+        operations.push({ at: [run.x + run.scaleX * penBefore, run.y - (placed ? glyph.yOffset * scale : 0)], items: [...shift, `<${code}>`] });
         current = null;
-        pending = 0;
+        // After a glyph that is not itself placed, the text continues from it: what its shaped advance (and its placement)
+        // differs from the font's width moves the next glyph (opf-render#188: a zero-width joiner after a mark put the rest of
+        // the run its nominal width off). After a placed glyph the next one is placed by its own Td.
+        pending = placed ? 0 : nominal - shaped + glyph.xOffset * 1000 / upem;
         placedBefore = placed;
         return;
       }
       if (current === null) { current = { items: [] }; operations.push(current); }
+      // A small horizontal placement (at most the threshold above) moves the glyph inside the TJ array and back after it
+      // (opf-render#188: it was dropped, which put an Arabic or Telugu glyph up to 0.025 em off).
+      const shift = glyph.xOffset * 1000 / upem;
+      pending -= shift;
       addNumber();
       hex += code;
-      pending += nominal - shaped;
+      pending += nominal - shaped + shift;
     };
     // Each unit is a glyph, or for a left-to-right run the glyph map cannot give back (reordered Indic or Khmer clusters, a
     // no-break space) a cluster of glyphs. A unit whose text the map cannot give carries it as /ActualText, one span per
@@ -1228,7 +1238,7 @@ async function listFonts(directory, { readdir, path }) {
 }
 
 /**
- * Convert SVG slides to a vector PDF. `options` carries the resolved conversion settings (see svgToPdf in raster.js).
+ * Convert SVG slides to a vector PDF. `options` carries the resolved conversion settings (see toPdf in raster.js).
  */
 export async function svgsToVectorPdf(svgs, options) {
   const converter = new Converter(options);

package/dist/pdf-writer.js

@@ -1,4 +1,4 @@
-import pako from "pako";
+import { deflate } from "pako";
 import { sha256Bytes } from "./sha256.js";
 
 // A small PDF object writer for the vector export (RR-12). Everything it emits is a pure function of the objects
@@ -62,8 +62,11 @@ export function ref(number) {
   return `${number} 0 R`;
 }
 
+// legacyHash keeps the classic zlib hash (canonical zlib bytes, as pako 1 wrote them). pako 3 defaults to the faster hash
+// of Chromium zlib (Node), which writes different and about 1% larger streams: the inflated content is the same, the
+// PDF bytes and their hashes are not.
 export function flate(bytes) {
-  return pako.deflate(bytes, { level: 9 });
+  return deflate(bytes, { level: 9, legacyHash: true });
 }
 
 export function sha256(bytes) {

package/dist/pdf.d.ts

@@ -1,2 +1,2 @@
-export { svgToPdf } from "./index.js";
-export type { SvgToPdfOptions, PdfDiagnostic, PdfMetadata } from "./index.js";
+export { toPdf } from "./index.js";
+export type { ToPdfOptions, PdfDiagnostic, PdfMetadata } from "./index.js";

package/dist/pdf.js

@@ -1,4 +1,4 @@
-// RR-63: the PDF format entry (Node). The default vector `svgToPdf` needs no converter for text and shapes; it loads the optional peer
-// `sharp` for pictures and `@resvg/resvg-js` for the rare element it rasterizes, and `mode: "raster"` also loads `pdf-lib`. A converter
+// RR-63: the PDF format entry (Node). The default vector `toPdf` needs no converter for text and shapes; it loads the optional peer
+// `sharp` for pictures and `@resvg/resvg-js` for the rare element it rasterizes, and `raster: true` also loads `pdf-lib`. A converter
 // that is not installed rejects with `OPFRenderError` code `converter-missing`. For a page use `@openpresentation/opf-render/export-browser`.
-export { svgToPdf } from "./raster.js";
+export { toPdf } from "./raster.js";

package/dist/player.d.ts

@@ -1,5 +1,5 @@
 import type { BrowserFontsHandle } from "./fonts-browser.js";
-import type { RenderSvgOptions } from "./svg.js";
+import type { ToSvgOptions } from "./svg.js";
 
 /**
  * Why a deck could not be loaded, drawn or presented. `code` is stable: `invalid-document`, `fetch-failed`, `fonts-unavailable`,
@@ -19,8 +19,8 @@ export type BlankMode = "none" | "black" | "white";
 export interface PresentOptions {
   /** The self-hosted font root URL (see `copyPreviewFonts`), or a browser fonts handle the page already has (`loadFonts` from `/fonts-browser`). Without it layout uses estimated widths and system fonts. */
   fonts?: string | BrowserFontsHandle;
-  /** Extra `renderSlideSvg` options (catalogs, imageResolver, date, ...). */
-  renderOptions?: Partial<RenderSvgOptions>;
+  /** Extra `toSvg` options (catalogs, imageResolver, date, ...). */
+  renderOptions?: Partial<ToSvgOptions>;
   /** 1-based slide to start on, in the sequence that plays. Default 1. */
   startSlide?: number;
   /** Play hidden slides too. Default false. */

package/dist/player.js

@@ -35,7 +35,10 @@ const AUDIENCE_CSS = `
 .goto[hidden] { display: none; }
 .sr-only { position: absolute; width: 1px; height: 1px; margin: -1px; padding: 0; overflow: hidden; clip-path: inset(50%); white-space: nowrap; border: 0; }
 .msg { position: absolute; inset: 0; display: grid; place-items: center; padding: 24px; text-align: center; }
-@media (forced-colors: active) { .hud button { border-color: ButtonText; } }
+@media (forced-colors: active) {
+  .hud button { border-color: ButtonText; }
+  .hud button[aria-disabled="true"] { opacity: 1; color: GrayText; border-color: GrayText; }
+}
 `;
 
 const PRESENTER_CSS = `
@@ -63,7 +66,10 @@ button[aria-pressed="true"] { background: #3d5a99; }
 button[aria-disabled="true"] { opacity: 0.45; cursor: default; }
 .sr-only { position: absolute; width: 1px; height: 1px; margin: -1px; padding: 0; overflow: hidden; clip-path: inset(50%); white-space: nowrap; border: 0; }
 @media (max-width: 760px) { main { grid-template-columns: 1fr; overflow: auto; } }
-@media (forced-colors: active) { button, .notes, .slidebox { border-color: ButtonText; } }
+@media (forced-colors: active) {
+  button, .notes, .slidebox { border-color: ButtonText; }
+  button[aria-disabled="true"] { opacity: 1; color: GrayText; border-color: GrayText; }
+}
 `;
 
 /** Document indexes in the presentation order, from the options. */
@@ -632,7 +638,7 @@ async function readSource(source, signal) {
  * player covers the page at once (and asks for full screen), then resolves with the running session when the first slide is
  * drawn. Call it from a click or key handler: full screen and the speaker view both need a user gesture.
  *
- * Options: `fonts` (the self-hosted font root URL, or a browser fonts handle from `loadFonts`), `renderOptions` (extra `renderSlideSvg` options),
+ * Options: `fonts` (the self-hosted font root URL, or a browser fonts handle from `loadFonts`), `renderOptions` (extra `toSvg` options),
  * `startSlide` (1-based), `includeHidden`, `fullscreen` (default true), `presenterView` (open the speaker view too),
  * `role: "presenter"` (this window is the speaker view: for a second tab or window of your page), `channel` (name, or `false`
  * for no sync), `container`, `signal` and `now` (an injectable clock).

package/dist/png.d.ts

@@ -1,2 +1,2 @@
-export { svgToPng } from "./index.js";
-export type { SvgToPngOptions } from "./index.js";
+export { toPng } from "./index.js";
+export type { ToPngOptions } from "./index.js";

package/dist/png.js

@@ -1,4 +1,4 @@
-// RR-63: the PNG format entry (Node). `svgToPng` loads the optional peers `@resvg/resvg-js` (and `sharp` for WebP and rotated JPEG
+// RR-63: the PNG format entry (Node). `toPng` loads the optional peers `@resvg/resvg-js` (and `sharp` for WebP and rotated JPEG
 // pictures) on first use and rejects with `OPFRenderError` code `converter-missing` when they are not installed. For a page use
 // `@openpresentation/opf-render/export-browser`.
-export { svgToPng } from "./raster.js";
+export { toPng } from "./raster.js";

package/dist/preview-fonts-node.js

@@ -5,16 +5,14 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
 import { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
 import { previewFontLayout } from "./preview-fonts.js";
 import { scriptFontPackages } from "./script-font-pack.js";
+import { packageRoot as rendererRoot, resolveInstalled } from "./node-resolve.js";
 
 const ALLOWED_LICENSES = ["OFL-1.1", "Apache-2.0", "MIT", "UFL-1.0"];
 const sha256 = (bytes) => crypto.createHash("sha256").update(bytes).digest("hex");
 const safeFile = /^[A-Za-z0-9_./-]+$/;
-const rendererRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
 function within(directory, file) {
   const resolved = path.resolve(directory, file);
@@ -23,9 +21,8 @@ function within(directory, file) {
 }
 
 function resolvePackageDirectory(name, from) {
-  const searched = [createRequire(path.join(rendererRoot, "package.json")), createRequire(path.join(from ?? process.cwd(), "package.json"))];
-  for (const requireFrom of searched) {
-    try { return path.dirname(requireFrom.resolve(`${name}/package.json`)); } catch { /* try the next location */ }
+  for (const directory of [rendererRoot, from ?? process.cwd()]) {
+    try { return path.dirname(resolveInstalled(`${name}/package.json`, directory)); } catch { /* try the next location */ }
   }
   return undefined;
 }

package/dist/raster-text.js

@@ -9,7 +9,9 @@
 // For the SVG about to be rasterized (never the emitted SVG), every <text> whose content has characters of an affected script (the
 // Indic scripts, Thai, Lao, Khmer, Myanmar), or Hangul in a KOR-language text, becomes a <g> that carries the text's attributes and
 // draws its content cluster by cluster at absolute positions:
-//   - the x of each cluster is the fontkit advance of the prefix of its run, measured with the face resvg will pick for the run
+//   - the x of each cluster is the fontkit pen at its first character in its run shaped as a whole (opf-render#189: a prefix shaped
+//     alone loses the context of the next character, such as a Thai leading vowel kerned to its consonant; the prefix's advance is used
+//     where the run's glyphs do not map back to its characters, or the run has a kinzi), measured with the face resvg will pick for the run
 //     (fontdb's family, style and weight matching over the same font files, with the same glyph fallback order), the OpenType language
 //     of the SVG's lang and the policy features, scaled to the run's textLength when it has one; text-anchor middle and end are
 //     resolved into absolute starts, baseline-shift into the y;
@@ -27,6 +29,7 @@
 import { readFile } from "node:fs/promises";
 import { create } from "fontkit";
 import { disabledFeaturesFor } from "./font-compatibility.js";
+import { pinGlyphCodePoints } from "./font-registry.js";
 import { openTypeLanguage } from "./script-fonts.js";
 
 const AFFECTED = /[\p{scx=Devanagari}\p{scx=Bengali}\p{scx=Gurmukhi}\p{scx=Gujarati}\p{scx=Oriya}\p{scx=Tamil}\p{scx=Telugu}\p{scx=Kannada}\p{scx=Malayalam}\p{scx=Sinhala}\p{scx=Thai}\p{scx=Lao}\p{scx=Khmer}\p{scx=Myanmar}]/u;
@@ -353,6 +356,8 @@ async function readFace(file) {
   const data = new Uint8Array(await readFile(file));
   const font = create(data);
   if (!font?.layout || !font.unitsPerEm) return null;
+  // opf-render#125: an outline drawn for one cluster (ऱ, whose component is the nukta glyph) must not change how a later nukta shapes.
+  pinGlyphCodePoints(font);
   const records = font.name?.records ?? {};
   const names = Object.values(records.preferredFamily ?? {}).length ? Object.values(records.preferredFamily) : Object.values(records.fontFamily ?? {});
   const os2 = font["OS/2"], selection = os2?.fsSelection;
@@ -433,16 +438,42 @@ function measurePrefixes(runs, ends, props) {
   };
   const widths = [];
   try {
+    const pens = new Map();
+    // opf-render#189: the pen at a cluster boundary inside a run is read from the run shaped as a whole, so an advance its context
+    // changes (a Thai leading vowel kerned to its consonant) is the one the browser draws; a prefix shaped alone ends without it.
+    const prefix = (run, length) => {
+      if (!pens.has(run)) pens.set(run, contextPens(run.face, run.text, props));
+      return pens.get(run)?.get(length) ?? width(run.face, run.text.slice(0, length));
+    };
     let runIndex = 0, before = 0;
     for (const end of ends) {
       while (runIndex < runs.length && runs[runIndex].start + runs[runIndex].text.length <= end) { before += width(runs[runIndex].face, runs[runIndex].text); runIndex++; }
       const run = runs[runIndex];
-      widths.push(run && end > run.start ? before + width(run.face, run.text.slice(0, end - run.start)) : before);
+      widths.push(run && end > run.start ? before + prefix(run, end - run.start) : before);
     }
   } catch { return null; }
   return widths;
 }
 
+/**
+ * The pen (px) at each character offset of `value` where a glyph carrying characters starts, with `value` shaped as one run: the sum
+ * of the advances of the glyphs before it. Null for text with a kinzi (measured without it, so its offsets are not the text's).
+ */
+function contextPens(face, value, props) {
+  if (value.includes(KINZI)) return null;
+  const { run } = shapeRun(face, value, props);
+  const pens = new Map(), scale = props.fontSize / face.font.unitsPerEm;
+  let consumed = 0, pen = 0;
+  for (const [index, glyph] of run.glyphs.entries()) {
+    if (glyph.codePoints?.length) {
+      if (!pens.has(consumed)) pens.set(consumed, pen * scale);
+      for (const point of glyph.codePoints) consumed += point > 0xffff ? 2 : 1;
+    }
+    pen += run.positions[index].xAdvance;
+  }
+  return consumed === value.length ? pens : null;
+}
+
 /** The glyph outlines of one cluster, or null when fontkit needed the mark retry (its glyph placement is then not the browser's). */
 function shapeOutlines(face, value, props) {
   let shaped;