@popcraft/kit 0.29.0 → 0.31.0

package/dist/chunks/pdf-E3BMX2WG.js

@@ -0,0 +1,1217 @@
+import { createRequire as __popcraftRequire } from 'node:module';
+import { fileURLToPath as __popcraftPath } from 'node:url';
+import { dirname as __popcraftDirname } from 'node:path';
+const require = __popcraftRequire(import.meta.url);
+const __filename = __popcraftPath(import.meta.url);
+const __dirname = __popcraftDirname(__filename);
+import {
+  photoCredits,
+  photoCreditsText
+} from "./chunk-VEI7VBHL.js";
+import "./chunk-KTY54Z6Y.js";
+import {
+  buildExportIR
+} from "./chunk-W5ZC3QXY.js";
+import "./chunk-BVAEGM2L.js";
+import {
+  roundedRectCmds,
+  trimCmds
+} from "./chunk-BDOXBX6U.js";
+import "./chunk-E5ADUDER.js";
+import {
+  documentForExport
+} from "./chunk-CLEN2YD3.js";
+import {
+  require_polygon_clipping_cjs
+} from "./chunk-SGMR2EDA.js";
+import "./chunk-HYO4HW5U.js";
+import "./chunk-72TPH6VC.js";
+import "./chunk-BMOIW4EK.js";
+import {
+  resolvedFills
+} from "./chunk-BRLZFJJU.js";
+import "./chunk-5YD4P6WO.js";
+import "./chunk-THLMVVIT.js";
+import "./chunk-CGIPDP5Y.js";
+import "./chunk-TSZHCWC6.js";
+import "./chunk-AVWA3JAF.js";
+import "./chunk-SZGQEUZO.js";
+import "./chunk-KKJKAW2M.js";
+import "./chunk-MOJFHUGP.js";
+import "./chunk-UBYSDAJE.js";
+import "./chunk-SVJQJLCO.js";
+import "./chunk-R74YSMDO.js";
+import "./chunk-NKU65PDL.js";
+import "./chunk-XJRLX66V.js";
+import "./chunk-QZWEMMEL.js";
+import "./chunk-YQC2IVAU.js";
+import "./chunk-EAVQBTTA.js";
+import "./chunk-VDJPGIAE.js";
+import "./chunk-Z73UNUL7.js";
+import "./chunk-QLDV5WV5.js";
+import {
+  getWorldRenderBounds,
+  init_print_pages,
+  init_scene_graph,
+  isPrintPage,
+  jobPageSize
+} from "./chunk-MQ66HDKC.js";
+import "./chunk-N7XUSTLZ.js";
+import "./chunk-XBVMM6ZD.js";
+import "./chunk-5XSI3MNX.js";
+import "./chunk-2LYY4KTS.js";
+import "./chunk-SMR77HUB.js";
+import "./chunk-2YBOCBPA.js";
+import "./chunk-FREAHUVP.js";
+import "./chunk-PXXO7PQR.js";
+import "./chunk-4VICNBUI.js";
+import "./chunk-IPETYEVH.js";
+import "./chunk-RW67KLLE.js";
+import "./chunk-5X7A23T7.js";
+import "./chunk-ONN5A5XM.js";
+import "./chunk-EPG7TW6Z.js";
+import "./chunk-NMFXCSU4.js";
+import "./chunk-TSWHCDM7.js";
+import "./chunk-CK43FENV.js";
+import {
+  IDENTITY,
+  init_transform,
+  invert,
+  multiply
+} from "./chunk-X53QDCNX.js";
+import "./chunk-VBAS5IB5.js";
+import "./chunk-CZXJDKOJ.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-FFS4SO7R.js";
+import {
+  __toESM
+} from "./chunk-LJSVREWM.js";
+
+// lib/io/pdf/index.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_scene_graph();
+init_print_pages();
+
+// lib/print/impose.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var at = (x, y, scale = 1) => [scale, 0, 0, scale, x, y];
+var rotated = (x, y, scale) => [0, scale, -scale, 0, x, y];
+var near = (a, b) => Math.abs(a - b) <= 1.5;
+function commonSize(sizes) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const s of sizes) {
+    const key = `${Math.round(s.width)}x${Math.round(s.height)}`;
+    const hit = counts.get(key);
+    if (hit) hit.n++;
+    else counts.set(key, { size: s, n: 1 });
+  }
+  let best = null;
+  for (const c of counts.values()) {
+    if (!best || c.n > best.n) best = c;
+  }
+  return best?.size ?? { width: 612, height: 792 };
+}
+function normalisePages(sizes, opts = {}) {
+  const base = opts.base ?? commonSize(sizes);
+  const split = opts.split !== false;
+  const pages = [];
+  sizes.forEach((size, index2) => {
+    const across = Math.round(size.width / base.width);
+    const isSpread = split && across >= 2 && near(size.width, across * base.width) && near(size.height, base.height);
+    if (isSpread) {
+      for (let i = 0; i < across; i++) {
+        pages.push({ index: index2, crop: { x: i * base.width, y: 0, width: base.width, height: base.height }, scale: 1, offset: { x: 0, y: 0 } });
+      }
+      return;
+    }
+    const crop = { x: 0, y: 0, width: size.width, height: size.height };
+    if (near(size.width, base.width) && near(size.height, base.height)) {
+      pages.push({ index: index2, crop, scale: 1, offset: { x: 0, y: 0 } });
+      return;
+    }
+    const scale = Math.min(base.width / size.width, base.height / size.height, 1);
+    pages.push({
+      index: index2,
+      crop,
+      scale,
+      offset: { x: (base.width - size.width * scale) / 2, y: (base.height - size.height * scale) / 2 }
+    });
+  });
+  return { base, pages };
+}
+function bookletOrder(count) {
+  const total = Math.ceil(Math.max(count, 1) / 4) * 4;
+  const page = (n) => n <= count ? n - 1 : null;
+  const out = [];
+  for (let i = 0; i < total / 4; i++) {
+    out.push({ front: [page(total - 2 * i), page(1 + 2 * i)], back: [page(2 + 2 * i), page(total - 1 - 2 * i)] });
+  }
+  return out;
+}
+function impose(sizes, layout, opts = {}) {
+  if (!sizes.length) return [];
+  const { base, pages } = normalisePages(sizes, opts);
+  const w = base.width, h = base.height;
+  const slot = (i, matrix) => ({ page: i === null ? null : pages[i] ?? null, matrix });
+  if (layout === "pages") return pages.map((_, i) => ({ width: w, height: h, slots: [slot(i, at(0, 0))] }));
+  if (layout === "spreads") {
+    const out2 = [{ width: w * 2, height: h, slots: [slot(0, at(w, 0))] }];
+    for (let i = 1; i < pages.length; i += 2) {
+      out2.push({ width: w * 2, height: h, slots: [slot(i, at(0, 0)), ...pages[i + 1] ? [slot(i + 1, at(w, 0))] : []] });
+    }
+    return out2;
+  }
+  if (layout === "booklet") {
+    return bookletOrder(pages.length).flatMap(({ front, back }) => [
+      { width: w * 2, height: h, side: "front", slots: front.map((p, i) => slot(p, at(i * w, 0))).filter((s) => s.page) },
+      { width: w * 2, height: h, side: "back", slots: back.map((p, i) => slot(p, at(i * w, 0))).filter((s) => s.page) }
+    ]);
+  }
+  const perSheet = layout === "nup2" ? 2 : 4;
+  const out = [];
+  for (let i = 0; i < pages.length; i += perSheet) {
+    const slots = [];
+    for (let j = 0; j < perSheet && i + j < pages.length; j++) {
+      if (layout === "nup2") {
+        const scale = Math.min(w / h, h / 2 / w);
+        slots.push(slot(i + j, rotated(scale * h, j * (h / 2), scale)));
+      } else {
+        slots.push(slot(i + j, at(j % 2 * (w / 2), Math.floor(j / 2) * (h / 2), 0.5)));
+      }
+    }
+    out.push({ width: w, height: h, slots });
+  }
+  return out;
+}
+
+// lib/io/pdf/content.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_transform();
+
+// lib/io/pdf/writer.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+async function deflate(data) {
+  const stream = new Blob([data]).stream().pipeThrough(new CompressionStream("deflate"));
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+var enc = new TextEncoder();
+function num(n) {
+  if (!Number.isFinite(n)) return "0";
+  const r = Math.round(n * 1e3) / 1e3;
+  return Object.is(r, -0) || r === 0 ? "0" : String(r);
+}
+var PDFWriter = class {
+  constructor() {
+    this.chunks = [];
+    this.offset = 0;
+    this.offsets = [];
+    // object number → byte offset
+    this.next = 1;
+    this.push("%PDF-1.7\n%\xE2\xE3\xCF\xD3\n");
+  }
+  /** Reserve an object number to reference before the object is written. */
+  reserve() {
+    return this.next++;
+  }
+  push(part) {
+    const bytes = typeof part === "string" ? enc.encode(part) : part;
+    this.chunks.push(bytes);
+    this.offset += bytes.length;
+  }
+  /** Write a dictionary/value object. `id` from `reserve()`, or a fresh number when omitted. */
+  object(body, id = this.reserve()) {
+    this.offsets[id] = this.offset;
+    this.push(`${id} 0 obj
+${body}
+endobj
+`);
+    return id;
+  }
+  /** Write a stream object; `dict` is the dictionary's inner entries (Length is added). */
+  stream(dict, data, id = this.reserve()) {
+    this.offsets[id] = this.offset;
+    this.push(`${id} 0 obj
+<< ${dict} /Length ${data.length} >>
+stream
+`);
+    this.push(data);
+    this.push("\nendstream\nendobj\n");
+    return id;
+  }
+  async flateStream(dict, data, id = this.reserve()) {
+    return this.stream(`${dict} /Filter /FlateDecode`, await deflate(data), id);
+  }
+  /** Finish with the catalog as root; returns the whole file. */
+  finish(rootId, info = {}) {
+    const infoId = this.object(`<< ${Object.entries(info).map(([k, v]) => `/${k} ${pdfTextString(v)}`).join(" ")} >>`);
+    const count = this.next;
+    const xref = this.offset;
+    let table = `xref
+0 ${count}
+0000000000 65535 f 
+`;
+    for (let n = 1; n < count; n++) table += `${String(this.offsets[n] ?? 0).padStart(10, "0")} 00000 n 
+`;
+    this.push(table);
+    this.push(`trailer
+<< /Size ${count} /Root ${rootId} 0 R /Info ${infoId} 0 R >>
+startxref
+${xref}
+%%EOF
+`);
+    return new Blob(this.chunks, { type: "application/pdf" });
+  }
+};
+function pdfTextString(s) {
+  if (/^[\x20-\x7e]*$/.test(s)) return `(${pdfString(s)})`;
+  let hex = "FEFF";
+  for (let i = 0; i < s.length; i++) hex += s.charCodeAt(i).toString(16).padStart(4, "0").toUpperCase();
+  return `<${hex}>`;
+}
+function pdfString(s) {
+  return s.replace(/[^\x20-\x7e]/g, "?").replace(/[\\()]/g, (c) => `\\${c}`);
+}
+
+// lib/io/pdf/content.ts
+var WHITE = { r: 1, g: 1, b: 1, a: 1 };
+function whiten(item) {
+  if (item.t === "group") return { ...item, children: item.children.map(whiten), mask: void 0 };
+  if (item.t === "path") {
+    return {
+      ...item,
+      fills: item.fills.map((f) => f.kind === "solid" ? { ...f, color: WHITE } : { ...f, stops: f.stops.map((s) => ({ ...s, color: WHITE })) }),
+      strokes: item.strokes.map((s) => ({ ...s, color: WHITE }))
+    };
+  }
+  if (item.t === "text") return { ...item, runs: item.runs.map((r) => ({ ...r, color: WHITE })) };
+  return item;
+}
+function simpleClip(content) {
+  if (content.t === "path") return { cmds: content.cmds, fillRule: content.fillRule, local: IDENTITY };
+  if (content.t !== "group" || content.mask || content.opacity < 1) return null;
+  const drawn = content.children.filter((c) => c.t !== "group" || c.children.length > 0);
+  if (drawn.length !== 1) return null;
+  const only = drawn[0];
+  if (only.t === "path") {
+    if (only.strokes.length || only.fills.length !== 1) return null;
+    const fill = only.fills[0];
+    if (fill.kind !== "solid" || fill.alpha < 1 || (fill.color.a ?? 1) < 1) return null;
+    return { cmds: only.cmds, fillRule: only.fillRule, local: content.local };
+  }
+  const inner = simpleClip(only);
+  return inner ? { ...inner, local: multiply(content.local, inner.local) } : null;
+}
+var HUGE = [-1e6, -1e6, 1e6, 1e6];
+function pathOps(cmds) {
+  let cx = 0, cy = 0, sx = 0, sy = 0, s = "";
+  for (const c of cmds) {
+    switch (c.op) {
+      case "M":
+        s += `${num(c.x)} ${num(c.y)} m
+`;
+        cx = sx = c.x;
+        cy = sy = c.y;
+        break;
+      case "L":
+        s += `${num(c.x)} ${num(c.y)} l
+`;
+        cx = c.x;
+        cy = c.y;
+        break;
+      case "C":
+        s += `${num(c.x1)} ${num(c.y1)} ${num(c.x2)} ${num(c.y2)} ${num(c.x)} ${num(c.y)} c
+`;
+        cx = c.x;
+        cy = c.y;
+        break;
+      case "Q": {
+        const x1 = cx + 2 / 3 * (c.x1 - cx), y1 = cy + 2 / 3 * (c.y1 - cy);
+        const x2 = c.x + 2 / 3 * (c.x1 - c.x), y2 = c.y + 2 / 3 * (c.y1 - c.y);
+        s += `${num(x1)} ${num(y1)} ${num(x2)} ${num(y2)} ${num(c.x)} ${num(c.y)} c
+`;
+        cx = c.x;
+        cy = c.y;
+        break;
+      }
+      case "Z":
+        s += "h\n";
+        cx = sx;
+        cy = sy;
+        break;
+    }
+  }
+  return s;
+}
+var CAP = { BUTT: 0, ROUND: 1, SQUARE: 2 };
+var JOIN = { MITER: 0, ROUND: 1, BEVEL: 2 };
+var BLEND = {
+  MULTIPLY: "Multiply",
+  SCREEN: "Screen",
+  OVERLAY: "Overlay",
+  DARKEN: "Darken",
+  LIGHTEN: "Lighten",
+  COLOR_DODGE: "ColorDodge",
+  COLOR_BURN: "ColorBurn",
+  HARD_LIGHT: "HardLight",
+  SOFT_LIGHT: "SoftLight",
+  DIFFERENCE: "Difference",
+  EXCLUSION: "Exclusion",
+  HUE: "Hue",
+  SATURATION: "Saturation",
+  COLOR: "Color",
+  LUMINOSITY: "Luminosity"
+};
+function shadingDict(fill, color) {
+  const stops = fill.stops;
+  const fns = stops.slice(0, -1).map((s, i) => `<< /FunctionType 2 /Domain [0 1] /C0 [${color.comps(s.color)}] /C1 [${color.comps(stops[i + 1].color)}] /N 1 >>`);
+  const bounds = stops.slice(1, -1).map((s) => num(s.position));
+  const encode = stops.slice(0, -1).map(() => "0 1").join(" ");
+  const fn = fns.length === 1 ? fns[0] : `<< /FunctionType 3 /Domain [0 1] /Functions [${fns.join(" ")}] /Bounds [${bounds.join(" ")}] /Encode [${encode}] >>`;
+  const coords = fill.kind === "linear" ? `[${num(fill.from.x)} ${num(fill.from.y)} ${num(fill.to.x)} ${num(fill.to.y)}]` : `[${num(fill.center.x)} ${num(fill.center.y)} 0 ${num(fill.center.x)} ${num(fill.center.y)} ${num(fill.radius)}]`;
+  return `<< /ShadingType ${fill.kind === "linear" ? 2 : 3} /ColorSpace ${color.colorSpace} /Coords ${coords} /Domain [${num(stops[0].position)} ${num(stops[stops.length - 1].position)}] /Function ${fn} /Extend [true true] >>`;
+}
+var ContentBuilder = class {
+  constructor(res) {
+    this.res = res;
+    /** Buffer 0 is the page; each transparency group / mask gets its own buffer while it is being built. */
+    this.buffers = [""];
+    this.cur = 0;
+    this.rasters = [];
+  }
+  get out() {
+    return this.buffers[0];
+  }
+  w(s) {
+    this.buffers[this.cur] += s;
+  }
+  gs(fillAlpha, strokeAlpha, blend, smask) {
+    const bm = BLEND[blend] ?? "Normal";
+    const key = `GS${num(fillAlpha)}_${num(strokeAlpha)}_${bm}${smask ? `_${smask}` : ""}`.replace(/[^A-Za-z0-9_]/g, "_");
+    if (!this.res.gstates.has(key)) this.res.gstates.set(key, `<< /Type /ExtGState /ca ${num(fillAlpha)} /CA ${num(strokeAlpha)} /BM /${bm}${smask ? ` /SMask ${smask}` : " /SMask /None"} >>`);
+    return key;
+  }
+  shading(fill) {
+    const name = `Sh${this.res.shadings.size + 1}`;
+    this.res.shadings.set(name, shadingDict(fill, this.res.color));
+    return name;
+  }
+  /** Build `items` into a new form XObject (a transparency group) and return its name. */
+  form(children, group = true) {
+    const id = this.res.reserve();
+    const name = `Fm${id}`;
+    const parent = this.cur;
+    this.buffers.push("");
+    this.cur = this.buffers.length - 1;
+    for (const child of this.ordered(children)) this.emit(child, 1, "NORMAL");
+    const content = this.buffers[this.cur];
+    this.buffers.pop();
+    this.cur = parent;
+    const form = { name, id, content, bbox: HUGE, group };
+    this.res.forms.push(form);
+    return form;
+  }
+  /** ATS reading order: text-only groups sorted by their position, after everything else. */
+  ordered(children) {
+    if (!this.res.ats) return children;
+    const isText = (c) => c.t === "group" && c.children.every((x) => x.t === "text" || x.t === "path" && !x.fills.length && !x.strokes.length);
+    const rest = children.filter((c) => !isText(c));
+    const text = children.filter(isText).sort((a, b) => a.t === "group" && b.t === "group" ? a.local[5] - b.local[5] || a.local[4] - b.local[4] : 0);
+    return [...rest, ...text];
+  }
+  /** Emit one item under the accumulated opacity/blend. */
+  emit(item, opacity = 1, blend = "NORMAL") {
+    if (item.t === "group") {
+      const own = item.opacity < 1 || item.blend !== "NORMAL" || !!item.mask;
+      const m = item.local;
+      this.w(`q
+${num(m[0])} ${num(m[1])} ${num(m[2])} ${num(m[3])} ${num(m[4])} ${num(m[5])} cm
+`);
+      if (item.clip) this.w(item.clip.radii ? `${pathOps(roundedRectCmds(item.clip.width, item.clip.height, item.clip.radii))}W n
+` : `0 0 ${num(item.clip.width)} ${num(item.clip.height)} re W n
+`);
+      const clipShape = item.mask ? simpleClip(item.mask.content) : null;
+      if (clipShape) {
+        const c = clipShape.local;
+        this.w(`q
+${num(c[0])} ${num(c[1])} ${num(c[2])} ${num(c[3])} ${num(c[4])} ${num(c[5])} cm
+`);
+        this.w(`${pathOps(clipShape.cmds)}${clipShape.fillRule === "evenodd" ? "W*" : "W"} n
+`);
+        const inv = invert(c);
+        if (inv) this.w(`${num(inv[0])} ${num(inv[1])} ${num(inv[2])} ${num(inv[3])} ${num(inv[4])} ${num(inv[5])} cm
+`);
+        if (item.opacity < 1 || item.blend !== "NORMAL") {
+          const form = this.form(item.children, true);
+          this.w(`q /${this.gs(opacity * item.opacity, opacity * item.opacity, item.blend !== "NORMAL" ? item.blend : blend)} gs /${form.name} Do Q
+`);
+        } else {
+          for (const child of this.ordered(item.children)) this.emit(child, opacity, blend);
+        }
+        this.w("Q\nQ\n");
+        return;
+      }
+      if (!own) {
+        for (const child of this.ordered(item.children)) this.emit(child, opacity, blend);
+      } else {
+        let smask;
+        if (item.mask) {
+          const lum = item.mask.type === "LUMINANCE";
+          const maskForm = this.form([lum ? item.mask.content : whiten(item.mask.content)], true);
+          smask = `<< /S /Luminosity /G ${maskForm.id} 0 R /BC [${this.res.color.mode === "CMYK" ? "0 0 0 1" : "0 0 0"}] >>`;
+          maskForm.group = true;
+        }
+        const form = this.form(item.children, true);
+        const g = this.gs(opacity * item.opacity, opacity * item.opacity, item.blend !== "NORMAL" ? item.blend : blend, smask);
+        this.w(`q /${g} gs /${form.name} Do Q
+`);
+      }
+      this.w("Q\n");
+      return;
+    }
+    if (item.t === "raster") {
+      const name = `Im${this.rasters.length}`;
+      this.rasters.push({ name, node: item });
+      this.w(`%%RASTER ${name} ${num(opacity)} ${blend} ${this.cur}
+`);
+      return;
+    }
+    if (item.t === "text") {
+      for (const run of item.runs) {
+        this.w(`q /${this.gs(opacity * run.alpha, 1, blend)} gs ${this.res.color.fill(run.color)} BT
+`);
+        let current = "";
+        for (const g of run.glyphs) {
+          const { resource, gid } = this.res.fonts.use(g.font, g.gid, g.codePoints);
+          if (resource !== current) {
+            this.w(`/${resource} ${num(run.size)} Tf
+`);
+            current = resource;
+          }
+          this.w(`1 0 0 -1 ${num(g.x)} ${num(g.y)} Tm <${gid.toString(16).padStart(4, "0")}> Tj
+`);
+        }
+        this.w("ET\nQ\n");
+      }
+      return;
+    }
+    const ops = pathOps(item.trim ? trimCmds(item.cmds, item.trim) : item.cmds);
+    const clipOp = item.fillRule === "evenodd" ? "W*" : "W";
+    const paintFills = () => {
+      for (const f of item.fills) {
+        if (f.kind === "solid") {
+          this.w(`q /${this.gs(opacity * f.alpha, 1, blend)} gs ${this.res.color.fill(f.color)}
+${ops}${item.fillRule === "evenodd" ? "f*" : "f"}
+Q
+`);
+        } else {
+          const box = item.box ?? { width: 1, height: 1 };
+          this.w(`q /${this.gs(opacity * f.alpha, 1, blend)} gs
+${ops}${clipOp} n
+${num(box.width)} 0 0 ${num(box.height)} 0 0 cm
+/${this.shading(f)} sh
+Q
+`);
+        }
+      }
+    };
+    const paintStrokes = () => {
+      for (const s of item.strokes) {
+        const inside = s.alignment === "INSIDE";
+        const wdt = inside ? s.width * 2 : s.width;
+        this.w(`q /${this.gs(1, opacity * s.alpha, blend)} gs ${this.res.color.stroke(s.color)} ${num(wdt)} w ${CAP[s.cap]} J ${JOIN[s.join]} j`);
+        this.w(s.dash ? ` [${num(s.dash[0])} ${num(s.dash[1])}] 0 d
+` : " [] 0 d\n");
+        if (inside) this.w(`${ops}${clipOp} n
+`);
+        this.w(`${ops}S
+Q
+`);
+      }
+    };
+    if (item.strokesFirst) {
+      paintStrokes();
+      paintFills();
+    } else {
+      paintFills();
+      paintStrokes();
+    }
+  }
+  /** Replace a raster placeholder (in whichever buffer holds it) with the image draw at its world bounds. */
+  placeRaster(name, bounds, acc) {
+    const line = new RegExp(`%%RASTER ${name} (\\S+) (\\S+) (\\d+)\\n`);
+    for (let i = 0; i < this.buffers.length; i++) {
+      const m = line.exec(this.buffers[i]);
+      if (!m) continue;
+      const [, opacity, blend] = m;
+      this.buffers[i] = this.buffers[i].replace(m[0], this.rasterDraw(name, bounds, acc, opacity, blend));
+      return;
+    }
+    for (const f of this.res.forms) {
+      const m = line.exec(f.content);
+      if (!m) continue;
+      const [, opacity, blend] = m;
+      f.content = f.content.replace(m[0], this.rasterDraw(name, bounds, acc, opacity, blend));
+      return;
+    }
+  }
+  /** The image draw at its world bounds, in the space `acc` placed the placeholder in (none when that collapsed). */
+  rasterDraw(name, bounds, acc, opacity, blend) {
+    const inv = invert(acc);
+    if (!inv) return "";
+    const w = bounds.maxX - bounds.minX, h = bounds.maxY - bounds.minY;
+    const place = multiply(inv, [w, 0, 0, -h, bounds.minX, bounds.minY + h]);
+    return `q /${this.gs(parseFloat(opacity), 1, blend)} gs ${place.map(num).join(" ")} cm /${name} Do Q
+`;
+  }
+  dropRaster(name) {
+    const line = new RegExp(`%%RASTER ${name} \\S+ \\S+ \\d+\\n`);
+    this.buffers = this.buffers.map((b) => b.replace(line, ""));
+    for (const f of this.res.forms) f.content = f.content.replace(line, "");
+  }
+};
+
+// lib/io/pdf/fonts.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/io/pdf/cff.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var import_polygon_clipping = __toESM(require_polygon_clipping_cjs());
+function dictInt(v) {
+  const n = Math.round(v);
+  return [29, n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255];
+}
+function dictReal(v) {
+  const s = v.toExponential(8).replace("e+", "E").replace("e-", "E-");
+  const nibbles = [];
+  for (const ch of s) {
+    if (ch >= "0" && ch <= "9") nibbles.push(ch.charCodeAt(0) - 48);
+    else if (ch === ".") nibbles.push(10);
+    else if (ch === "E") nibbles.push(11);
+    else if (ch === "-") nibbles.push(nibbles.length && nibbles[nibbles.length - 1] === 11 ? 12 : 14);
+  }
+  for (let i = 0; i < nibbles.length - 1; i++) if (nibbles[i] === 11 && nibbles[i + 1] === 12) {
+    nibbles.splice(i, 2, 12);
+  }
+  nibbles.push(15);
+  if (nibbles.length % 2) nibbles.push(15);
+  const out = [30];
+  for (let i = 0; i < nibbles.length; i += 2) out.push(nibbles[i] << 4 | nibbles[i + 1]);
+  return out;
+}
+function csNum(v) {
+  const n = Math.round(v);
+  if (n >= -107 && n <= 107) return [n + 139];
+  if (n >= 108 && n <= 1131) {
+    const w = n - 108;
+    return [(w >> 8) + 247, w & 255];
+  }
+  if (n >= -1131 && n <= -108) {
+    const w = -n - 108;
+    return [(w >> 8) + 251, w & 255];
+  }
+  return [28, n >> 8 & 255, n & 255];
+}
+function index(items) {
+  if (!items.length) return new Uint8Array([0, 0]);
+  const total = items.reduce((a, b) => a + b.length, 1);
+  const offSize = total < 256 ? 1 : total < 65536 ? 2 : total < 16777216 ? 3 : 4;
+  const out = [items.length >> 8 & 255, items.length & 255, offSize];
+  let off = 1;
+  const pushOff = (o) => {
+    for (let i = offSize - 1; i >= 0; i--) out.push(o >> 8 * i & 255);
+  };
+  pushOff(off);
+  for (const it of items) {
+    off += it.length;
+    pushOff(off);
+  }
+  const head = new Uint8Array(out);
+  const res = new Uint8Array(head.length + total - 1);
+  res.set(head);
+  let p = head.length;
+  for (const it of items) {
+    res.set(it, p);
+    p += it.length;
+  }
+  return res;
+}
+function contoursOf(cmds) {
+  const out = [];
+  let cur = [];
+  for (const c of cmds) {
+    if (c.command === "moveTo") {
+      if (cur.length) out.push(cur);
+      cur = [c];
+    } else if (c.command === "closePath") {
+      if (cur.length) out.push(cur);
+      cur = [];
+    } else if (cur.length) cur.push(c);
+  }
+  if (cur.length) out.push(cur);
+  return out;
+}
+var signedArea = (p) => p.reduce((a, [x, y], i) => {
+  const [nx, ny] = p[(i + 1) % p.length];
+  return a + x * ny - nx * y;
+}, 0) / 2;
+var bbox = (p) => p.reduce((b, [x, y]) => ({ minX: Math.min(b.minX, x), minY: Math.min(b.minY, y), maxX: Math.max(b.maxX, x), maxY: Math.max(b.maxY, y) }), { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity });
+var intersects = (a, b) => a.minX < b.maxX && b.minX < a.maxX && a.minY < b.maxY && b.minY < a.maxY;
+function crossingRings(a, b) {
+  const orient = (p, q, r) => Math.sign((q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]));
+  for (let i = 0; i < a.length; i++) {
+    const p1 = a[i], p2 = a[(i + 1) % a.length];
+    for (let j = 0; j < b.length; j++) {
+      const q1 = b[j], q2 = b[(j + 1) % b.length];
+      const o1 = orient(p1, p2, q1), o2 = orient(p1, p2, q2), o3 = orient(q1, q2, p1), o4 = orient(q1, q2, p2);
+      if (o1 !== o2 && o3 !== o4 && o1 !== 0 && o2 !== 0 && o3 !== 0 && o4 !== 0) return true;
+    }
+  }
+  return false;
+}
+function flatten(contour) {
+  const out = [];
+  let x = 0, y = 0;
+  for (const c of contour) {
+    const a = c.args;
+    if (c.command === "moveTo" || c.command === "lineTo") {
+      x = a[0];
+      y = a[1];
+      out.push([x, y]);
+      continue;
+    }
+    const x0 = x, y0 = y;
+    const [c1x, c1y, c2x, c2y, ex, ey] = c.command === "quadraticCurveTo" ? [x0 + 2 / 3 * (a[0] - x0), y0 + 2 / 3 * (a[1] - y0), a[2] + 2 / 3 * (a[0] - a[2]), a[3] + 2 / 3 * (a[1] - a[3]), a[2], a[3]] : [a[0], a[1], a[2], a[3], a[4], a[5]];
+    const len = Math.hypot(c1x - x0, c1y - y0) + Math.hypot(c2x - c1x, c2y - c1y) + Math.hypot(ex - c2x, ey - c2y);
+    const steps = Math.max(6, Math.min(48, Math.ceil(len / 12)));
+    for (let i = 1; i <= steps; i++) {
+      const t = i / steps, u = 1 - t;
+      out.push([u * u * u * x0 + 3 * u * u * t * c1x + 3 * u * t * t * c2x + t * t * t * ex, u * u * u * y0 + 3 * u * u * t * c1y + 3 * u * t * t * c2y + t * t * t * ey]);
+    }
+    x = ex;
+    y = ey;
+  }
+  return out;
+}
+function removeOverlaps(cmds) {
+  const contours = contoursOf(cmds);
+  if (contours.length < 2) return cmds;
+  const rings = contours.map(flatten).filter((r) => r.length >= 3);
+  const boxes = rings.map(bbox);
+  let touching = false;
+  for (let i = 0; i < rings.length && !touching; i++) for (let j = i + 1; j < rings.length; j++) if (intersects(boxes[i], boxes[j]) && crossingRings(rings[i], rings[j])) {
+    touching = true;
+    break;
+  }
+  if (!touching) return cmds;
+  const pos = rings.filter((r) => signedArea(r) > 0).map((r) => [r]), neg = rings.filter((r) => signedArea(r) < 0).map((r) => [r]);
+  const clip = import_polygon_clipping.default;
+  let result;
+  try {
+    const a = pos.length ? clip.union(...pos) : [], b = neg.length ? clip.union(...neg) : [];
+    result = a.length && b.length ? clip.xor(a, b) : a.length ? a : b;
+  } catch {
+    return cmds;
+  }
+  const out = [];
+  for (const poly of result) for (const ring of poly) {
+    const pts = ring[0][0] === ring[ring.length - 1][0] && ring[0][1] === ring[ring.length - 1][1] ? ring.slice(0, -1) : ring;
+    if (pts.length < 3) continue;
+    out.push({ command: "moveTo", args: [pts[0][0], pts[0][1]] });
+    for (let i = 1; i < pts.length; i++) out.push({ command: "lineTo", args: [pts[i][0], pts[i][1]] });
+    out.push({ command: "closePath", args: [] });
+  }
+  return out.length ? out : cmds;
+}
+function charstring(g) {
+  const out = [...csNum(g.advance)];
+  let x = 0, y = 0, open = false;
+  const rel = (nx, ny) => {
+    const rx = Math.round(nx), ry = Math.round(ny);
+    const d = [rx - x, ry - y];
+    x = rx;
+    y = ry;
+    return d;
+  };
+  for (const c of removeOverlaps(g.commands)) {
+    const a = c.args;
+    switch (c.command) {
+      case "moveTo": {
+        const [dx, dy] = rel(a[0], a[1]);
+        out.push(...csNum(dx), ...csNum(dy), 21);
+        open = true;
+        break;
+      }
+      case "lineTo": {
+        const [dx, dy] = rel(a[0], a[1]);
+        out.push(...csNum(dx), ...csNum(dy), 5);
+        break;
+      }
+      case "quadraticCurveTo": {
+        const x0 = x, y0 = y;
+        const c1x = x0 + 2 / 3 * (a[0] - x0), c1y = y0 + 2 / 3 * (a[1] - y0);
+        const c2x = a[2] + 2 / 3 * (a[0] - a[2]), c2y = a[3] + 2 / 3 * (a[1] - a[3]);
+        const d1 = rel(c1x, c1y), d2 = rel(c2x, c2y), d3 = rel(a[2], a[3]);
+        out.push(...csNum(d1[0]), ...csNum(d1[1]), ...csNum(d2[0]), ...csNum(d2[1]), ...csNum(d3[0]), ...csNum(d3[1]), 8);
+        break;
+      }
+      case "bezierCurveTo": {
+        const d1 = rel(a[0], a[1]), d2 = rel(a[2], a[3]), d3 = rel(a[4], a[5]);
+        out.push(...csNum(d1[0]), ...csNum(d1[1]), ...csNum(d2[0]), ...csNum(d2[1]), ...csNum(d3[0]), ...csNum(d3[1]), 8);
+        break;
+      }
+      case "closePath":
+        open = false;
+        break;
+    }
+  }
+  void open;
+  out.push(14);
+  return new Uint8Array(out);
+}
+function buildCFF(name, unitsPerEm, glyphs) {
+  const enc2 = new TextEncoder();
+  const header = new Uint8Array([1, 0, 4, 1]);
+  const nameIndex = index([enc2.encode(name.replace(/[^\x21-\x7e]/g, "") || "Font")]);
+  const strings = index(glyphs.map((_, i) => enc2.encode(`g${i + 1}`)));
+  const gsubrs = index([]);
+  const charStrings = index([new Uint8Array([14]), ...glyphs.map(charstring)]);
+  const charset = new Uint8Array(1 + glyphs.length * 2);
+  charset[0] = 0;
+  glyphs.forEach((_, i) => {
+    const sid = 391 + i;
+    charset[1 + i * 2] = sid >> 8;
+    charset[2 + i * 2] = sid & 255;
+  });
+  const privateDict = new Uint8Array([]);
+  const scale = 1 / unitsPerEm;
+  const topDict = (charsetOff2, charStringsOff2, privateOff2) => new Uint8Array([
+    ...dictReal(scale),
+    ...dictInt(0),
+    ...dictInt(0),
+    ...dictReal(scale),
+    ...dictInt(0),
+    ...dictInt(0),
+    12,
+    7,
+    // FontMatrix
+    ...dictInt(charsetOff2),
+    15,
+    ...dictInt(charStringsOff2),
+    17,
+    ...dictInt(privateDict.length),
+    ...dictInt(privateOff2),
+    18
+  ]);
+  const topSize = index([topDict(0, 0, 0)]).length;
+  const base = header.length + nameIndex.length + topSize + strings.length + gsubrs.length;
+  const charsetOff = base;
+  const charStringsOff = charsetOff + charset.length;
+  const privateOff = charStringsOff + charStrings.length;
+  const top = index([topDict(charsetOff, charStringsOff, privateOff)]);
+  const parts = [header, nameIndex, top, strings, gsubrs, charset, charStrings, privateDict];
+  const out = new Uint8Array(parts.reduce((a, p2) => a + p2.length, 0));
+  let p = 0;
+  for (const part of parts) {
+    out.set(part, p);
+    p += part.length;
+  }
+  return out;
+}
+
+// lib/io/pdf/fonts.ts
+var psSafe = (s) => s.replace(/[^A-Za-z0-9-]/g, "");
+function postscriptNameOf(font) {
+  const f = font;
+  const own = psSafe(f.postscriptName || "Font") || "Font";
+  const coords = f.variationCoords;
+  const fvar = f.fvar;
+  if (!coords?.length || !fvar?.axis?.length) return own;
+  const family = psSafe(f.familyName || "") || own.split("-")[0];
+  const named = fvar.instance?.find((i) => i.coord.length === coords.length && i.coord.every((c, k) => Math.abs(c - coords[k]) < 1e-3));
+  const instanceName = named?.name?.en ? psSafe(named.name.en) : "";
+  if (instanceName) return `${family}-${instanceName}`;
+  const off = fvar.axis.map((a, k) => ({ tag: a.axisTag.trim(), v: coords[k], d: a.defaultValue })).filter((a) => Math.abs(a.v - a.d) >= 1e-3);
+  if (!off.length) return own;
+  return `${family}_${off.map((a) => `${Math.round(a.v * 100) / 100}${psSafe(a.tag)}`).join("_")}`;
+}
+function fontWeightOf(font) {
+  const f = font;
+  const k = f.fvar?.axis?.findIndex((a) => a.axisTag.trim() === "wght") ?? -1;
+  if (k >= 0 && f.variationCoords?.length) return Math.round(f.variationCoords[k]);
+  return f["OS/2"]?.usWeightClass || void 0;
+}
+var isInstance = (font) => {
+  const f = font;
+  return !!(f.variationCoords && f.variationCoords.length);
+};
+function canEmbed(font) {
+  const fs = font["OS/2"]?.fsType;
+  return !(fs?.noEmbedding || fs?.bitmapOnly);
+}
+var hex4 = (n) => n.toString(16).padStart(4, "0").toUpperCase();
+var utf16be = (cps) => cps.map((cp) => cp > 65535 ? hex4(55296 + (cp - 65536 >> 10)) + hex4(56320 + (cp - 65536 & 1023)) : hex4(cp)).join("");
+var PDFFontSet = class {
+  constructor(w) {
+    this.w = w;
+    this.faces = /* @__PURE__ */ new Map();
+  }
+  /** Register a glyph; returns the font's resource name and the subset gid to show. */
+  use(font, gid, codePoints) {
+    let e = this.faces.get(font);
+    if (!e) {
+      e = { font, resource: `F${this.faces.size + 1}`, subset: isInstance(font) ? null : font.createSubset(), glyphs: /* @__PURE__ */ new Map(), objectId: this.w.reserve() };
+      this.faces.set(font, e);
+    }
+    let g = e.glyphs.get(gid);
+    if (!g) {
+      const glyph = font.getGlyph(gid);
+      g = { newGid: e.subset ? e.subset.includeGlyph(gid) : e.glyphs.size + 1, codePoints: codePoints.length ? codePoints : glyph.codePoints ?? [], advance: glyph.advanceWidth };
+      e.glyphs.set(gid, g);
+    }
+    return { resource: e.resource, gid: g.newGid };
+  }
+  get size() {
+    return this.faces.size;
+  }
+  /** `/F1 12 0 R /F2 …` for a page's resource dictionary (every face, since pages share the set). */
+  resources() {
+    return [...this.faces.values()].map((e) => `/${e.resource} ${e.objectId} 0 R`).join(" ");
+  }
+  /** Write every font's objects. Call once, after all pages. */
+  async write() {
+    for (const e of this.faces.values()) await this.writeFace(e);
+  }
+  async writeFace(e) {
+    const f = e.font;
+    let isCFF = !!f.directory?.tables?.["CFF "];
+    let program;
+    if (e.subset) {
+      const encoded = e.subset.encode();
+      program = encoded instanceof Uint8Array ? encoded : new Uint8Array(encoded);
+    } else {
+      const byNew2 = [...e.glyphs.entries()].sort((a, b) => a[1].newGid - b[1].newGid);
+      const glyphs = byNew2.map(([gid, g]) => {
+        const glyph = f.getGlyph(gid);
+        return { advance: g.advance, commands: glyph.path?.commands ?? [] };
+      });
+      program = buildCFF(postscriptNameOf(f), f.unitsPerEm, glyphs);
+      isCFF = true;
+    }
+    const scale = 1e3 / f.unitsPerEm;
+    const tag = "PCSUB+";
+    const base = tag + postscriptNameOf(f);
+    const weight = fontWeightOf(f);
+    const fileId = isCFF ? await this.w.flateStream("/Subtype /CIDFontType0C", program) : await this.w.flateStream(`/Length1 ${program.length}`, program);
+    const bbox2 = f.bbox;
+    const descriptor = this.w.object(
+      `<< /Type /FontDescriptor /FontName /${base} /Flags 4 /FontBBox [${num(bbox2.minX * scale)} ${num(bbox2.minY * scale)} ${num(bbox2.maxX * scale)} ${num(bbox2.maxY * scale)}] /ItalicAngle ${num(f.italicAngle ?? 0)} /Ascent ${num(f.ascent * scale)} /Descent ${num(f.descent * scale)} /CapHeight ${num((f.capHeight ?? f.ascent) * scale)}${weight ? ` /FontWeight ${weight}` : ""} /StemV 80 /${isCFF ? "FontFile3" : "FontFile2"} ${fileId} 0 R >>`
+    );
+    const byNew = [...e.glyphs.values()].sort((a, b) => a.newGid - b.newGid);
+    const W = byNew.map((g) => `${g.newGid} [${num(g.advance * scale)}]`).join(" ");
+    const bfchars = byNew.filter((g) => g.codePoints.length).map((g) => `<${hex4(g.newGid)}> <${utf16be(g.codePoints)}>`);
+    const cmap = [
+      "/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",
+      ...chunk(bfchars, 100).flatMap((c) => [`${c.length} beginbfchar`, ...c, "endbfchar"]),
+      "endcmap",
+      "CMapName currentdict /CMap defineresource pop",
+      "end",
+      "end"
+    ].join("\n");
+    const toUnicode = await this.w.flateStream("", new TextEncoder().encode(cmap));
+    const descendant = this.w.object(
+      `<< /Type /Font /Subtype /${isCFF ? "CIDFontType0" : "CIDFontType2"} /BaseFont /${base} /CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> /FontDescriptor ${descriptor} 0 R /DW 1000 /W [${W}]${isCFF ? "" : " /CIDToGIDMap /Identity"} >>`
+    );
+    this.w.object(`<< /Type /Font /Subtype /Type0 /BaseFont /${base} /Encoding /Identity-H /DescendantFonts [${descendant} 0 R] /ToUnicode ${toUnicode} 0 R >>`, e.objectId);
+  }
+};
+function chunk(arr, n) {
+  const out = [];
+  for (let i = 0; i < arr.length; i += n) out.push(arr.slice(i, i + n));
+  return out;
+}
+
+// lib/io/pdf/color.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+function rgbToCmyk(r, g, b) {
+  const k = 1 - Math.max(r, g, b);
+  if (k >= 1) return [0, 0, 0, 1];
+  return [(1 - r - k) / (1 - k), (1 - g - k) / (1 - k), (1 - b - k) / (1 - k), k];
+}
+function cmykToRgb(c, m, y, k) {
+  return [(1 - c) * (1 - k), (1 - m) * (1 - k), (1 - y) * (1 - k)];
+}
+var ColorOut = class {
+  constructor(mode) {
+    this.mode = mode;
+  }
+  get colorSpace() {
+    return this.mode === "CMYK" ? "/DeviceCMYK" : "/DeviceRGB";
+  }
+  get components() {
+    return this.mode === "CMYK" ? 4 : 3;
+  }
+  /** Component list for shading functions and color operators. */
+  comps(c) {
+    return this.mode === "CMYK" ? rgbToCmyk(c.r, c.g, c.b).map(num).join(" ") : `${num(c.r)} ${num(c.g)} ${num(c.b)}`;
+  }
+  fill(c) {
+    return `${this.comps(c)} ${this.mode === "CMYK" ? "k" : "rg"}`;
+  }
+  stroke(c) {
+    return `${this.comps(c)} ${this.mode === "CMYK" ? "K" : "RG"}`;
+  }
+  /** Image samples: RGBA in → RGB or CMYK bytes out. */
+  imageBytes(data, width, height) {
+    const n = width * height;
+    if (this.mode === "RGB") {
+      const out2 = new Uint8Array(n * 3);
+      for (let i = 0, j = 0; i < n; i++, j += 3) {
+        out2[j] = data[i * 4];
+        out2[j + 1] = data[i * 4 + 1];
+        out2[j + 2] = data[i * 4 + 2];
+      }
+      return out2;
+    }
+    const out = new Uint8Array(n * 4);
+    for (let i = 0, j = 0; i < n; i++, j += 4) {
+      const [c, m, y, k] = rgbToCmyk(data[i * 4] / 255, data[i * 4 + 1] / 255, data[i * 4 + 2] / 255);
+      out[j] = Math.round(c * 255);
+      out[j + 1] = Math.round(m * 255);
+      out[j + 2] = Math.round(y * 255);
+      out[j + 3] = Math.round(k * 255);
+    }
+    return out;
+  }
+};
+
+// lib/io/pdf/index.ts
+var PT = 0.75;
+var MARK_LEN = 12 / PT;
+var MARK_GAP = 3 / 25.4 * 96;
+var MAX_TEX = 8e3;
+var MAX_RASTER_PIXELS = 16e6;
+var posterFrames = (renderer, fn) => typeof renderer.withVideoPosters === "function" ? renderer.withVideoPosters(fn) : fn();
+function paperFill(root, doc) {
+  const solid = (n) => {
+    const fills = resolvedFills(n, doc.styles).filter((f2) => f2.visible !== false);
+    const f = fills.length ? fills[fills.length - 1] : void 0;
+    return f && f.type === "SOLID" && f.color ? { kind: "solid", color: f.color, alpha: (f.opacity ?? 1) * (f.color.a ?? 1) } : null;
+  };
+  const own = solid(root);
+  if (own && own.alpha >= 0.999) return own;
+  for (const id of root.childIds ?? []) {
+    const c = doc.nodes[id];
+    if (!c || !c.visible || c.x > 0.5 || c.y > 0.5 || c.x + c.width < root.width - 0.5 || c.y + c.height < root.height - 0.5) continue;
+    const f = solid(c);
+    if (f && f.alpha >= 0.999) return f;
+  }
+  return own;
+}
+function pageBox(node, doc, opts) {
+  const bounds = getWorldRenderBounds(doc, node.id);
+  const print = isPrintPage(node);
+  const trim = print ? { minX: node.x, minY: node.y, maxX: node.x + node.width, maxY: node.y + node.height } : bounds ?? { minX: node.x, minY: node.y, maxX: node.x + node.width, maxY: node.y + node.height };
+  const bleedOn = opts.bleed ?? print;
+  const b = bleedOn ? (print ? node.print?.bleed : void 0) ?? doc.settings?.bleed ?? { top: 0, right: 0, bottom: 0, left: 0 } : { top: 0, right: 0, bottom: 0, left: 0 };
+  const marks = !!opts.marks && print;
+  const slug = bleedOn && print ? doc.settings?.slug ?? 0 : 0;
+  const pad = (marks ? MARK_GAP + MARK_LEN : 0) + slug;
+  const media = { minX: trim.minX - b.left - pad, minY: trim.minY - b.top - pad, maxX: trim.maxX + b.right + pad, maxY: trim.maxY + b.bottom + pad };
+  const bleed = { minX: trim.minX - b.left, minY: trim.minY - b.top, maxX: trim.maxX + b.right, maxY: trim.maxY + b.bottom };
+  return { trim, bleed, media, marks, print };
+}
+function printerMarks(trim, color, bars) {
+  const w = 0.25 / PT;
+  const g = MARK_GAP, l = MARK_LEN;
+  let s = `q /CSReg CS 1 SC /CSReg cs 1 sc ${num(w)} w 0 J
+`;
+  const line = (x1, y1, x2, y2) => {
+    s += `${num(x1)} ${num(y1)} m ${num(x2)} ${num(y2)} l S
+`;
+  };
+  for (const x of [trim.minX, trim.maxX]) {
+    line(x, trim.minY - g, x, trim.minY - g - l);
+    line(x, trim.maxY + g, x, trim.maxY + g + l);
+  }
+  for (const y of [trim.minY, trim.maxY]) {
+    line(trim.minX - g, y, trim.minX - g - l, y);
+    line(trim.maxX + g, y, trim.maxX + g + l, y);
+  }
+  if (bars) {
+    const r = l * 0.3, k = 0.5523 * r;
+    for (const [cx, cy] of [[trim.minX - g - l / 2, trim.minY - g - l / 2], [trim.maxX + g + l / 2, trim.minY - g - l / 2], [trim.minX - g - l / 2, trim.maxY + g + l / 2], [trim.maxX + g + l / 2, trim.maxY + g + l / 2]]) {
+      s += `${num(cx + r)} ${num(cy)} m ${num(cx + r)} ${num(cy + k)} ${num(cx + k)} ${num(cy + r)} ${num(cx)} ${num(cy + r)} c ${num(cx - k)} ${num(cy + r)} ${num(cx - r)} ${num(cy + k)} ${num(cx - r)} ${num(cy)} c ${num(cx - r)} ${num(cy - k)} ${num(cx - k)} ${num(cy - r)} ${num(cx)} ${num(cy - r)} c ${num(cx + k)} ${num(cy - r)} ${num(cx + r)} ${num(cy - k)} ${num(cx + r)} ${num(cy)} c S
+`;
+      line(cx - r * 1.5, cy, cx + r * 1.5, cy);
+      line(cx, cy - r * 1.5, cx, cy + r * 1.5);
+    }
+    const patches = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [1, 1, 0, 0], [0, 1, 1, 0], [1, 0, 1, 0], [1, 1, 1, 0], [0, 0, 0, 0.75], [0, 0, 0, 0.5], [0, 0, 0, 0.25]];
+    const size = l * 0.8, y = trim.minY - g - l / 2 - size / 2, x0 = trim.minX + l;
+    patches.forEach(([c, m, yy, kk], i) => {
+      const x = x0 + i * (size + 2);
+      if (x + size > trim.maxX - l) return;
+      const fill = color.mode === "CMYK" ? `${num(c)} ${num(m)} ${num(yy)} ${num(kk)} k` : `${cmykToRgb(c, m, yy, kk).map(num).join(" ")} rg`;
+      s += `${fill} ${num(x)} ${num(y)} ${num(size)} ${num(size)} re f
+`;
+    });
+  }
+  return s + "Q\n";
+}
+function plan(roots, opts) {
+  const layout = opts.layout ?? (opts.spreads ? "spreads" : "pages");
+  const usable = layout === "pages" || roots.every(isPrintPage);
+  const effective = usable ? layout : "pages";
+  const split = opts.splitSpreads !== false;
+  const size = opts.pageSize;
+  return { layout: effective, sheets: impose(roots.map((r) => ({ width: r.width, height: r.height })), effective, { split, base: size }) };
+}
+async function exportNodesToPDF(renderer, nodes, scaleOrOpts, doc, styles) {
+  const opts = typeof scaleOrOpts === "number" ? { dpi: 96 * (scaleOrOpts || 1) } : scaleOrOpts;
+  doc = documentForExport(doc);
+  const roots = nodes.map((n) => doc.nodes[n.id] ?? n).filter((n) => n && n.visible);
+  if (!roots.length) return null;
+  const w = new PDFWriter();
+  const catalogId = w.reserve(), pagesId = w.reserve();
+  const pageIds = [];
+  const fonts = new PDFFontSet(w);
+  const color = new ColorOut(opts.colorMode ?? doc.settings?.colorMode ?? "RGB");
+  const ctx = { renderer, doc, styles, textAs: opts.ats ? "FONT" : opts.textAs ?? "FONT", canEmbed, ats: !!opts.ats };
+  const regCS = w.object(`[/Separation /All ${color.colorSpace} << /FunctionType 2 /Domain [0 1] /C0 [${color.mode === "CMYK" ? "0 0 0 0" : "1 1 1"}] /C1 [${color.mode === "CMYK" ? "1 1 1 1" : "0 0 0"}] /N 1 >>]`);
+  const { layout, sheets: imposed } = plan(roots, {
+    ...opts,
+    pageSize: opts.pageSize ?? (roots.every(isPrintPage) ? jobPageSize(doc) : void 0)
+  });
+  const perPage = layout === "pages" || layout === "spreads";
+  await posterFrames(renderer, async () => {
+    for (const sheet of imposed) {
+      const slots = sheet.slots.filter((sl) => !!sl.page);
+      if (!slots.length) continue;
+      const root = roots[slots[0].page.index];
+      const geo = pageBox(root, doc, opts);
+      const single = perPage && sheet.slots.length === 1 && slots[0].page.crop.width >= sheet.width - 1;
+      if (!single) {
+        geo.print = false;
+        geo.marks = false;
+        geo.trim = { minX: 0, minY: 0, maxX: sheet.width, maxY: sheet.height };
+        geo.bleed = { ...geo.trim };
+        geo.media = { ...geo.trim };
+      } else {
+        const crop = slots[0].page.crop;
+        const bleedOn = opts.bleed ?? true;
+        const b = bleedOn ? root.print?.bleed ?? doc.settings?.bleed ?? { top: 0, right: 0, bottom: 0, left: 0 } : { top: 0, right: 0, bottom: 0, left: 0 };
+        void crop;
+        const pad = geo.marks ? MARK_GAP + MARK_LEN : 0;
+        const slug = doc.settings?.slug ?? 0;
+        geo.trim = { minX: 0, minY: 0, maxX: sheet.width, maxY: sheet.height };
+        geo.bleed = { minX: -b.left, minY: -b.top, maxX: sheet.width + b.right, maxY: sheet.height + b.bottom };
+        geo.media = { minX: geo.bleed.minX - pad - slug, minY: geo.bleed.minY - pad - slug, maxX: geo.bleed.maxX + pad + slug, maxY: geo.bleed.maxY + pad + slug };
+      }
+      const dpi = opts.dpi ?? (geo.print ? 300 : 144);
+      const res = { ats: !!opts.ats, color, fonts, gstates: /* @__PURE__ */ new Map(), images: /* @__PURE__ */ new Map(), shadings: /* @__PURE__ */ new Map(), forms: [], reserve: () => w.reserve() };
+      const cb = new ContentBuilder(res);
+      if (geo.print && (geo.bleed.minX < geo.trim.minX || geo.bleed.minY < geo.trim.minY || geo.bleed.maxX > geo.trim.maxX || geo.bleed.maxY > geo.trim.maxY)) {
+        const paper = paperFill(root, doc);
+        if (paper) {
+          const b = geo.bleed;
+          cb.emit({ t: "path", cmds: [{ op: "M", x: b.minX, y: b.minY }, { op: "L", x: b.maxX, y: b.minY }, { op: "L", x: b.maxX, y: b.maxY }, { op: "L", x: b.minX, y: b.maxY }, { op: "Z" }], fillRule: "nonzero", fills: [paper], strokes: [] });
+        }
+      }
+      for (const sl of slots) {
+        const vp = sl.page;
+        const node = roots[vp.index];
+        const ir = buildExportIR(node, ctx);
+        if (!ir) continue;
+        const m = sl.matrix;
+        const s2 = vp.scale;
+        const place = [
+          m[0] * s2,
+          m[1] * s2,
+          m[2] * s2,
+          m[3] * s2,
+          m[4] + m[0] * vp.offset.x + m[2] * vp.offset.y,
+          m[5] + m[1] * vp.offset.x + m[3] * vp.offset.y
+        ];
+        const inner = { t: "group", name: "page", local: [1, 0, 0, 1, -node.x - vp.crop.x, -node.y - vp.crop.y], opacity: 1, blend: "NORMAL", clip: null, children: [ir] };
+        const bleedOut = single ? Math.max(geo.bleed.maxX - geo.trim.maxX, geo.trim.minX - geo.bleed.minX, geo.bleed.maxY - geo.trim.maxY, geo.trim.minY - geo.bleed.minY) : 0;
+        cb.emit({
+          t: "group",
+          name: "slot",
+          local: place,
+          opacity: 1,
+          blend: "NORMAL",
+          // The clip is the page slice, grown by the bleed so full-bleed art still reaches past the trim.
+          clip: { width: vp.crop.width + bleedOut * 2, height: vp.crop.height + bleedOut * 2 },
+          children: [{ t: "group", name: "bleed", local: [1, 0, 0, 1, bleedOut, bleedOut], opacity: 1, blend: "NORMAL", clip: null, children: [inner] }]
+        });
+      }
+      for (const r of cb.rasters) {
+        const rb = getWorldRenderBounds(doc, r.node.node.id);
+        const rw = rb ? Math.max(1, rb.maxX - rb.minX) : 1;
+        const rh = rb ? Math.max(1, rb.maxY - rb.minY) : 1;
+        const scale = rb ? Math.min(dpi / 96, MAX_TEX / Math.max(rw, rh), Math.sqrt(MAX_RASTER_PIXELS / (rw * rh))) : 1;
+        const img = rb ? await renderer.exportNode(r.node.node, scale, doc, styles).catch(() => null) : null;
+        if (!img || !rb) {
+          cb.dropRaster(r.name);
+          continue;
+        }
+        const id = await writeImage(w, img, color);
+        res.images.set(r.name, id);
+        cb.placeRaster(r.name, rb, r.node.acc);
+      }
+      const { media, trim, bleed } = geo;
+      const base = [PT, 0, 0, -PT, -media.minX * PT, media.maxY * PT];
+      let content = `q ${base.map(num).join(" ")} cm
+`;
+      if (geo.marks) content += printerMarks(trim, color, !!opts.colorBars);
+      content += cb.out + "Q\n";
+      const contentId = await w.flateStream("", new TextEncoder().encode(content));
+      const gs = [...res.gstates].map(([k, v]) => `/${k} ${v}`).join(" ");
+      const xo = [...res.images].map(([k, id]) => `/${k} ${id} 0 R`).join(" ") + " " + res.forms.map((f) => `/${f.name} ${f.id} 0 R`).join(" ");
+      const sh = [...res.shadings].map(([k, v]) => `/${k} ${v}`).join(" ");
+      const resources = `<< /ExtGState << ${gs} >> /XObject << ${xo} >> /Shading << ${sh} >> /ColorSpace << /CSReg ${regCS} 0 R >> /Font << ${fonts.resources()} >> >>`;
+      for (const f of res.forms) {
+        const body = f.content;
+        await w.flateStream(`/Type /XObject /Subtype /Form /BBox [${f.bbox.map(num).join(" ")}] ${f.group ? "/Group << /S /Transparency /CS /DeviceRGB /I true /K false >> " : ""}/Resources ${resources}`, new TextEncoder().encode(body), f.id);
+      }
+      const box = (b) => `[0 0 ${num((b.maxX - b.minX) * PT)} ${num((b.maxY - b.minY) * PT)}]`;
+      const rel = (b) => `[${num((b.minX - media.minX) * PT)} ${num((media.maxY - b.maxY) * PT)} ${num((b.maxX - media.minX) * PT)} ${num((media.maxY - b.minY) * PT)}]`;
+      const boxes = geo.print ? ` /TrimBox ${rel(trim)} /BleedBox ${rel(bleed)} /ArtBox ${rel(trim)}` : "";
+      pageIds.push(w.object(`<< /Type /Page /Parent ${pagesId} 0 R /MediaBox ${box(media)}${boxes} /Resources ${resources} /Contents ${contentId} 0 R >>`));
+    }
+  });
+  await fonts.write();
+  w.object(`<< /Type /Pages /Kids [${pageIds.map((id) => `${id} 0 R`).join(" ")}] /Count ${pageIds.length} >>`, pagesId);
+  w.object(`<< /Type /Catalog /Pages ${pagesId} 0 R /Lang (${opts.lang ?? "en-US"}) /ViewerPreferences << /DisplayDocTitle true >> >>`, catalogId);
+  const credits = photoCredits(doc.nodes, nodes.map((n) => n.id));
+  return w.finish(catalogId, { Producer: "PopCraft", Creator: "PopCraft", Title: doc.name, ...credits.length ? { Subject: `Photo credits: ${photoCreditsText(credits).replace(/\n/g, "; ")}` } : {} });
+}
+async function exportNodeToPDF(renderer, node, scaleOrOpts, doc, styles) {
+  return exportNodesToPDF(renderer, [node], scaleOrOpts, doc, styles);
+}
+var pdfOptionsFor = (setting) => setting.pdf ?? { dpi: 96 * (setting.scale || 1) };
+async function writeImage(w, img, color) {
+  const { width, height, data } = img;
+  const alpha = new Uint8Array(width * height);
+  let opaque = true;
+  for (let i = 0, k = 0; i < data.length; i += 4, k++) {
+    const a = data[i + 3];
+    alpha[k] = a;
+    if (a !== 255) opaque = false;
+  }
+  const smask = opaque ? null : await w.flateStream(`/Type /XObject /Subtype /Image /Width ${width} /Height ${height} /ColorSpace /DeviceGray /BitsPerComponent 8`, alpha);
+  return w.flateStream(`/Type /XObject /Subtype /Image /Width ${width} /Height ${height} /ColorSpace ${color.colorSpace} /BitsPerComponent 8${smask ? ` /SMask ${smask} 0 R` : ""}`, color.imageBytes(data, width, height));
+}
+export {
+  exportNodeToPDF,
+  exportNodesToPDF,
+  pdfOptionsFor
+};