@weasel-js/pdf 1.11.1 → 1.12.0

package/README.md

@@ -36,8 +36,10 @@ masks for transparency), strokes (native, or outlined where PDF cannot express
 them) with their markers, images, sprites, tiling patterns, text as Type0 fonts
 with a ToUnicode map, color matrices, and isolated groups.
 
-Handed to the `rasterize` hook: effects groups, shader commands, and fills in
-a registered paint kind. Without a hook they are skipped.
+Handed to the `rasterize` hook: effects groups, shader commands, fills in a
+registered paint kind, and groups with a Porter-Duff `composite` other than
+`source-over`, which PDF has no operator for. Without a hook the first three are
+skipped and a composite is drawn source-over.
 
 ```ts
 rasterize(commands, rect, scale, view) => Promise<{ width, height, data }>
@@ -45,9 +47,18 @@ rasterize(commands, rect, scale, view) => Promise<{ width, height, data }>
 
 `rect` is the region in page points, `scale` the pixels per point, and `view`
 the page's `view`, which `world`-unit paint in `commands` resolves through.
-`data` is straight RGBA, top-down.
-
-A face that is CFF-only, restricted (`fsType` 0x0002), bitmap-only (`fsType`
+`data` is straight RGBA, top-down. The hook draws `commands` in order onto a
+clear raster.
+
+For a composite group, `commands` are the page up to and including that group,
+so the raster is the group composited onto what it was drawn over. It is placed
+on white paper over the group's bounds, or over the whole page for an operator
+that clears what the group leaves empty (`source-in`, `source-out`,
+`destination-in`, `destination-atop`, `copy`). An isolated group holding a
+composite is rasterized whole.
+
+Each TrueType face is embedded as a subset of the glyphs the document draws;
+`subsetFonts: false` embeds it whole. A face that is CFF-only, restricted (`fsType` 0x0002), bitmap-only (`fsType`
 0x0200), registered from a WOFF file, or unreadable is drawn as glyph outlines
 instead, so its text is not selectable.
 
@@ -55,16 +66,14 @@ instead, so its text is not selectable.
 
 Each entry is `{ kind: 'glyph' | 'command', detail }`. It reports:
 
-- an effects group, shader command or registered-paint fill with no `rasterize` hook, or one whose hook threw or returned the wrong number of pixels;
+- an effects group, shader command or registered-paint fill with no `rasterize` hook, a composite group with none (drawn source-over), or a raster whose hook threw or returned the wrong number of pixels;
 - an image that could not be read, and a texture that cannot be drawn;
 - a glyph nothing can draw: a color glyph, a slot the layout left empty, or one with no outline in the outline fallback;
 - a command holding NaN or an infinity, which is left out whole;
-- the approximations below, except the stroke width and `screen`-unit paint.
+- the approximations below, except the stroke width.
 
 ## Known approximations
 
 - A `{ px }` stroke width under an anisotropic view uses the mean scale.
 - A `vertexColors` stroke uses a single paint, and a `vertexColors` fill its solid fill.
-- `screen`-unit paint inside a rasterized group is placed in the raster's pixels, not the page's points.
-- A Porter-Duff composite is drawn source-over.
 - An isolated group's color matrix alpha offset is not drawn.

package/dist/index.d.ts

@@ -35,11 +35,18 @@ interface RasterPixels {
 /** Settings and host callbacks for `writePdf`; only `fonts` is required. */
 interface WritePdfOptions {
     fonts: PdfFontSource;
+    /** Default true: each face carries only the glyphs the document draws. False embeds each face whole. */
+    subsetFonts?: boolean;
     title?: string;
     /** Default true; unit tests pass false because jsdom realms lack `CompressionStream`. */
     compress?: boolean;
     readPixels?: (image: ImageBitmap | HTMLImageElement) => RasterPixels;
-    /** `view` is the page's `PdfPage.view`: what a `world`-unit paint in `commands` resolves through. */
+    /**
+     * Draws `commands`, which are in the page's frame, in order onto a clear raster of `rect` at `scale`
+     * pixels per point. `view` is the page's `PdfPage.view`: what a `world`-unit paint in `commands`
+     * resolves through. For a group with its own `composite`, `commands` are the page up to and including
+     * that group, so the raster is the group composited onto what it was drawn over.
+     */
     rasterize?: (commands: readonly DrawCommand[], rect: Rect, scale: number, view: GlMat3 | undefined) => Promise<RasterPixels>;
 }
 /** A glyph or command the writer left out of the file, with the reason. */

package/dist/index.js

@@ -1,8 +1,8 @@
 import { glyphOutline, fontEmbedding } from '@weasel-js/font';
 import { mat3, fillsOpenSubpaths, transformPath, pathFromD, resolveCorners, forEachSegment, PATH_M, PATH_L, PATH_C, PATH_Q, PATH_Z, boundsOfPath } from '@weasel-js/geom';
-import { fillHasInk, strokeHasInk, isGradientPaint, isSolidPaint, parseColor, resolveGradientStops, sampleResolvedStops, gradientGeometry } from '@weasel-js/paint';
-import { isOwnComposite, SPRITE_STRIDE, markerDrawCommands, commandsBounds, composeColorMatrix, resolveStrokeLengths, textureRegistry, applyColorMatrix } from '@weasel-js/renderer';
-import { strokeToPath, strokeInsets } from '@weasel-js/stroke';
+import { fillHasInk, strokeHasInk, isGradientPaint, isSolidPaint, dashPattern, parseColor, resolveGradientStops, sampleResolvedStops, gradientGeometry } from '@weasel-js/paint';
+import { isOwnComposite, readsBackdrop, SPRITE_STRIDE, markerDrawCommands, leavesUncovered, commandsBounds, composeColorMatrix, resolveStrokeLengths, textureRegistry, applyColorMatrix } from '@weasel-js/renderer';
+import { strokeToPath, strokeInsets, dashLength } from '@weasel-js/stroke';
 import { resolveTextStyle, cachedLayoutRuns, verticalAlignOffset, cachedPaintRuns, syntheticBoldOffset, emboldenGlyphD, SYNTHETIC_ITALIC_RADIANS } from '@weasel-js/text';
 
 // src/fonts/fontSource.ts
@@ -692,7 +692,7 @@ function setClip(ctx, clip) {
 function compositeName(op) {
   return typeof op === "string" ? op : `${op.source}/${op.destination}`;
 }
-async function drawRaster(ctx, commands, box, state, reason, unhooked = reason) {
+async function drawRaster(ctx, commands, box, state, reason, unhooked = reason, paper = false) {
   const hook = ctx.opts.rasterize;
   if (!hook) return skip(ctx, unhooked);
   if (box.width <= 0 || box.height <= 0) return;
@@ -708,6 +708,11 @@ async function drawRaster(ctx, commands, box, state, reason, unhooked = reason)
   const { out } = ctx;
   out.op("q");
   out.op("cm", ...mat3.toAffine(inverse));
+  if (paper) {
+    out.op("rg", 1, 1, 1);
+    out.op("re", box.x, box.y, box.width, box.height);
+    out.op("f");
+  }
   writeRaster(ctx, { ...px, data: foldPixels(px.data, state) }, box, state.alpha);
   out.op("Q");
 }
@@ -728,16 +733,13 @@ function rasterFill(ctx, cmd, state, kind) {
   const box = commandsBounds([wrapper], mat3.identity(), ctx);
   return drawRaster(ctx, [wrapper], box, state, `paint kind ${kind}`, `paint kind ${kind} needs a raster`);
 }
-async function rasterGroup(ctx, cmd, state, reason) {
+function inPageFrame(cmd, state) {
   const full = cmd.transform ? mat3.multiply(Float64Array.from(state.transform), cmd.transform) : state.transform;
-  const wrapper = {
-    kind: "group",
-    transform: full,
-    clip: cmd.clip,
-    effects: cmd.effects,
-    children: cmd.children
-  };
-  const box = commandsBounds([wrapper], mat3.identity(), ctx);
+  return { kind: "group", transform: full, clip: cmd.clip, effects: cmd.effects, children: cmd.children };
+}
+async function rasterGroup(ctx, cmd, state, reason) {
+  const wrapper = inPageFrame(cmd, state);
+  const box = commandsBounds([wrapper], mat3.identity(), ctx, RASTER_SCALE);
   const grouped = {
     transform: state.transform,
     alpha: state.alpha * (cmd.alpha ?? 1),
@@ -745,6 +747,13 @@ async function rasterGroup(ctx, cmd, state, reason) {
   };
   await drawRaster(ctx, [wrapper], box, grouped, reason);
 }
+function compositeGroup(ctx, cmd, state) {
+  const composite = cmd.composite;
+  const box = leavesUncovered(composite) ? commandsBounds([inPageFrame(cmd, state)], mat3.identity(), ctx, RASTER_SCALE) : { x: 0, y: 0, width: ctx.width, height: ctx.height };
+  const reason = `composite ${compositeName(composite)}`;
+  const placed = { transform: state.transform, alpha: 1, colorMatrix: null };
+  return drawRaster(ctx, pageThrough(ctx.trail), box, placed, reason, reason, true);
+}
 async function isolatedGroup(ctx, cmd, state, inner) {
   if (cmd.colorMatrix?.[19]) skip(ctx, "group color matrix alpha offset is not drawn");
   const flip = pageFlip(ctx);
@@ -754,7 +763,7 @@ async function isolatedGroup(ctx, cmd, state, inner) {
   const sub = { ...ctx, out: new ContentStream(), resources: new PageResources() };
   sub.out.op("cm", ...mat3.toAffine(mat3.multiply(flip, Float64Array.from(inner.transform))));
   if (cmd.clip) setClip(sub, cmd.clip);
-  await writeCommands(sub, cmd.children, { ...inner, alpha: 1 });
+  await writeCommands(sub, cmd.children, { ...inner, alpha: 1 }, cmd);
   const form = ctx.objects.alloc();
   ctx.objects.streamDeflated(
     form,
@@ -775,10 +784,13 @@ async function isolatedGroup(ctx, cmd, state, inner) {
   out.op("Q");
 }
 async function writeGroup(ctx, cmd, state) {
+  const hooked = ctx.opts.rasterize !== void 0;
   if (cmd.composite && isOwnComposite(cmd.composite)) {
+    if (hooked) return compositeGroup(ctx, cmd, state);
     skip(ctx, `composite ${compositeName(cmd.composite)} drawn as source-over`);
   }
   if (cmd.effects?.length) return rasterGroup(ctx, cmd, state, "effects");
+  if (cmd.isolate && hooked && readsBackdrop(cmd.children)) return rasterGroup(ctx, cmd, state, "composite");
   const m = cmd.transform;
   const inner = {
     transform: m ? mat3.multiply(Float64Array.from(state.transform), m) : state.transform,
@@ -790,7 +802,7 @@ async function writeGroup(ctx, cmd, state) {
   out.op("q");
   if (m) out.op("cm", ...mat3.toAffine(m));
   if (cmd.clip) setClip(ctx, cmd.clip);
-  await writeCommands(ctx, cmd.children, inner);
+  await writeCommands(ctx, cmd.children, inner, cmd);
   out.op("Q");
 }
 var CAPS = { butt: 0, round: 1, square: 2 };
@@ -801,14 +813,15 @@ function isNative(stroke, width) {
   const { start, end } = strokeInsets(stroke, width);
   return start === 0 && end === 0;
 }
-function strokeStyleOps(ctx, stroke, width) {
+function strokeStyleOps(ctx, stroke, width, length) {
   const { out } = ctx;
   out.op("w", width);
   out.op("J", CAPS[stroke.cap ?? "butt"]);
   out.op("j", JOINS[stroke.join ?? "miter"]);
   out.op("M", stroke.miterLimit ?? 4);
-  const dash = stroke.dash ?? [];
-  if (dash.reduce((a, b) => a + b, 0) > 0) out.op("d", `[${dash.map(num).join(" ")}]`, 0);
+  const dash = dashPattern(stroke.dash, length);
+  if (dash === "non-finite") throw new NonFiniteNumber(`pdf: cannot write non-finite dash ${stroke.dash}`);
+  if (dash !== "solid") out.op("d", `[${dash.map(num).join(" ")}]`, 0);
 }
 function resolveStroke(path, raw, state) {
   const { cmd } = resolveStrokeLengths(state.transform, { kind: "path", path, stroke: raw }, { quantize: false });
@@ -822,7 +835,7 @@ function writeNative(ctx, path, stroke, state, width) {
   out.op("q");
   out.op("gs", `/${ctx.resources.extGState(alpha, alpha)}`);
   out.op("RG", ...rgb);
-  strokeStyleOps(ctx, stroke, width);
+  strokeStyleOps(ctx, stroke, width, stroke.dash ? dashLength(path) : void 0);
   pathOps(out, path, "all");
   out.op("S");
   out.op("Q");
@@ -918,6 +931,14 @@ function textObject(ctx, seg, mode, dx, dy) {
   out.op("TJ", `[${parts.join(" ")}]`);
   out.op("ET");
 }
+function longestOutline(ctx, seg, dx, dy) {
+  let length = 0;
+  for (const { g } of seg.glyphs) {
+    const outline = isSpace(g.cp) ? null : placedOutline(ctx, g, dx, dy);
+    if (outline) length = Math.max(length, dashLength(outline));
+  }
+  return length;
+}
 async function paintOutlines(ctx, seg, cmd, dx, dy, state, paint) {
   for (const { g } of seg.glyphs) {
     if (isSpace(g.cp)) continue;
@@ -962,7 +983,8 @@ async function writeSegment(ctx, seg, cmd, dx, dy, state) {
   if (paintsFill) out.op("rg", ...fillColor.rgb);
   if (stroke && strokeColor) {
     out.op("RG", ...strokeColor.rgb);
-    strokeStyleOps(ctx, stroke.stroke, stroke.width);
+    const length = stroke.stroke.dash ? longestOutline(ctx, seg, dx, dy) : void 0;
+    strokeStyleOps(ctx, stroke.stroke, stroke.width, length);
   } else if (bold && fillColor) {
     out.op("RG", ...fillColor.rgb);
     out.op("w", 2 * bold.growth * first.fontSize);
@@ -1034,6 +1056,15 @@ async function writeText2(ctx, cmd, state) {
 }
 
 // src/drawCommands.ts
+function pageThrough(trail) {
+  let tail = [];
+  for (let i = trail.length - 1; i >= 0; i--) {
+    const { cmds, at, group } = trail[i];
+    const list = [...cmds.slice(0, at), ...tail.length ? tail : [cmds[at]]];
+    tail = group ? [{ ...group, children: list }] : list;
+  }
+  return tail;
+}
 function skip(ctx, detail) {
   ctx.skipped.push({ kind: "command", detail });
 }
@@ -1094,23 +1125,170 @@ async function writeCommand(ctx, cmd, state) {
   else if (cmd.kind === "text") await writeText2(ctx, cmd, state);
   else await writeShader(ctx, cmd, state);
 }
-async function writeCommands(ctx, cmds, state) {
-  for (const cmd of cmds) {
-    const line = ctx.out.mark();
-    const object = ctx.objects.mark();
-    const skips = ctx.skipped.length;
-    try {
-      await writeCommand(ctx, cmd, state);
-    } catch (err) {
-      if (!(err instanceof NonFiniteNumber)) throw err;
-      ctx.out.rollback(line);
-      ctx.objects.nullUnset(object);
-      ctx.skipped.length = skips;
-      skip(ctx, `${cmd.kind} has a non-finite coordinate`);
-    }
+async function writeCommands(ctx, cmds, state, group) {
+  const step = { cmds, at: 0, group };
+  ctx.trail.push(step);
+  try {
+    for (; step.at < cmds.length; step.at++) await writeOne(ctx, cmds[step.at], state);
+  } finally {
+    ctx.trail.pop();
+  }
+}
+async function writeOne(ctx, cmd, state) {
+  const line = ctx.out.mark();
+  const object = ctx.objects.mark();
+  const skips = ctx.skipped.length;
+  try {
+    await writeCommand(ctx, cmd, state);
+  } catch (err) {
+    if (!(err instanceof NonFiniteNumber)) throw err;
+    ctx.out.rollback(line);
+    ctx.objects.nullUnset(object);
+    ctx.skipped.length = skips;
+    skip(ctx, `${cmd.kind} has a non-finite coordinate`);
   }
 }
 
+// src/fonts/subset.ts
+var KEPT = ["cvt ", "fpgm", "glyf", "head", "hhea", "hmtx", "loca", "maxp", "prep"];
+var REQUIRED = ["glyf", "head", "hhea", "hmtx", "loca", "maxp"];
+var ARG_1_AND_2_ARE_WORDS = 1;
+var WE_HAVE_A_SCALE = 8;
+var MORE_COMPONENTS = 32;
+var WE_HAVE_AN_X_AND_Y_SCALE = 64;
+var WE_HAVE_A_TWO_BY_TWO = 128;
+function readTables(sfnt) {
+  const view = new DataView(sfnt);
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0; i < view.getUint16(4); i++) {
+    const at = 12 + i * 16;
+    const tag = String.fromCharCode(...new Uint8Array(sfnt, at, 4));
+    out.set(tag, new Uint8Array(sfnt, view.getUint32(at + 8), view.getUint32(at + 12)));
+  }
+  for (const tag of REQUIRED) if (!out.has(tag)) throw new Error(`pdf: a TrueType face has no "${tag}" table`);
+  return out;
+}
+var viewOf = (b) => new DataView(b.buffer, b.byteOffset, b.byteLength);
+function glyphRanges(t, numGlyphs) {
+  const loca = viewOf(t.get("loca"));
+  const long = viewOf(t.get("head")).getInt16(50) === 1;
+  const at = (i) => long ? loca.getUint32(i * 4) : loca.getUint16(i * 2) * 2;
+  return Array.from({ length: numGlyphs }, (_, i) => [at(i), at(i + 1)]);
+}
+function componentsOf(glyph) {
+  if (glyph.byteLength < 10) return [];
+  const v = viewOf(glyph);
+  if (v.getInt16(0) >= 0) return [];
+  const out = [];
+  let at = 10;
+  for (; ; ) {
+    const flags = v.getUint16(at);
+    out.push(v.getUint16(at + 2));
+    at += 4 + (flags & ARG_1_AND_2_ARE_WORDS ? 4 : 2);
+    if (flags & WE_HAVE_A_SCALE) at += 2;
+    else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) at += 4;
+    else if (flags & WE_HAVE_A_TWO_BY_TWO) at += 8;
+    if (!(flags & MORE_COMPONENTS)) return out;
+  }
+}
+function closure(used, glyf, ranges) {
+  const keep = /* @__PURE__ */ new Set();
+  const queue = [0, ...used];
+  while (queue.length > 0) {
+    const gid = queue.pop();
+    if (keep.has(gid) || gid < 0 || gid >= ranges.length) continue;
+    keep.add(gid);
+    const [start, end] = ranges[gid];
+    queue.push(...componentsOf(glyf.subarray(start, end)));
+  }
+  return keep;
+}
+function checksum(b) {
+  const v = viewOf(b);
+  let sum = 0;
+  for (let i = 0; i < b.byteLength; i += 4) sum = sum + v.getUint32(i) >>> 0;
+  return sum;
+}
+var pad4 = (n) => n + 3 & -4;
+function writeSfnt(tables) {
+  const tags = [...tables.keys()].sort();
+  const dirBytes = 12 + tags.length * 16;
+  let total = dirBytes;
+  for (const tag of tags) total += pad4(tables.get(tag).byteLength);
+  const out = new Uint8Array(total);
+  const v = viewOf(out);
+  v.setUint32(0, 65536);
+  v.setUint16(4, tags.length);
+  const entrySelector = Math.floor(Math.log2(tags.length));
+  const searchRange = 2 ** entrySelector * 16;
+  v.setUint16(6, searchRange);
+  v.setUint16(8, entrySelector);
+  v.setUint16(10, tags.length * 16 - searchRange);
+  let cursor = dirBytes;
+  let headAt = 0;
+  tags.forEach((tag, i) => {
+    const data = tables.get(tag);
+    const rec = 12 + i * 16;
+    for (let c = 0; c < 4; c++) out[rec + c] = tag.charCodeAt(c);
+    out.set(data, cursor);
+    v.setUint32(rec + 4, checksum(out.subarray(cursor, cursor + pad4(data.byteLength))));
+    v.setUint32(rec + 8, cursor);
+    v.setUint32(rec + 12, data.byteLength);
+    if (tag === "head") headAt = cursor;
+    cursor += pad4(data.byteLength);
+  });
+  v.setUint32(headAt + 8, 2981146554 - checksum(out) >>> 0);
+  return out;
+}
+function subsetTrueType(sfnt, used) {
+  const t = readTables(sfnt);
+  const numGlyphs = viewOf(t.get("maxp")).getUint16(4);
+  const glyf = t.get("glyf");
+  const ranges = glyphRanges(t, numGlyphs);
+  const keep = closure(used, glyf, ranges);
+  const count = Math.max(...keep) + 1;
+  let glyfBytes = 0;
+  for (const gid of keep) glyfBytes += pad4(ranges[gid][1] - ranges[gid][0]);
+  const newGlyf = new Uint8Array(glyfBytes);
+  const newLoca = new Uint8Array((count + 1) * 4);
+  const loca = viewOf(newLoca);
+  let cursor = 0;
+  for (let gid = 0; gid < count; gid++) {
+    loca.setUint32(gid * 4, cursor);
+    if (!keep.has(gid)) continue;
+    const [start, end] = ranges[gid];
+    newGlyf.set(glyf.subarray(start, end), cursor);
+    cursor += pad4(end - start);
+  }
+  loca.setUint32(count * 4, cursor);
+  const hhea = t.get("hhea").slice();
+  const hmtxIn = viewOf(t.get("hmtx"));
+  const longMetrics = viewOf(hhea).getUint16(34);
+  const hmtx = new Uint8Array(count * 4);
+  for (let gid = 0; gid < count; gid++) {
+    const advance = hmtxIn.getUint16(Math.min(gid, longMetrics - 1) * 4);
+    const lsb = gid < longMetrics ? hmtxIn.getInt16(gid * 4 + 2) : hmtxIn.getInt16(longMetrics * 4 + (gid - longMetrics) * 2);
+    viewOf(hmtx).setUint16(gid * 4, advance);
+    viewOf(hmtx).setInt16(gid * 4 + 2, lsb);
+  }
+  viewOf(hhea).setUint16(34, count);
+  const head = t.get("head").slice();
+  viewOf(head).setUint32(8, 0);
+  viewOf(head).setInt16(50, 1);
+  const maxp = t.get("maxp").slice();
+  viewOf(maxp).setUint16(4, count);
+  const out = /* @__PURE__ */ new Map([
+    ["glyf", newGlyf],
+    ["head", head],
+    ["hhea", hhea],
+    ["hmtx", hmtx],
+    ["loca", newLoca],
+    ["maxp", maxp]
+  ]);
+  for (const tag of KEPT) if (!out.has(tag) && t.has(tag)) out.set(tag, t.get(tag));
+  return writeSfnt(out);
+}
+
 // src/fonts/toUnicode.ts
 var MAX_PER_BLOCK = 100;
 var hex4 = (n) => n.toString(16).toUpperCase().padStart(4, "0");
@@ -1148,15 +1326,24 @@ function baseFontName(e, family, weight, style) {
   const safe = (s) => s.replace(/[^A-Za-z0-9._-]/g, "");
   return safe(e.postScriptName) || safe(`${family}-${weight}-${style}`);
 }
+function subsetTag(gids) {
+  let h = 2166136261;
+  for (const gid of [...gids].sort((a, b) => a - b)) h = Math.imul(h ^ gid, 16777619) >>> 0;
+  let tag = "";
+  for (let i = 0; i < 6; i++, h = Math.floor(h / 26)) tag += String.fromCharCode(65 + h % 26);
+  return tag;
+}
 var Face = class {
-  constructor(objects, emb, baseFont) {
+  constructor(objects, emb, baseFont, subset) {
     this.objects = objects;
     this.emb = emb;
     this.baseFont = baseFont;
+    this.subset = subset;
   }
   objects;
   emb;
   baseFont;
+  subset;
   /** Glyph id to the first codepoint that asked for it. */
   used = /* @__PURE__ */ new Map();
   fontRef;
@@ -1184,11 +1371,13 @@ var Face = class {
     const descriptor = objects.alloc();
     const cid = objects.alloc();
     const toUnicode = objects.alloc();
-    objects.streamDeflated(file, { Length1: emb.sfnt.byteLength }, new Uint8Array(emb.sfnt));
+    const program = this.subset ? subsetTrueType(emb.sfnt, this.used.keys()) : new Uint8Array(emb.sfnt);
+    const fontName = this.subset ? `${subsetTag(this.used.keys())}+${this.baseFont}` : this.baseFont;
+    objects.streamDeflated(file, { Length1: program.byteLength }, program);
     objects.streamDeflated(toUnicode, {}, encoder.encode(toUnicodeCMap(this.used)));
     objects.set(descriptor, {
       Type: name("FontDescriptor"),
-      FontName: name(this.baseFont),
+      FontName: name(fontName),
       Flags: 4,
       FontBBox: emb.bbox.map((v, i) => i < 2 ? Math.floor(v * k) : Math.ceil(v * k)),
       ItalicAngle: emb.italicAngle,
@@ -1204,7 +1393,7 @@ var Face = class {
     objects.set(cid, {
       Type: name("Font"),
       Subtype: name("CIDFontType2"),
-      BaseFont: name(this.baseFont),
+      BaseFont: name(fontName),
       CIDSystemInfo: { Registry: text("Adobe"), Ordering: text("Identity"), Supplement: 0 },
       FontDescriptor: descriptor,
       CIDToGIDMap: name("Identity"),
@@ -1213,7 +1402,7 @@ var Face = class {
     objects.set(this.fontRef, {
       Type: name("Font"),
       Subtype: name("Type0"),
-      BaseFont: name(this.baseFont),
+      BaseFont: name(fontName),
       Encoding: name("Identity-H"),
       DescendantFonts: [cid],
       ToUnicode: toUnicode
@@ -1221,12 +1410,14 @@ var Face = class {
   }
 };
 var DocumentFonts = class {
-  constructor(objects, source) {
+  constructor(objects, source, subset = true) {
     this.objects = objects;
     this.source = source;
+    this.subset = subset;
   }
   objects;
   source;
+  subset;
   faces = /* @__PURE__ */ new Map();
   /** The embedded font for a face, or null to draw its glyphs as outlines. */
   face(family, weight, style) {
@@ -1246,7 +1437,7 @@ var DocumentFonts = class {
       return null;
     }
     if (!emb || emb.outlines !== "truetype" || !emb.embeddable) return null;
-    return new Face(this.objects, emb, baseFontName(emb, family, weight, style));
+    return new Face(this.objects, emb, baseFontName(emb, family, weight, style), this.subset);
   }
   /** Writes every face's objects; call before `PdfObjects.settle`. */
   async finish() {
@@ -1266,7 +1457,7 @@ async function writePdfWith(pages, opts, deflate2) {
   const info = objects.alloc();
   const skipped = [];
   const kids = [];
-  const fonts = new DocumentFonts(objects, opts.fonts);
+  const fonts = new DocumentFonts(objects, opts.fonts, opts.subsetFonts !== false);
   for (const page of pages) {
     const pageRef = objects.alloc();
     const contentRef = objects.alloc();
@@ -1279,7 +1470,8 @@ async function writePdfWith(pages, opts, deflate2) {
       skipped,
       view: page.view,
       width: page.width,
-      height: page.height
+      height: page.height,
+      trail: []
     };
     ctx.out.op("cm", ...mat3.toAffine(pageFlip(page)));
     await writeCommands(ctx, page.commands, { transform: mat3.identity(), alpha: 1, colorMatrix: null });