pdf-parser.js 4.7.0 → 4.8.0

package/README.md

@@ -205,7 +205,27 @@ const image = decodeJpeg2000(jp2OrCodestreamBytes); // -> { width, height, bitDe
 
 Both accept a whole JP2 file or a bare codestream; `decodeJpeg2000` takes an optional `onWarning` for recoverable cases and throws `Jpeg2000UnsupportedError` for anything outside [JPEG 2000 scope](#jpeg-2000-scope). Inside a PDF none of this needs calling: `readPdf` decodes a `/JPXDecode` image XObject through the same path automatically.
 
-The generic byte- and image-container primitives (`crc32`, `deflate`/`inflate`/`inflateTolerant`, `ByteReader`/`ByteWriter`/`concatBytes`, `readJpegInfo`, `decodePng`/`encodePng`, `unfilterScanlines`/`filterScanlines`) are re-exported from [byte-codec](../byte-codec/README.md). The PDF-specific image codecs (`decodeCcittFax`, `decodeJbig2Embedded`, `decodeJpeg2000`/`readJpeg2000Metadata`/`parseJp2Container`) stay here.
+Rendering a page, or one region of one, to pixels — for OCR, a vision model, or a thumbnail — through a rasteriser the caller supplies ([#1198](https://github.com/ExaDev/documents.js/issues/1198)):
+
+```ts
+import { renderPdfPage } from "pdf-codec";
+import { createCpuRasteriser } from "pdf-raster-cpu"; // the pure-software reference backend
+
+const pngBytes = renderPdfPage(
+  pdfBytes,
+  0,
+  { dpi: 200 },
+  createCpuRasteriser(),
+);
+```
+
+`renderPdfPage(pdfBytes, pageIndex, options, rasteriser)` walks the page's content through the same read machinery `readPdf` runs (the same interpreter, the same image recovery), transforms everything into a top-left-origin device space at the requested `scale` (or `dpi` — a PDF point is 1/72 inch, so `dpi: 144` is `scale: 2`), and drives the rasteriser with positioned draw operations: rectangle fills, filled/stroked vector paths (ellipses, arbitrary curves, and glyph outlines), and affine-placed images. It returns whatever the rasteriser's `finish()` produces — PNG bytes with the reference backend. The deliberate design point, from the issue's own clarification: **this package defines the `PageRasteriser` interface and takes an implementation; it does not pick a rasteriser or depend on any canvas API.** A runtime with no canvas at all (Cloudflare Workers has neither `canvas` nor `OffscreenCanvas`) and a runtime with a free hardware-accelerated one consume the same port, and the weight of a real raster backend lands only in the backend package a consumer installs — [`pdf-raster-cpu`](../pdf-raster-cpu/README.md) is this family's pure-software reference implementation, a browser consumer can wrap its own 2D canvas, and a Cloudflare consumer can drive Browser Rendering. No OCR, no vision, no network calls anywhere: the port hands a caller pixels and stops.
+
+`options.clipPt` names the region to render, in the same point coordinates `LayoutFrame` (and `LayoutPage` items, and `document-outline.js`'s `segmentPdfRegions` region bounds) use — PDF user space relative to the visible region's lower-left corner, y increasing upward. A caller that located a figure via `segmentPdfRegions` passes `region.bounds` straight through as `clipPt` and gets exactly that figure's pixels, re-origined at the image's own top-left and scaled; `src/raster.test.ts` pins the coordinate agreement against `readPdf` itself (including a rotated, cropped page), so the clip contract is a tested fact rather than a hope. Text render order, fill rules, and optional-content visibility follow what a viewer displays: items in a layer the default configuration leaves `OFF` are not drawn.
+
+**Text renders through the page's own embedded sfnt outlines, or not at all.** Each text run's embedded TrueType program (`/Type0` + `/Identity-H` + `/CIDFontType2`, the dominant mainstream shape, or a simple `/TrueType` font with a usable cmap) is opened with this package's own `glyf`/`cmap` readers and handed to the rasteriser as filled outline paths — a backend needs no font machinery of any kind. Faces that state no sfnt outlines are refused through named diagnostics (`raster/text-cff-outlines` for CFF programs, `raster/text-outlines-unavailable` for standard-14/unembedded fonts, Type 3 glyph procedures, and unreadable programs) rather than approximated with a substitute shape; the rest of the page still renders. Per-glyph placement follows the run's own text matrices, with one documented approximation: character-, word-, and horizontal-spacing state (`Tc`/`Tw`/`Tz`) is not modelled per glyph, and the residual is distributed uniformly across the run so its total extent always matches what the page draws.
+
+The generic byte- and image-container primitives (`crc32`, `deflate`/`inflate`/`inflateTolerant`, `ByteWriter`/`concatBytes`, `readJpegInfo`, `decodePng`/`encodePng`, `unfilterScanlines`/`filterScanlines`) are re-exported from [byte-codec](../byte-codec/README.md). The PDF-specific image codecs (`decodeCcittFax`, `decodeJbig2Embedded`, `decodeJpeg2000`/`readJpeg2000Metadata`/`parseJp2Container`) stay here.
 
 Every module under `src/` is also deep-importable directly by its own subpath:
 
@@ -222,7 +242,7 @@ One subpath is a declared entry point in its own right: **`pdf-codec/read`** (an
 import { readPdf } from "pdf-codec/read";
 ```
 
-`src/read-graph.test.ts` walks the entry's static import graph and fails the build if `write.ts`, `math-font.ts`, `font-registry.ts`, or any asset module becomes reachable (type-only imports are exempt — they erase at compile time — so a read-side module can keep typing against the root barrel's types while its runtime graph stays narrow). The entry carries `readPdf` and the read pipeline's own helpers (`normalizeRotation`, `pageRotationTransform`); the other read-adjacent surfaces it does not itself own stay deep-importable through the wildcard and are asset-free the same way — the diagnostics vocabulary (`pdf-codec/diagnostics`), the `LayoutDocument` item family (`pdf-codec/layout`), PDF string/date scalar decoding (`pdf-codec/pdf-text`), and standard-14 resolution/AFM metrics (`pdf-codec/fonts`, `pdf-codec/afm-widths`).
+`src/read-graph.test.ts` walks the entry's static import graph and fails the build if `write.ts`, `math-font.ts`, `font-registry.ts`, or any asset module becomes reachable (type-only imports are exempt — they erase at compile time — so a read-side module can keep typing against the root barrel's types while its runtime graph stays narrow). The entry carries `readPdf` and the read pipeline's own helpers (`normalizeRotation`, `pageRotationTransform`); the other read-adjacent surfaces it does not itself own stay deep-importable through the wildcard and are asset-free the same way — the diagnostics vocabulary (`pdf-codec/diagnostics`), the `LayoutDocument` item family (`pdf-codec/layout`), PDF string/date scalar decoding (`pdf-codec/pdf-text`), standard-14 resolution/AFM metrics (`pdf-codec/fonts`, `pdf-codec/afm-widths`), and the rasterisation port (`pdf-codec/raster`, whose glyph machinery reads outlines out of the page's own embedded font programs rather than any vendored face).
 
 ## Architecture
 
@@ -235,13 +255,14 @@ The package is layered from generic primitives outward to the codec itself:
 - **`src/crypto/`** — MD5, SHA-256/384/512, RC4, and AES-CBC, hand-written with zero local imports, plus a thin `random.ts` wrapper around `globalThis.crypto.getRandomValues` for the writer's own salts/file keys/IVs. Not a preference: ISO 32000-1's key-derivation algorithms name MD5 and RC4 directly, neither offered by any portable platform crypto API, and `crypto.subtle` is asynchronous where this codec's read and write paths are both synchronous end to end — `getRandomValues` itself, unlike `crypto.subtle`, is synchronous and portable, so it is used directly rather than hand-written. Reaching for `node:crypto` would break the browser bundle. Each hash/cipher module cites its specification (RFC 1321, FIPS 180-4, FIPS 197) and is tested against published conformance vectors.
 - **The codec itself, importing only `layout`/`bytes`/`image`/`crypto`/`util` plus `document-schema.js`'s port types (no OOXML or ODF knowledge):**
   - **Write**: `objects.ts` (the `PdfObject` discriminated union), `afm-widths.ts`/`encoding.ts`/`winansi.ts`/`fonts.ts` (standard-14 metrics, WinAnsi encoding, family resolution), `font-registry.ts` (resolution port plus `resolveFaceWithRegistry`, the one step both measurer and writer resolve through so they can never disagree about which face a `LayoutFont` means), `font-face.ts` (`readFontFace`, reading a standalone font file's family/bold/italic triple off its `name`/`OS/2`/`head` tables), `measure.ts`/`text-layout.ts` (greedy line-wrapping against either standard-14 AFM widths plus per-family correction or a resolved face's own real `hmtx` advances — never both), `content-write.ts` (`LayoutItem[]` → content-stream operators, with text branching on standard-14 vs embedded face encoding, pair-kerning split into `TJ` arrays, stroke `style` becoming real dash/line-cap state, and `/P <</MCID n /OC R>> BDC`…`EMC` spans around items carrying a structure owner or an optional-content layer — the one marked-content spelling both read-side channels resolve through), `write.ts` (the full object graph, cross-reference table, trailer, and embedded font groups, plus the document-level round-trip surfaces: the `/Names /EmbeddedFiles` attachments tree and `/Outlines` bookmark tree, `/OCProperties` optional-content groups with each layer stated explicitly into the default configuration's `/ON` or `/OFF` list, the `/AcroForm` field tree with the merged-field/widget spelling (a single widget merges into its field dict; a multi-widget field's widgets are separate `/Subtype /Widget` kids, each also referenced from its page's `/Annots` — the same annotation object in both places, so a viewer reading only page-level annotations still renders every widget — and fully-qualified names decompose back into the `/T` chain), the `/StructTreeRoot` element tree with its `/ParentTree` number tree associating each marked item's MCID to its owning element, and the package-level residue rows restored inline onto the Catalog or trailer — the XMP packet as an uncompressed `/Metadata` stream, and any row whose serialisation references source-file objects skipped rather than emitted as a dangling reference).
-  - **sfnt font tables**: `sfnt.ts` (bounds-checked table-directory reader), `cmap-table.ts` (character code → glyph ID, formats 0/4/6/12, exposed both as the best Unicode lookup and as every subtable individually, since a (3, 0) or (1, 0) subtable is keyed by a font's own codes rather than by code points), `hmtx-table.ts` (per-glyph advance widths), `font-tables.ts` (`head`/`maxp`/`OS/2`/`post`/`name`, including `post`'s own glyph names where a font still carries them), `glyf.ts` (`loca` offset index, per-glyph headers, composite component records, `glyphInkBounds`), `math-table.ts` (OpenType `MATH` constants/glyph-info/variants subtables). `ot-layout-common.ts` (Coverage/ClassDef, stored as sorted glyph ranges searched by bisection). `gpos-table.ts` reads `GPOS` for exactly one thing: pair-advance kerning through the `kern` feature, both PairPos formats and LookupType 9 Extension indirection — mark attachment, cursive joining, and contextual positioning have no consumer here. `gsub-table.ts` reads `GSUB` for the default-on feature set (`liga`/`rlig`/`calt`/`clig`) through Single, Ligature, Contextual, and Chaining Contextual substitutions (LookupTypes 1, 4, 5, 6, and the 7 Extension wrapper), with each lookup's `lookupFlag` skip semantics — ignore-base/ligature/marks, mark attachment classes, mark filtering sets — evaluated against `gdef-table.ts`'s reading of the font's `GDEF`; `smcp`/`dlig` stay opt-in through `GsubShaperOptions`, the switch a real shaper's caller flips. Every parser degrades to `undefined` on a missing/truncated table rather than throwing.
+  - **sfnt font tables**: `sfnt.ts` (bounds-checked table-directory reader), `cmap-table.ts` (character code → glyph ID, formats 0/4/6/12, exposed both as the best Unicode lookup and as every subtable individually, since a (3, 0) or (1, 0) subtable is keyed by a font's own codes rather than by code points), `hmtx-table.ts` (per-glyph advance widths), `font-tables.ts` (`head`/`maxp`/`OS/2`/`post`/`name`, including `post`'s own glyph names where a font still carries them), `glyf.ts` (`loca` offset index, per-glyph headers, composite component records, `glyphInkBounds`), `glyf-contours.ts` (the point arrays glyf.ts deliberately leaves undecoded: a glyph's on/off-curve contours, composites resolved, consumed by the raster port's outline rendering and differentially tested against the header-declared ink boxes), `math-table.ts` (OpenType `MATH` constants/glyph-info/variants subtables). `ot-layout-common.ts` (Coverage/ClassDef, stored as sorted glyph ranges searched by bisection). `gpos-table.ts` reads `GPOS` for exactly one thing: pair-advance kerning through the `kern` feature, both PairPos formats and LookupType 9 Extension indirection — mark attachment, cursive joining, and contextual positioning have no consumer here. `gsub-table.ts` reads `GSUB` for the default-on feature set (`liga`/`rlig`/`calt`/`clig`) through Single, Ligature, Contextual, and Chaining Contextual substitutions (LookupTypes 1, 4, 5, 6, and the 7 Extension wrapper), with each lookup's `lookupFlag` skip semantics — ignore-base/ligature/marks, mark attachment classes, mark filtering sets — evaluated against `gdef-table.ts`'s reading of the font's `GDEF`; `smcp`/`dlig` stay opt-in through `GsubShaperOptions`, the switch a real shaper's caller flips. Every parser degrades to `undefined` on a missing/truncated table rather than throwing.
   - **sfnt subsetting**: `sfnt-subset.ts` — a TrueType-outline glyph subsetter (Unicode code points → glyph IDs via `cmap`, transitive closure over `glyf` composite components, rebuilt sfnt carrying only used outlines). **Glyph IDs are preserved, never renumbered**, keeping composite component references valid and making CID == GID trivially true. Output rebuilds `head`/`hhea`/`maxp`/`loca`/`glyf`/`hmtx`, copies hinting programs verbatim, stubs `post`, omits `cmap`/`name`/`OS/2`/`GSUB`/`GPOS`/`kern` (none read through a `CIDFontType2` program per ISO 32000-1 9.9). Applies to `glyf`-flavoured fonts only; CFF returns `undefined`.
   - **Embedded math font**: `math-font.ts` (parses/caches the vendored STIX Two Math font, exposing size-specific `MathFontMetrics` and stretchy-glyph entry points), `math-stretch.ts` (OpenType MATH two-stage stretching: pick smallest pre-built variant reaching target, else assemble from repeated parts with seams overlapped), `math-font-write.ts` (builds the `/Type0`/`/CIDFontType0`/`/FontDescriptor`/`/FontFile3`/ToUnicode group), `math-content-write.ts` (`PositionedFormula[]` → content-stream bytes, Identity-H CIDs for text, `re`/`m`/`l` operators for rules, glyph-ID-addressed text objects for stretched constructions wrapped in `/ActualText`).
   - **Embedded text faces**: `embedded-font.ts` (parses one TrueType-outline face's metrics and `GPOS` pair kerning, and `encodeForShowEmbedded` — the single code path both measurement and text-showing go through so encoding and measuring cannot disagree). Every geometry field is converted into PDF's 1000-units-per-em glyph space. `embedded-font-write.ts` builds the `/Type0`/`/CIDFontType2`/`/FontDescriptor`/`/FontFile2`/ToUnicode group, with `/CIDToGIDMap /Identity` written explicitly and `/Length1` set to the **uncompressed** subset length. Its subset tag is a CRC32 over the face's PostScript name and glyph-ID list, so identical input yields byte-identical output.
   - **ToUnicode CMaps**: `tounicode.ts`, shared by both embedded-font writers — a character code → Unicode code point mapping written as a bfchar CMap (9.10.3), with supplementary-plane code points encoded as UTF-16BE surrogate pairs and entries emitted in blocks of at most 100.
   - **CFF reading**: `cff.ts` (shared `INDEX`/`DICT` container structures), `cff-bounds.ts` (a Type 2 charstring interpreter computing each glyph's tight ink bounding box by tracking the current point through every path operator and solving each cubic's real extrema from the roots of its derivative — a path walker, not a rasteriser; verified against the vendored STIX Two Math font's whole 5,543-glyph repertoire, matching fontTools' `BoundsPen` to within 0.01 design units). `cff-probe.ts` reads a bare CFF program's header/Name INDEX/Top DICT to detect the `ROS` operator defining a CID-keyed font — the guard a future source-embedded-font phase needs before it can trust CID == GID against an arbitrary caller-supplied font.
   - **Read**: `lexer.ts`/`parse.ts` (byte tokenizer and tokens → `PdfObject`), `filters.ts`/`predictors.ts` (Flate/LZW/ASCII85/ASCIIHex/RunLength/CCITTFax, TIFF/PNG predictors), `xref.ts`/`document.ts` (classic and cross-reference-stream resolution, object streams, `/Prev` chains, linear-scan recovery, the page tree with attribute inheritance), `encrypt.ts` (standard security handler: `/Encrypt` parsing, empty-user-password key derivation and `/U` verification, per-object keys, transparent string/stream decryption), `content-read.ts`/`interpret.ts` (content-stream tokenizer and graphics/text state machine, form-XObject recursion, general vector-path tracking), `cmap.ts`/`font-style.ts`/`font-read.ts` (`/ToUnicode` CMaps, font-dictionary resolution), `builtin-encoding.ts` (a font's own built-in encoding, read out of the embedded program itself — see [Text extraction and font encodings](#text-extraction-and-font-encodings)), `images-read.ts` (Image XObjects → PNG/JPEG bytes), `names.ts` (the document-level name-tree walker: one flattening pass for every `/Names` tenant), `navigation.ts` (named destinations from `/Dests` and `/Names` `/Dests`, reader-minted entries for direct destination arrays, and the `/Outlines` bookmark tree), `attachments.ts` (embedded files from the name tree, `/FileAttachment` filespecs, and `/AF`), `optional-content.ts` (`/OCProperties` groups and default-configuration visibility, plus the `/OC`-to-name resolution `interpret.ts` stamps onto span items), `annotations.ts` (sticky notes, FreeText, the `/QuadPoints` markup family, and residue for the opaque kinds), `form.ts` (the AcroForm field tree), `structure.ts` (the tagged-PDF `/StructTreeRoot` element tree with `/RoleMap` resolution and `/ClassMap` attribute merging, plus the `/ParentTree` walk that resolves each `(page, MCID)` pair to the owning element `read.ts` stamps onto an item), `xmp.ts` (a bounded Dublin Core extractor for the `/Metadata` packet), `pdf-text.ts` (PDF string/date scalar decoding), `read.ts` (`readPdf`, assembling all of the above into a `LayoutDocument`).
+  - **Raster**: `raster.ts` — the `PageRasteriser` port and `renderPdfPage` (#1198): re-walks one page through `interpretContentStream` (the same interpreter `readPdf` runs), recomputes the page's crop/rotation geometry (test-pinned to agree with `readPdf` bit for bit, since the `clipPt` contract rides on it), and drives a caller-supplied rasteriser with device-space draw ops — rect fills, filled/stroked vector paths, affine-placed images, and text as filled glyph-outline paths resolved from the page's own embedded sfnt programs (`glyf-contours.ts`'s decoded contours through the run's text matrices, per-glyph advances corrected against the run's exact end matrix). Optional-content layers the default configuration leaves OFF are not drawn; faces with no sfnt outlines are refused by name. No canvas dependency, no backend, no OCR/vision/network — the port is pure data plus callbacks, so `pdf-raster-cpu` (or a browser canvas wrapper) implements it elsewhere.
   - `codec.ts` — `pdfCodec`, a `z.codec()` pair over `readPdf`/`writePdf`, plus a standalone local copy of the `%PDF-` header check.
 - **`src/test-support/`** — hand-built PDF fixtures (`pdf.ts`) built by literal byte/string concatenation and deliberately importing NOTHING from this package's own writer (a fixture built by `writePdf` would let a writer bug hide from the corresponding reader test). `encrypted-pdfs.ts` applies the same principle: real PDFs encrypted by [qpdf](https://qpdf.sourceforge.io/), embedded as base64, so a bug in key derivation cannot cancel out between write and read halves. `fonts.ts` holds the real vendored Carlito and Caladea faces as raw sfnt bytes, and asserts values read out of the `.ttf` files by a standalone script with a bare `DataView`, not by this package's own parsers — external cross-checks rather than a parser's output compared against itself.
 
@@ -266,6 +287,7 @@ Dependency direction is strictly downward and checkable: `layout` imports only `
 - **`CCITTFaxDecode`, `JBIG2Decode` and `JPXDecode` images all decode for real** via hand-written decoders (`src/image/ccitt.ts` for ITU-T T.4/T.6 fax; `src/image/jbig2*.ts` for ITU-T T.88; `src/image/jpeg2000*.ts` for ISO/IEC 15444-1). JPEG images (`DCTDecode`) pass through losslessly in both directions. See [JBIG2 scope](#jbig2-scope) and [JPEG 2000 scope](#jpeg-2000-scope) for exactly what is and is not implemented.
 - **The write side re-encodes bilevel images as CCITT Group 4** (`src/image/ccitt-encode.ts`, a hand-written ITU-T T.6 encoder sharing the decoder's own code-table transcription): a grayscale image whose samples are all 0 or 255, with no soft mask, is written as `/CCITTFaxDecode` with `/K -1` whenever the G4 encoding comes out smaller than Flate over the same pixels — which for vertically coherent bilevel content (a scan's edges and text baselines) it does by an order of magnitude. Whichever encoding is smaller wins, deterministically, so decorrelated or repetitive bilevel content where Flate happens to win keeps Flate. **JBIG2 and JPEG 2000 re-encoding remain permanent boundaries, not gaps**: a hand-written JBIG2 encoder is research-grade symbol-dictionary design and a JPEG 2000 encoder is the full EBCOT/wavelet stack, and re-encoding lossy JPX back is not fidelity-preserving anyway. **What no longer follows from that boundary is generation loss on a pdf-to-pdf round trip**: `LayoutImageAsset.original` (the layout twin of `document-schema.js`'s `ContentImageOriginal`, landed through the #975-scorecard schema change it named) carries a source's own JBIG2/JPX compressed stream beside the decoded canonical, captured at read time together with the decoded `/JBIG2Globals` segments a symbol-dictionary stream needs, and the writer re-embeds those bytes verbatim under their own filter — the decoded canonical never reaches the file at all for such an image, a source soft mask still re-emits as a generated `/SMask`, and the round trip pays zero generation loss for exactly the two filters this package cannot re-encode.
 - **`interpret.ts` tracks general vector paths, not just axis-aligned `re` rectangles.** `m`/`l`/`c`/`v`/`y`/`h` (and `re` itself) accumulate real subpaths — CTM-transformed line/cubic segments, open or closed — and any paint operator emits an item built from them. A recovered path matching one of three characteristic shape patterns comes back as that shape's own kind, not a generic `LayoutPath`: an axis-aligned closed four-corner subpath is a `LayoutRect`; a closed subpath of four cubic segments meeting its bounding box at cardinal points with kappa-ratio control points is a `LayoutEllipse`; an open single-straight-segment stroke-only subpath is a `LayoutLine` (tolerance: `max(1e-3pt, 1e-4 × extent)`). **These are deliberate, bounded heuristics** — a false positive changes an item's kind, never its geometry, since every detected shape reproduces its source path's own points exactly. Off-axis rotations, non-quadrant curves, polygons, and multi-subpath figures stay a `LayoutPath`.
+- **`renderPdfPage` renders vectors, images, and embedded-sfnt text; everything else it refuses by name.** Text whose font states no TrueType/glyf outlines (CFF programs, standard-14 faces with nothing embedded, Type 3 glyph procedures, Type0 fonts under a non-Identity-H encoding) draws nothing and reports `raster/text-cff-outlines` or `raster/text-outlines-unavailable` through the sink — a substitute shape would be a silent misrender, so the refusal is the honest behaviour and the rest of the page still renders. Image pixels are the rasteriser's own concern: the port hands through exactly what `images-read.ts` recovered (PNG for every decoded filter, JPEG bytes verbatim), so a canvas-owning backend draws DCTDecode scans natively while `pdf-raster-cpu` declines them by name (it has no JPEG decoder, and a scanned page's XObject remains extractable through `readPdf` for consumers that want the scan's own pixels). Per-glyph text placement distributes the interpreter's spacing state (`Tc`/`Tw`/`Tz`) uniformly across each run rather than modelling it per glyph, so a run's extent is exact while its internal glyph spacing under active spacing state is a bounded approximation.
 - **`writePdf`/`readPdf` round-trip a page's own `notes` field via a hidden `/Subtype /Text` annotation** with the `Hidden` flag set so it never renders or prints, distinguished from a genuine third-party sticky note by an internal author marker. This is a round-trip mechanism specific to this package's own writer/reader pair. `documents.js` uses this to carry pptx/odp speaker notes through PDF.
 - **STIX Two Math is a CFF-flavoured OpenType font, not TrueType/glyf** — the **entire** `CFF ` table is embedded verbatim as a single `/FontFile3` `/Subtype /CIDFontType0C` stream (a real, correct, working embedded font, just not glyph-subsetted). Everything else genuinely IS built from a targeted parse of only what's used: `cmap` resolves exactly the Unicode code points a document's formulas reference, and the emitted `/W` widths array covers only drawn glyph IDs. A CID-keyed composite font built this way needs no `/CIDToGIDMap` — per ISO 32000-1 9.7.4.2, a `/CIDFontType0` whose `/FontFile3` is a non-CID-keyed CFF program is read with CID directly indexing `CharStrings` by glyph order (CID == GID).
 - **The OpenType `MATH` table's `MathVariants` is parsed, stretchy-glyph assembly implemented, and the result genuinely drawable** via `MathAssembledGlyphs` (glyph-ID-addressed placements, since most construction glyphs have no Unicode code point — they draw directly because CID == GID here). An unencoded glyph gets no ToUnicode entry; the construction is wrapped in an `/ActualText` span carrying the operator's own text so it still extracts as `(`. `MathConstants` and `MathGlyphInfo` (italics correction, top-accent attachment) are parsed in full.

package/dist/glyf-contours.cjs

@@ -0,0 +1,122 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+//#region src/glyf-contours.ts
+const FLAG_ON_CURVE = 1;
+const FLAG_X_SHORT = 2;
+const FLAG_Y_SHORT = 4;
+const FLAG_REPEAT = 8;
+const FLAG_X_SAME_OR_POSITIVE = 16;
+const FLAG_Y_SAME_OR_POSITIVE = 32;
+const MAX_COMPOSITE_DEPTH = 5;
+function decodeSimpleContours(glyph) {
+	const numberOfContours = require_sfnt.i16(glyph, 0);
+	const endPtsOffset = 10;
+	if (!require_sfnt.hasBytes(glyph, endPtsOffset, numberOfContours * 2 + 2)) return;
+	const endPts = [];
+	for (let i = 0; i < numberOfContours; i++) endPts.push(require_sfnt.u16(glyph, endPtsOffset + i * 2));
+	const numPoints = endPts.length > 0 ? endPts[endPts.length - 1] + 1 : 0;
+	for (let i = 1; i < endPts.length; i++) if (endPts[i] <= endPts[i - 1]) return;
+	let offset = endPtsOffset + numberOfContours * 2;
+	const instructionLength = require_sfnt.u16(glyph, offset);
+	offset += 2 + instructionLength;
+	if (!require_sfnt.hasBytes(glyph, offset, numPoints)) return;
+	const flags = [];
+	while (flags.length < numPoints) {
+		const flag = require_sfnt.u8(glyph, offset);
+		flags.push(flag);
+		offset += 1;
+		if ((flag & FLAG_REPEAT) !== 0) {
+			if (!require_sfnt.hasBytes(glyph, offset, 1)) return;
+			const repeat = require_sfnt.u8(glyph, offset);
+			offset += 1;
+			if (flags.length + repeat > numPoints) return;
+			for (let r = 0; r < repeat; r++) flags.push(flag);
+		}
+	}
+	const xs = [];
+	let x = 0;
+	for (const flag of flags) {
+		if ((flag & FLAG_X_SHORT) !== 0) {
+			if (!require_sfnt.hasBytes(glyph, offset, 1)) return;
+			const magnitude = require_sfnt.u8(glyph, offset);
+			offset += 1;
+			x += (flag & FLAG_X_SAME_OR_POSITIVE) !== 0 ? magnitude : -magnitude;
+		} else if ((flag & FLAG_X_SAME_OR_POSITIVE) === 0) {
+			if (!require_sfnt.hasBytes(glyph, offset, 2)) return;
+			x += require_sfnt.i16(glyph, offset);
+			offset += 2;
+		}
+		xs.push(x);
+	}
+	const ys = [];
+	let y = 0;
+	for (const flag of flags) {
+		if ((flag & FLAG_Y_SHORT) !== 0) {
+			if (!require_sfnt.hasBytes(glyph, offset, 1)) return;
+			const magnitude = require_sfnt.u8(glyph, offset);
+			offset += 1;
+			y += (flag & FLAG_Y_SAME_OR_POSITIVE) !== 0 ? magnitude : -magnitude;
+		} else if ((flag & FLAG_Y_SAME_OR_POSITIVE) === 0) {
+			if (!require_sfnt.hasBytes(glyph, offset, 2)) return;
+			y += require_sfnt.i16(glyph, offset);
+			offset += 2;
+		}
+		ys.push(y);
+	}
+	const contours = [];
+	let pointIndex = 0;
+	for (const endPt of endPts) {
+		const points = [];
+		while (pointIndex <= endPt) {
+			const flag = flags[pointIndex];
+			points.push({
+				x: xs[pointIndex],
+				y: ys[pointIndex],
+				onCurve: (flag & FLAG_ON_CURVE) !== 0
+			});
+			pointIndex += 1;
+		}
+		contours.push(points);
+	}
+	return contours;
+}
+function placeComponentContours(contours, component) {
+	const [a, b, c, d] = component.transform ?? [
+		1,
+		0,
+		0,
+		1
+	];
+	const scaledOffset = (component.flags & 2048) !== 0 && (component.flags & 4096) === 0;
+	const dx = scaledOffset ? a * component.argument1 + c * component.argument2 : component.argument1;
+	const dy = scaledOffset ? b * component.argument1 + d * component.argument2 : component.argument2;
+	return contours.map((points) => points.map((point) => ({
+		x: a * point.x + c * point.y + dx,
+		y: b * point.x + d * point.y + dy,
+		onCurve: point.onCurve
+	})));
+}
+function decodeGlyphOutline(glyf, glyphId) {
+	return decodeOutline(glyf, glyphId, 0);
+}
+function decodeOutline(glyf, glyphId, depth) {
+	const header = glyf.glyphHeader(glyphId);
+	if (header === void 0) return;
+	if (header.numberOfContours >= 0) {
+		const contours = decodeSimpleContours(glyf.glyphBytes(glyphId));
+		return contours === void 0 ? void 0 : { contours };
+	}
+	if (depth >= MAX_COMPOSITE_DEPTH) return;
+	const components = glyf.compositeComponents(glyphId);
+	if (components === void 0) return;
+	const contours = [];
+	for (const component of components) {
+		if (!component.argsAreXyValues) return;
+		const componentOutline = decodeOutline(glyf, component.glyphIndex, depth + 1);
+		if (componentOutline === void 0) return;
+		contours.push(...placeComponentContours(componentOutline.contours, component));
+	}
+	return { contours };
+}
+//#endregion
+exports.decodeGlyphOutline = decodeGlyphOutline;

package/dist/glyf-contours.d.cts

@@ -0,0 +1,13 @@
+import { GlyfTable } from "./glyf.cjs";
+//#region src/glyf-contours.d.ts
+interface GlyphContourPoint {
+  readonly x: number;
+  readonly y: number;
+  readonly onCurve: boolean;
+}
+interface GlyphOutline {
+  readonly contours: readonly (readonly GlyphContourPoint[])[];
+}
+declare function decodeGlyphOutline(glyf: GlyfTable, glyphId: number): GlyphOutline | undefined;
+//#endregion
+export { GlyphContourPoint, GlyphOutline, decodeGlyphOutline };

package/dist/glyf-contours.d.ts

@@ -0,0 +1,13 @@
+import { GlyfTable } from "./glyf.js";
+//#region src/glyf-contours.d.ts
+interface GlyphContourPoint {
+  readonly x: number;
+  readonly y: number;
+  readonly onCurve: boolean;
+}
+interface GlyphOutline {
+  readonly contours: readonly (readonly GlyphContourPoint[])[];
+}
+declare function decodeGlyphOutline(glyf: GlyfTable, glyphId: number): GlyphOutline | undefined;
+//#endregion
+export { GlyphContourPoint, GlyphOutline, decodeGlyphOutline };

package/dist/glyf-contours.js

@@ -0,0 +1,121 @@
+import { hasBytes, i16, u16, u8 } from "./sfnt.js";
+//#region src/glyf-contours.ts
+const FLAG_ON_CURVE = 1;
+const FLAG_X_SHORT = 2;
+const FLAG_Y_SHORT = 4;
+const FLAG_REPEAT = 8;
+const FLAG_X_SAME_OR_POSITIVE = 16;
+const FLAG_Y_SAME_OR_POSITIVE = 32;
+const MAX_COMPOSITE_DEPTH = 5;
+function decodeSimpleContours(glyph) {
+	const numberOfContours = i16(glyph, 0);
+	const endPtsOffset = 10;
+	if (!hasBytes(glyph, endPtsOffset, numberOfContours * 2 + 2)) return;
+	const endPts = [];
+	for (let i = 0; i < numberOfContours; i++) endPts.push(u16(glyph, endPtsOffset + i * 2));
+	const numPoints = endPts.length > 0 ? endPts[endPts.length - 1] + 1 : 0;
+	for (let i = 1; i < endPts.length; i++) if (endPts[i] <= endPts[i - 1]) return;
+	let offset = endPtsOffset + numberOfContours * 2;
+	const instructionLength = u16(glyph, offset);
+	offset += 2 + instructionLength;
+	if (!hasBytes(glyph, offset, numPoints)) return;
+	const flags = [];
+	while (flags.length < numPoints) {
+		const flag = u8(glyph, offset);
+		flags.push(flag);
+		offset += 1;
+		if ((flag & FLAG_REPEAT) !== 0) {
+			if (!hasBytes(glyph, offset, 1)) return;
+			const repeat = u8(glyph, offset);
+			offset += 1;
+			if (flags.length + repeat > numPoints) return;
+			for (let r = 0; r < repeat; r++) flags.push(flag);
+		}
+	}
+	const xs = [];
+	let x = 0;
+	for (const flag of flags) {
+		if ((flag & FLAG_X_SHORT) !== 0) {
+			if (!hasBytes(glyph, offset, 1)) return;
+			const magnitude = u8(glyph, offset);
+			offset += 1;
+			x += (flag & FLAG_X_SAME_OR_POSITIVE) !== 0 ? magnitude : -magnitude;
+		} else if ((flag & FLAG_X_SAME_OR_POSITIVE) === 0) {
+			if (!hasBytes(glyph, offset, 2)) return;
+			x += i16(glyph, offset);
+			offset += 2;
+		}
+		xs.push(x);
+	}
+	const ys = [];
+	let y = 0;
+	for (const flag of flags) {
+		if ((flag & FLAG_Y_SHORT) !== 0) {
+			if (!hasBytes(glyph, offset, 1)) return;
+			const magnitude = u8(glyph, offset);
+			offset += 1;
+			y += (flag & FLAG_Y_SAME_OR_POSITIVE) !== 0 ? magnitude : -magnitude;
+		} else if ((flag & FLAG_Y_SAME_OR_POSITIVE) === 0) {
+			if (!hasBytes(glyph, offset, 2)) return;
+			y += i16(glyph, offset);
+			offset += 2;
+		}
+		ys.push(y);
+	}
+	const contours = [];
+	let pointIndex = 0;
+	for (const endPt of endPts) {
+		const points = [];
+		while (pointIndex <= endPt) {
+			const flag = flags[pointIndex];
+			points.push({
+				x: xs[pointIndex],
+				y: ys[pointIndex],
+				onCurve: (flag & FLAG_ON_CURVE) !== 0
+			});
+			pointIndex += 1;
+		}
+		contours.push(points);
+	}
+	return contours;
+}
+function placeComponentContours(contours, component) {
+	const [a, b, c, d] = component.transform ?? [
+		1,
+		0,
+		0,
+		1
+	];
+	const scaledOffset = (component.flags & 2048) !== 0 && (component.flags & 4096) === 0;
+	const dx = scaledOffset ? a * component.argument1 + c * component.argument2 : component.argument1;
+	const dy = scaledOffset ? b * component.argument1 + d * component.argument2 : component.argument2;
+	return contours.map((points) => points.map((point) => ({
+		x: a * point.x + c * point.y + dx,
+		y: b * point.x + d * point.y + dy,
+		onCurve: point.onCurve
+	})));
+}
+function decodeGlyphOutline(glyf, glyphId) {
+	return decodeOutline(glyf, glyphId, 0);
+}
+function decodeOutline(glyf, glyphId, depth) {
+	const header = glyf.glyphHeader(glyphId);
+	if (header === void 0) return;
+	if (header.numberOfContours >= 0) {
+		const contours = decodeSimpleContours(glyf.glyphBytes(glyphId));
+		return contours === void 0 ? void 0 : { contours };
+	}
+	if (depth >= MAX_COMPOSITE_DEPTH) return;
+	const components = glyf.compositeComponents(glyphId);
+	if (components === void 0) return;
+	const contours = [];
+	for (const component of components) {
+		if (!component.argsAreXyValues) return;
+		const componentOutline = decodeOutline(glyf, component.glyphIndex, depth + 1);
+		if (componentOutline === void 0) return;
+		contours.push(...placeComponentContours(componentOutline.contours, component));
+	}
+	return { contours };
+}
+//#endregion
+export { decodeGlyphOutline };

package/dist/index.cjs

@@ -19,6 +19,7 @@ const require_measure = require("./measure.cjs");
 const require_write = require("./write.cjs");
 const require_codec = require("./codec.cjs");
 const require_font_face = require("./font-face.cjs");
+const require_raster = require("./raster.cjs");
 exports.DEFAULT_VERTICAL_METRIC_POLICY = require_measure.DEFAULT_VERTICAL_METRIC_POLICY;
 exports.FontFaceParseError = require_font_face.FontFaceParseError;
 exports.Jbig2ParseError = require_image_jbig2_errors.Jbig2ParseError;
@@ -72,6 +73,7 @@ exports.pdfCodec = require_codec.pdfCodec;
 exports.readFontFace = require_font_face.readFontFace;
 exports.readJpeg2000Metadata = require_image_jpeg2000.readJpeg2000Metadata;
 exports.readPdf = require_read.readPdf;
+exports.renderPdfPage = require_raster.renderPdfPage;
 exports.resolveFaceWithRegistry = require_font_registry.resolveFaceWithRegistry;
 exports.resolveStandardFont = require_fonts.resolveStandardFont;
 exports.scaleMathStretchConstruction = require_math_stretch.scaleMathStretchConstruction;

package/dist/index.d.cts

@@ -23,6 +23,7 @@ import { a as MathGlyphPart, c as MathVariants, n as MathGlyphAssembly, o as Mat
 import { a as scaleMathStretchConstruction, i as assembleStretchyGlyph, n as MathStretchOptions, r as MathStretchPlacement, t as MathStretchConstruction } from "./math-stretch-C2JanDAz.cjs";
 import { LoadedMathFont, MathFont, MathFontDescriptorMetrics, loadMathFont } from "./math-font.cjs";
 import { DEFAULT_VERTICAL_METRIC_POLICY, FontMeasurerOptions, StandardFontMeasurerOptions, VerticalMetricPolicy, createFontMeasurer, createStandardFontMeasurer } from "./measure.cjs";
+import { PageRasteriser, RasterDrawOp, RasterFillRectOp, RasterFillSpec, RasterImageOp, RasterMatrix, RasterPageGeometry, RasterPathOp, RasterPathSegment, RasterRegionPt, RasterStrokeSpec, RasterSubpath, RenderPdfPageOptions, renderPdfPage } from "./raster.cjs";
 import { FontRegistryOptions, FontSubstitution, MathAssembledGlyphs, MathBox, MathColor, MathFontMetrics, MathGlyphMetrics, MathGlyphPlacement, MathGlyphRun, MathLayoutItem, MathRule, MathStretchAxis, MathStretchGlyph, MathStretchResult, MathStroke, Point, PositionedFormula, ProvidedFont, StyledFragment, StyledRun, TextMeasurer, UnderlineMetrics, WrapOptions, WrappedLine } from "document-schema.js";
 export * from "byte-codec";
-export { type CcittFaxImage, type CcittFaxOptions, DEFAULT_VERTICAL_METRIC_POLICY, type EmbeddedFace, type EmbeddedFaceMetrics, type EmbeddedFaceSubstitution, type FontFace, FontFaceParseError, type FontMeasurerOptions, type FontMetrics, type FontRegistry, type FontRegistryOptions, type FontSubstitution, type GlyphInkBounds, type Jbig2DecodeOptions, type Jbig2Image, Jbig2ParseError, Jbig2UnsupportedError, type Jp2ChannelDefinition, type Jp2ColourSpace, type Jp2Container, type Jp2ImageHeader, type Jpeg2000ComponentMetadata, type Jpeg2000DecodeOptions, type Jpeg2000Image, type Jpeg2000Metadata, Jpeg2000ParseError, type Jpeg2000ProgressionOrder, type Jpeg2000QuantizationStyle, type Jpeg2000Transform, Jpeg2000UnsupportedError, LAYOUT_FORMAT_VERSION, LayoutAnnotation, LayoutAnnotationQuad, LayoutAnnotationQuadSchema, LayoutAnnotationSchema, LayoutAttachment, LayoutAttachmentSchema, LayoutDestination, LayoutDestinationSchema, LayoutDestinationTarget, LayoutDestinationTargetSchema, LayoutDocument, LayoutDocumentSchema, LayoutEllipse, LayoutEllipseSchema, LayoutFormField, LayoutFormFieldSchema, LayoutFormWidget, LayoutFormWidgetSchema, LayoutImage, LayoutImageAsset, LayoutImageAssetSchema, LayoutImageSchema, LayoutInternalLink, LayoutInternalLinkSchema, LayoutItem, LayoutItemSchema, LayoutLayer, LayoutLayerSchema, LayoutLine, LayoutLineSchema, LayoutLink, LayoutLinkSchema, LayoutOutlineItem, LayoutOutlineItemSchema, LayoutPage, LayoutPageSchema, LayoutPath, LayoutPathSchema, LayoutPathSegment, LayoutPathSegmentSchema, LayoutRect, LayoutRectSchema, LayoutStructureElement, LayoutStructureElementSchema, LayoutSubpath, LayoutSubpathSchema, LayoutText, LayoutTextSchema, type LoadedMathFont, type MathAssembledGlyphs, type MathBox, type MathColor, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphAssembly, type MathGlyphConstruction, type MathGlyphMetrics, type MathGlyphPart, type MathGlyphPlacement, type MathGlyphRun, type MathGlyphVariant, type MathLayoutItem, type MathRule, type MathStretchAxis, type MathStretchConstruction, type MathStretchGlyph, type MathStretchOptions, type MathStretchPlacement, type MathStretchResult, type MathStroke, type MathVariants, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfEncryptionError, type PdfEncryptionOptions, type PdfEncryptionPermissions, type PdfEncryptionScheme, PdfParseError, PdfPasswordRequiredError, type Point, type PositionedFormula, type ProvidedFont, type ReadPdfOptions, type ResolvedFace, type ResolvedFont, STANDARD_METRICS, type StandardFontMeasurerOptions, type StandardFontName, type StyledFragment, type StyledRun, type TextMeasurer, type UnderlineMetrics, type VerticalMetricPolicy, type WinAnsiSubstitution, type WrapOptions, type WrappedLine, type WritePdfOptions, assembleStretchyGlyph, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodeJbig2Embedded, decodeJpeg2000, filterScanlines, loadMathFont, looksLikeBareCodestream, parseJp2Container, pdfCodec, readFontFace, readJpeg2000Metadata, readPdf, resolveFaceWithRegistry, resolveStandardFont, scaleMathStretchConstruction, unfilterScanlines, writePdf };
+export { type CcittFaxImage, type CcittFaxOptions, DEFAULT_VERTICAL_METRIC_POLICY, type EmbeddedFace, type EmbeddedFaceMetrics, type EmbeddedFaceSubstitution, type FontFace, FontFaceParseError, type FontMeasurerOptions, type FontMetrics, type FontRegistry, type FontRegistryOptions, type FontSubstitution, type GlyphInkBounds, type Jbig2DecodeOptions, type Jbig2Image, Jbig2ParseError, Jbig2UnsupportedError, type Jp2ChannelDefinition, type Jp2ColourSpace, type Jp2Container, type Jp2ImageHeader, type Jpeg2000ComponentMetadata, type Jpeg2000DecodeOptions, type Jpeg2000Image, type Jpeg2000Metadata, Jpeg2000ParseError, type Jpeg2000ProgressionOrder, type Jpeg2000QuantizationStyle, type Jpeg2000Transform, Jpeg2000UnsupportedError, LAYOUT_FORMAT_VERSION, LayoutAnnotation, LayoutAnnotationQuad, LayoutAnnotationQuadSchema, LayoutAnnotationSchema, LayoutAttachment, LayoutAttachmentSchema, LayoutDestination, LayoutDestinationSchema, LayoutDestinationTarget, LayoutDestinationTargetSchema, LayoutDocument, LayoutDocumentSchema, LayoutEllipse, LayoutEllipseSchema, LayoutFormField, LayoutFormFieldSchema, LayoutFormWidget, LayoutFormWidgetSchema, LayoutImage, LayoutImageAsset, LayoutImageAssetSchema, LayoutImageSchema, LayoutInternalLink, LayoutInternalLinkSchema, LayoutItem, LayoutItemSchema, LayoutLayer, LayoutLayerSchema, LayoutLine, LayoutLineSchema, LayoutLink, LayoutLinkSchema, LayoutOutlineItem, LayoutOutlineItemSchema, LayoutPage, LayoutPageSchema, LayoutPath, LayoutPathSchema, LayoutPathSegment, LayoutPathSegmentSchema, LayoutRect, LayoutRectSchema, LayoutStructureElement, LayoutStructureElementSchema, LayoutSubpath, LayoutSubpathSchema, LayoutText, LayoutTextSchema, type LoadedMathFont, type MathAssembledGlyphs, type MathBox, type MathColor, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphAssembly, type MathGlyphConstruction, type MathGlyphMetrics, type MathGlyphPart, type MathGlyphPlacement, type MathGlyphRun, type MathGlyphVariant, type MathLayoutItem, type MathRule, type MathStretchAxis, type MathStretchConstruction, type MathStretchGlyph, type MathStretchOptions, type MathStretchPlacement, type MathStretchResult, type MathStroke, type MathVariants, NOOP_DIAGNOSTIC_SINK, type PageRasteriser, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfEncryptionError, type PdfEncryptionOptions, type PdfEncryptionPermissions, type PdfEncryptionScheme, PdfParseError, PdfPasswordRequiredError, type Point, type PositionedFormula, type ProvidedFont, type RasterDrawOp, type RasterFillRectOp, type RasterFillSpec, type RasterImageOp, type RasterMatrix, type RasterPageGeometry, type RasterPathOp, type RasterPathSegment, type RasterRegionPt, type RasterStrokeSpec, type RasterSubpath, type ReadPdfOptions, type RenderPdfPageOptions, type ResolvedFace, type ResolvedFont, STANDARD_METRICS, type StandardFontMeasurerOptions, type StandardFontName, type StyledFragment, type StyledRun, type TextMeasurer, type UnderlineMetrics, type VerticalMetricPolicy, type WinAnsiSubstitution, type WrapOptions, type WrappedLine, type WritePdfOptions, assembleStretchyGlyph, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodeJbig2Embedded, decodeJpeg2000, filterScanlines, loadMathFont, looksLikeBareCodestream, parseJp2Container, pdfCodec, readFontFace, readJpeg2000Metadata, readPdf, renderPdfPage, resolveFaceWithRegistry, resolveStandardFont, scaleMathStretchConstruction, unfilterScanlines, writePdf };

package/dist/index.d.ts

@@ -23,6 +23,7 @@ import { a as MathGlyphPart, c as MathVariants, n as MathGlyphAssembly, o as Mat
 import { a as scaleMathStretchConstruction, i as assembleStretchyGlyph, n as MathStretchOptions, r as MathStretchPlacement, t as MathStretchConstruction } from "./math-stretch-BbC2o4Br.js";
 import { LoadedMathFont, MathFont, MathFontDescriptorMetrics, loadMathFont } from "./math-font.js";
 import { DEFAULT_VERTICAL_METRIC_POLICY, FontMeasurerOptions, StandardFontMeasurerOptions, VerticalMetricPolicy, createFontMeasurer, createStandardFontMeasurer } from "./measure.js";
+import { PageRasteriser, RasterDrawOp, RasterFillRectOp, RasterFillSpec, RasterImageOp, RasterMatrix, RasterPageGeometry, RasterPathOp, RasterPathSegment, RasterRegionPt, RasterStrokeSpec, RasterSubpath, RenderPdfPageOptions, renderPdfPage } from "./raster.js";
 import { FontRegistryOptions, FontSubstitution, MathAssembledGlyphs, MathBox, MathColor, MathFontMetrics, MathGlyphMetrics, MathGlyphPlacement, MathGlyphRun, MathLayoutItem, MathRule, MathStretchAxis, MathStretchGlyph, MathStretchResult, MathStroke, Point, PositionedFormula, ProvidedFont, StyledFragment, StyledRun, TextMeasurer, UnderlineMetrics, WrapOptions, WrappedLine } from "document-schema.js";
 export * from "byte-codec";
-export { type CcittFaxImage, type CcittFaxOptions, DEFAULT_VERTICAL_METRIC_POLICY, type EmbeddedFace, type EmbeddedFaceMetrics, type EmbeddedFaceSubstitution, type FontFace, FontFaceParseError, type FontMeasurerOptions, type FontMetrics, type FontRegistry, type FontRegistryOptions, type FontSubstitution, type GlyphInkBounds, type Jbig2DecodeOptions, type Jbig2Image, Jbig2ParseError, Jbig2UnsupportedError, type Jp2ChannelDefinition, type Jp2ColourSpace, type Jp2Container, type Jp2ImageHeader, type Jpeg2000ComponentMetadata, type Jpeg2000DecodeOptions, type Jpeg2000Image, type Jpeg2000Metadata, Jpeg2000ParseError, type Jpeg2000ProgressionOrder, type Jpeg2000QuantizationStyle, type Jpeg2000Transform, Jpeg2000UnsupportedError, LAYOUT_FORMAT_VERSION, LayoutAnnotation, LayoutAnnotationQuad, LayoutAnnotationQuadSchema, LayoutAnnotationSchema, LayoutAttachment, LayoutAttachmentSchema, LayoutDestination, LayoutDestinationSchema, LayoutDestinationTarget, LayoutDestinationTargetSchema, LayoutDocument, LayoutDocumentSchema, LayoutEllipse, LayoutEllipseSchema, LayoutFormField, LayoutFormFieldSchema, LayoutFormWidget, LayoutFormWidgetSchema, LayoutImage, LayoutImageAsset, LayoutImageAssetSchema, LayoutImageSchema, LayoutInternalLink, LayoutInternalLinkSchema, LayoutItem, LayoutItemSchema, LayoutLayer, LayoutLayerSchema, LayoutLine, LayoutLineSchema, LayoutLink, LayoutLinkSchema, LayoutOutlineItem, LayoutOutlineItemSchema, LayoutPage, LayoutPageSchema, LayoutPath, LayoutPathSchema, LayoutPathSegment, LayoutPathSegmentSchema, LayoutRect, LayoutRectSchema, LayoutStructureElement, LayoutStructureElementSchema, LayoutSubpath, LayoutSubpathSchema, LayoutText, LayoutTextSchema, type LoadedMathFont, type MathAssembledGlyphs, type MathBox, type MathColor, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphAssembly, type MathGlyphConstruction, type MathGlyphMetrics, type MathGlyphPart, type MathGlyphPlacement, type MathGlyphRun, type MathGlyphVariant, type MathLayoutItem, type MathRule, type MathStretchAxis, type MathStretchConstruction, type MathStretchGlyph, type MathStretchOptions, type MathStretchPlacement, type MathStretchResult, type MathStroke, type MathVariants, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfEncryptionError, type PdfEncryptionOptions, type PdfEncryptionPermissions, type PdfEncryptionScheme, PdfParseError, PdfPasswordRequiredError, type Point, type PositionedFormula, type ProvidedFont, type ReadPdfOptions, type ResolvedFace, type ResolvedFont, STANDARD_METRICS, type StandardFontMeasurerOptions, type StandardFontName, type StyledFragment, type StyledRun, type TextMeasurer, type UnderlineMetrics, type VerticalMetricPolicy, type WinAnsiSubstitution, type WrapOptions, type WrappedLine, type WritePdfOptions, assembleStretchyGlyph, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodeJbig2Embedded, decodeJpeg2000, filterScanlines, loadMathFont, looksLikeBareCodestream, parseJp2Container, pdfCodec, readFontFace, readJpeg2000Metadata, readPdf, resolveFaceWithRegistry, resolveStandardFont, scaleMathStretchConstruction, unfilterScanlines, writePdf };
+export { type CcittFaxImage, type CcittFaxOptions, DEFAULT_VERTICAL_METRIC_POLICY, type EmbeddedFace, type EmbeddedFaceMetrics, type EmbeddedFaceSubstitution, type FontFace, FontFaceParseError, type FontMeasurerOptions, type FontMetrics, type FontRegistry, type FontRegistryOptions, type FontSubstitution, type GlyphInkBounds, type Jbig2DecodeOptions, type Jbig2Image, Jbig2ParseError, Jbig2UnsupportedError, type Jp2ChannelDefinition, type Jp2ColourSpace, type Jp2Container, type Jp2ImageHeader, type Jpeg2000ComponentMetadata, type Jpeg2000DecodeOptions, type Jpeg2000Image, type Jpeg2000Metadata, Jpeg2000ParseError, type Jpeg2000ProgressionOrder, type Jpeg2000QuantizationStyle, type Jpeg2000Transform, Jpeg2000UnsupportedError, LAYOUT_FORMAT_VERSION, LayoutAnnotation, LayoutAnnotationQuad, LayoutAnnotationQuadSchema, LayoutAnnotationSchema, LayoutAttachment, LayoutAttachmentSchema, LayoutDestination, LayoutDestinationSchema, LayoutDestinationTarget, LayoutDestinationTargetSchema, LayoutDocument, LayoutDocumentSchema, LayoutEllipse, LayoutEllipseSchema, LayoutFormField, LayoutFormFieldSchema, LayoutFormWidget, LayoutFormWidgetSchema, LayoutImage, LayoutImageAsset, LayoutImageAssetSchema, LayoutImageSchema, LayoutInternalLink, LayoutInternalLinkSchema, LayoutItem, LayoutItemSchema, LayoutLayer, LayoutLayerSchema, LayoutLine, LayoutLineSchema, LayoutLink, LayoutLinkSchema, LayoutOutlineItem, LayoutOutlineItemSchema, LayoutPage, LayoutPageSchema, LayoutPath, LayoutPathSchema, LayoutPathSegment, LayoutPathSegmentSchema, LayoutRect, LayoutRectSchema, LayoutStructureElement, LayoutStructureElementSchema, LayoutSubpath, LayoutSubpathSchema, LayoutText, LayoutTextSchema, type LoadedMathFont, type MathAssembledGlyphs, type MathBox, type MathColor, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphAssembly, type MathGlyphConstruction, type MathGlyphMetrics, type MathGlyphPart, type MathGlyphPlacement, type MathGlyphRun, type MathGlyphVariant, type MathLayoutItem, type MathRule, type MathStretchAxis, type MathStretchConstruction, type MathStretchGlyph, type MathStretchOptions, type MathStretchPlacement, type MathStretchResult, type MathStroke, type MathVariants, NOOP_DIAGNOSTIC_SINK, type PageRasteriser, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfEncryptionError, type PdfEncryptionOptions, type PdfEncryptionPermissions, type PdfEncryptionScheme, PdfParseError, PdfPasswordRequiredError, type Point, type PositionedFormula, type ProvidedFont, type RasterDrawOp, type RasterFillRectOp, type RasterFillSpec, type RasterImageOp, type RasterMatrix, type RasterPageGeometry, type RasterPathOp, type RasterPathSegment, type RasterRegionPt, type RasterStrokeSpec, type RasterSubpath, type ReadPdfOptions, type RenderPdfPageOptions, type ResolvedFace, type ResolvedFont, STANDARD_METRICS, type StandardFontMeasurerOptions, type StandardFontName, type StyledFragment, type StyledRun, type TextMeasurer, type UnderlineMetrics, type VerticalMetricPolicy, type WinAnsiSubstitution, type WrapOptions, type WrappedLine, type WritePdfOptions, assembleStretchyGlyph, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodeJbig2Embedded, decodeJpeg2000, filterScanlines, loadMathFont, looksLikeBareCodestream, parseJp2Container, pdfCodec, readFontFace, readJpeg2000Metadata, readPdf, renderPdfPage, resolveFaceWithRegistry, resolveStandardFont, scaleMathStretchConstruction, unfilterScanlines, writePdf };

package/dist/index.js

@@ -18,5 +18,6 @@ import { DEFAULT_VERTICAL_METRIC_POLICY, createFontMeasurer, createStandardFontM
 import { writePdf } from "./write.js";
 import { PdfBytesSchema, pdfCodec } from "./codec.js";
 import { FontFaceParseError, readFontFace } from "./font-face.js";
+import { renderPdfPage } from "./raster.js";
 export * from "byte-codec";
-export { DEFAULT_VERTICAL_METRIC_POLICY, FontFaceParseError, Jbig2ParseError, Jbig2UnsupportedError, Jpeg2000ParseError, Jpeg2000UnsupportedError, LAYOUT_FORMAT_VERSION, LayoutAnnotationQuadSchema, LayoutAnnotationSchema, LayoutAttachmentSchema, LayoutDestinationSchema, LayoutDestinationTargetSchema, LayoutDocumentSchema, LayoutEllipseSchema, LayoutFormFieldSchema, LayoutFormWidgetSchema, LayoutImageAssetSchema, LayoutImageSchema, LayoutInternalLinkSchema, LayoutItemSchema, LayoutLayerSchema, LayoutLineSchema, LayoutLinkSchema, LayoutOutlineItemSchema, LayoutPageSchema, LayoutPathSchema, LayoutPathSegmentSchema, LayoutRectSchema, LayoutStructureElementSchema, LayoutSubpathSchema, LayoutTextSchema, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, PdfEncryptedError, PdfEncryptionError, PdfParseError, PdfPasswordRequiredError, STANDARD_METRICS, assembleStretchyGlyph, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodeJbig2Embedded, decodeJpeg2000, filterScanlines, loadMathFont, looksLikeBareCodestream, parseJp2Container, pdfCodec, readFontFace, readJpeg2000Metadata, readPdf, resolveFaceWithRegistry, resolveStandardFont, scaleMathStretchConstruction, unfilterScanlines, writePdf };
+export { DEFAULT_VERTICAL_METRIC_POLICY, FontFaceParseError, Jbig2ParseError, Jbig2UnsupportedError, Jpeg2000ParseError, Jpeg2000UnsupportedError, LAYOUT_FORMAT_VERSION, LayoutAnnotationQuadSchema, LayoutAnnotationSchema, LayoutAttachmentSchema, LayoutDestinationSchema, LayoutDestinationTargetSchema, LayoutDocumentSchema, LayoutEllipseSchema, LayoutFormFieldSchema, LayoutFormWidgetSchema, LayoutImageAssetSchema, LayoutImageSchema, LayoutInternalLinkSchema, LayoutItemSchema, LayoutLayerSchema, LayoutLineSchema, LayoutLinkSchema, LayoutOutlineItemSchema, LayoutPageSchema, LayoutPathSchema, LayoutPathSegmentSchema, LayoutRectSchema, LayoutStructureElementSchema, LayoutSubpathSchema, LayoutTextSchema, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, PdfEncryptedError, PdfEncryptionError, PdfParseError, PdfPasswordRequiredError, STANDARD_METRICS, assembleStretchyGlyph, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodeJbig2Embedded, decodeJpeg2000, filterScanlines, loadMathFont, looksLikeBareCodestream, parseJp2Container, pdfCodec, readFontFace, readJpeg2000Metadata, readPdf, renderPdfPage, resolveFaceWithRegistry, resolveStandardFont, scaleMathStretchConstruction, unfilterScanlines, writePdf };