@weasel-js/pdf 0.0.0-stage → 1.11.1

package/dist/index.js

@@ -0,0 +1,1307 @@
+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 { resolveTextStyle, cachedLayoutRuns, verticalAlignOffset, cachedPaintRuns, syntheticBoldOffset, emboldenGlyphD, SYNTHETIC_ITALIC_RADIANS } from '@weasel-js/text';
+
+// src/fonts/fontSource.ts
+var registryFontSource = {
+  embedding: fontEmbedding,
+  outline: glyphOutline
+};
+
+// src/latin1.ts
+function latin1Bytes(s) {
+  return Uint8Array.from(s, (c) => c.charCodeAt(0));
+}
+
+// src/num.ts
+var NonFiniteNumber = class extends Error {
+};
+function num(n) {
+  if (!Number.isFinite(n)) throw new NonFiniteNumber(`pdf: cannot write non-finite number ${n}`);
+  if (Math.abs(n) >= 1e21) return BigInt(n).toString();
+  const s = n.toFixed(4).replace(/\.?0+$/, "");
+  return s === "-0" || s === "" ? "0" : s;
+}
+
+// src/content.ts
+var ContentStream = class {
+  lines = [];
+  /** Numbers are written with `num`; strings go in as given, so a name operand is `'/GS1'`. */
+  op(operator, ...operands) {
+    const args = operands.map((o) => typeof o === "number" ? num(o) : o);
+    this.lines.push(args.length ? `${args.join(" ")} ${operator}` : operator);
+    return this;
+  }
+  /** Where the stream ends now, for `rollback`. */
+  mark() {
+    return this.lines.length;
+  }
+  /** Drops every operator written since `mark` answered `at`. */
+  rollback(at) {
+    this.lines.length = at;
+  }
+  bytes() {
+    return latin1Bytes(`${this.lines.join("\n")}
+`);
+  }
+};
+
+// src/deflate.ts
+async function deflate(data) {
+  const stream = new Blob([data]).stream().pipeThrough(new CompressionStream("deflate"));
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+function foldColor(rgba, m) {
+  const [r, g, b, a] = rgba;
+  return m ? applyColorMatrix(m, r, g, b, a) : [r, g, b, a];
+}
+function composeMatrix(outer, inner) {
+  if (!inner) return outer ? [...outer] : null;
+  if (!outer) return [...inner];
+  return composeColorMatrix(outer, inner, new Array(20));
+}
+function colorFor(color, state) {
+  return foldColor(typeof color === "string" ? parseColor(color) : color, state.colorMatrix);
+}
+function solidColor(paint, state) {
+  const [r, g, b, a] = colorFor(paint.color, state);
+  return { rgb: [r, g, b], alpha: a * (paint.opacity ?? 1) * state.alpha };
+}
+function foldPixels(data, state) {
+  if (!state.colorMatrix) return data;
+  const out = new Uint8ClampedArray(data.length);
+  for (let i = 0; i + 3 < data.length; i += 4) {
+    const [r, g, b, a] = foldColor(
+      [data[i] / 255, data[i + 1] / 255, data[i + 2] / 255, data[i + 3] / 255],
+      state.colorMatrix
+    );
+    out[i] = r * 255;
+    out[i + 1] = g * 255;
+    out[i + 2] = b * 255;
+    out[i + 3] = a * 255;
+  }
+  return out;
+}
+
+// src/objects.ts
+var PdfName = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+};
+var PdfRef = class {
+  constructor(id) {
+    this.id = id;
+  }
+  id;
+};
+var PdfText = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+};
+var PdfBytes = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+};
+function name(n) {
+  return new PdfName(n);
+}
+function text(s) {
+  return new PdfText(s);
+}
+var hex2 = (b) => b.toString(16).toUpperCase().padStart(2, "0");
+function writeName(n) {
+  let out = "/";
+  for (const b of new TextEncoder().encode(n)) {
+    const ch = String.fromCharCode(b);
+    out += b < 33 || b > 126 || "#()<>[]{}/%".includes(ch) ? `#${hex2(b)}` : ch;
+  }
+  return out;
+}
+function writeText(s) {
+  if (/^[\x20-\x7e]*$/.test(s)) return `(${s.replace(/[\\()]/g, "\\$&")})`;
+  let out = "<FEFF";
+  for (let i = 0; i < s.length; i++) out += s.charCodeAt(i).toString(16).toUpperCase().padStart(4, "0");
+  return `${out}>`;
+}
+function write(v) {
+  if (v === null) return "null";
+  if (typeof v === "number") return num(v);
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (v instanceof PdfName) return writeName(v.value);
+  if (v instanceof PdfRef) return `${v.id} 0 R`;
+  if (v instanceof PdfText) return writeText(v.value);
+  if (v instanceof PdfBytes) return `<${Array.from(v.value, hex2).join("")}>`;
+  if (Array.isArray(v)) return `[${v.map(write).join(" ")}]`;
+  return writeDict(v);
+}
+function writeDict(d) {
+  const parts = [];
+  for (const [k, v] of Object.entries(d)) if (v !== void 0) parts.push(`${writeName(k)} ${write(v)}`);
+  return `<<${parts.join(" ")}>>`;
+}
+var PdfObjects = class {
+  bodies = [];
+  pending = [];
+  alloc() {
+    this.bodies.push(void 0);
+    return new PdfRef(this.bodies.length);
+  }
+  set(ref, value) {
+    this.bodies[ref.id - 1] = latin1Bytes(write(value));
+  }
+  /** Writes `/Length` itself; the caller passes the already-encoded bytes. */
+  stream(ref, dict, data) {
+    const head = latin1Bytes(`${writeDict({ ...dict, Length: data.length })}
+stream
+`);
+    const tail = latin1Bytes("\nendstream");
+    const out = new Uint8Array(head.length + data.length + tail.length);
+    out.set(head, 0);
+    out.set(data, head.length);
+    out.set(tail, head.length + data.length);
+    this.bodies[ref.id - 1] = out;
+  }
+  /** Like `stream`, but takes the raw bytes: `settle` compresses them (or not) before `serialize`. */
+  streamDeflated(ref, dict, data) {
+    writeDict(dict);
+    this.pending.push({ ref, dict, data });
+  }
+  /** How many objects are allocated, for `nullUnset`. */
+  mark() {
+    return this.bodies.length;
+  }
+  /** Sets every object allocated since `mark` answered `at` and not yet written to `null`, so a dropped command leaves no hole. */
+  nullUnset(at) {
+    const waiting = new Set(this.pending.map((p) => p.ref.id));
+    for (let id = at + 1; id <= this.bodies.length; id++) {
+      if (!this.bodies[id - 1] && !waiting.has(id)) this.set(new PdfRef(id), null);
+    }
+  }
+  /** Writes every `streamDeflated` stream, FlateDecode-compressed when `compress` is set. */
+  async settle(compress, deflate2) {
+    for (const { ref, dict, data } of this.pending.splice(0)) {
+      if (compress) this.stream(ref, { ...dict, Filter: name("FlateDecode") }, await deflate2(data));
+      else this.stream(ref, dict, data);
+    }
+  }
+  serialize(root, info) {
+    const chunks = [];
+    let offset = 0;
+    const push = (c) => {
+      chunks.push(c);
+      offset += c.length;
+    };
+    push(Uint8Array.of(...latin1Bytes("%PDF-1.7\n%"), 226, 227, 207, 211, 10));
+    const offsets = [];
+    this.bodies.forEach((body, i) => {
+      if (!body) throw new Error(`pdf: object ${i + 1} was allocated but never set`);
+      offsets.push(offset);
+      push(latin1Bytes(`${i + 1} 0 obj
+`));
+      push(body);
+      push(latin1Bytes("\nendobj\n"));
+    });
+    const xref = offset;
+    let table = `xref
+0 ${this.bodies.length + 1}
+0000000000 65535 f 
+`;
+    for (const o of offsets) table += `${String(o).padStart(10, "0")} 00000 n 
+`;
+    const trailer = writeDict({ Size: this.bodies.length + 1, Root: root, Info: info });
+    push(latin1Bytes(`${table}trailer
+${trailer}
+startxref
+${xref}
+%%EOF
+`));
+    const out = new Uint8Array(offset);
+    let at = 0;
+    for (const c of chunks) {
+      out.set(c, at);
+      at += c.length;
+    }
+    return out;
+  }
+};
+var SAMPLED_STOPS = 64;
+var CONIC_WEDGES = 360;
+function paintShading(ctx, paint, state, path) {
+  if (!isGradientPaint(paint)) return null;
+  const toFrame = paintToFrame(ctx, paint, state);
+  const toPaint = toFrame && mat3.invert(toFrame);
+  if (!toFrame || !toPaint) return null;
+  const box = paintBox(path, toPaint);
+  let segments = rampSegments(stopsOf(paint, state));
+  const geometry = geometryOf(paint, box);
+  if (geometry.degenerate) segments = [{ lo: 0, hi: 1, c0: segments[0].c0, c1: segments[0].c0 }];
+  let alpha = (paint.opacity ?? 1) * state.alpha;
+  const a0 = segments[0].c0[3];
+  const uniform = segments.every((s) => s.c0[3] === a0 && s.c1[3] === a0);
+  let softMask = null;
+  if (uniform) alpha *= a0;
+  else {
+    const mask = writeShading(ctx, geometry, rampFunction(segments, (c) => [c[3]]), "DeviceGray");
+    softMask = ctx.resources.softMask(writeMaskGroup(ctx, mask, box));
+  }
+  const color = writeShading(ctx, geometry, rampFunction(segments, (c) => [c[0], c[1], c[2]]), "DeviceRGB");
+  return { shading: ctx.resources.shading(color), softMask, alpha, matrix: isIdentity(toFrame) ? null : toFrame };
+}
+function paintToFrame(ctx, paint, state) {
+  if (paint.units === "local") return mat3.identity();
+  const fromPage = mat3.invert(state.transform);
+  if (!fromPage) return null;
+  return paint.units === "world" && ctx.view ? mat3.multiply(fromPage, ctx.view) : fromPage;
+}
+function isIdentity(m) {
+  return m[0] === 1 && m[1] === 0 && m[3] === 0 && m[4] === 1 && m[6] === 0 && m[7] === 0;
+}
+function paintBox(path, toPaint) {
+  const b = boundsOfPath(path);
+  const corners = [
+    mat3.apply(toPaint, b.x, b.y),
+    mat3.apply(toPaint, b.x + b.width, b.y),
+    mat3.apply(toPaint, b.x, b.y + b.height),
+    mat3.apply(toPaint, b.x + b.width, b.y + b.height)
+  ];
+  const xs = corners.map((c) => c[0]);
+  const ys = corners.map((c) => c[1]);
+  return { x0: Math.min(...xs) - 1, y0: Math.min(...ys) - 1, x1: Math.max(...xs) + 1, y1: Math.max(...ys) + 1 };
+}
+function stopsOf(paint, state) {
+  const resolved = resolveGradientStops(paint.stops);
+  const space = paint.interpolate ?? "rgb";
+  if (resolved.length === 0) return [{ offset: 0, rgba: colorFor([0, 0, 0, 0], state) }];
+  if (space === "rgb") return resolved.map((s) => ({ offset: s.offset, rgba: colorFor(s.rgba, state) }));
+  return Array.from({ length: SAMPLED_STOPS }, (_, i) => {
+    const t = i / (SAMPLED_STOPS - 1);
+    return { offset: t, rgba: colorFor(sampleResolvedStops(resolved, t, space), state) };
+  });
+}
+var lerp = (a, b, f) => a.map((v, i) => v + (b[i] - v) * f);
+function rampSegments(stops) {
+  const first = stops[0];
+  const last = stops[stops.length - 1];
+  const raw = [];
+  if (first.offset > 0) raw.push({ lo: Math.min(0, first.offset), hi: first.offset, c0: first.rgba, c1: first.rgba });
+  for (let i = 0; i < stops.length - 1; i++) {
+    const a = stops[i];
+    const b = stops[i + 1];
+    raw.push({ lo: a.offset, hi: b.offset, c0: a.rgba, c1: b.rgba });
+  }
+  if (last.offset < 1) raw.push({ lo: last.offset, hi: Math.max(1, last.offset), c0: last.rgba, c1: last.rgba });
+  const out = [];
+  for (const s of raw) {
+    const lo = Math.max(s.lo, 0);
+    const hi = Math.min(s.hi, 1);
+    if (hi <= lo) continue;
+    const span = s.hi - s.lo;
+    out.push({ lo, hi, c0: lerp(s.c0, s.c1, (lo - s.lo) / span), c1: lerp(s.c0, s.c1, (hi - s.lo) / span) });
+  }
+  if (out.length === 0) {
+    const c = first.offset >= 1 ? first.rgba : last.rgba;
+    out.push({ lo: 0, hi: 1, c0: c, c1: c });
+  }
+  return out;
+}
+function rampFunction(segments, channels) {
+  const pieces = segments.map(
+    (s) => ({ FunctionType: 2, Domain: [0, 1], C0: channels(s.c0), C1: channels(s.c1), N: 1 })
+  );
+  if (pieces.length === 1) return pieces[0];
+  return {
+    FunctionType: 3,
+    Domain: [0, 1],
+    Functions: pieces,
+    Bounds: segments.slice(0, -1).map((s) => s.hi),
+    Encode: segments.flatMap(() => [0, 1])
+  };
+}
+function geometryOf(paint, box) {
+  const extend = [true, true];
+  if (paint.kind === "linear-gradient") {
+    const { from, to } = paint;
+    const degenerate = from.x === to.x && from.y === to.y;
+    const coords = degenerate ? [from.x, from.y, from.x + 1, from.y] : [from.x, from.y, to.x, to.y];
+    return { dict: { ShadingType: 2, Coords: coords, Extend: extend }, degenerate };
+  }
+  const { center, radius, angle } = gradientGeometry(paint);
+  if (paint.kind === "radial-gradient") {
+    const r = Math.max(radius, 1e-4);
+    return { dict: { ShadingType: 3, Coords: [center.x, center.y, 0, center.x, center.y, r], Extend: extend } };
+  }
+  const reach = Math.max(
+    ...[box.x0, box.x1].flatMap((x) => [box.y0, box.y1].map((y) => Math.hypot(x - center.x, y - center.y)))
+  );
+  return conicMesh(center, angle, reach * 1.01 + 1);
+}
+function conicMesh(center, angle, r) {
+  const x0 = center.x - r;
+  const y0 = center.y - r;
+  const data = new Uint8Array(CONIC_WEDGES * 3 * 11);
+  const view = new DataView(data.buffer);
+  const coord = (v, lo) => Math.round(Math.min(1, Math.max(0, (v - lo) / (2 * r))) * 4294967295);
+  let at = 0;
+  const vertex = (x, y, t) => {
+    view.setUint8(at, 0);
+    view.setUint32(at + 1, coord(x, x0));
+    view.setUint32(at + 5, coord(y, y0));
+    view.setUint16(at + 9, Math.round(t * 65535));
+    at += 11;
+  };
+  const rim = (i) => {
+    const a = angle + 2 * Math.PI * i / CONIC_WEDGES;
+    vertex(center.x + r * Math.cos(a), center.y + r * Math.sin(a), i / CONIC_WEDGES);
+  };
+  for (let i = 0; i < CONIC_WEDGES; i++) {
+    vertex(center.x, center.y, (i + 0.5) / CONIC_WEDGES);
+    rim(i);
+    rim(i + 1);
+  }
+  return {
+    dict: {
+      ShadingType: 4,
+      BitsPerCoordinate: 32,
+      BitsPerComponent: 16,
+      BitsPerFlag: 8,
+      Decode: [x0, x0 + 2 * r, y0, y0 + 2 * r, 0, 1]
+    },
+    data
+  };
+}
+function writeShading(ctx, g, fn, colorSpace) {
+  const ref = ctx.objects.alloc();
+  const dict = { ...g.dict, ColorSpace: name(colorSpace), Function: fn };
+  if (g.data) ctx.objects.streamDeflated(ref, dict, g.data);
+  else ctx.objects.set(ref, dict);
+  return ref;
+}
+function writeMaskGroup(ctx, mask, box) {
+  const ref = ctx.objects.alloc();
+  const body = latin1Bytes("/Sh1 sh\n");
+  ctx.objects.streamDeflated(
+    ref,
+    {
+      Type: name("XObject"),
+      Subtype: name("Form"),
+      BBox: [box.x0, box.y0, box.x1, box.y1],
+      Group: { Type: name("Group"), S: name("Transparency"), CS: name("DeviceGray"), I: true },
+      Resources: { Shading: { Sh1: mask } }
+    },
+    body
+  );
+  return ref;
+}
+
+// src/images.ts
+var ids = /* @__PURE__ */ new WeakMap();
+var embedded = /* @__PURE__ */ new WeakMap();
+var nextId = 0;
+function sizeOf(image) {
+  const w = "naturalWidth" in image ? image.naturalWidth : image.width;
+  const h = "naturalHeight" in image ? image.naturalHeight : image.height;
+  return { w: w || 1, h: h || 1 };
+}
+function defaultReadPixels(image) {
+  const { w, h } = sizeOf(image);
+  const ctx = new OffscreenCanvas(w, h).getContext("2d");
+  if (!ctx) throw new Error("pdf: no 2D context to read image pixels with");
+  ctx.drawImage(image, 0, 0);
+  return { width: w, height: h, data: ctx.getImageData(0, 0, w, h).data };
+}
+function memo(ctx) {
+  let m = embedded.get(ctx.objects);
+  if (!m) embedded.set(ctx.objects, m = /* @__PURE__ */ new Map());
+  return m;
+}
+function idOf(image) {
+  let id = ids.get(image);
+  if (id === void 0) ids.set(image, id = ++nextId);
+  return id;
+}
+function imageObject(ctx, dict, data) {
+  const ref = ctx.objects.alloc();
+  ctx.objects.streamDeflated(ref, { Type: name("XObject"), Subtype: name("Image"), ...dict }, data);
+  return ref;
+}
+function imageXObject(ctx, image, state = { transform: mat3.identity(), alpha: 1, colorMatrix: null }, sampling = "linear") {
+  const interpolate = sampling !== "nearest";
+  const key = `${idOf(image)} ${interpolate} ${state.colorMatrix?.join(",") ?? ""}`;
+  const cache = memo(ctx);
+  const hit = cache.get(key);
+  if (hit) return hit;
+  let raw;
+  try {
+    raw = (ctx.opts.readPixels ?? defaultReadPixels)(image);
+  } catch {
+    skip(ctx, "image could not be read");
+    return null;
+  }
+  const ref = pixelsXObject(ctx, { ...raw, data: foldPixels(raw.data, state) }, interpolate);
+  cache.set(key, ref);
+  return ref;
+}
+function pixelsXObject(ctx, raw, interpolate) {
+  const rgba = raw.data;
+  const n = raw.width * raw.height;
+  const rgb = new Uint8Array(n * 3);
+  const alpha = new Uint8Array(n);
+  let translucent = false;
+  for (let i = 0; i < n; i++) {
+    rgb[i * 3] = rgba[i * 4];
+    rgb[i * 3 + 1] = rgba[i * 4 + 1];
+    rgb[i * 3 + 2] = rgba[i * 4 + 2];
+    alpha[i] = rgba[i * 4 + 3];
+    if (alpha[i] < 255) translucent = true;
+  }
+  const dims = (space) => ({
+    Width: raw.width,
+    Height: raw.height,
+    ColorSpace: name(space),
+    BitsPerComponent: 8,
+    Interpolate: interpolate
+  });
+  const mask = translucent ? imageObject(ctx, dims("DeviceGray"), alpha) : void 0;
+  return imageObject(ctx, { ...dims("DeviceRGB"), SMask: mask }, rgb);
+}
+function writeRaster(ctx, raw, rect, opacity) {
+  place(ctx, pixelsXObject(ctx, raw, true), raw.width, raw.height, {
+    x: rect.x,
+    y: rect.y,
+    w: rect.width,
+    h: rect.height,
+    opacity
+  });
+}
+function place(ctx, ref, iw, ih, p) {
+  const src = p.source ?? { x: 0, y: 0, w: iw, h: ih };
+  if (!(src.w > 0 && src.h > 0 && p.w !== 0 && p.h !== 0)) return;
+  const { out } = ctx;
+  const W = iw * p.w / src.w;
+  const H = ih * p.h / src.h;
+  const left = p.x - src.x * p.w / src.w;
+  const top = p.y - src.y * p.h / src.h;
+  const right = p.x + p.w + src.x * p.w / src.w;
+  const bottom = p.y + p.h + src.y * p.h / src.h;
+  const a = p.flipX ? -W : W;
+  const e = p.flipX ? right : left;
+  const d = p.flipY ? H : -H;
+  const f = p.flipY ? bottom - H : top + H;
+  out.op("q");
+  if (p.opacity < 1) out.op("gs", `/${ctx.resources.extGState(p.opacity, p.opacity)}`);
+  if (p.source) out.op("re", p.x, p.y, p.w, p.h).op("W").op("n");
+  out.op("cm", a, 0, 0, d, e, f);
+  out.op("Do", `/${ctx.resources.xobject(ref)}`);
+  out.op("Q");
+}
+function writeImage(ctx, cmd, state) {
+  const { w: iw, h: ih } = sizeOf(cmd.image);
+  const ref = imageXObject(ctx, cmd.image, state, cmd.sampling);
+  if (!ref) return;
+  if (cmd.kind === "image") {
+    place(ctx, ref, iw, ih, { ...cmd, opacity: (cmd.opacity ?? 1) * state.alpha });
+    return;
+  }
+  const s = cmd.sprites;
+  for (let i = 0; i + SPRITE_STRIDE <= s.length; i += SPRITE_STRIDE) {
+    const [dx, dy, dw, dh, sx, sy, sw, sh, opacity] = s.subarray(i, i + SPRITE_STRIDE);
+    place(ctx, ref, iw, ih, {
+      x: dx,
+      y: dy,
+      w: dw,
+      h: dh,
+      source: { x: sw < 0 ? sx + sw : sx, y: sh < 0 ? sy + sh : sy, w: Math.abs(sw), h: Math.abs(sh) },
+      flipX: sw < 0,
+      flipY: sh < 0,
+      opacity: opacity * state.alpha
+    });
+  }
+}
+function texturePattern(ctx, paint, state) {
+  const entry = textureRegistry.get(paint.texture.id);
+  if (!entry) return null;
+  const toFrame = paintToFrame(ctx, paint, state);
+  if (!toFrame) return null;
+  const [a, b, c, d] = paint.transform ?? [1, 0, 0, 1];
+  const o = paint.origin ?? { x: 0, y: 0 };
+  const placement = mat3.fromAffine([a, b, c, d, o.x, o.y]);
+  if (!mat3.invert(placement)) return null;
+  const m = mat3.multiply(mat3.multiply(pageFlip(ctx), mat3.multiply(Float64Array.from(state.transform), toFrame)), placement);
+  const matrix = mat3.toAffine(m);
+  const key = `pattern ${paint.texture.id} ${matrix.join(",")} ${state.colorMatrix?.join(",") ?? ""}`;
+  const cache = memo(ctx);
+  let ref = cache.get(key);
+  if (!ref) {
+    const { w, h } = sizeOf(entry.source);
+    const image = imageXObject(ctx, entry.source, state, "linear");
+    if (!image) return null;
+    ref = ctx.objects.alloc();
+    ctx.objects.streamDeflated(
+      ref,
+      {
+        Type: name("Pattern"),
+        PatternType: 1,
+        PaintType: 1,
+        TilingType: 1,
+        BBox: [0, 0, w, h],
+        XStep: w,
+        YStep: h,
+        Matrix: matrix,
+        Resources: { XObject: { Im1: image } }
+      },
+      latin1Bytes(`${w} 0 0 -${h} 0 ${h} cm
+/Im1 Do
+`)
+    );
+    cache.set(key, ref);
+  }
+  return ctx.resources.pattern(ref);
+}
+function pathOps(out, path, which) {
+  if (path.kind === "rect") {
+    out.op("re", path.x, path.y, path.width, path.height);
+    return;
+  }
+  const { commands, coords } = resolveCorners(path);
+  const contours = [];
+  let cur;
+  forEachSegment(commands, coords, (cmd, ci, px, py, _i, opens) => {
+    if (cmd === PATH_M || opens || !cur) {
+      cur = { ops: [], closed: false };
+      contours.push(cur);
+      if (cmd === PATH_M) {
+        cur.ops.push(["m", [coords[ci], coords[ci + 1]]]);
+        return;
+      }
+      cur.ops.push(["m", [px, py]]);
+    }
+    if (cmd === PATH_L) cur.ops.push(["l", [coords[ci], coords[ci + 1]]]);
+    else if (cmd === PATH_C) cur.ops.push(["c", Array.from({ length: 6 }, (_, k) => coords[ci + k])]);
+    else if (cmd === PATH_Q) {
+      const [qx, qy, x, y] = [coords[ci], coords[ci + 1], coords[ci + 2], coords[ci + 3]];
+      cur.ops.push(["c", [px + (qx - px) * 2 / 3, py + (qy - py) * 2 / 3, x + (qx - x) * 2 / 3, y + (qy - y) * 2 / 3, x, y]]);
+    } else if (cmd === PATH_Z) {
+      cur.ops.push(["h", []]);
+      cur.closed = true;
+      cur = void 0;
+    }
+  });
+  for (const c of contours) {
+    if (which === "closed" && !c.closed) continue;
+    for (const [op, args] of c.ops) out.op(op, ...args);
+  }
+}
+function fillPathOps(out, path) {
+  const closeOpen = path.kind === "rect" || fillsOpenSubpaths(path);
+  pathOps(out, path, closeOpen ? "all" : "closed");
+  return path.kind === "polygon" && path.fillRule === "evenodd";
+}
+
+// src/resources.ts
+var PageResources = class {
+  gstates = /* @__PURE__ */ new Map();
+  masks = /* @__PURE__ */ new Map();
+  refs = {
+    Shading: /* @__PURE__ */ new Map(),
+    XObject: /* @__PURE__ */ new Map(),
+    Font: /* @__PURE__ */ new Map(),
+    Pattern: /* @__PURE__ */ new Map()
+  };
+  extGState(fillAlpha, strokeAlpha) {
+    num(fillAlpha);
+    num(strokeAlpha);
+    const key = `${fillAlpha} ${strokeAlpha}`;
+    let n = this.gstates.get(key);
+    if (n === void 0) {
+      n = this.nextGState();
+      this.gstates.set(key, n);
+    }
+    return n;
+  }
+  /** An ExtGState whose `/SMask` is the luminosity of the transparency group `group`. */
+  softMask(group) {
+    let n = this.masks.get(group.id);
+    if (n === void 0) {
+      n = this.nextGState();
+      this.masks.set(group.id, n);
+    }
+    return n;
+  }
+  nextGState() {
+    return `GS${this.gstates.size + this.masks.size + 1}`;
+  }
+  shading(ref) {
+    return this.named("Shading", "Sh", ref);
+  }
+  xobject(ref) {
+    return this.named("XObject", "Im", ref);
+  }
+  font(ref) {
+    return this.named("Font", "F", ref);
+  }
+  pattern(ref) {
+    return this.named("Pattern", "P", ref);
+  }
+  named(kind, prefix, ref) {
+    const m = this.refs[kind];
+    let n = m.get(ref.id);
+    if (n === void 0) {
+      n = `${prefix}${m.size + 1}`;
+      m.set(ref.id, n);
+    }
+    return n;
+  }
+  dict() {
+    const out = {};
+    if (this.gstates.size || this.masks.size) {
+      const g = {};
+      for (const [key, n] of this.gstates) {
+        const [ca, CA] = key.split(" ").map(Number);
+        g[n] = { Type: name("ExtGState"), ca, CA };
+      }
+      for (const [id, n] of this.masks) {
+        g[n] = { Type: name("ExtGState"), SMask: { Type: name("Mask"), S: name("Luminosity"), G: new PdfRef(id) } };
+      }
+      out.ExtGState = g;
+    }
+    for (const [kind, m] of Object.entries(this.refs)) {
+      if (!m.size) continue;
+      const d = {};
+      for (const [id, n] of m) d[n] = new PdfRef(id);
+      out[kind] = d;
+    }
+    return out;
+  }
+};
+
+// src/groupOps.ts
+var RASTER_SCALE = 2;
+function setClip(ctx, clip) {
+  ctx.out.op(fillPathOps(ctx.out, clip) ? "W*" : "W");
+  ctx.out.op("n");
+}
+function compositeName(op) {
+  return typeof op === "string" ? op : `${op.source}/${op.destination}`;
+}
+async function drawRaster(ctx, commands, box, state, reason, unhooked = reason) {
+  const hook = ctx.opts.rasterize;
+  if (!hook) return skip(ctx, unhooked);
+  if (box.width <= 0 || box.height <= 0) return;
+  let px;
+  try {
+    px = await hook(commands, box, RASTER_SCALE, ctx.view);
+  } catch (err) {
+    return skip(ctx, `${reason} raster failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (px.data.length !== px.width * px.height * 4) return skip(ctx, `${reason} raster has the wrong number of pixels`);
+  const inverse = mat3.invert(state.transform);
+  if (!inverse) return;
+  const { out } = ctx;
+  out.op("q");
+  out.op("cm", ...mat3.toAffine(inverse));
+  writeRaster(ctx, { ...px, data: foldPixels(px.data, state) }, box, state.alpha);
+  out.op("Q");
+}
+function writeShader(ctx, cmd, state) {
+  const { x, y, w, h } = cmd.bounds;
+  const x0 = Math.max(0, Math.floor(x));
+  const y0 = Math.max(0, Math.floor(y));
+  const x1 = Math.min(ctx.width, Math.ceil(x + w));
+  const y1 = Math.min(ctx.height, Math.ceil(y + h));
+  return drawRaster(ctx, [cmd], { x: x0, y: y0, width: x1 - x0, height: y1 - y0 }, state, "shader");
+}
+function rasterFill(ctx, cmd, state, kind) {
+  const wrapper = {
+    kind: "group",
+    transform: state.transform,
+    children: [{ kind: "path", path: cmd.path, fill: cmd.fill }]
+  };
+  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) {
+  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);
+  const grouped = {
+    transform: state.transform,
+    alpha: state.alpha * (cmd.alpha ?? 1),
+    colorMatrix: composeMatrix(state.colorMatrix, cmd.colorMatrix)
+  };
+  await drawRaster(ctx, [wrapper], box, grouped, reason);
+}
+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);
+  const toPage = mat3.multiply(flip, Float64Array.from(state.transform));
+  const fromPage = mat3.invert(toPage);
+  if (!fromPage) return;
+  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 });
+  const form = ctx.objects.alloc();
+  ctx.objects.streamDeflated(
+    form,
+    {
+      Type: name("XObject"),
+      Subtype: name("Form"),
+      BBox: [0, 0, ctx.width, ctx.height],
+      Group: { Type: name("Group"), S: name("Transparency"), I: true },
+      Resources: sub.resources.dict()
+    },
+    sub.out.bytes()
+  );
+  const { out } = ctx;
+  out.op("q");
+  out.op("cm", ...mat3.toAffine(fromPage));
+  if (inner.alpha < 1) out.op("gs", `/${ctx.resources.extGState(inner.alpha, inner.alpha)}`);
+  out.op("Do", `/${ctx.resources.xobject(form)}`);
+  out.op("Q");
+}
+async function writeGroup(ctx, cmd, state) {
+  if (cmd.composite && isOwnComposite(cmd.composite)) {
+    skip(ctx, `composite ${compositeName(cmd.composite)} drawn as source-over`);
+  }
+  if (cmd.effects?.length) return rasterGroup(ctx, cmd, state, "effects");
+  const m = cmd.transform;
+  const inner = {
+    transform: m ? mat3.multiply(Float64Array.from(state.transform), m) : state.transform,
+    alpha: state.alpha * (cmd.alpha ?? 1),
+    colorMatrix: composeMatrix(state.colorMatrix, cmd.colorMatrix)
+  };
+  if (cmd.isolate) return isolatedGroup(ctx, cmd, state, inner);
+  const { out } = ctx;
+  out.op("q");
+  if (m) out.op("cm", ...mat3.toAffine(m));
+  if (cmd.clip) setClip(ctx, cmd.clip);
+  await writeCommands(ctx, cmd.children, inner);
+  out.op("Q");
+}
+var CAPS = { butt: 0, round: 1, square: 2 };
+var JOINS = { miter: 0, round: 1, bevel: 2 };
+function isNative(stroke, width) {
+  if (stroke.align && stroke.align !== "center") return false;
+  if (stroke.vertexWidths || stroke.nib || stroke.vertexColors) return false;
+  const { start, end } = strokeInsets(stroke, width);
+  return start === 0 && end === 0;
+}
+function strokeStyleOps(ctx, stroke, width) {
+  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);
+}
+function resolveStroke(path, raw, state) {
+  const { cmd } = resolveStrokeLengths(state.transform, { kind: "path", path, stroke: raw }, { quantize: false });
+  return { stroke: cmd.stroke, width: typeof cmd.stroke.width === "number" ? cmd.stroke.width : 1 };
+}
+function writeNative(ctx, path, stroke, state, width) {
+  const paint = stroke.paint;
+  if (!paint || !isSolidPaint(paint)) return;
+  const { rgb, alpha } = solidColor(paint, state);
+  const { out } = ctx;
+  out.op("q");
+  out.op("gs", `/${ctx.resources.extGState(alpha, alpha)}`);
+  out.op("RG", ...rgb);
+  strokeStyleOps(ctx, stroke, width);
+  pathOps(out, path, "all");
+  out.op("S");
+  out.op("Q");
+}
+async function writeStroke(ctx, path, rawStroke, state) {
+  if (!rawStroke.paint) return;
+  const { stroke, width } = resolveStroke(path, { ...rawStroke, paint: rawStroke.paint }, state);
+  if (!(width > 0)) return;
+  let heads = stroke.markerStart || stroke.markerMid || stroke.markerEnd ? markerDrawCommands(path, stroke, width, void 0) : [];
+  if (isNative(stroke, width) && isSolidPaint(stroke.paint)) writeNative(ctx, path, stroke, state, width);
+  else {
+    if (stroke.vertexColors) skip(ctx, "stroke vertexColors approximated by a single paint");
+    heads = heads.filter((h) => h.stroke || h.fill?.paint !== stroke.paint);
+    const outline = strokeToPath(path, stroke);
+    await writeCommands(ctx, [{ kind: "path", path: outline, fill: { paint: stroke.paint } }], state);
+  }
+  if (heads.length) await writeCommands(ctx, heads, state);
+}
+function isSpace(cp) {
+  return cp === 32 || cp === 160;
+}
+function codepointLabel(cp) {
+  return `U+${cp.toString(16).toUpperCase().padStart(4, "0")}`;
+}
+function skipGlyph(ctx, g, why) {
+  const { family, weight, style } = g.resolved.resolved;
+  ctx.skipped.push({ kind: "glyph", detail: `${codepointLabel(g.cp)} in ${family} ${weight} ${style} ${why}` });
+}
+function placedOutline(ctx, g, dx, dy) {
+  const { family, weight, style } = g.resolved.resolved;
+  let d;
+  try {
+    d = ctx.opts.fonts.outline(family, weight, style, g.cp);
+  } catch {
+    return null;
+  }
+  if (d === null) return null;
+  const grown = emboldenGlyphD(d, g.resolved)?.d ?? d;
+  const s = g.fontSize;
+  const shear = g.resolved.synthetic.italic ? Math.tan(SYNTHETIC_ITALIC_RADIANS) : 0;
+  return transformPath(pathFromD(grown), [s, 0, -shear * s, s, g.x + dx, g.baselineY + dy]);
+}
+function outlineCommand(ctx, g, cmd, dx, dy, paint = "all") {
+  const path = placedOutline(ctx, g, dx, dy);
+  if (!path) return null;
+  const run = cmd.runs[g.run];
+  const out = { kind: "path", path };
+  if (paint !== "stroke" && fillHasInk(run.fill)) out.fill = run.fill;
+  if (strokeHasInk(run.stroke)) out.stroke = run.stroke;
+  return out;
+}
+var FILL = 0;
+var STROKE = 1;
+var FILL_STROKE = 2;
+var INVISIBLE = 3;
+var CLIP = 7;
+var JOINS2 = { miter: 0, round: 1 };
+var BOLD_MITER_LIMIT = 4;
+function inkBox(seg, dx, dy) {
+  const { fontSize: s, baselineY } = seg.glyphs[0].g;
+  let x0 = Infinity;
+  let x1 = -Infinity;
+  for (const { g } of seg.glyphs) {
+    x0 = Math.min(x0, g.x);
+    x1 = Math.max(x1, g.x + g.advance);
+  }
+  return { kind: "rect", x: x0 + dx - s, y: baselineY + dy - 1.5 * s, width: x1 - x0 + 2 * s, height: 2.5 * s };
+}
+function textObject(ctx, seg, mode, dx, dy) {
+  const { out } = ctx;
+  const first = seg.glyphs[0].g;
+  const s = first.fontSize;
+  const shear = first.resolved.synthetic.italic ? Math.tan(SYNTHETIC_ITALIC_RADIANS) : 0;
+  out.op("BT");
+  out.op("Tf", `/${ctx.resources.font(seg.font.ref)}`, 1);
+  if (mode !== FILL) out.op("Tr", mode);
+  out.op("Tm", s, 0, s * shear, -s, first.x + dx, first.baselineY + dy);
+  const parts = [];
+  let hex = "";
+  let pen = 0;
+  for (const { g, gid } of seg.glyphs) {
+    const adjust = num((pen - (g.x - first.x) / s) * 1e3);
+    if (adjust !== "0") {
+      if (hex) parts.push(`<${hex}>`);
+      hex = "";
+      parts.push(adjust);
+      pen -= Number(adjust) / 1e3;
+    }
+    hex += gid.toString(16).toUpperCase().padStart(4, "0");
+    pen += seg.font.widthOf(gid) / 1e3;
+  }
+  parts.push(`<${hex}>`);
+  out.op("TJ", `[${parts.join(" ")}]`);
+  out.op("ET");
+}
+async function paintOutlines(ctx, seg, cmd, dx, dy, state, paint) {
+  for (const { g } of seg.glyphs) {
+    if (isSpace(g.cp)) continue;
+    const outline = outlineCommand(ctx, g, cmd, dx, dy, paint);
+    if (outline) await writeCommands(ctx, [outline], state);
+    else skipGlyph(ctx, g, "has no outline to paint its ink with");
+  }
+}
+async function writeOutlinedInk(ctx, seg, cmd, dx, dy, state) {
+  ctx.out.op("q");
+  textObject(ctx, seg, INVISIBLE, dx, dy);
+  ctx.out.op("Q");
+  await paintOutlines(ctx, seg, cmd, dx, dy, state, "all");
+}
+async function writeSegment(ctx, seg, cmd, dx, dy, state) {
+  const first = seg.glyphs[0].g;
+  const run = cmd.runs[first.run];
+  const fill = fillHasInk(run.fill) ? run.fill.paint : void 0;
+  const box = inkBox(seg, dx, dy);
+  const rawStroke = strokeHasInk(run.stroke) ? run.stroke : void 0;
+  const stroke = rawStroke && resolveStroke(box, rawStroke, state);
+  const nativeStroke = stroke && isNative(stroke.stroke, stroke.width) && isSolidPaint(stroke.stroke.paint);
+  const solidFill = !fill || isSolidPaint(fill);
+  const bold = syntheticBoldOffset(first.resolved);
+  const fillColor = fill && isSolidPaint(fill) ? solidColor(fill, state) : void 0;
+  const boldInText = bold && !stroke && solidFill && fillColor.alpha >= 1;
+  if (stroke && !nativeStroke || bold && !boldInText) return writeOutlinedInk(ctx, seg, cmd, dx, dy, state);
+  const { out } = ctx;
+  if (!solidFill) {
+    out.op("q");
+    textObject(ctx, seg, CLIP, dx, dy);
+    await writeCommands(ctx, [{ kind: "path", path: box, fill: { paint: fill } }], state);
+    out.op("Q");
+    if (stroke) await paintOutlines(ctx, seg, cmd, dx, dy, state, "stroke");
+    return;
+  }
+  const strokeColor = nativeStroke ? solidColor(stroke.stroke.paint, state) : void 0;
+  const paintsFill = fillColor;
+  if (!paintsFill && !strokeColor) return;
+  out.op("q");
+  out.op("gs", `/${ctx.resources.extGState(paintsFill ? fillColor.alpha : 1, strokeColor?.alpha ?? fillColor?.alpha ?? 1)}`);
+  if (paintsFill) out.op("rg", ...fillColor.rgb);
+  if (stroke && strokeColor) {
+    out.op("RG", ...strokeColor.rgb);
+    strokeStyleOps(ctx, stroke.stroke, stroke.width);
+  } else if (bold && fillColor) {
+    out.op("RG", ...fillColor.rgb);
+    out.op("w", 2 * bold.growth * first.fontSize);
+    out.op("j", JOINS2[bold.join]);
+    out.op("M", BOLD_MITER_LIMIT);
+  }
+  textObject(ctx, seg, paintsFill ? strokeColor || bold ? FILL_STROKE : FILL : STROKE, dx, dy);
+  out.op("Q");
+}
+
+// src/textOps.ts
+var BLANK = /^[\s\p{Default_Ignorable_Code_Point}]$/u;
+function joins(seg, g, line) {
+  if (!seg || seg.line !== line) return false;
+  const a = seg.glyphs[0].g;
+  const [ra, rg] = [a.resolved, g.resolved];
+  return a.run === g.run && a.fontSize === g.fontSize && a.baselineY === g.baselineY && ra.source === rg.source && ra.resolved.family === rg.resolved.family && ra.resolved.weight === rg.resolved.weight && ra.resolved.style === rg.resolved.style && ra.synthetic.bold === rg.synthetic.bold && ra.synthetic.italic === rg.synthetic.italic;
+}
+async function writeText2(ctx, cmd, state) {
+  const style = resolveTextStyle(cmd.style);
+  const laid = cachedLayoutRuns(cmd.runs, {
+    maxWidth: cmd.maxWidth ?? Infinity,
+    alignWidth: cmd.width,
+    lineHeight: style.lineHeight,
+    align: cmd.align ?? style.align,
+    direction: cmd.direction ?? style.direction,
+    tabSize: style.tabSize,
+    justify: cmd.justify
+  });
+  const dx = cmd.x;
+  const dy = cmd.y + verticalAlignOffset(cmd.verticalAlign, cmd.height, laid.bounds.height);
+  const items = [];
+  let seg;
+  for (const [line, box] of laid.lines.entries()) {
+    for (const g of box.glyphs) {
+      const run = cmd.runs[g.run];
+      if (!fillHasInk(run.fill) && !strokeHasInk(run.stroke)) continue;
+      const space = isSpace(g.cp);
+      if (!space && BLANK.test(String.fromCodePoint(g.cp))) continue;
+      if (!space && (g.glyph?.color || g.resolved.source !== "outline" && g.glyph === null)) {
+        skipGlyph(ctx, g, "has no glyph to draw");
+        continue;
+      }
+      const { family, weight, style: fontStyle } = g.resolved.resolved;
+      const font = await ctx.fonts.face(family, weight, fontStyle);
+      const gid = font?.use(g.cp) ?? null;
+      if (font && gid !== null) {
+        if (!joins(seg, g, line)) items.push(seg = { font, line, glyphs: [] });
+        seg.glyphs.push({ g, gid });
+        continue;
+      }
+      if (space) continue;
+      const outline = outlineCommand(ctx, g, cmd, dx, dy);
+      if (outline) items.push(outline);
+      else skipGlyph(ctx, g, "has no glyph to draw");
+    }
+  }
+  for (const item of items) {
+    if ("kind" in item) await writeCommands(ctx, [item], state);
+    else await writeSegment(ctx, item, cmd, dx, dy, state);
+  }
+  const { decorations } = cachedPaintRuns(laid, cmd.runs, {});
+  const rules = decorations.map((d) => ({
+    kind: "path",
+    path: { kind: "rect", x: d.x0 + dx, y: d.y0 + dy, width: d.x1 - d.x0, height: d.y1 - d.y0 },
+    fill: d.fill
+  }));
+  await writeCommands(ctx, rules, state);
+}
+
+// src/drawCommands.ts
+function skip(ctx, detail) {
+  ctx.skipped.push({ kind: "command", detail });
+}
+function pageFlip(ctx) {
+  return mat3.fromAffine([1, 0, 0, -1, 0, ctx.height]);
+}
+function setAlpha(ctx, fill, stroke) {
+  ctx.out.op("gs", `/${ctx.resources.extGState(fill, stroke)}`);
+}
+function writeShadedFill(ctx, cmd, state, paint) {
+  const sh = paintShading(ctx, paint, state, cmd.path);
+  if (!sh) return;
+  const { out } = ctx;
+  out.op("q");
+  out.op(fillPathOps(out, cmd.path) ? "W*" : "W");
+  out.op("n");
+  if (sh.alpha < 1) setAlpha(ctx, sh.alpha, sh.alpha);
+  if (sh.matrix) out.op("cm", ...mat3.toAffine(sh.matrix));
+  if (sh.softMask) out.op("gs", `/${sh.softMask}`);
+  out.op("sh", `/${sh.shading}`);
+  out.op("Q");
+}
+function writeTextureFill(ctx, cmd, state, paint) {
+  const pattern = texturePattern(ctx, paint, state);
+  if (!pattern) return skip(ctx, `texture ${paint.texture.id} cannot be drawn`);
+  const alpha = (paint.opacity ?? 1) * state.alpha;
+  const { out } = ctx;
+  out.op("q");
+  setAlpha(ctx, alpha, alpha);
+  out.op("cs", "/Pattern");
+  out.op("scn", `/${pattern}`);
+  out.op(fillPathOps(out, cmd.path) ? "f*" : "f");
+  out.op("Q");
+}
+async function writeFill(ctx, cmd, state) {
+  const paint = cmd.fill?.paint;
+  if (!paint) return;
+  if (isGradientPaint(paint)) return writeShadedFill(ctx, cmd, state, paint);
+  if (paint.kind === "texture") return writeTextureFill(ctx, cmd, state, paint);
+  if (!isSolidPaint(paint)) return rasterFill(ctx, cmd, state, paint.kind);
+  if (cmd.vertexColors?.length) skip(ctx, "fill vertexColors approximated by the solid fill");
+  const { rgb, alpha } = solidColor(paint, state);
+  const { out } = ctx;
+  out.op("q");
+  setAlpha(ctx, alpha, alpha);
+  out.op("rg", ...rgb);
+  out.op(fillPathOps(out, cmd.path) ? "f*" : "f");
+  out.op("Q");
+}
+async function writePath(ctx, cmd, state) {
+  await writeFill(ctx, cmd, state);
+  if (cmd.stroke) await writeStroke(ctx, cmd.path, cmd.stroke, state);
+}
+async function writeCommand(ctx, cmd, state) {
+  if (cmd.kind === "path") await writePath(ctx, cmd, state);
+  else if (cmd.kind === "group") await writeGroup(ctx, cmd, state);
+  else if (cmd.kind === "image" || cmd.kind === "sprites") writeImage(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`);
+    }
+  }
+}
+
+// src/fonts/toUnicode.ts
+var MAX_PER_BLOCK = 100;
+var hex4 = (n) => n.toString(16).toUpperCase().padStart(4, "0");
+function utf16Hex(cp) {
+  if (cp <= 65535) return hex4(cp);
+  const v = cp - 65536;
+  return hex4(55296 + (v >> 10)) + hex4(56320 + (v & 1023));
+}
+function toUnicodeCMap(glyphs) {
+  const entries = [...glyphs].sort((a, b) => a[0] - b[0]);
+  const lines = [
+    "/CIDInit /ProcSet findresource begin",
+    "12 dict begin",
+    "begincmap",
+    "/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def",
+    "/CMapName /Adobe-Identity-UCS def",
+    "/CMapType 2 def",
+    "1 begincodespacerange",
+    "<0000> <FFFF>",
+    "endcodespacerange"
+  ];
+  for (let i = 0; i < entries.length; i += MAX_PER_BLOCK) {
+    const block = entries.slice(i, i + MAX_PER_BLOCK);
+    lines.push(`${block.length} beginbfchar`);
+    for (const [gid, cp] of block) lines.push(`<${hex4(gid)}> <${utf16Hex(cp)}>`);
+    lines.push("endbfchar");
+  }
+  lines.push("endcmap", "CMapName currentdict /CMap defineresource pop", "end", "end");
+  return lines.join("\n");
+}
+
+// src/fonts/embedFont.ts
+var encoder = new TextEncoder();
+function baseFontName(e, family, weight, style) {
+  const safe = (s) => s.replace(/[^A-Za-z0-9._-]/g, "");
+  return safe(e.postScriptName) || safe(`${family}-${weight}-${style}`);
+}
+var Face = class {
+  constructor(objects, emb, baseFont) {
+    this.objects = objects;
+    this.emb = emb;
+    this.baseFont = baseFont;
+  }
+  objects;
+  emb;
+  baseFont;
+  /** Glyph id to the first codepoint that asked for it. */
+  used = /* @__PURE__ */ new Map();
+  fontRef;
+  written = false;
+  get ref() {
+    if (!this.fontRef) throw new Error("pdf: font ref read before any glyph was used");
+    return this.fontRef;
+  }
+  use(cp) {
+    const gid = this.emb.glyphIndexOf(cp);
+    if (gid === null || gid === 0) return null;
+    if (!this.used.has(gid)) this.used.set(gid, cp);
+    this.fontRef ??= this.objects.alloc();
+    return gid;
+  }
+  widthOf(gid) {
+    return Math.round(this.emb.advanceOfGlyph(gid) * 1e3 / this.emb.unitsPerEm);
+  }
+  write() {
+    if (this.written || !this.fontRef) return;
+    this.written = true;
+    const { objects, emb } = this;
+    const k = 1e3 / emb.unitsPerEm;
+    const file = objects.alloc();
+    const descriptor = objects.alloc();
+    const cid = objects.alloc();
+    const toUnicode = objects.alloc();
+    objects.streamDeflated(file, { Length1: emb.sfnt.byteLength }, new Uint8Array(emb.sfnt));
+    objects.streamDeflated(toUnicode, {}, encoder.encode(toUnicodeCMap(this.used)));
+    objects.set(descriptor, {
+      Type: name("FontDescriptor"),
+      FontName: name(this.baseFont),
+      Flags: 4,
+      FontBBox: emb.bbox.map((v, i) => i < 2 ? Math.floor(v * k) : Math.ceil(v * k)),
+      ItalicAngle: emb.italicAngle,
+      Ascent: Math.round(emb.ascent * k),
+      Descent: Math.round(emb.descent * k),
+      CapHeight: Math.round(emb.capHeight * k),
+      StemV: 80,
+      // required by the spec, advisory for TrueType
+      FontFile2: file
+    });
+    const widths = [];
+    for (const gid of [...this.used.keys()].sort((a, b) => a - b)) widths.push(gid, [this.widthOf(gid)]);
+    objects.set(cid, {
+      Type: name("Font"),
+      Subtype: name("CIDFontType2"),
+      BaseFont: name(this.baseFont),
+      CIDSystemInfo: { Registry: text("Adobe"), Ordering: text("Identity"), Supplement: 0 },
+      FontDescriptor: descriptor,
+      CIDToGIDMap: name("Identity"),
+      W: widths
+    });
+    objects.set(this.fontRef, {
+      Type: name("Font"),
+      Subtype: name("Type0"),
+      BaseFont: name(this.baseFont),
+      Encoding: name("Identity-H"),
+      DescendantFonts: [cid],
+      ToUnicode: toUnicode
+    });
+  }
+};
+var DocumentFonts = class {
+  constructor(objects, source) {
+    this.objects = objects;
+    this.source = source;
+  }
+  objects;
+  source;
+  faces = /* @__PURE__ */ new Map();
+  /** The embedded font for a face, or null to draw its glyphs as outlines. */
+  face(family, weight, style) {
+    const key = JSON.stringify([family, weight, style]);
+    let p = this.faces.get(key);
+    if (!p) {
+      p = this.load(family, weight, style);
+      this.faces.set(key, p);
+    }
+    return p;
+  }
+  async load(family, weight, style) {
+    let emb;
+    try {
+      emb = await this.source.embedding(family, weight, style);
+    } catch {
+      return null;
+    }
+    if (!emb || emb.outlines !== "truetype" || !emb.embeddable) return null;
+    return new Face(this.objects, emb, baseFontName(emb, family, weight, style));
+  }
+  /** Writes every face's objects; call before `PdfObjects.settle`. */
+  async finish() {
+    for (const p of this.faces.values()) (await p)?.write();
+  }
+};
+
+// src/writePdf.ts
+function writePdf(pages, opts) {
+  return writePdfWith(pages, opts, deflate);
+}
+async function writePdfWith(pages, opts, deflate2) {
+  if (pages.length === 0) throw new Error("pdf: a document needs at least one page");
+  const objects = new PdfObjects();
+  const catalog = objects.alloc();
+  const tree = objects.alloc();
+  const info = objects.alloc();
+  const skipped = [];
+  const kids = [];
+  const fonts = new DocumentFonts(objects, opts.fonts);
+  for (const page of pages) {
+    const pageRef = objects.alloc();
+    const contentRef = objects.alloc();
+    const ctx = {
+      objects,
+      resources: new PageResources(),
+      out: new ContentStream(),
+      opts,
+      fonts,
+      skipped,
+      view: page.view,
+      width: page.width,
+      height: page.height
+    };
+    ctx.out.op("cm", ...mat3.toAffine(pageFlip(page)));
+    await writeCommands(ctx, page.commands, { transform: mat3.identity(), alpha: 1, colorMatrix: null });
+    const raw = ctx.out.bytes();
+    objects.streamDeflated(contentRef, {}, raw);
+    objects.set(pageRef, {
+      Type: name("Page"),
+      Parent: tree,
+      MediaBox: [0, 0, page.width, page.height],
+      Contents: contentRef,
+      Resources: ctx.resources.dict()
+    });
+    kids.push(pageRef);
+  }
+  objects.set(catalog, { Type: name("Catalog"), Pages: tree });
+  objects.set(tree, { Type: name("Pages"), Kids: kids, Count: kids.length });
+  objects.set(info, { Producer: text("weasel"), Title: opts.title === void 0 ? void 0 : text(opts.title) });
+  await fonts.finish();
+  await objects.settle(opts.compress !== false, deflate2);
+  return { bytes: objects.serialize(catalog, info), skipped };
+}
+
+export { registryFontSource, writePdf };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map