@quario/pdf 0.2.0 → 0.4.0

package/lib/canvas.js

@@ -1,376 +0,0 @@
-/**
- * The drawing surface. Every mark on a page goes through here, so nothing above
- * this module talks to pdf-lib page primitives.
- *
- * Two adapters satisfy one interface. `drawing` puts marks on a document;
- * `measuring` moves the cursor and marks nothing, which is how `probe` reserves
- * a band's height without emitting it. Measuring is therefore a choice of
- * adapter rather than a mode every primitive has to remember to check — and
- * since a measuring canvas is built from seven numbers and a font registry,
- * there is no parameter through which a document could reach it. Pagination is
- * the one thing measuring must never do: a page turn would reset the cursor
- * mid-measure and return a silently wrong height, so `newPage` throws there.
- */
-import { degrees, drawImage, drawText, rgb } from "pdf-lib";
-import { BLACK, dressed, shift } from "./style.js";
-
-// The operator builder wants explicit rotation and skew; report text has none.
-let NO_TURN = degrees(0);
-
-/** @typedef {import('./text.js').Line} Line */
-/** @typedef {import('./text.js').Metrics} Metrics */
-/** @typedef {import('pdf-lib').PDFPage} PDFPage */
-/** @typedef {import('pdf-lib').PDFFont} PDFFont */
-/** @typedef {import('pdf-lib').PDFName} PDFName */
-
-// 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
-// `style` 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.
-/**
- * `style` is the report default — the outermost style layer, resolved once per
- * render from `report-start` and carried here so a measuring canvas built off
- * this frame reads the same one the drawing canvas does. Null when the report
- * declares none.
- *
- * @typedef {{ width: number, height: number, margin: number, base: number,
- *   content: number, top: number, bottom: number, style: any }} 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, style?: any) => Frame} */
-let frame = (width, height, margin, base, style = null) => ({
-  width,
-  height,
-  margin,
-  base,
-  style,
-  content: width - 2 * margin,
-  top: height - margin,
-  bottom: margin,
-});
-
-// `y` is the cursor on the open page and `fresh` says nothing has been drawn on
-// it yet, which is what makes a break legal. `count` is how many pages exist.
-/**
- * @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,
- *   picture: (bytes: Uint8Array, format: string, x: number, y: number,
- *     w: number, h: number) => void,
- *   drawLine: (line: Line, x: number, yTop: number, avail: number,
- *     align: any) => void }} Canvas
- */
-
-// The page passes on top of the interface: re-visiting finished pages, handing
-// out their refs for the outline, and stamping them. Deliberately not on
-// `Canvas` — the layout may not re-target a page mid-walk, and a measurement
-// has no business doing any of it.
-/**
- * @typedef {Canvas & { select: (i: number) => void, refs: any[],
- *   pictures: () => Promise<void>, watermark: (mark: any) => void }} Drawing
- */
-
-// What every canvas starts as, whichever adapter it is: its frame and faces,
-// and a cursor that has drawn nothing yet. Shared because the parity test
-// compares member names, not their values — two hand-written copies of this
-// could drift in what they start from and nothing would notice.
-/**
- * @type {(box: Frame, fonts: import('./fonts.js').Fonts) =>
- *   Frame & Metrics & { y: number, fresh: boolean }}
- */
-let blank = (box, fonts) => ({ ...box, fonts, y: 0, fresh: true });
-
-let GREY = rgb(0.5, 0.5, 0.5);
-
-// Text decoration in the text colour. Thickness and offset come from the
-// 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 {(line: Line) => any} */
-let ink = (line) => (line.pieces[0] && line.pieces[0].color) || BLACK;
-
-/** @type {(line: Line) => boolean} */
-let wantsDeco = (line) => !!line.w && dressed(line);
-
-/**
- * @type {(stroke: (x1: number, x2: number, y: number, thickness: number, color: any) => void,
- *   line: Line, left: number, baseline: number) => void}
- */
-let decorateLine = (stroke, line, left, baseline) => {
-  if (!wantsDeco(line)) return;
-  let thickness = Math.max(line.asc / 12, 0.5);
-  let right = left + line.w;
-  let color = ink(line);
-  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);
-};
-
-/**
- * The adapter that draws: a canvas over a real document.
- *
- * @type {(doc: import('pdf-lib').PDFDocument, box: Frame,
- *   fonts: import('./fonts.js').Fonts) => Drawing}
- */
-let drawing = (doc, box, fonts) => {
-  /** @type {PDFPage} */
-  let page;
-  /** @type {PDFPage[]} */
-  let pages = [];
-  /**
-   * The resource name a page refers to a face or an image by, minted once per
-   * resource per page.
-   *
-   * pdf-lib's own page-level state cannot do this: `setFont` mints a fresh
-   * random-suffixed name on every call, and `drawText({ font })` calls it twice
-   * — once to select the face and once to restore the previous one. A report
-   * that alternates bold and regular therefore grows its font dictionary with
-   * its text rather than with its faces, and measured 4.8x larger for the same
-   * content. `drawImage` on the page has the same shape, so one logo down a
-   * thousand rows would put a thousand entries in one XObject dictionary,
-   * every one of them pointing at the same stream.
-   *
-   * Keyed by page and kept for the canvas's whole life, never reset per page,
-   * because the page-band pass returns to pages the body already drew on and
-   * must reuse what they registered.
-   *
-   * @type {(mint: (on: PDFPage, resource: any) => PDFName) =>
-   *   (on: PDFPage, resource: any) => PDFName}
-   */
-  let perPage = (mint) => {
-    /** @type {WeakMap<PDFPage, Map<any, PDFName>>} */
-    let keys = new WeakMap();
-    return (on, resource) => {
-      let minted = keys.get(on);
-      if (!minted) keys.set(on, (minted = new Map()));
-      let key = minted.get(resource);
-      if (!key) minted.set(resource, (key = mint(on, resource)));
-      return key;
-    };
-  };
-  let faceKey = perPage((on, font) => on.node.newFontDictionary(font.name, font.ref));
-  let imageKey = perPage((on, image) => on.node.newXObject("Image", image.ref));
-  /** @type {(font: PDFFont) => PDFName} */
-  let fontKey = (font) => faceKey(page, font);
-
-  // Open a fresh page and put the cursor at its top.
-  let newPage = () => {
-    page = doc.addPage([canvas.width, canvas.height]);
-    pages.push(page);
-    canvas.y = canvas.top;
-    canvas.fresh = true;
-  };
-
-  /** @type {Canvas['rect']} */
-  let rect = (color, x, y, w, h) => page.drawRectangle({ x, y, width: w, height: h, color });
-
-  // Where every image goes, recorded as the walk passes it and drawn once the
-  // walk is over. Embedding is asynchronous and a walk handler is not, so the
-  // placement is what the flow makes and the bytes are turned into a document
-  // resource afterwards -- which is also what lets one logo repeated on every
-  // page be embedded once and referenced, keyed by the array the source
-  // expression yielded.
-  /** @type {{ page: PDFPage, bytes: Uint8Array, format: string, x: number,
-   *   y: number, w: number, h: number }[]} */
-  let placed = [];
-  // Drawn once, at the end of the render, so nothing clears this: the canvas
-  // and the document it marks end together.
-  /** @type {Canvas['picture']} */
-  let picture = (bytes, format, x, y, w, h) => {
-    placed.push({ page, bytes, format, x, y, w, h });
-  };
-  /** @type {Drawing['pictures']} */
-  let pictures = async () => {
-    // Keyed by the array the source expression yielded, so one logo reused
-    // across pages is embedded once and every placement references it.
-    /** @type {Map<Uint8Array, any>} */
-    let embedded = new Map();
-    for (let spot of placed) {
-      let image = embedded.get(spot.bytes);
-      if (!image) {
-        image = await (spot.format === "png" ? doc.embedPng(spot.bytes) : doc.embedJpg(spot.bytes));
-        embedded.set(spot.bytes, image);
-      }
-      spot.page.pushOperators(
-        ...drawImage(imageKey(spot.page, image), {
-          x: spot.x,
-          y: spot.y,
-          width: spot.w,
-          height: spot.h,
-          rotate: NO_TURN,
-          xSkew: NO_TURN,
-          ySkew: NO_TURN,
-        }),
-      );
-    }
-  };
-
-  /** @type {Canvas['rule']} */
-  let rule = (x1, x2, y) =>
-    page.drawLine({ start: { x: x1, y }, end: { x: x2, y }, thickness: 0.5, color: BLACK });
-
-  /** @type {(piece: Line['pieces'][number], x: number, y: number) => void} */
-  let writePiece = (piece, x, y) => {
-    if (!piece.text) return;
-    page.pushOperators(
-      ...drawText(piece.font.encodeText(piece.text), {
-        font: fontKey(piece.font),
-        size: piece.size,
-        color: piece.color || BLACK,
-        x,
-        y,
-        rotate: NO_TURN,
-        xSkew: NO_TURN,
-        ySkew: NO_TURN,
-      }),
-    );
-  };
-
-  /** @type {(left: number, right: number, y: number, thickness: number, color: any) => void} */
-  let strokeAt = (left, right, y, thickness, color) =>
-    page.drawLine({
-      start: { x: left, y },
-      end: { x: right, y },
-      thickness,
-      color,
-    });
-
-  // Draw one wrapped line with its baseline the line's ascender under `yTop`,
-  // horizontally placed by `align` within `avail` starting at `x`.
-  /** @type {Canvas['drawLine']} */
-  let drawLine = (line, x, yTop, avail, align) => {
-    let left = x + shift(align, avail - line.w);
-    let baseline = yTop - line.asc;
-    let cursor = left;
-    for (let piece of line.pieces) {
-      writePiece(piece, cursor, baseline);
-      cursor += piece.w;
-    }
-    decorateLine(strokeAt, line, left, baseline);
-  };
-
-  // Draw one page's marking through the same operator path as body text, so the
-  // face reuses the page's `fontKey` resource instead of growing the dictionary
-  // per draw.
-  /** @type {Drawing['watermark']} */
-  let watermark = (mark) =>
-    page.pushOperators(
-      ...drawText(mark.line, {
-        font: fontKey(mark.font),
-        size: mark.size,
-        color: GREY,
-        x: mark.x,
-        y: mark.y,
-        rotate: mark.rotate,
-        xSkew: NO_TURN,
-        ySkew: NO_TURN,
-        // Opacity needs a named ExtGState resource on the page, and pdf-lib
-        // declares the only method that mints one private, with no public
-        // equivalent. The cast is deliberate and stays as narrow as the call.
-        graphicsState: /** @type {any} */ (page).maybeEmbedGraphicsState({ opacity: 0.15 }),
-      }),
-    );
-
-  /** @type {Drawing} */
-  let canvas = {
-    ...blank(box, fonts),
-    get count() {
-      return pages.length;
-    },
-    newPage,
-    rect,
-    rule,
-    picture,
-    pictures,
-    drawLine,
-    // Re-open a finished page, for the passes that run over them all.
-    select: (i) => {
-      page = pages[i];
-    },
-    get refs() {
-      return pages.map((each) => each.ref);
-    },
-    watermark,
-  };
-  return canvas;
-};
-
-// Nothing at all — what every primitive does when the canvas only measures.
-let MARKS_NOTHING = () => {};
-
-/**
- * The adapter that only measures: the same cursor arithmetic with every mark
- * discarded. It holds no document and no page, so a measurement cannot write.
- *
- * @type {(box: Frame, fonts: import('./fonts.js').Fonts) => Canvas}
- */
-let measuring = (box, fonts) => ({
-  ...blank(box, fonts),
-  count: 0,
-  newPage: () => {
-    throw new Error("probe reached newPage: the measuring path must not paginate");
-  },
-  rect: MARKS_NOTHING,
-  rule: MARKS_NOTHING,
-  picture: MARKS_NOTHING,
-  drawLine: MARKS_NOTHING,
-});
-
-/**
- * Take on a content box someone else worked out — how much page furniture
- * needs is layout's policy (`reserve` there), while which of a frame's members
- * may move at all is this module's invariant. `top` and `bottom` are the two,
- * and the only two read here: the page box and the base size are fixed for the
- * whole document, so the rest of the frame that arrives is this canvas's own
- * and is left alone. Layout reads the bounds live, so every page the body then
- * flows through sees the narrowed box.
- *
- * Legal only while the render has not committed to a page — the band flow
- * adopts from its `report-start` handler, with its own first page open but
- * empty. `fresh` alone would not say that: a page turn makes it true again on
- * page five, where narrowing would silently mix two geometries in one document.
- *
- * @param {Canvas} canvas The canvas to narrow.
- * @param {Frame} box The frame it takes its content box from.
- */
-let adopt = (canvas, box) => {
-  if (canvas.count > 1 || !canvas.fresh) throw Error("adopt: the content box is fixed");
-  canvas.top = box.top;
-  canvas.bottom = box.bottom;
-  // The open page has drawn nothing, so its cursor moves with the box — the
-  // same statement `newPage` makes, and nothing on the page can be lost by it.
-  canvas.y = canvas.top;
-};
-
-// The unlicensed-output marking (LICENSE section 6): one translucent line
-// drawn corner-to-corner across the finished page — over the content, not
-// under it, so no filled table header or background rectangle can cover it.
-// The wording comes from the engine, on `report-start`; this target owns the
-// geometry, which depends only on the page size and never on key contents,
-// so document bytes stay deterministic in both licensed states.
-
-// The per-render half of the marking, computed once: page geometry, the face
-// and the wording are all fixed for a whole render, so the trig and the
-// glyph-width walk never repeat per page.
-/** @type {(canvas: Canvas, text: string) => any} */
-let stamp = (canvas, text) => {
-  let font = canvas.fonts.families.sans[0];
-  let angle = Math.atan2(canvas.height, canvas.width);
-  // Scale the line to three quarters of the page diagonal, whatever the size.
-  let span = Math.hypot(canvas.width, canvas.height) * 0.75;
-  return {
-    font,
-    line: font.encodeText(text),
-    size: (54 * span) / font.widthOfTextAtSize(text, 54),
-    x: canvas.width / 2 - (span / 2) * Math.cos(angle),
-    y: canvas.height / 2 - (span / 2) * Math.sin(angle),
-    rotate: degrees((angle * 180) / Math.PI),
-  };
-};
-
-export { adopt, decorateLine, drawing, frame, measuring, stamp };

package/lib/fonts.js

@@ -1,180 +0,0 @@
-/**
- * The faces a render can draw with.
- *
- * Every face is embedded on the document before the walk starts, so resolving
- * a style to a face during layout is synchronous — pdf-lib's `embedFont` is
- * async, and the walk is not. Embedding the twelve base-14 faces up front
- * costs under 200 bytes in the output, which is cheaper than threading a
- * two-pass measure/draw split through the layout to embed only what is used.
- */
-import { StandardFonts } from "pdf-lib";
-
-// The three families the vocabulary names, four variants each, indexed by
-// `bold + 2 * italic` — the same ordering the schema's `bold`/`italic` flags
-// produce. Unknown family names fall back to sans, as SCHEMA.md specifies.
-let BASE = {
-  sans: [
-    StandardFonts.Helvetica,
-    StandardFonts.HelveticaBold,
-    StandardFonts.HelveticaOblique,
-    StandardFonts.HelveticaBoldOblique,
-  ],
-  serif: [
-    StandardFonts.TimesRoman,
-    StandardFonts.TimesRomanBold,
-    StandardFonts.TimesRomanItalic,
-    StandardFonts.TimesRomanBoldItalic,
-  ],
-  mono: [
-    StandardFonts.Courier,
-    StandardFonts.CourierBold,
-    StandardFonts.CourierOblique,
-    StandardFonts.CourierBoldOblique,
-  ],
-};
-
-/** @typedef {{ families: Record<string, any[]> }} Fonts */
-
-// Host-supplied TrueType families need a font parser, which is an optional
-// peer: base-14 reports install nothing extra. Loaded only when `fonts` is
-// passed, and a missing package is reported as what it is.
-/** @type {(doc: any) => Promise<void>} */
-let useFontkit = async (doc) => {
-  let fontkit;
-  try {
-    fontkit = (await import("@pdf-lib/fontkit")).default;
-  } catch {
-    throw Error("options.fonts: install @pdf-lib/fontkit to embed TrueType families");
-  }
-  doc.registerFontkit(fontkit);
-};
-
-/** @type {(doc: any) => Promise<Record<string, any[]>>} */
-let embedBase = async (doc) => {
-  /** @type {Record<string, any[]>} */
-  let families = {};
-  for (let [name, variants] of Object.entries(BASE))
-    families[name] = await Promise.all(variants.map((v) => doc.embedFont(v)));
-  return families;
-};
-
-/** @type {(name: string, def: any) => string} */
-let asFamily = (name, def) => {
-  let path = "options.fonts." + name;
-  if (!def || typeof def !== "object")
-    throw Error(path + ": expected { regular, bold?, italic?, boldItalic? }");
-  if (def.regular == null) throw Error(path + ".regular: required");
-  return path;
-};
-
-/** @type {(doc: any, src: any, path: string, variant: string) => Promise<any>} */
-let embedOne = async (doc, src, path, variant) => {
-  try {
-    return await doc.embedFont(src[variant], { subset: true });
-  } catch (e) {
-    throw Error(path + "." + variant + ": " + /** @type {Error} */ (e).message);
-  }
-};
-
-// Missing variants fall back to the family's regular, so a face is
-// always resolvable once the family is named.
-/** @type {(doc: any, src: any, path: string, variant: string, faces: any[]) => Promise<any>} */
-let embedVariant = async (doc, src, path, variant, faces) => {
-  if (src[variant] == null) return faces[0];
-  return embedOne(doc, src, path, variant);
-};
-
-/** @type {(doc: any, name: string, def: any) => Promise<any[]>} */
-let familyOf = async (doc, name, def) => {
-  let path = asFamily(name, def);
-  /** @type {any[]} */
-  let faces = [];
-  for (let variant of ["regular", "bold", "italic", "boldItalic"])
-    faces.push(await embedVariant(doc, def, path, variant, faces));
-  return faces;
-};
-
-/** @type {(doc: any, custom: any, families: Record<string, any[]>) => Promise<void>} */
-let embedCustom = async (doc, custom, families) => {
-  if (!(custom && Object.keys(custom).length)) return;
-  await useFontkit(doc);
-  for (let [name, def] of Object.entries(custom))
-    families[name.toLowerCase()] = await familyOf(doc, name, def);
-};
-
-/**
- * Embed every face the render can reach and return the registry `face()` reads.
- *
- * @param {any} doc The pdf-lib document.
- * @param {any} custom `options.fonts`, or null.
- * @returns {Promise<Fonts>}
- */
-export async function embedFonts(doc, custom) {
-  let families = await embedBase(doc);
-  await embedCustom(doc, custom, families);
-  return { families };
-}
-
-/** @type {(style: any) => string} */
-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[]} */
-let variantsOf = (fonts, 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)];
-}
-
-// The distance from a line's top to its baseline: pdf-lib's ascender, which
-// matches the per-family fractions the hand-rolled writer used.
-/** @type {(font: any, size: number) => number} */
-export let ascOf = (font, size) => font.heightAtSize(size, { descender: false });
-
-// Text measurement. pdf-lib encodes on draw, so nothing here needs to know
-// about WinAnsi or glyph ids.
-/** @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.
-let ASCII = /^[\x20-\x7E]*$/;
-
-/**
- * Replace characters a face cannot encode 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`.
- *
- * 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.
- *
- * @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.
-  // oxlint-disable-next-line typescript/no-misused-spread
-  return [...text].map((char) => (encodable(font, char) ? char : "?")).join("");
-};
-
-/** @type {(font: any, text: string) => boolean} */
-let encodable = (font, text) => {
-  try {
-    font.widthOfTextAtSize(text, 1);
-    return true;
-  } catch {
-    return false;
-  }
-};

package/lib/image.js

@@ -1,58 +0,0 @@
-/**
- * An image's own size, read from its header. Sizing is a fact about the bytes
- * rather than anything a page can answer, so it sits here and not on the
- * drawing surface: the band flow asks for it while measuring, where no
- * document is in reach at all, and again while drawing, where one is.
- *
- * Read, never decoded — a PNG's IHDR and a JPEG's frame header carry the two
- * numbers this target needs, and nothing else here looks at a pixel.
- *
- * The XLSX target reads the same two headers for its own placement, in pixels.
- * Whether that fact belongs on the engine's event instead — it already reads
- * the magic numbers to name the format — is bead `quario-b0h`.
- */
-
-// Points, at the conventional 96 dpi the schema names: 72/96 of a pixel.
-let PER_PX = 72 / 96;
-
-/** @type {(bytes: Uint8Array, at: number) => number} */
-let word = (bytes, at) => (bytes[at] << 8) | bytes[at + 1];
-
-/** @type {(code: number) => boolean} */
-let inSof = (code) => code >= 0xc0 && code <= 0xcf;
-
-/** @type {(code: number) => boolean} */
-let notTable = (code) => code !== 0xc4 && code !== 0xc8 && code !== 0xcc;
-
-// The frame header carries the dimensions, and it is the first SOFn marker:
-// every code in C0..CF except the three in that range that are not frames --
-// DHT, the JPG extension, and DAC.
-/** @type {(code: number) => boolean} */
-let isFrame = (code) => inSof(code) && notTable(code);
-
-/** @type {(bytes: Uint8Array) => { w: number, h: number }} */
-let jpegSize = (bytes) => {
-  for (let at = 2; at + 9 < bytes.length; at += 2 + word(bytes, at + 2)) {
-    if (bytes[at] !== 0xff) break;
-    if (isFrame(bytes[at + 1])) return { w: word(bytes, at + 7), h: word(bytes, at + 5) };
-  }
-  return { w: 0, h: 0 };
-};
-
-/**
- * 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.
- *
- * @param {Uint8Array} bytes The image file.
- * @param {string} format The engine's sniff: `"png"` or `"jpeg"`.
- * @returns {{ w: number, h: number }} The size, in points.
- */
-export let intrinsic = (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").
-  if (!(w > 0 && h > 0)) throw Error("image: could not read the image's size from its bytes");
-  return { w: w * PER_PX, h: h * PER_PX };
-};