@quario/pdf 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quario/pdf",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "The browserless, paginated PDF render target for quario — in the makings, not yet released",
   "homepage": "https://getquario.com",
   "license": "SEE LICENSE IN LICENSE",
@@ -36,19 +36,20 @@
     "postpack": "node -e \"require('fs').rmSync('LICENSE',{force:true})\""
   },
   "dependencies": {
+    "@quario/layout": "^0.1.0",
     "pdf-lib": "^1.17.1"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.3",
     "@pdf-lib/fontkit": "^1.1.1",
     "@size-limit/preset-small-lib": "^13.0.3",
-    "quario": "^0.3.0",
+    "quario": "^0.4.0",
     "size-limit": "^13.0.3",
     "typescript": "^7.0.2"
   },
   "peerDependencies": {
     "@pdf-lib/fontkit": "^1.1.1",
-    "quario": "^0.3.0"
+    "quario": "^0.4.0"
   },
   "peerDependenciesMeta": {
     "@pdf-lib/fontkit": {
@@ -60,9 +61,10 @@
       "path": "lib/index.js",
       "ignore": [
         "quario",
+        "@quario/layout",
         "pdf-lib"
       ],
-      "limit": "10.5 kB"
+      "limit": "6 kB"
     }
   ],
   "engines": {

package/lib/balance.js

@@ -1,90 +0,0 @@
-// The one number a balanced region decides: how tall each of its strips is
-// (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
-// does not divide: a group instance, a table row and an image each move whole.
-// A share that is not a whole number of them holds one fewer than it should,
-// and the page-bounded last strip absorbs the remainder (beads `quario-s5c`,
-// `quario-cgk`). So the height is not `measured / count` but the shortest
-// whole-line height at which placing the units in order lands them all in
-// `count` strips.
-//
-// The candidates are line multiples, for the reason the average was rounded to
-// one before this: a floor cuts between lines, so a height that is not a whole
-// number of them leaves every strip a fraction short. They are scanned from the
-// shortest upward rather than searched, because the range is bounded by the
-// lines a page holds and a scan owes nothing to an argument about the fill
-// being monotone in the height. The average is not the starting point and not
-// a lower bound: an instance drops its opening gap at a strip head, so `count`
-// of those gaps are measured that no strip ever pays.
-
-// A **unit** is one thing a strip places: `h` is what it costs mid-strip and
-// `head` what it costs when it is the first thing in a strip — which can be
-// less (a group instance drops its opening gap there) or more (a table row
-// pays for the column headings restated above it). `whole` units move
-// undivided and are the only ones `head` is read for; the rest flow, and
-// nothing that flows costs a different amount for opening a strip. What fills each of these in is the caller's, in
-// `layout.js`, which is also where the model's stated limits are.
-/**
- * @typedef {{ whole: boolean, h: number, head: number }} Unit
- */
-// How far one trial has filled: the strips it has opened and the height taken
-// out of the one it is in.
-/**
- * @typedef {{ strips: number, used: number }} Fill
- */
-
-// The height, or `null` when no candidate packs the units into `count` strips
-// and the region should fill instead. `room` is what one strip could hold at
-// most — the page — and `line` the height a floor cuts on.
-/** @type {(units: Unit[], count: number, room: number, line: number) => number | null} */
-export let balance = (units, count, room, line) => {
-  for (let lines = 1; lines * line <= room; lines++) {
-    let height = lines * line;
-    if (stripsFor(units, height) <= count) return height;
-  }
-  return null;
-};
-
-// How many strips this height needs. `Infinity` when a unit is too tall for a
-// strip of it at all — the scan answers that by looking higher, and the region
-// fills once even the page is too short.
-// The only way a height fails outright is a whole unit taller than a strip of
-// it, so that case is answered here rather than through a result both helpers
-// would have to carry.
-/** @type {(units: Unit[], height: number) => number} */
-let stripsFor = (units, height) => {
-  /** @type {Fill} */
-  let fill = { strips: 1, used: 0 };
-  for (let unit of units) {
-    if (!unit.whole) placeFlow(fill, unit, height);
-    else if (unit.head > height) return Infinity;
-    else placeWhole(fill, unit, height);
-  }
-  return fill.strips;
-};
-
-// A whole unit that would cross the floor opens the next strip instead, where
-// its opening gap is dropped — the rule `breaksFor` applies during the replay.
-/** @type {(fill: Fill, unit: Unit, height: number) => void} */
-let placeWhole = (fill, unit, height) => {
-  if (!fill.used) fill.used = unit.head;
-  else if (fill.used + unit.h <= height) fill.used += unit.h;
-  else {
-    fill.strips++;
-    fill.used = unit.head;
-  }
-};
-
-// Breakable content fills to the floor and continues in the next strip, so it
-// spills across as many as it takes rather than moving whole. No height is too
-// short for it: content that splits always goes somewhere.
-/** @type {(fill: Fill, unit: Unit, height: number) => void} */
-let placeFlow = (fill, unit, height) => {
-  fill.used += unit.h;
-  while (fill.used > height) {
-    fill.strips++;
-    fill.used -= height;
-  }
-};

package/lib/box.js

@@ -1,111 +0,0 @@
-/**
- * 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

@@ -1,389 +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
-// `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, 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,
- *   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,
-});
-
-// `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,
- *   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,
- *     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['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) => {
-    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,
-    stroke,
-    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,
-  stroke: 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 };