@quario/pdf 0.1.0 → 0.3.0

package/CHANGELOG.md

@@ -7,6 +7,99 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-09-02
+
+### Added
+
+- **`format` stringifies at the edge from the instance locale.** A PDF
+  without a host locale still uses `en-US` / UTC, so the bytes stay
+  reproducible (`docs/adr/0041`, `docs/adr/0025`).
+
+- **A height-declared report header pins from the page top.** Leftover sits
+  under the items; the next band starts at the pin. The half-line group gap
+  drops after it. `page.margin` on the document is the inset when the host
+  omits it; both is a render error.
+
+- **`spaceBefore` / `spaceAfter` skip the cursor.** Adjacent gaps add.
+  `spaceBefore` drops at a fresh body page or strip top; page-band items
+  keep it.
+
+- **The box is honoured in layout.** Padding and border inset wrap width; a
+  named padding `0` beats the cell omakase (`PADX` 6 / `PADY` 2) on that
+  side. Incomplete sides draw nothing.
+
+### Changed
+
+- **The last data row keeps the whole emitted total block.** A stack taller
+  than a page degrades like a tall row.
+
+- **An unstyled table has no rules.** This target used to draw two 0.5 pt
+  rules, under the header and above the total, that no declaration could
+  ask for or refuse. Those strokes are gone. The strokes an author wants
+  are the box they declared. Cell padding omakase stays on undeclared cell
+  sides.
+
+- **A visible text item occupies a line at its own `size`, empty or not.** An
+  empty or whitespace-only value used to sit at the report's base leading
+  (~14 pt at the 10 pt baseline). It now occupies `1.4 ×` the item's size, the
+  same as a glyph line. A literal newline is a line break; the blank line
+  among `"a\n\nb"` is that size too. A table cell that is empty or only
+  horizontal whitespace still has no content height.
+
+### Fixed
+
+- **A missing TrueType glyph draws as `?`, not `.notdef`.** Characters
+  outside WinAnsi already substituted `?`; an embedded face's cmap holes
+  drew a box instead, and text extraction hid it. Same rule for every
+  face: a character the face cannot draw becomes `?`.
+
+- **CR, LF, and CRLF are one hard line break.** Cell text already broke
+  on LF; a CRLF left a CR on the previous line, and a lone CR did not
+  break. All three are now one break, matching `SCHEMA.md` Cell values.
+  Wrapping still applies within each line.
+
+## [0.2.0] - 2026-09-01
+
+### Added
+
+- **The report default sets the document's face and base size.** A report's
+  top-level `style` replaces this target's own baseline, so its `size` scales
+  row heights and band gaps with the type rather than leaving them at a size
+  nothing is set in. It is the layer _under_ the band-role defaults: a report
+  declaring `size: 12` still renders its report header at 14, and an item's own
+  style wins over both.
+
+- **`uppercase` draws capitals.** With no text-transform to defer to, this
+  target capitalises the string before measuring it, so wrapping and column
+  widths are those of the text actually drawn. The mapping is Unicode default
+  case, never the host's locale, so output stays byte-reproducible.
+
+- **Splits lay out across the content width.** Each slot is measured and
+  wrapped inside its own share, all slots draw from a common top, and the
+  split takes the height of its tallest slot so the band below clears them
+  all. **A split is never broken across a page**: one that does not fit the
+  remaining height moves whole, exactly as an image does, and one taller than
+  any page renders in full past the bottom margin. The split's own style is
+  the layer under each slot's, and its `background` fills the whole split
+  behind them.
+
+### Changed
+
+- **A bare `Date` draws as ISO 8601 UTC, the same on every machine.** Cell
+  text and outline bookmark titles for `Date` values used `String(date)`,
+  which bakes the host's timezone and locale into the document — at odds with
+  this target's byte-reproducibility guarantee. Both now render through the
+  engine's shared display rule, so a `Date` group key titles its bookmark
+  with the same ISO text its cells draw.
+
+### Removed
+
+- **`options.baseSize`.** A document's type size is the document's own, so it
+  is the report's `style.size` — portable, travelling with the definition to
+  every target — rather than a host option one target honoured. Text with
+  nothing declared still renders at 10 points. Replace `pdf({ baseSize: 11 })`
+  with `"style": { "size": 11 }` on the report.
+
 ## [0.1.0] - 2026-08-27
 
 ### Added

package/README.md

@@ -89,7 +89,6 @@ Page geometry is target configuration, never schema:
 ```js
 {
   page: { size: "A4", margin: 54 },   // 'A4' | 'letter' | [width, height] in points
-  baseSize: 10,                       // base font size in points
   meta: { title, author, subject },   // optional /Info — strings only, never a date
   fonts: { Inter: { regular, bold, italic, boldItalic } },  // TrueType bytes
 }
@@ -97,8 +96,9 @@ Page geometry is target configuration, never schema:
 
 `size` defaults to `A4` (595.28 × 841.89 pt); an array is a custom `[width, height]` in points. An
 unknown size name is a definition error, thrown by the factory. `margin` applies to all four sides and defaults to 54
-(0.75 in). `baseSize` defaults to 10 and style `size` declarations override it per element; line
-leading is 1.4× a line's largest font size.
+(0.75 in). Text renders at 10pt when nothing declares a size: a document's type size is the
+document's own, so it is the report's `style.size`, not a host option. Line leading is 1.4× a line's
+largest font size.
 
 ## Layout
 
@@ -135,8 +135,9 @@ without authored margins.
 
 The base-14 Helvetica, Times, and Courier families carry the default output (`family: "sans"`,
 `"serif"`, `"mono"`, each with regular, bold, italic, and bold-italic faces), using WinAnsi
-encoding. Characters outside WinAnsi render as `?` rather than failing the report, because cell
-text is untrusted data and one stray character must not take a document down.
+encoding. Characters a face cannot draw render as `?` rather than failing the report, because cell
+text is untrusted data and one stray character must not take a document down. WinAnsi is the
+base-14 limit; a TrueType face's cmap is its own.
 
 For full Unicode, supply TrueType families and select them by name:
 

package/lib/balance.js

@@ -1,5 +1,5 @@
 // The one number a balanced region decides: how tall each of its strips is
-// (ADR 0020 — balancing is a strip height, not a pass). Pure arithmetic over
+// (ADR 0027 — balancing is a strip height, not a pass). Pure arithmetic over
 // what the buffer holds, so nothing here reaches a canvas or the band flow.
 //
 // Balancing by height alone under-fills, because most of what a region holds

package/lib/box.js

@@ -0,0 +1,111 @@
+/**
+ * The box model this target honours: per-side padding and border, border-box,
+ * no collapse. Cell omakase (PADX / PADY) applies only where the author named
+ * no padding on that side; a named 0 wins. A border side contributes only when
+ * width, style and colour all resolve and width is positive — an incomplete
+ * result at render is nothing, not a solid black stroke.
+ */
+import { PADX, PADY, col } from "./style.js";
+
+let SIDES = ["Top", "Right", "Bottom", "Left"];
+/** @type {Record<string, number[] | null>} */
+let DASH = { solid: null, dashed: [3, 2], dotted: [1, 1.5] };
+
+/** @typedef {{ t: number, r: number, b: number, l: number }} Inset */
+
+/** @type {Inset} */
+let CELL_PAD = { t: PADY, r: PADX, b: PADY, l: PADX };
+/** @type {Inset} */
+let NO_PAD = { t: 0, r: 0, b: 0, l: 0 };
+
+/** @type {(name: string) => boolean} */
+let isBox = (name) => name.startsWith("padding") || name.startsWith("border");
+
+/** @type {(style: any) => any} */
+let unbox = (style) => {
+  if (!style) return style;
+  let names = Object.keys(style).filter((name) => !isBox(name));
+  if (!names.length) return null;
+  return Object.fromEntries(names.map((name) => [name, style[name]]));
+};
+
+/** @type {(style: any, side: string, fallback: number) => number} */
+let padOf = (style, side, fallback) => {
+  let value = style?.["padding" + side];
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+};
+
+/** @type {(width: any) => boolean} */
+let isStroke = (width) => Number.isFinite(width) && width > 0;
+/** @type {(line: any) => boolean} */
+let isLine = (line) => typeof line === "string" && Object.hasOwn(DASH, line);
+
+/**
+ * @type {(width: any, line: any, color: any) =>
+ *   { width: number, dash: number[] | null, color: any } | null}
+ */
+let strokeOf = (width, line, color) => {
+  if (!isStroke(width) || !isLine(line) || !color) return null;
+  return { width, dash: DASH[line], color };
+};
+
+/**
+ * @type {(style: any, side: string) =>
+ *   { width: number, dash: number[] | null, color: any } | null}
+ */
+let edgeOf = (style, side) => {
+  if (!style) return null;
+  return strokeOf(
+    style["border" + side + "Width"],
+    style["border" + side + "Style"],
+    col(style["border" + side + "Color"]),
+  );
+};
+
+/** @type {(style: any, side: string) => number} */
+let thick = (style, side) => {
+  let edge = edgeOf(style, side);
+  return edge ? edge.width : 0;
+};
+
+/** @type {(style: any, side: string, fallback: number) => number} */
+let inset = (style, side, fallback) => padOf(style, side, fallback) + thick(style, side);
+
+/** @type {(style: any, omakase: Inset) => Inset} */
+let insetOf = (style, omakase) => ({
+  t: inset(style, "Top", omakase.t),
+  r: inset(style, "Right", omakase.r),
+  b: inset(style, "Bottom", omakase.b),
+  l: inset(style, "Left", omakase.l),
+});
+
+/** Endpoints of one inner-centred edge, as stroke() takes them. */
+/** @type {Record<string, (x: number, yTop: number, w: number, h: number, half: number) => number[]>} */
+let SPAN = {
+  Top: (x, yTop, w, _h, half) => [x, yTop - half, x + w, yTop - half],
+  Bottom: (x, yTop, w, h, half) => [x, yTop - h + half, x + w, yTop - h + half],
+  Left: (x, yTop, _w, h, half) => [x + half, yTop, x + half, yTop - h],
+  Right: (x, yTop, w, h, half) => [x + w - half, yTop, x + w - half, yTop - h],
+};
+
+/** @type {(canvas: { stroke: Function }, x: number, yTop: number, w: number, h: number, style: any, side: string) => void} */
+let paintEdge = (canvas, x, yTop, w, h, style, side) => {
+  let edge = edgeOf(style, side);
+  if (!edge) return;
+  canvas.stroke(...SPAN[side](x, yTop, w, h, edge.width / 2), edge.width, edge.color, edge.dash);
+};
+
+/**
+ * Fill and stroke one border-box. Background is the whole rect; each edge
+ * sits inside it, centred on its own width, so a stroke does not spill past
+ * the box the caller measured.
+ *
+ * @type {(canvas: { rect: Function, stroke: Function }, x: number, yTop: number,
+ *   w: number, h: number, style: any, bg: any) => void}
+ */
+let paintBox = (canvas, x, yTop, w, h, style, bg) => {
+  if (bg) canvas.rect(bg, x, yTop - h, w, h);
+  if (style) for (let side of SIDES) paintEdge(canvas, x, yTop, w, h, style, side);
+};
+
+export { CELL_PAD, NO_PAD, insetOf, paintBox, unbox };

package/lib/canvas.js

@@ -12,7 +12,7 @@
  * mid-measure and return a silently wrong height, so `newPage` throws there.
  */
 import { degrees, drawImage, drawText, rgb } from "pdf-lib";
-import { BLACK, shift } from "./style.js";
+import { BLACK, dressed, shift } from "./style.js";
 
 // The operator builder wants explicit rotation and skew; report text has none.
 let NO_TURN = degrees(0);
@@ -23,24 +23,38 @@ let NO_TURN = degrees(0);
 /** @typedef {import('pdf-lib').PDFFont} PDFFont */
 /** @typedef {import('pdf-lib').PDFName} PDFName */
 
-// The page box and the content box. Fixed for the whole render, from the moment
-// it commits to a page: the page bands are measured against the page box and
-// take their height off `top`/`bottom` through `adopt` below, while the first
-// page is still untouched.
+// The page box and the content box. Settled at `report-start` and fixed
+// thereafter: the geometry is the factory's and never moves, while `base` and
+// `family` take the report default one event into the render, before anything
+// is measured. The page bands are measured against the page box and take their
+// height off `top`/`bottom` through `adopt` below, while the first page is
+// still untouched.
 /**
+ * `family` is the report default's typeface, normalised, and `base` its size —
+ * the two declarations that default is narrowed to. They ride the frame so a
+ * measuring canvas built off it reads the same pair the drawing canvas does,
+ * and so the default reaches a node as a fallback rather than a merged layer;
+ * `layout.js`'s `adoptDefault` carries why. `family` is null when the report
+ * declares none.
+ *
  * @typedef {{ width: number, height: number, margin: number, base: number,
- *   content: number, top: number, bottom: number }} Frame
+ *   content: number, top: number, bottom: number, family: string | null,
+ *   locale?: string, currency?: string, timeZone?: string }} Frame
  */
 
 // A frame from the page box and the base size: how `content`/`top`/`bottom`
 // fall out of a page and a margin is derived here, once, so no caller and no
 // suite has to restate it and drift from what a real render uses.
-/** @type {(width: number, height: number, margin: number, base: number) => Frame} */
-let frame = (width, height, margin, base) => ({
+/**
+ * @type {(width: number, height: number, margin: number, base: number,
+ *   family?: string | null) => Frame}
+ */
+let frame = (width, height, margin, base, family = null) => ({
   width,
   height,
   margin,
   base,
+  family,
   content: width - 2 * margin,
   top: height - margin,
   bottom: margin,
@@ -52,7 +66,8 @@ let frame = (width, height, margin, base) => ({
  * @typedef {Frame & Metrics & { y: number, fresh: boolean, count: number,
  *   newPage: () => void,
  *   rect: (color: any, x: number, y: number, w: number, h: number) => void,
- *   rule: (x1: number, x2: number, y: number) => void,
+ *   stroke: (x1: number, y1: number, x2: number, y2: number, thickness: number,
+ *     color: any, dash: number[] | null) => void,
  *   picture: (bytes: Uint8Array, format: string, x: number, y: number,
  *     w: number, h: number) => void,
  *   drawLine: (line: Line, x: number, yTop: number, avail: number,
@@ -84,17 +99,11 @@ let GREY = rgb(0.5, 0.5, 0.5);
 // line's ascender (the face metric already measured for baseline placement).
 // Empty lines (no width) draw nothing. Shared by the drawing adapter and the
 // layout recorder so both exercise the same path.
-/** @type {{ flag: 'underline' | 'strikethrough', at: (baseline: number, asc: number) => number }[]} */
-let DECO = [
-  { flag: "underline", at: (baseline, asc) => baseline - asc * 0.12 },
-  { flag: "strikethrough", at: (baseline, asc) => baseline + asc * 0.35 },
-];
-
 /** @type {(line: Line) => any} */
 let ink = (line) => (line.pieces[0] && line.pieces[0].color) || BLACK;
 
 /** @type {(line: Line) => boolean} */
-let wantsDeco = (line) => !!(line.w && (line.underline || line.strikethrough));
+let wantsDeco = (line) => !!line.w && dressed(line);
 
 /**
  * @type {(stroke: (x1: number, x2: number, y: number, thickness: number, color: any) => void,
@@ -105,9 +114,8 @@ let decorateLine = (stroke, line, left, baseline) => {
   let thickness = Math.max(line.asc / 12, 0.5);
   let right = left + line.w;
   let color = ink(line);
-  for (let { flag, at } of DECO) {
-    if (line[flag]) stroke(left, right, at(baseline, line.asc), thickness, color);
-  }
+  if (line.underline) stroke(left, right, baseline - line.asc * 0.12, thickness, color);
+  if (line.strikethrough) stroke(left, right, baseline + line.asc * 0.35, thickness, color);
 };
 
 /**
@@ -209,9 +217,15 @@ let drawing = (doc, box, fonts) => {
     }
   };
 
-  /** @type {Canvas['rule']} */
-  let rule = (x1, x2, y) =>
-    page.drawLine({ start: { x: x1, y }, end: { x: x2, y }, thickness: 0.5, color: BLACK });
+  /** @type {Canvas['stroke']} */
+  let stroke = (x1, y1, x2, y2, thickness, color, dash) =>
+    page.drawLine({
+      start: { x: x1, y: y1 },
+      end: { x: x2, y: y2 },
+      thickness,
+      color,
+      ...(dash ? { dashArray: dash, dashPhase: 0 } : {}),
+    });
 
   /** @type {(piece: Line['pieces'][number], x: number, y: number) => void} */
   let writePiece = (piece, x, y) => {
@@ -283,7 +297,7 @@ let drawing = (doc, box, fonts) => {
     },
     newPage,
     rect,
-    rule,
+    stroke,
     picture,
     pictures,
     drawLine,
@@ -315,7 +329,7 @@ let measuring = (box, fonts) => ({
     throw new Error("probe reached newPage: the measuring path must not paginate");
   },
   rect: MARKS_NOTHING,
-  rule: MARKS_NOTHING,
+  stroke: MARKS_NOTHING,
   picture: MARKS_NOTHING,
   drawLine: MARKS_NOTHING,
 });

package/lib/fonts.js

@@ -49,8 +49,6 @@ let useFontkit = async (doc) => {
   doc.registerFontkit(fontkit);
 };
 
-let VARIANTS = ["regular", "bold", "italic", "boldItalic"];
-
 /** @type {(doc: any) => Promise<Record<string, any[]>>} */
 let embedBase = async (doc) => {
   /** @type {Record<string, any[]>} */
@@ -91,7 +89,8 @@ let familyOf = async (doc, name, def) => {
   let path = asFamily(name, def);
   /** @type {any[]} */
   let faces = [];
-  for (let variant of VARIANTS) faces.push(await embedVariant(doc, def, path, variant, faces));
+  for (let variant of ["regular", "bold", "italic", "boldItalic"])
+    faces.push(await embedVariant(doc, def, path, variant, faces));
   return faces;
 };
 
@@ -116,22 +115,43 @@ export async function embedFonts(doc, custom) {
   return { families };
 }
 
+// What a declared `family` normalises to before it is looked up: lower case,
+// and nothing at all when the value is not a name. Exported because the report
+// default is normalised once per render rather than once per cell, and two
+// spellings of this would drift.
 /** @type {(style: any) => string} */
-let familyName = (style) => (typeof style.family === "string" ? style.family.toLowerCase() : "");
+export let familyName = (style) =>
+  typeof style.family === "string" ? style.family.toLowerCase() : "";
 
 // Own-key lookup: the family name is render data, so `constructor` must
 // fall back to sans rather than resolve an inherited member.
-/** @type {(fonts: Fonts, name: string) => any[]} */
+/** @type {(fonts: Fonts, name: string | null) => any[]} */
 let variantsOf = (fonts, name) =>
-  Object.hasOwn(fonts.families, name) ? fonts.families[name] : fonts.families.sans;
+  name && Object.hasOwn(fonts.families, name) ? fonts.families[name] : fonts.families.sans;
 
 /** @type {(style: any) => number} */
 let faceIndex = (style) => (style.bold ? 1 : 0) | (style.italic ? 2 : 0);
 
-// Resolve a style block to one embedded face.
-/** @type {(fonts: Fonts, style: any) => any} */
-export function face(fonts, style) {
-  return variantsOf(fonts, familyName(style))[faceIndex(style)];
+/**
+ * Resolve a style block to one embedded face.
+ *
+ * `fallback` is the report default's family, which the canvas carries for the
+ * whole render (docs/adr/0033) — so text declaring no family is set in the
+ * document's.
+ *
+ * The fallback turns on whether a family was *declared*, never on whether the
+ * declared one resolves: a literal `family` is a non-empty string by the time
+ * the engine passes it, but an `=` expression is resolved at render and
+ * reaches here unchecked, so an item can declare `""`, a number or `null`.
+ * Those are the item's own declaration and fall to sans like any other name
+ * this target cannot resolve (SCHEMA.md) — the document's family is for text
+ * that declared none. Own-key, because the block is render data.
+ *
+ * @type {(fonts: Fonts, style: any, fallback: string | null) => any}
+ */
+export function face(fonts, style, fallback) {
+  let declared = Object.hasOwn(style, "family");
+  return variantsOf(fonts, declared ? familyName(style) : fallback)[faceIndex(style)];
 }
 
 // The distance from a line's top to its baseline: pdf-lib's ascender, which
@@ -144,38 +164,60 @@ export let ascOf = (font, size) => font.heightAtSize(size, { descender: false })
 /** @type {(font: any, text: string, size: number) => number} */
 export let width = (font, text, size) => font.widthOfTextAtSize(text, size);
 
-// Printable ASCII, which every face encodes and which almost all report text
-// is. Asking the face instead costs a full measurement per atom.
+// Printable ASCII, which every text face encodes and which almost all report
+// text is. Asking the cmap instead costs a set walk per atom.
 let ASCII = /^[\x20-\x7E]*$/;
 
+// pdf-lib's getCharacterSet() is the cmap for both kinds of face: WinAnsi
+// code points on the base-14, fontkit's characterSet on an embedded TTF.
+// widthOfTextAtSize does not throw on a TrueType .notdef, so the old probe
+// let cmap holes through as glyph id 0. A face with no cmap (the layout
+// suite's measuring doubles) does not substitute: width is its whole contract.
+let CHARSETS = new WeakMap();
+let OPEN = { has: () => true };
+
+/** @typedef {{ has: (code: number) => boolean }} Cmap */
+
+/** @type {(font: any) => Cmap} */
+let charsetOf = (font) => {
+  let set = CHARSETS.get(font);
+  if (set) return set;
+  set = typeof font.getCharacterSet === "function" ? new Set(font.getCharacterSet()) : OPEN;
+  CHARSETS.set(font, set);
+  return set;
+};
+
 /**
- * Replace characters a face cannot encode with `?`.
+ * Replace characters a face cannot draw with `?`.
  *
- * The base-14 faces are WinAnsi and pdf-lib refuses anything outside it. Cell
- * text is untrusted data, so one stray character must not fail the render:
- * SCHEMA.md promises `?`, and full Unicode through `options.fonts`.
+ * Cell text is untrusted data, so one stray character must not fail the
+ * render: SCHEMA.md promises `?` for any face — WinAnsi on the base-14, the
+ * cmap on an embedded TrueType. A face that also lacks `?` omits the
+ * character rather than drawing .notdef.
  *
- * There is no way to ask a pdf-lib face what it can encode without measuring
- * against it, so the ASCII guard carries the common case and only text with a
- * character outside it pays for the answer. WinAnsi is a superset of printable
- * ASCII, so the guard never lets an unencodable character through.
+ * The ASCII guard carries the common case; only text with a character
+ * outside it pays for the cmap walk. Printable ASCII is a subset of WinAnsi
+ * and of every text face this target embeds.
  *
  * @type {(font: any, text: string) => string}
  */
 export let printable = (font, text) => {
   if (!text || ASCII.test(text) || encodable(font, text)) return text;
-  // WinAnsi encodability is a per-code-point question, so that is the unit to
-  // ask it in — the grapheme clusters the rule protects are unencodable anyway.
+  return replaceUndrawable(charsetOf(font), text);
+};
+
+/** @type {(set: Cmap, text: string) => string} */
+let replaceUndrawable = (set, text) => {
+  let sub = set.has(0x3f) ? "?" : "";
+  // Encodedness is a per-code-point question, so that is the unit to ask it
+  // in — the grapheme clusters the rule protects are undrawable anyway.
   // oxlint-disable-next-line typescript/no-misused-spread
-  return [...text].map((char) => (encodable(font, char) ? char : "?")).join("");
+  return [...text].map((char) => (set.has(char.codePointAt(0) ?? -1) ? char : sub)).join("");
 };
 
 /** @type {(font: any, text: string) => boolean} */
 let encodable = (font, text) => {
-  try {
-    font.widthOfTextAtSize(text, 1);
-    return true;
-  } catch {
-    return false;
-  }
+  let set = charsetOf(font);
+  // oxlint-disable-next-line typescript/no-misused-spread
+  return [...text].every((char) => set.has(char.codePointAt(0) ?? -1));
 };

package/lib/image.js

@@ -18,9 +18,6 @@ let PER_PX = 72 / 96;
 /** @type {(bytes: Uint8Array, at: number) => number} */
 let word = (bytes, at) => (bytes[at] << 8) | bytes[at + 1];
 
-/** @type {(bytes: Uint8Array) => { w: number, h: number }} */
-let pngSize = (bytes) => ({ w: word(bytes, 18), h: word(bytes, 22) });
-
 /** @type {(code: number) => boolean} */
 let inSof = (code) => code >= 0xc0 && code <= 0xcf;
 
@@ -42,9 +39,6 @@ let jpegSize = (bytes) => {
   return { w: 0, h: 0 };
 };
 
-/** @type {(bytes: Uint8Array, format: string) => { w: number, h: number }} */
-let pixels = (bytes, format) => (format === "png" ? pngSize(bytes) : jpegSize(bytes));
-
 /**
  * The image's intrinsic size in points. The format is the engine's sniff,
  * riding on the event, so nothing here decides it a second time.
@@ -54,7 +48,8 @@ let pixels = (bytes, format) => (format === "png" ? pngSize(bytes) : jpegSize(by
  * @returns {{ w: number, h: number }} The size, in points.
  */
 export let intrinsic = (bytes, format) => {
-  let { w, h } = pixels(bytes, format);
+  // A PNG carries the two numbers in its IHDR at a fixed offset.
+  let { w, h } = format === "png" ? { w: word(bytes, 18), h: word(bytes, 22) } : jpegSize(bytes);
   // The engine vouched for the magic numbers, not for the rest of the file:
   // a truncated header reaches here as a zero, and failing loudly beats
   // drawing an image with no size (SCHEMA.md, "Image item").

package/lib/index.d.ts

@@ -26,8 +26,6 @@ export interface PdfFontFamily {
 /** Host controls, taken and validated at the factory call. */
 export interface PdfOptions {
   page?: PdfPage;
-  /** Base font size in points — the size styles override per element. Default `10`. */
-  baseSize?: number;
   meta?: PdfMeta;
   /**
    * TrueType families to embed (subset), selected from styles by