@openpresentation/opf-render 0.17.0 → 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,7 +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";
@@ -139,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 : {}; }
 
@@ -512,43 +514,56 @@ 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();
+  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 };
   const attributeText = Object.entries(attributes).filter(([, value]) => value !== undefined && value !== false).map(([name, value]) => (value === true ? ` ${name}` : ` ${name}="${escapeHtml(value)}"`)).join("")
     + (options.thumbnails ? " thumbnails" : "") + (options.present ? " present" : "") + (options.includeHidden ? " include-hidden" : "");
   const date = options.renderOptions?.date ?? options.date;
   const figures = shown.map((position) => {
     const index = sequence[position];
-    let svg = renderSlideSvg(deck, index, { ...options.renderOptions, fonts: renderFonts, ...(fontMode === "external" ? { embedFonts: false } : {}), ...(date ? { date } : {}) });
-    if (fontMode === "shared") svg = svg.replace(/<style>(@font-face[\s\S]*?)<\/style>/g, (_, css) => {
-      // These rules are produced by renderSlideSvg after its used-face selection and validation.
-      for (const rule of css.split("\n")) sharedRules.add(rule);
-      return "";
-    });
+    // 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 = 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 toSvg after its used-face selection and validation.
+        for (const rule of css.split("\n")) sharedRules.add(rule);
+        return "";
+      });
+    }
     const { width, height } = svgDimensions(svg);
     const prepared = prepareSlideSvg(svg).replace(/^<svg\b/, `<svg style="display:block;width:100%;height:auto;aspect-ratio:${width} / ${height}"`);
     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 shared = sharedRules.size ? `<style>${[...sharedRules].join("\n")}</style>` : "";
+  const subsets = options.renderOptions?.subsetFonts === false ? undefined : renderFonts?.subsets;
+  const sharedRule = (rule) => {
+    const face = /^@font-face\{font-family:"([^"]+)";font-weight:(\d+);font-style:(\w+);src:url\("([^"]+)"\)\}$/.exec(rule);
+    const points = face && sharedCharacters.get(face[1].toLowerCase());
+    if (!subsets || !points?.size) return rule;
+    return rule.replace(face[4], subsets.subsetDataUrl({ family: face[1], weight: Number(face[2]), italic: face[3] === "italic", dataUrl: face[4] }, points));
+  };
+  const shared = sharedRules.size ? `<style>${[...sharedRules].map(sharedRule).join("\n")}</style>` : "";
   return `<${tag}${attributeText}>${shared}${figures.join("")}${titles}${embedded}</${tag}>`;
 }

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-fstype.js

@@ -0,0 +1,70 @@
+// RR-76: what a face's license lets a document embed, from its OS/2 fsType (the OpenType embedding permissions). Bit 0x0002
+// (Restricted License) forbids embedding; 0x0200 (bitmap embedding only) allows only bitmaps, so an outline face cannot be
+// embedded either; 0x0100 (no subsetting) allows the whole face only. 0x0004 (preview and print) and 0x0008 (editable) allow it.
+// A face with no OS/2 table carries no restriction. No imports: the SVG writer and the subsetter both read it.
+
+const RESTRICTED = 0x0002, NO_SUBSETTING = 0x0100, BITMAP_ONLY = 0x0200;
+
+/** The OS/2 fsType of font bytes, or null when the font has no OS/2 table. */
+export function fsTypeOf(data) {
+  if (!data || data.length < 12) return null;
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const count = view.getUint16(4);
+  for (let index = 0; index < count; index++) {
+    const at = 12 + index * 16;
+    if (at + 16 > data.length) return null;
+    if (String.fromCharCode(data[at], data[at + 1], data[at + 2], data[at + 3]) !== "OS/2") continue;
+    const offset = view.getUint32(at + 8);
+    return offset + 10 <= data.length ? view.getUint16(offset + 8) : null;
+  }
+  return null;
+}
+
+/**
+ * The OS/2 fsType of a font data URL (base64), reading only the table directory and the two fsType bytes, so a large face is
+ * never decoded whole; null when the font has no OS/2 table or the URL cannot be read.
+ */
+export function dataUrlFsType(dataUrl) {
+  const comma = String(dataUrl ?? "").indexOf(",");
+  if (comma < 0) return null;
+  const base64 = dataUrl.slice(comma + 1);
+  const head = decodeRange(base64, 0, 12);
+  if (head.length < 12) return null;
+  const count = (head[4] << 8) | head[5];
+  const directory = decodeRange(base64, 12, 12 + count * 16);
+  for (let index = 0; index + 16 <= directory.length; index += 16) {
+    if (String.fromCharCode(directory[index], directory[index + 1], directory[index + 2], directory[index + 3]) !== "OS/2") continue;
+    const offset = ((directory[index + 8] << 24) | (directory[index + 9] << 16) | (directory[index + 10] << 8) | directory[index + 11]) >>> 0;
+    const bytes = decodeRange(base64, offset + 8, offset + 10);
+    return bytes.length === 2 ? (bytes[0] << 8) | bytes[1] : null;
+  }
+  return null;
+}
+
+/** Whether the face may be embedded at all (as outline data). */
+export function embeddingAllowed(fsType) {
+  return fsType === null || ((fsType & RESTRICTED) === 0 && (fsType & BITMAP_ONLY) === 0);
+}
+
+/** Whether the face may be embedded as a subset. */
+export function subsettingAllowed(fsType) {
+  return fsType !== null && embeddingAllowed(fsType) && (fsType & NO_SUBSETTING) === 0;
+}
+
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const VALUES = new Map([...ALPHABET].map((character, index) => [character, index]));
+
+// Bytes [start, end) of base64 text, decoding only the 4-character groups that hold them.
+function decodeRange(base64, start, end) {
+  const first = Math.floor(start / 3), last = Math.ceil(end / 3);
+  const text = base64.slice(first * 4, last * 4);
+  const bytes = [];
+  for (let index = 0; index + 4 <= text.length; index += 4) {
+    const [a, b, c, d] = [...text.slice(index, index + 4)].map((character) => VALUES.get(character));
+    if (a === undefined || b === undefined) break;
+    bytes.push((a << 2) | (b >> 4));
+    if (c !== undefined) bytes.push(((b & 15) << 4) | (c >> 2));
+    if (d !== undefined) bytes.push(((c & 3) << 6) | d);
+  }
+  return bytes.slice(start - first * 3, end - first * 3);
+}

package/dist/font-subset.js

@@ -0,0 +1,173 @@
+// RR-65: glyph subsets for the faces an SVG embeds as @font-face data. HarfBuzz's own subsetter (hb-subset, the
+// `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 `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
+// (a subset is a modified version, owner decision 2026-09-29), and whose OS/2 fsType allows subsetting. Every other face
+// (a host's own faces, Carlito, Raleway, ...) is embedded whole, as before.
+
+import { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
+import { sha256Bytes } from "./sha256.js";
+import { fsTypeOf, subsettingAllowed } from "./font-fstype.js";
+
+const SUBSET_LICENSES = new Set(["OFL-1.1", "Apache-2.0", "MIT", "UFL-1.0"]);
+const HB_MEMORY_MODE_READONLY = 1;
+const HB_SUBSET_SETS_LAYOUT_FEATURE_TAG = 6;
+const CACHE_LIMIT = 256;
+
+/** The manifest faces that may be subset, by sha256: permissive license, no Reserved Font Name in the family or file name. */
+const SUBSETTABLE = (() => {
+  const hashes = new Set();
+  for (const pkg of BUNDLED_FONT_MANIFEST.packages) {
+    if (!SUBSET_LICENSES.has(pkg.license)) continue;
+    const reserved = (pkg.reservedFontNames ?? []).map((name) => name.toLowerCase());
+    for (const face of pkg.faces) {
+      const names = `${face.family} ${face.file}`.toLowerCase();
+      if (!reserved.some((name) => names.includes(name)) && /^[0-9a-f]{64}$/.test(face.sha256 ?? "")) hashes.add(face.sha256);
+    }
+  }
+  return hashes;
+})();
+
+/** Whether a face may be subset: a permitted bundled face whose OS/2 fsType allows subsetting (and embedding). */
+export function subsetPermitted(data) {
+  return SUBSETTABLE.has(hexDigest(data)) && fsTypeAllowsSubset(data);
+}
+
+/** Whether the OS/2 fsType allows embedding a subset: not restricted (0x0002), not "no subsetting" (0x0100), not bitmap-only (0x0200). */
+export function fsTypeAllowsSubset(data) {
+  return subsettingAllowed(fsTypeOf(data));
+}
+
+function hexDigest(data) {
+  return [...sha256Bytes(data)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+/**
+ * A synchronous subsetter over hb-subset: `subset(data, codePoints)` returns the subset font bytes, or null when HarfBuzz
+ * cannot subset the face. `wasm` is the `harfbuzz-subset.wasm` bytes, a compiled WebAssembly.Module or an Instance.
+ */
+export function createSubsetter(wasm) {
+  // A browser instantiates asynchronously (large modules may not compile synchronously on the main thread) and passes the instance.
+  const instance = wasm instanceof WebAssembly.Instance ? wasm : new WebAssembly.Instance(wasm instanceof WebAssembly.Module ? wasm : new WebAssembly.Module(wasm), {});
+  const exports = instance.exports;
+  const required = ["memory", "malloc", "free", "hb_blob_create", "hb_blob_destroy", "hb_blob_get_length", "hb_blob_get_data", "hb_face_create", "hb_face_destroy",
+    "hb_face_reference_blob", "hb_set_add", "hb_set_clear", "hb_set_invert", "hb_subset_input_create_or_fail", "hb_subset_input_destroy", "hb_subset_input_unicode_set",
+    "hb_subset_input_set", "hb_subset_or_fail"];
+  for (const name of required) if (!(name in exports)) throw new Error(`harfbuzz-subset.wasm has no export ${name}.`);
+  return {
+    subset(data, codePoints) {
+      const pointer = exports.malloc(data.length);
+      if (!pointer) return null;
+      new Uint8Array(exports.memory.buffer, pointer, data.length).set(data);
+      const blob = exports.hb_blob_create(pointer, data.length, HB_MEMORY_MODE_READONLY, 0, 0);
+      const face = exports.hb_face_create(blob, 0);
+      const input = exports.hb_subset_input_create_or_fail();
+      let result = 0, output = null;
+      try {
+        if (!input) return null;
+        const unicodes = exports.hb_subset_input_unicode_set(input);
+        for (const codePoint of codePoints) exports.hb_set_add(unicodes, codePoint);
+        // Every layout feature, not only HarfBuzz's default list: the browser shapes the subset like the whole face whatever
+        // font-feature-settings the SVG asks for.
+        const features = exports.hb_subset_input_set(input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG);
+        exports.hb_set_clear(features);
+        exports.hb_set_invert(features);
+        result = exports.hb_subset_or_fail(face, input);
+        if (!result) return null;
+        const subsetBlob = exports.hb_face_reference_blob(result);
+        const length = exports.hb_blob_get_length(subsetBlob), at = exports.hb_blob_get_data(subsetBlob, 0);
+        output = length && at ? new Uint8Array(exports.memory.buffer, at, length).slice() : null;
+        exports.hb_blob_destroy(subsetBlob);
+        return output && glyfBeforeLastTable(output);
+      } finally {
+        if (result) exports.hb_face_destroy(result);
+        if (input) exports.hb_subset_input_destroy(input);
+        exports.hb_face_destroy(face);
+        exports.hb_blob_destroy(blob);
+        exports.free(pointer);
+      }
+    },
+  };
+}
+
+// hb-subset writes glyf as the last table. fontkit reads a 10-byte glyph header even for an empty glyph (a space), so when
+// the last glyph is empty it reads past the end of the file, and the vector PDF and the outline engine (which parse SVG
+// @font-face data with fontkit) would fail. Table order in the file is free: glyf moves before the other tables, every table
+// keeps its bytes and checksum, and head.checkSumAdjustment is recomputed for the new file.
+function glyfBeforeLastTable(font) {
+  const view = new DataView(font.buffer, font.byteOffset, font.byteLength);
+  const count = view.getUint16(4);
+  const tables = [];
+  for (let index = 0; index < count; index++) {
+    const at = 12 + index * 16;
+    tables.push({ entry: at, tag: String.fromCharCode(font[at], font[at + 1], font[at + 2], font[at + 3]), offset: view.getUint32(at + 8), length: view.getUint32(at + 12) });
+  }
+  const byOffset = [...tables].sort((a, b) => a.offset - b.offset);
+  if (byOffset.at(-1)?.tag !== "glyf" || byOffset.length < 2) return font;
+  const order = [byOffset.at(-1), ...byOffset.slice(0, -1)];
+  const padded = (length) => (length + 3) & ~3;
+  const start = 12 + count * 16;
+  const out = new Uint8Array(start + order.reduce((sum, table) => sum + padded(table.length), 0));
+  out.set(font.subarray(0, start));
+  const outView = new DataView(out.buffer);
+  let offset = start;
+  for (const table of order) {
+    out.set(font.subarray(table.offset, table.offset + table.length), offset);
+    outView.setUint32(table.entry + 8, offset);
+    offset += padded(table.length);
+  }
+  const head = tables.find((table) => table.tag === "head");
+  if (head) {
+    const at = outView.getUint32(head.entry + 8) + 8;
+    outView.setUint32(at, 0);
+    let sum = 0;
+    for (let index = 0; index < out.length; index += 4) sum = (sum + outView.getUint32(index)) >>> 0;
+    outView.setUint32(at, (0xB1B0AFBA - sum) >>> 0);
+  }
+  return out;
+}
+
+/**
+ * The subset engine a fonts handle carries as `subsets` (RR-65): `subsetDataUrl(font, codePoints)` returns the data URL of
+ * the embedded face `font` cut to the code points, or its own data URL when the face may not be subset (license, Reserved
+ * Font Name, fsType), HarfBuzz cannot subset it, or the subset is not smaller. Faces are found in the registry by family,
+ * weight and style; results are cached per face and code point set.
+ */
+export function fontSubsets(registry, subsetter) {
+  const permitted = new Map();
+  const cache = new Map();
+  const bytesOf = (font) => {
+    const faces = registry.exportFaces(), described = registry.describeFaces();
+    const index = described.findIndex((face) => face.family === font.family && face.weight === font.weight && Boolean(face.italic) === Boolean(font.italic));
+    return index >= 0 ? faces[index].data : null;
+  };
+  return Object.freeze({
+    subsetDataUrl(font, codePoints) {
+      const points = [...new Set(codePoints)].sort((a, b) => a - b);
+      const key = `${font.family}|${font.weight}|${font.italic ? 1 : 0}|${font.dataUrl.length}|${points.join(",")}`;
+      if (cache.has(key)) return cache.get(key);
+      const data = bytesOf(font);
+      let url = font.dataUrl;
+      if (data) {
+        let allowed = permitted.get(data);
+        if (allowed === undefined) { allowed = subsetPermitted(data); permitted.set(data, allowed); }
+        const subset = allowed ? subsetter.subset(data, points) : null;
+        if (subset && subset.length < data.length) url = `${font.dataUrl.slice(0, font.dataUrl.indexOf(",") + 1)}${base64(subset)}`;
+      }
+      if (cache.size >= CACHE_LIMIT) cache.delete(cache.keys().next().value);
+      cache.set(key, url);
+      return url;
+    },
+  });
+}
+
+function base64(bytes) {
+  if (typeof Buffer !== "undefined") return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+  let binary = "";
+  for (let index = 0; index < bytes.length; index += 0x8000) binary += String.fromCharCode(...bytes.subarray(index, index + 0x8000));
+  return btoa(binary);
+}