@reportwright/viewer 0.12.1 → 0.13.0

package/dist/{chunk-PGP3QA6L.js → chunk-TZXEEVKE.js}

@@ -1,11 +1,13 @@
 import {
   FORMAT_CHAR
-} from "./chunk-ULKEEARQ.js";
+} from "./chunk-EK5CJY22.js";
+import "./chunk-BR5K6SBL.js";
 import {
   asciiUrl,
   drillUrl,
   safeUrl
 } from "./chunk-72S6DETS.js";
+import "./chunk-GJS242RR.js";
 import {
   withDeadline
 } from "./chunk-D2NTLAKL.js";
@@ -18,25 +20,40 @@ import {
   cellVisuals,
   figures,
   parseColor
-} from "./chunk-M6AYND5G.js";
+} from "./chunk-UJL7C2AS.js";
 import {
   IMAGE_LIMITS,
+  PDFArray,
+  PDFBool,
+  PDFDict,
+  PDFDocument,
+  PDFHexString,
+  PDFName,
+  PDFNumber,
+  PDFRawStream,
+  PDFStream,
+  PDFString,
+  concatTransformationMatrix,
   dataUriBytes,
   dataUriBytesOf,
+  embeddedFace,
+  fontCss,
+  fontkit,
   imageInfoOf,
+  isStandard,
+  loadFontkit,
+  loadPdfLib,
+  popGraphicsState,
+  pushGraphicsState,
+  rgb,
   svgLength,
   svgRootAttrs,
   xmlAttrs,
   xmlTags
-} from "./chunk-Z7MKH66Z.js";
+} from "./chunk-QFLVVM3H.js";
 import "./chunk-OLLMACWA.js";
 
-// src/exporters/pdf.js
-import { PDFDocument, PDFName as PDFName3, PDFString as PDFString4, PDFHexString as PDFHexString5, PDFRawStream as PDFRawStream2, rgb as rgb3 } from "pdf-lib";
-import fontkitModule from "@pdf-lib/fontkit";
-
 // src/exporters/pdfa.js
-import { PDFName, PDFNumber, PDFString, PDFHexString, PDFArray, PDFDict } from "pdf-lib";
 var xml = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 function makePdfA(doc, { icc, title = "Report", author, created = /* @__PURE__ */ new Date(), conformance = "B", ua = false, id } = {}) {
   if (!icc?.length) throw new Error("PDF/A needs an sRGB colour profile: pass pdfa.icc (public/icc/sRGB-v2-magic.icc)");
@@ -107,7 +124,6 @@ function setUaMetadata(doc, { title = "Report", author = void 0, created = /* @_
 }
 
 // src/exporters/svgimage.js
-import { pushGraphicsState, popGraphicsState, concatTransformationMatrix, rgb } from "pdf-lib";
 var mul = (a, b) => [a[0] * b[0] + a[2] * b[1], a[1] * b[0] + a[3] * b[1], a[0] * b[2] + a[2] * b[3], a[1] * b[2] + a[3] * b[3], a[0] * b[4] + a[2] * b[5] + a[4], a[1] * b[4] + a[3] * b[5] + a[5]];
 var I = [1, 0, 0, 1, 0, 0];
 var TRANSFORMS = /* @__PURE__ */ new Set(["matrix", "translate", "scale", "rotate", "skewX", "skewY"]);
@@ -264,7 +280,6 @@ function drawSvg(page, svg, at) {
 }
 
 // src/exporters/encrypt.js
-import { PDFArray as PDFArray2, PDFDict as PDFDict2, PDFNumber as PDFNumber2, PDFString as PDFString2, PDFHexString as PDFHexString2, PDFRawStream, PDFStream, PDFBool } from "pdf-lib";
 var subtle = () => {
   const s = globalThis.crypto?.subtle;
   if (!s) throw new Error("PDF encryption needs WebCrypto (a browser, or Node 20 or later)");
@@ -338,12 +353,12 @@ async function encryptPdf(doc, opt) {
   };
   const seen = /* @__PURE__ */ new Set();
   const walk = async (obj) => {
-    if (obj instanceof PDFString2 || obj instanceof PDFHexString2) return PDFHexString2.of(hex(await enc(obj.asBytes())));
-    if (obj instanceof PDFArray2) {
+    if (obj instanceof PDFString || obj instanceof PDFHexString) return PDFHexString.of(hex(await enc(obj.asBytes())));
+    if (obj instanceof PDFArray) {
       for (let i = 0; i < obj.size(); i++) obj.set(i, await walk(obj.get(i)));
       return obj;
     }
-    if (obj instanceof PDFDict2) {
+    if (obj instanceof PDFDict) {
       if (seen.has(obj)) return obj;
       seen.add(obj);
       for (const [k, v] of obj.entries()) obj.set(k, await walk(v));
@@ -368,21 +383,20 @@ async function encryptPdf(doc, opt) {
     CF: { StdCF: { AuthEvent: "DocOpen", CFM: "AESV3", Length: 32 } },
     StmF: "StdCF",
     StrF: "StdCF",
-    O: PDFHexString2.of(hex(O)),
-    U: PDFHexString2.of(hex(U)),
-    OE: PDFHexString2.of(hex(OE)),
-    UE: PDFHexString2.of(hex(UE)),
-    P: PDFNumber2.of(P),
-    Perms: PDFHexString2.of(hex(Perms)),
+    O: PDFHexString.of(hex(O)),
+    U: PDFHexString.of(hex(U)),
+    OE: PDFHexString.of(hex(OE)),
+    UE: PDFHexString.of(hex(UE)),
+    P: PDFNumber.of(P),
+    Perms: PDFHexString.of(hex(Perms)),
     EncryptMetadata: PDFBool.True
   });
   ctx.trailerInfo.Encrypt = ctx.register(encrypt);
-  const id = PDFHexString2.of(hex(random(16)));
+  const id = PDFHexString.of(hex(random(16)));
   ctx.trailerInfo.ID = ctx.obj([id, id]);
 }
 
 // src/exporters/pdfua.js
-import { PDFName as PDFName2, PDFNumber as PDFNumber3, PDFHexString as PDFHexString3, PDFDict as PDFDict3, PDFArray as PDFArray3, PDFString as PDFString3 } from "pdf-lib";
 var MARKER = /^\s*(?:[•◦▪▫‣·○●■□–—-]|\d{1,4}[.)]|[a-zA-Z][.)]|[ivxlcdmIVXLCDM]{1,6}[.)])\s*$/;
 function createTagger(model, doc) {
   const ctx = doc.context;
@@ -412,6 +426,11 @@ function createTagger(model, doc) {
     /** A link annotation of item ii (or a field's widget): its structure element; returns its StructParent key. */
     annot(pi, ii, ref, kind) {
       const p = plans[pi].get(ii);
+      if (p?.link) {
+        p.link.kids.push({ objr: ref, pi });
+        annots.push({ ref, el: p.link, pi });
+        return;
+      }
       const el = node(kind === "field" ? "Form" : "Link");
       (p?.near || root).kids.push(el);
       el.parent = p?.near || root;
@@ -436,14 +455,14 @@ function createTagger(model, doc) {
       let key = 0;
       pages.forEach((pg, pi) => {
         if (!mcids[pi].length) return;
-        pg.node.set(PDFName2.of("StructParents"), PDFNumber3.of(key));
-        nums.push(PDFNumber3.of(key++), ctx.obj(mcids[pi].map((n) => refOf.get(n))));
+        pg.node.set(PDFName.of("StructParents"), PDFNumber.of(key));
+        nums.push(PDFNumber.of(key++), ctx.obj(mcids[pi].map((n) => refOf.get(n))));
       });
       for (const a of annots) {
         const d = ctx.lookup(a.ref);
-        if (d instanceof PDFDict3) d.set(PDFName2.of("StructParent"), PDFNumber3.of(key));
-        nums.push(PDFNumber3.of(key++), refOf.get(a.el));
-        pages[a.pi]?.node.set(PDFName2.of("Tabs"), PDFName2.of("S"));
+        if (d instanceof PDFDict) d.set(PDFName.of("StructParent"), PDFNumber.of(key));
+        nums.push(PDFNumber.of(key++), refOf.get(a.el));
+        pages[a.pi]?.node.set(PDFName.of("Tabs"), PDFName.of("S"));
       }
       const treeRef = ctx.nextRef();
       for (const n of all) {
@@ -451,20 +470,20 @@ function createTagger(model, doc) {
         const K = n.kids.map((k) => {
           if (k.S) return refOf.get(k);
           if (k.objr) return ctx.obj({ Type: "OBJR", Obj: k.objr, Pg: pages[k.pi].ref });
-          return k.pi === pgOf ? PDFNumber3.of(k.mcid) : ctx.obj({ Type: "MCR", Pg: pages[k.pi].ref, MCID: k.mcid });
+          return k.pi === pgOf ? PDFNumber.of(k.mcid) : ctx.obj({ Type: "MCR", Pg: pages[k.pi].ref, MCID: k.mcid });
         });
         const d = ctx.obj({ Type: "StructElem", S: n.S, P: n === root ? treeRef : refOf.get(n.parent || root), K });
-        if (pgOf != null) d.set(PDFName2.of("Pg"), pages[pgOf].ref);
-        if (n.alt != null) d.set(PDFName2.of("Alt"), PDFHexString3.fromText(n.alt));
-        if (n.attrs) d.set(PDFName2.of("A"), ctx.obj(n.attrs));
+        if (pgOf != null) d.set(PDFName.of("Pg"), pages[pgOf].ref);
+        if (n.alt != null) d.set(PDFName.of("Alt"), PDFHexString.fromText(n.alt));
+        if (n.attrs) d.set(PDFName.of("A"), ctx.obj(n.attrs));
         ctx.assign(refOf.get(n), d);
       }
       ctx.assign(treeRef, ctx.obj({ Type: "StructTreeRoot", K: refOf.get(root), ParentTree: ctx.obj({ Nums: nums }), ParentTreeNextKey: key }));
       const cat2 = doc.catalog;
-      cat2.set(PDFName2.of("StructTreeRoot"), treeRef);
-      cat2.set(PDFName2.of("MarkInfo"), ctx.obj({ Marked: true }));
-      cat2.set(PDFName2.of("Lang"), PDFString3.of(String(lang).replace(/[^A-Za-z0-9-]/g, "") || "en"));
-      cat2.set(PDFName2.of("ViewerPreferences"), ctx.obj({ DisplayDocTitle: true }));
+      cat2.set(PDFName.of("StructTreeRoot"), treeRef);
+      cat2.set(PDFName.of("MarkInfo"), ctx.obj({ Marked: true }));
+      cat2.set(PDFName.of("Lang"), PDFString.of(String(lang).replace(/[^A-Za-z0-9-]/g, "") || "en"));
+      cat2.set(PDFName.of("ViewerPreferences"), ctx.obj({ DisplayDocTitle: true }));
       doc.setTitle(title, { showInWindowTitleBar: true });
     }
   };
@@ -516,8 +535,38 @@ function plan(model, pg, pi, root) {
     return el;
   };
   let lastText = null;
+  const tocLink = (e) => {
+    const toc = root.toc || (root.toc = { el: null, last: -1, entries: /* @__PURE__ */ new Map() });
+    if (!toc.el || e < toc.last) {
+      toc.el = add(node("TOC"));
+      toc.entries = /* @__PURE__ */ new Map();
+    }
+    toc.last = Math.max(toc.last, e);
+    let link = toc.entries.get(e);
+    if (!link) {
+      const toci = node("TOCI"), ref = node("Reference");
+      link = node("Link");
+      toci.parent = toc.el;
+      toc.el.kids.push(toci);
+      ref.parent = toci;
+      toci.kids.push(ref);
+      link.parent = ref;
+      ref.kids.push(link);
+      toc.entries.set(e, link);
+    }
+    return link;
+  };
   items.forEach((it, i) => {
     if (it.t === "bookmark") return;
+    if (it.tocEntry != null && (it.t === "text" || it.t === "link") && !it.art) {
+      const link = tocLink(it.tocEntry);
+      out.set(i, it.t === "link" ? { link } : { el: link });
+      return;
+    }
+    if (it.tocTitle && it.t === "text" && it.lines?.length) {
+      out.set(i, { el: add(node("H1")) });
+      return;
+    }
     if (it.t === "link" || it.t === "field") {
       out.set(i, { near: lastText && overlaps(lastText.it, it) ? lastText.el : null });
       return;
@@ -749,8 +798,285 @@ function pngProblem(b) {
   return null;
 }
 
+// src/exporters/pdfstream.js
+import { Zlib } from "fflate";
+
+// src/exporters/pdfstreamtags.js
+function createStreamTagger(w, { maxElements = Infinity } = {}) {
+  let count = 0;
+  const made = () => {
+    if (++count > maxElements) throw Object.assign(new Error(`The tagged PDF has more than ${maxElements.toLocaleString("en-US")} structure elements (tagged.maxElements). Filter the data, or export it untagged.`), { status: 413 });
+  };
+  const rootRef = w.reserve(), docRef = w.reserve();
+  const docKids = [];
+  let table = (
+    /** @type {null | { ref: number, cols: number, rows: Int32Array, n: number }} */
+    null
+  );
+  let headerDone = false;
+  let nums = new Int32Array(1024), nn = 0, key = 0;
+  const num3 = (k, ref) => {
+    if (nn + 2 > nums.length) {
+      const b = new Int32Array(nums.length * 2);
+      b.set(nums);
+      nums = b;
+    }
+    nums[nn++] = k;
+    nums[nn++] = ref;
+  };
+  const addRow = (ref) => {
+    const t = (
+      /** @type {any} */
+      table
+    );
+    if (t.n === t.rows.length) {
+      const b = new Int32Array(t.n * 2);
+      b.set(t.rows);
+      t.rows = b;
+    }
+    t.rows[t.n++] = ref;
+  };
+  let mcids = (
+    /** @type {number[]} */
+    []
+  );
+  let rows = /* @__PURE__ */ new Map();
+  let els = (
+    /** @type {any[]} */
+    []
+  );
+  let last = (
+    /** @type {any} */
+    null
+  );
+  let links = false, win = 0;
+  const el = (S, parent, attrs2) => {
+    made();
+    const e = { ref: w.reserve(), S, parent, mcid: (
+      /** @type {number[]} */
+      []
+    ), kids: (
+      /** @type {any[]} */
+      []
+    ), attrs: attrs2 };
+    els.push(e);
+    return e;
+  };
+  const mark = (e) => {
+    const m = mcids.length;
+    mcids.push(e.ref);
+    e.mcid.push(m);
+    return `/${e.S} <</MCID ${m}>> BDC
+`;
+  };
+  return {
+    /** structure elements so far */
+    get count() {
+      return count;
+    },
+    /** a new page (window: the paged window it came from; row ids are its own) @param {number} window */
+    page(window) {
+      mcids = [];
+      rows = /* @__PURE__ */ new Map();
+      els = [];
+      last = null;
+      links = false;
+      win = window;
+    },
+    /**
+     * The marked content that opens item it: a structure element's MCID, or an artifact; null for a link.
+     * @param {any} it
+     */
+    open(it) {
+      if (it.t === "link" || it.t === "bookmark") return null;
+      if (it.art) return "/Artifact <</Type /Pagination>> BDC\n";
+      if (it.t !== "text" || !it.lines?.some((l) => String(l.text).trim())) return "/Artifact BMC\n";
+      const c = it.cell;
+      if (!c) {
+        const h = it.tag?.h ? Math.min(6, Math.max(1, it.tag.h)) : 0;
+        const e = el(h ? `H${h}` : "P", docRef);
+        docKids.push(e.ref);
+        last = { e, it };
+        return mark(e);
+      }
+      if (c.kind === "header" && headerDone) return "/Artifact <</Type /Pagination>> BDC\n";
+      if (!table) {
+        table = { ref: w.reserve(), cols: c.cols.length, rows: new Int32Array(4096), n: 0 };
+        docKids.push(table.ref);
+      }
+      const rk = `${win}:${c.row}`;
+      let r = rows.get(rk);
+      if (!r) {
+        made();
+        r = { ref: w.reserve(), kind: c.kind, cells: /* @__PURE__ */ new Map() };
+        rows.set(rk, r);
+        addRow(r.ref);
+      }
+      let cell = r.cells.get(c.col);
+      if (!cell) {
+        const attrs2 = c.kind === "header" || c.span > 1 ? { O: "/Table", ...c.kind === "header" ? { Scope: "/Column" } : {}, ...c.span > 1 ? { ColSpan: c.span } : {} } : null;
+        cell = el(c.kind === "header" ? "TH" : "TD", r.ref, attrs2);
+        r.cells.set(c.col, cell);
+      }
+      last = { e: cell, it };
+      return mark(cell);
+    },
+    /**
+     * A link annotation of the page: its Link element (in the element of the text it covers, else the Document).
+     * @returns {number} the annotation's StructParent
+     * @param {any} it @param {number} annot the annotation's object number
+     */
+    link(it, annot) {
+      const near = last && overlaps2(last.it, it) ? last.e : null;
+      const e = el("Link", near ? near.ref : docRef);
+      e.kids.push(`<< /Type /OBJR /Obj ${annot} 0 R >>`);
+      (near ? near.kids : docKids).push(near ? `${e.ref} 0 R` : e.ref);
+      links = true;
+      num3(key, e.ref);
+      return key++;
+    },
+    /**
+     * The page is drawn: its elements and parent-tree array are written. @returns {Promise<string>} the page's entries
+     * @param {number} pageRef
+     */
+    async end(pageRef) {
+      for (const r of rows.values()) {
+        const kids = [];
+        for (let col2 = 0; col2 < /** @type {any} */
+        table.cols; ) {
+          let cell = r.cells.get(col2);
+          if (!cell) {
+            cell = el(r.kind === "header" ? "TH" : "TD", r.ref, r.kind === "header" ? { O: "/Table", Scope: "/Column" } : null);
+          }
+          kids.push(cell.ref);
+          col2 += Math.max(1, cell.attrs?.ColSpan || 1);
+        }
+        for (const [col2, cell] of r.cells) if (!kids.includes(cell.ref)) {
+          void col2;
+          kids.push(cell.ref);
+        }
+        await w.objectAt(r.ref, `<< /S /TR /P ${/** @type {any} */
+        table.ref} 0 R /K [${kids.map((k) => `${k} 0 R`).join(" ")}] >>`);
+      }
+      if (rows.size && [...rows.values()].some((r) => r.kind === "header")) headerDone = true;
+      for (const e of els) {
+        const K = [...e.mcid.map(String), ...e.kids].join(" ");
+        const A = e.attrs ? ` /A << ${Object.entries(e.attrs).map(([k, v]) => `/${k} ${v}`).join(" ")} >>` : "";
+        const P = e.parent === docRef ? docRef : e.parent;
+        await w.objectAt(e.ref, `<< /S /${e.S} /P ${P} 0 R${e.mcid.length || e.S === "Link" ? ` /Pg ${pageRef} 0 R` : ""} /K [${K}]${A} >>`);
+      }
+      let extra = "";
+      if (mcids.length) {
+        const arr = await w.object(`[${mcids.map((r) => `${r} 0 R`).join(" ")}]`);
+        num3(key, arr);
+        extra += ` /StructParents ${key++}`;
+      }
+      if (links) extra += " /Tabs /S";
+      return extra;
+    },
+    /**
+     * The tree's top: Table, Document, the parent tree, the root. @returns {Promise<string>} the catalog's entries
+     * @param {{ lang?: string }} o
+     */
+    async finish({ lang = "en" } = {}) {
+      const t = table;
+      if (t) await w.bigObject(t.ref, `<< /Type /StructElem /S /Table /P ${docRef} 0 R /K [`, refs(t.rows, t.n), "] >>");
+      await w.objectAt(docRef, `<< /Type /StructElem /S /Document /P ${rootRef} 0 R /K [${docKids.map((k) => typeof k === "string" ? k : `${k} 0 R`).join(" ")}] >>`);
+      const pt = w.reserve();
+      await w.bigObject(pt, "<< /Nums [", pairs(nums, nn), "] >>");
+      await w.objectAt(rootRef, `<< /Type /StructTreeRoot /K ${docRef} 0 R /ParentTree ${pt} 0 R /ParentTreeNextKey ${key} >>`);
+      return ` /StructTreeRoot ${rootRef} 0 R /MarkInfo << /Marked true >> /Lang (${String(lang).replace(/[^A-Za-z0-9-]/g, "") || "en"}) /ViewerPreferences << /DisplayDocTitle true >>`;
+    }
+  };
+}
+function* refs(a, n) {
+  for (let i = 0; i < n; i += 4096) {
+    let s = "";
+    for (let j = i; j < Math.min(n, i + 4096); j++) s += `${a[j]} 0 R `;
+    yield s;
+  }
+}
+function* pairs(a, n) {
+  for (let i = 0; i < n; i += 4096) {
+    let s = "";
+    for (let j = i; j < Math.min(n, i + 4096); j += 2) s += `${a[j]} ${a[j + 1]} 0 R `;
+    yield s;
+  }
+}
+function overlaps2(t, l) {
+  const c = t.clip || { x: t.lines[0].x, y: t.lines[0].y - t.size, w: t.lines[0].w || 0, h: t.size * 1.3 };
+  return l.x < c.x + c.w && c.x < l.x + l.w && l.y < c.y + c.h && c.y < l.y + l.h;
+}
+
+// src/exporters/pdfstandard.js
+function standardFontEntries(f) {
+  return {
+    Type: "Font",
+    Subtype: "Type1",
+    BaseFont: f.postscriptName,
+    ...f.winAnsi ? { Encoding: "WinAnsiEncoding" } : {},
+    FirstChar: 32,
+    LastChar: 255,
+    Widths: f.widths.slice(32, 256)
+  };
+}
+function standardFontDict(f) {
+  const e = standardFontEntries(f);
+  return `<< /Type /Font /Subtype /Type1 /BaseFont /${e.BaseFont}${e.Encoding ? ` /Encoding /${e.Encoding}` : ""} /FirstChar 32 /LastChar 255 /Widths [${e.Widths.join(" ")}] >>`;
+}
+var standIns = (store) => [...new Set([...store.fonts.keys()].filter(isStandard).map(embeddedFace))];
+var esc = (b) => b === 40 || b === 41 || b === 92 ? "\\" + String.fromCharCode(b) : b === 13 ? "\\r" : String.fromCharCode(b);
+function standardLiteral(f, text) {
+  let out = "";
+  for (const ch of text) out += esc(f.glyphForCodePoint(
+    /** @type {number} */
+    ch.codePointAt(0)
+  ).id);
+  return out;
+}
+function embeddedPage(pg, fontOf, families) {
+  const line = (l, key, size) => {
+    const runs = l.runs || [{ font: key, x: 0, text: l.text, glyphs: null }];
+    if (!runs.some((r) => isStandard(r.font))) return l;
+    return { ...l, runs: runs.map((r) => {
+      if (!isStandard(r.font)) return r;
+      families.add(fontCss(r.font).family);
+      const std = fontOf(r.font), sub = embeddedFace(r.font), emb = fontOf(sub);
+      const glyphs = [];
+      if (r.glyphs) {
+        for (let i = 0; i < r.glyphs.length; i += 4) glyphs.push(emb.glyphForCodePoint(r.text.codePointAt(r.glyphs[i + 3])).id, r.glyphs[i + 1], r.glyphs[i + 2], r.glyphs[i + 3]);
+        return { ...r, font: sub, glyphs };
+      }
+      let pen = 0;
+      for (let i = 0; i < r.text.length; ) {
+        const cp = (
+          /** @type {number} */
+          r.text.codePointAt(i)
+        );
+        glyphs.push(emb.glyphForCodePoint(cp).id, pen, 0, i);
+        pen += std.glyphForCodePoint(cp).advanceWidth * size / 1e3;
+        i += cp > 65535 ? 2 : 1;
+      }
+      return { ...r, font: sub, w: pen, glyphs };
+    }) };
+  };
+  const item = (it) => {
+    if (it.t === "field") {
+      const draw = it.draw.map(item);
+      return draw.some((d, i) => d !== it.draw[i]) ? { ...it, draw } : it;
+    }
+    if (it.t !== "text") return it;
+    const lines = it.lines.map((l) => line(l, it.font, it.size));
+    return lines.some((l, i) => l !== it.lines[i]) ? { ...it, lines } : it;
+  };
+  const items = pg.items.map(item);
+  return items.some((x, i) => x !== pg.items[i]) ? { ...pg, items } : pg;
+}
+function embeddedWarnings(families) {
+  return [...families].map((f) => `PDF/A and PDF/UA need embedded fonts, and "${f}" is a standard font that is not embedded: its text is drawn in ${fontCss(embeddedFace(f)).family} at ${f}'s spacing (no metric-compatible font ships, so the letters' widths differ).`);
+}
+
 // src/exporters/pdfpaint.js
-import { PDFHexString as PDFHexString4, rgb as rgb2 } from "pdf-lib";
 var colors = /* @__PURE__ */ new Map();
 var col = (c) => {
   if (colors.has(c)) return colors.get(c);
@@ -759,6 +1085,17 @@ var col = (c) => {
   return v;
 };
 var BLACK = { color: rgb2(0, 0, 0), opacity: 1, rgb: "0 0 0" };
+function rgb2(red, green, blue) {
+  return { type: (
+    /** @type {any} */
+    "RGB"
+  ), red, green, blue };
+}
+var hexText = (s) => {
+  let h = "<FEFF";
+  for (let i = 0; i < s.length; i++) h += s.charCodeAt(i).toString(16).toUpperCase().padStart(4, "0");
+  return `${h}>`;
+};
 var n2 = (v) => Math.round(v * 100) / 100;
 var n3 = (v) => Math.round(v * 1e3) / 1e3;
 var n4 = (v) => Math.round(v * 1e4) / 1e4;
@@ -772,7 +1109,7 @@ var formatAt = (run, cl) => {
 function drawRun(c, run, x, y, size, pf, color, spans, texts) {
   const f = pf.embedder.font;
   const per = 1e3 / size;
-  const span = (text) => `/Span <</ActualText ${PDFHexString4.fromText(text).toString()}>> BDC
+  const span = (text) => `/Span <</ActualText ${hexText(text)}>> BDC
 `;
   c.et();
   c.paint(color, null);
@@ -823,7 +1160,7 @@ function drawRun(c, run, x, y, size, pf, color, spans, texts) {
     const adj = Math.round((pen - gx) * per * 1e3) / 1e3;
     if (id === 0 && (c.tagged || formatAt(run, cl))) pen = gx;
     else {
-      arr += (adj ? `${adj}` : "") + `<${hex4(id)}>`;
+      arr += (adj ? `${adj}` : "") + `<${f.standard ? id.toString(16).padStart(2, "0") : hex4(id)}>`;
       pen = gx + adv(id) * size / f.unitsPerEm;
     }
     if (inSpan && (i + 4 >= g.length || (quietAt < 0 || i + 4 < quietAt) && g[i + 7] !== cl || i + 4 === quietAt)) {
@@ -1082,11 +1419,852 @@ async function deflateNow(bytes) {
   return new Uint8Array(await new Response(new Blob([bytes]).stream().pipeThrough(new CompressionStream("deflate"))).arrayBuffer());
 }
 
+// src/exporters/pdfstream.js
+var CHUNK = 64 * 1024;
+var LEAF = 64;
+var OBJSTM = 100;
+var TAGGED_LARGE = 1e6;
+var IN_FLIGHT = 8;
+var hex42 = (id) => id.toString(16).padStart(4, "0");
+var num2 = (v) => String(Math.round(v * 1e3) / 1e3);
+var fontRes = (key) => `F_${key.replace(/[^A-Za-z0-9.-]/g, "_")}`;
+var esc2 = (b) => b === 40 || b === 41 || b === 92 ? "\\" + String.fromCharCode(b) : b === 13 ? "\\r" : String.fromCharCode(b);
+function written(sink, r) {
+  const s = (
+    /** @type {any} */
+    sink
+  );
+  if (r !== false || !s.once) return Promise.resolve(r);
+  return new Promise((ok, fail) => {
+    const off = () => {
+      s.off?.("drain", onDrain);
+      s.off?.("error", onError);
+      s.off?.("close", onClose);
+    };
+    const onDrain = () => {
+      off();
+      ok(void 0);
+    };
+    const onError = (e) => {
+      off();
+      fail(e);
+    };
+    const onClose = () => {
+      off();
+      fail(Object.assign(new Error("The sink closed before the PDF was written"), { code: "ERR_STREAM_PREMATURE_CLOSE" }));
+    };
+    s.once("drain", onDrain);
+    s.once("error", onError);
+    s.once("close", onClose);
+  });
+}
+function raced(p, signal) {
+  if (!signal) return p;
+  if (signal.aborted) {
+    p.catch(() => {
+    });
+    return Promise.reject(signal.reason);
+  }
+  return new Promise((ok, fail) => {
+    const on = () => fail(signal.reason);
+    signal.addEventListener("abort", on, { once: true });
+    p.then((v) => {
+      signal.removeEventListener("abort", on);
+      ok(v);
+    }, (e) => {
+      signal.removeEventListener("abort", on);
+      fail(e);
+    });
+  });
+}
+function createPdfStream(sink, opt) {
+  const { fontStore } = opt;
+  let pos = 0, nextNum = 1;
+  let kind = new Uint8Array(4096), loc = new Uint32Array(4096), idx = new Uint16Array(4096);
+  const place = (n, k, l, i = 0) => {
+    if (n >= kind.length) {
+      let L = kind.length;
+      while (L <= n) L *= 2;
+      const k2 = new Uint8Array(L), l2 = new Uint32Array(L), i2 = new Uint16Array(L);
+      k2.set(kind);
+      l2.set(loc);
+      i2.set(idx);
+      kind = k2;
+      loc = l2;
+      idx = i2;
+    }
+    kind[n] = k;
+    loc[n] = l;
+    idx[n] = i;
+  };
+  let parts = [];
+  let size = 0;
+  const reserve = () => nextNum++;
+  const flush = async () => {
+    if (!size) return;
+    const all = new Uint8Array(size);
+    let at = 0;
+    for (const p of parts) {
+      all.set(p, at);
+      at += p.length;
+    }
+    parts = [];
+    size = 0;
+    await raced(written(sink, sink.write(all)), opt.signal);
+  };
+  const put = (x) => {
+    const u8 = typeof x === "string" ? latin12(x) : x;
+    parts.push(u8);
+    size += u8.length;
+    pos += u8.length;
+    return size >= CHUNK ? flush() : void 0;
+  };
+  let batch = [];
+  const writeBatch = async () => {
+    if (!batch.length) return;
+    const b = batch;
+    batch = [];
+    const sn = reserve();
+    let head = "", body = "";
+    b.forEach(([n, d], i) => {
+      head += `${n} ${body.length} `;
+      body += `${d}
+`;
+      place(n, 2, sn, i);
+    });
+    const raw = latin12(head + body);
+    await writeObj(sn, `<< /Type /ObjStm /N ${b.length} /First ${head.length} /Filter /FlateDecode >>`, await deflate(raw));
+  };
+  const writeObj = async (n, dict, stream) => {
+    if (!stream) {
+      batch.push([n, dict]);
+      place(n, 3, 0);
+      return batch.length >= OBJSTM ? writeBatch() : void 0;
+    }
+    place(n, 1, pos);
+    await put(`${n} 0 obj
+${dict.replace(/>>\s*$/, `/Length ${stream.length} >>`)}
+stream
+`);
+    await put(stream);
+    return put("\nendstream\nendobj\n");
+  };
+  put("%PDF-1.7\n%âãÏÓ\n");
+  const fonts = /* @__PURE__ */ new Map();
+  let pages = 0, done = false;
+  const inFlight = [];
+  const fontOf = (key) => {
+    let f = fonts.get(key);
+    if (!f) {
+      if (done) throw new Error("The PDF is finished");
+      fonts.set(key, f = { name: fontRes(key), ref: reserve(), font: fontStore.get(key), cps: /* @__PURE__ */ new Set([32]), glyphs: /* @__PURE__ */ new Map(), memo: /* @__PURE__ */ new Map(), lit: /* @__PURE__ */ new Map() });
+    }
+    return f;
+  };
+  const resRef = reserve();
+  for (const key of opt.fonts || []) fontOf(key);
+  const res = /* @__PURE__ */ new Map();
+  const totals = [];
+  const pageRefs = [];
+  const leaves = [];
+  const w = {
+    /** @param {string} key @returns {string} the font's resource name (F1…) */
+    fontName: (key) => fontOf(key).name,
+    /**
+     * The text's glyphs, one per character (as the engine measured it: no layout features), as hex for <…> Tj, with
+     * the glyphs recorded for the subset, W and ToUnicode.
+     * @param {string} key @param {string} text
+     */
+    encode(key, text) {
+      const F = fontOf(key);
+      let out = "";
+      for (const ch of text) {
+        const cp = (
+          /** @type {number} */
+          ch.codePointAt(0)
+        );
+        let h = F.memo.get(cp);
+        if (h === void 0) {
+          const id = F.font.glyphForCodePoint(cp).id;
+          F.memo.set(cp, h = F.font.standard ? id.toString(16).padStart(2, "0") : hex42(id));
+          F.cps.add(cp);
+          if (!F.glyphs.has(id)) F.glyphs.set(id, ch);
+        }
+        out += h;
+      }
+      return out;
+    },
+    /**
+     * The same glyphs as a literal string's body, two bytes each, escaped (as pdf.js draws plain text): ( … ) Tj.
+     * @param {string} key @param {string} text
+     */
+    literal(key, text) {
+      const F = fontOf(key);
+      let out = "";
+      for (const ch of text) {
+        const cp = (
+          /** @type {number} */
+          ch.codePointAt(0)
+        );
+        let b = F.lit.get(cp);
+        if (b === void 0) {
+          const id = parseInt(w.encode(key, ch), 16);
+          F.lit.set(cp, b = F.font.standard ? esc2(id) : esc2(id >> 8) + esc2(id & 255));
+        }
+        out += b;
+      }
+      return out;
+    },
+    /**
+     * Shaped glyphs drawn by ID (conjuncts, joined forms): [glyph ID, the text it stands for ('' for none)].
+     * @param {string} key @param {Iterable<[number, string]>} glyphs
+     */
+    addGlyphs(key, glyphs) {
+      const F = fontOf(key);
+      for (const [id, text] of glyphs) if (!F.glyphs.has(id)) F.glyphs.set(id, text);
+    },
+    /**
+     * A name in the shared Resources dictionary for a value (an indirect ref "12 0 R" or an inline dictionary).
+     * @param {'ExtGState'|'XObject'|'Pattern'|'Shading'|'ColorSpace'} kind @param {string} value
+     */
+    resource(kind2, value, name = void 0) {
+      let m = res.get(kind2);
+      if (!m) res.set(kind2, m = /* @__PURE__ */ new Map());
+      let n = m.get(value);
+      if (!n) m.set(value, n = name || `${kind2 === "ExtGState" ? "GS" : kind2[0]}${m.size + 1}`);
+      return n;
+    },
+    /**
+     * The ExtGState name for fill and stroke opacity, named by its values (the same name in every writer: pages
+     * painted elsewhere, parallel.js, use it too). @param {number} ca @param {number} CA
+     */
+    gs: (ca, CA) => w.resource("ExtGState", `<< /Type /ExtGState /ca ${num2(ca)} /CA ${num2(CA)} >>`, `GS${num2(ca)}_${num2(CA)}`),
+    /** What this writer's pages used, for another writer to take over (pages painted elsewhere). */
+    used: () => ({ fonts: [...fonts].map(([key, F]) => [key, [...F.cps], [...F.glyphs]]), gs: [...res.get("ExtGState")?.keys() || []] }),
+    /** Take over what pages painted elsewhere used (used() of their writer). @param {any} u */
+    take(u) {
+      for (const [key, cps, glyphs] of u.fonts) {
+        const F = fontOf(key);
+        for (const cp of cps) F.cps.add(cp);
+        for (const [id, t] of glyphs) if (!F.glyphs.has(id)) F.glyphs.set(id, t);
+      }
+      for (const v of u.gs) {
+        const m = (
+          /** @type {any} */
+          v.match(/\/ca (\S+) \/CA (\S+)/)
+        );
+        w.gs(Number(m[1]), Number(m[2]));
+      }
+    },
+    /**
+     * Write an object now (an image: its dictionary and its stream, already filtered). @returns {Promise<number>} its number
+     * @param {string} dict @param {Uint8Array} [stream]
+     */
+    async object(dict, stream) {
+      const n = reserve();
+      await writeObj(n, dict, stream);
+      return n;
+    },
+    /** An object number to write later (objectAt). */
+    reserve: () => reserve(),
+    /** Write a reserved object. @param {number} n @param {string} dict @param {Uint8Array} [stream] */
+    objectAt: (n, dict, stream) => writeObj(n, dict, stream),
+    /**
+     * Write a reserved object whose text may be long (an array of every row's element): head, the parts as they come,
+     * tail; written out in place, never held whole. @param {number} n @param {string} head @param {Iterable<string>} parts @param {string} tail
+     */
+    async bigObject(n, head, parts2, tail) {
+      place(n, 1, pos);
+      await put(`${n} 0 obj
+${head}`);
+      for (const x of parts2) await put(x);
+      await put(`${tail}
+endobj
+`);
+    },
+    /** The object number of page i (0-based), written or not: links and outline entries may point ahead. @param {number} i */
+    pageRef(i) {
+      return pageRefs[i] ?? (pageRefs[i] = reserve());
+    },
+    /**
+     * The total page count, drawn at the end: a Form XObject whose origin is the text's baseline at the box's left;
+     * draw it with `q 1 0 0 1 x y cm /<name> Do Q`. align: within width.
+     * @param {{ font: string, size: number, width: number, align?: 'left'|'center'|'right', color?: string }} o
+     */
+    totalPages(o) {
+      fontOf(o.font);
+      const ref = reserve();
+      totals.push({ ref, font: o.font, size: o.size, width: o.width, align: o.align || "left", color: o.color || "0 0 0" });
+      return w.resource("XObject", `${ref} 0 R`);
+    },
+    /**
+     * Write a page: its content stream (deflated) and its dictionary, now. Nothing of it stays but two offsets.
+     * @param {{ width: number, height: number, content?: string | Uint8Array, deflated?: Uint8Array, annots?: (string | { ref: number, dict: string })[], extra?: string }} p
+     *   deflated: the content stream already compressed (zlib), as pages painted elsewhere come.
+     *   content: the page's operators (a string holds bytes 0–255, as pdf.js's Content makes). annots: annotation
+     *   dictionaries (with a reserved number: { ref, dict }). extra: more entries for the page dictionary (/StructParents 3).
+     */
+    async addPage(p) {
+      if (done) throw new Error("The PDF is finished");
+      const i = pages++;
+      const ref = w.pageRef(i);
+      if (i % LEAF === 0) leaves.push(reserve());
+      const contents = reserve(), parent = leaves[leaves.length - 1];
+      const z = p.deflated ? Promise.resolve(p.deflated) : deflate(typeof p.content === "string" ? latin12(p.content) : p.content);
+      z.catch(() => {
+      });
+      inFlight.push({ ref, contents, parent, p: { width: p.width, height: p.height, annots: p.annots, extra: p.extra }, z });
+      while (inFlight.length > IN_FLIGHT) await writeNext();
+    },
+    /**
+     * The end of the file: totals, fonts, resources, page tree, outline, catalog, Info, xref, trailer.
+     * @param {{ outline?: OutlineEntry[], info?: { title?: string, author?: string, subject?: string, creationDate?: Date }, catalog?: string }} [o]
+     *   catalog: more entries for the catalog (the structure tree, metadata, output intents).
+     * @returns {Promise<{ pages: number, bytes: number }>}
+     */
+    async finish(o = {}) {
+      if (done) throw new Error("The PDF is finished");
+      if (!pages) await w.addPage({ width: 595.28, height: 841.89, content: "" });
+      while (inFlight.length) await writeNext();
+      done = true;
+      for (const t of totals) {
+        const F = fontOf(t.font), text = String(pages), hex2 = w.encode(t.font, text);
+        let adv = 0;
+        for (const ch of text) adv += F.font.glyphForCodePoint(
+          /** @type {number} */
+          ch.codePointAt(0)
+        ).advanceWidth;
+        const tw = adv * t.size / F.font.unitsPerEm;
+        const dx = t.align === "right" ? t.width - tw : t.align === "center" ? (t.width - tw) / 2 : 0;
+        await writeObj(
+          t.ref,
+          `<< /Type /XObject /Subtype /Form /BBox [${num2(Math.min(0, dx))} ${num2(-t.size)} ${num2(Math.max(t.width, dx + tw))} ${num2(2 * t.size)}] /Resources << /Font << /${F.name} ${F.ref} 0 R >> >> /Filter /FlateDecode >>`,
+          await deflate(latin12(`${t.color} rg BT /${F.name} ${num2(t.size)} Tf ${num2(dx)} 0 Td <${hex2}> Tj ET`))
+        );
+      }
+      const fontDict = [];
+      for (const [key, F] of fonts) {
+        if (F.glyphs.size) {
+          await writeFont(key, F);
+          fontDict.push(`/${F.name} ${F.ref} 0 R`);
+        }
+      }
+      let resDict = `<< /ProcSet [/PDF /Text /ImageB /ImageC /ImageI] /Font << ${fontDict.join(" ")} >>`;
+      for (const [kind2, m] of res) resDict += ` /${kind2} << ${[...m].map(([v, n]) => `/${n} ${v}`).join(" ")} >>`;
+      await writeObj(resRef, resDict + " >>");
+      let level = leaves.map((ref, k) => ({ ref, kids: pageRefs.slice(k * LEAF, Math.min(pages, (k + 1) * LEAF)), count: Math.min(LEAF, pages - k * LEAF) }));
+      while (level.length > 1) {
+        const up = [];
+        for (let k = 0; k < level.length; k += LEAF) {
+          const kids = level.slice(k, k + LEAF);
+          up.push({ ref: reserve(), kids: kids.map((x) => x.ref), count: kids.reduce((s, x) => s + x.count, 0), below: kids });
+        }
+        for (const node2 of up) for (const kid of node2.below) kid.parent = node2.ref;
+        await writeNodes(level);
+        level = /** @type {any} */
+        up;
+      }
+      await writeNodes(level);
+      const pagesRoot = level[0].ref;
+      const outline = await writeOutline(o.outline || []);
+      const catalog = reserve();
+      await writeObj(catalog, `<< /Type /Catalog /Pages ${pagesRoot} 0 R /PageLabels << /Nums [0 << /S /D /St 1 >>] >>${outline ? ` /Outlines ${outline} 0 R /PageMode /UseOutlines` : ""}${o.catalog || ""} >>`);
+      const info = reserve(), I2 = o.info || {};
+      await writeObj(info, `<< /Producer ${pdfText("ReportWright")} /Creator ${pdfText("ReportWright")} /Title ${pdfText(I2.title || "Report")}${I2.author ? ` /Author ${pdfText(I2.author)}` : ""}${I2.subject ? ` /Subject ${pdfText(I2.subject)}` : ""} /CreationDate ${pdfDate(I2.creationDate || /* @__PURE__ */ new Date())} /ModDate ${pdfDate(I2.creationDate || /* @__PURE__ */ new Date())} >>`);
+      for (let n = 1; n < nextNum; n++) if (n >= kind.length || !kind[n]) await writeObj(n, "null");
+      await writeBatch();
+      const xn = reserve(), size2 = nextNum, xref = pos;
+      place(xn, 1, xref);
+      const out = (
+        /** @type {Uint8Array[]} */
+        []
+      );
+      const zs = new Zlib({ level: 6 }, (d) => {
+        out.push(d);
+      });
+      const prev = new Uint8Array(7), row = new Uint8Array(7);
+      for (let from = 0; from < size2; from += 65536) {
+        const to = Math.min(size2, from + 65536), rows = new Uint8Array((to - from) * 8);
+        for (let n = from; n < to; n++) {
+          row.fill(0);
+          const l = loc[n];
+          if (n === 0) {
+            row[5] = 255;
+            row[6] = 255;
+          } else {
+            row[0] = kind[n];
+            row[1] = l >>> 24 & 255;
+            row[2] = l >>> 16 & 255;
+            row[3] = l >>> 8 & 255;
+            row[4] = l & 255;
+            if (kind[n] === 2) {
+              row[5] = idx[n] >> 8;
+              row[6] = idx[n] & 255;
+            }
+          }
+          const at = (n - from) * 8;
+          rows[at] = 2;
+          for (let b = 0; b < 7; b++) {
+            rows[at + 1 + b] = row[b] - prev[b] & 255;
+            prev[b] = row[b];
+          }
+        }
+        zs.push(rows, to === size2);
+      }
+      let zn = 0;
+      for (const c of out) zn += c.length;
+      const z = new Uint8Array(zn);
+      zn = 0;
+      for (const c of out) {
+        z.set(c, zn);
+        zn += c.length;
+      }
+      const id = opt.id || [...globalThis.crypto.getRandomValues(new Uint8Array(16))].map((b) => b.toString(16).padStart(2, "0")).join("");
+      await put(`${xn} 0 obj
+<< /Type /XRef /Size ${size2} /W [1 4 2] /DecodeParms << /Columns 7 /Predictor 12 >> /Root ${catalog} 0 R /Info ${info} 0 R /ID [<${id}> <${id}>] /Filter /FlateDecode /Length ${z.length} >>
+stream
+`);
+      await put(z);
+      await put(`
+endstream
+endobj
+startxref
+${xref}
+%%EOF
+`);
+      await flush();
+      return { pages, bytes: pos };
+    }
+  };
+  async function writeNext() {
+    const { ref, contents, parent, p, z } = (
+      /** @type {any} */
+      inFlight.shift()
+    );
+    await writeObj(contents, "<< /Filter /FlateDecode >>", await z);
+    const annots = [];
+    for (const a of p.annots || []) annots.push(typeof a === "string" ? await w.object(a) : (await writeObj(a.ref, a.dict), a.ref));
+    await writeObj(ref, `<< /Type /Page /Parent ${parent} 0 R /MediaBox [0 0 ${num2(p.width)} ${num2(p.height)}] /Resources ${resRef} 0 R /Contents ${contents} 0 R${annots.length ? ` /Annots [${annots.map((a) => `${a} 0 R`).join(" ")}]` : ""}${p.extra || ""} >>`);
+  }
+  async function writeNodes(nodes) {
+    for (const n of nodes) await writeObj(n.ref, `<< /Type /Pages${n.parent ? ` /Parent ${n.parent} 0 R` : ""} /Kids [${n.kids.map((k) => `${k} 0 R`).join(" ")}] /Count ${n.count} >>`);
+  }
+  async function writeFont(key, F) {
+    if (F.font.standard) {
+      await writeObj(F.ref, standardFontDict(F.font));
+      return;
+    }
+    await loadFontkit();
+    const f = F.font, full = (
+      /** @type {Uint8Array} */
+      fontStore.bytes.get(key)
+    );
+    let bytes = full;
+    if (opt.subset && !f["OS/2"]?.fsType?.noSubsetting) {
+      try {
+        const sub = await opt.subset(full, F.cps, { glyphs: F.glyphs.keys() });
+        const padded = new Uint8Array(sub.length + 16);
+        padded.set(sub);
+        const check = fontkit.create(padded);
+        for (const id of F.glyphs.keys()) void check.getGlyph(id).advanceWidth;
+        bytes = sub;
+      } catch {
+      }
+    }
+    const cff = "CFF " in f.directory.tables || "CFF2" in f.directory.tables;
+    const base = `${bytes === full ? "" : `${subsetTag(bytes)}+`}${String(f.postscriptName || "Font").replace(/[^A-Za-z0-9_.-]/g, "")}`;
+    const k = 1e3 / f.unitsPerEm, s = (v) => String(v * k);
+    const desc = reserve(), file = reserve(), cid = reserve(), cmap = reserve();
+    const fileDict = cff ? "<< /Subtype /OpenType /Filter /FlateDecode >>" : `<< /Length1 ${bytes.length} /Filter /FlateDecode >>`;
+    await writeObj(file, fileDict, await deflate(bytes));
+    const bb = f.bbox, italic = f.italicAngle || 0;
+    const flags = (f.post?.isFixedPitch ? 1 : 0) | 4 | (italic ? 64 : 0);
+    await writeObj(desc, `<< /Type /FontDescriptor /FontName /${base} /Flags ${flags} /FontBBox [${s(bb.minX)} ${s(bb.minY)} ${s(bb.maxX)} ${s(bb.maxY)}] /ItalicAngle ${num2(italic)} /Ascent ${s(f.ascent)} /Descent ${s(f.descent)} /CapHeight ${s(f.capHeight || f.ascent)} /XHeight ${s(f.xHeight || 0)} /StemV 0 /${cff ? "FontFile3" : "FontFile2"} ${file} 0 R >>`);
+    const ids = [...F.glyphs.keys()].sort((a, b) => a - b);
+    let W = "";
+    for (let i = 0; i < ids.length; ) {
+      let j = i;
+      while (j + 1 < ids.length && ids[j + 1] === ids[j] + 1) j++;
+      W += `${ids[i]} [${ids.slice(i, j + 1).map((id) => s(f.getGlyph(id).advanceWidth)).join(" ")}] `;
+      i = j + 1;
+    }
+    await writeObj(cid, `<< /Type /Font /Subtype /${cff ? "CIDFontType0" : "CIDFontType2"} /BaseFont /${base} /CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> /FontDescriptor ${desc} 0 R /W [${W}]${cff ? "" : " /CIDToGIDMap /Identity"} >>`);
+    await writeObj(cmap, "<< /Filter /FlateDecode >>", await deflate(latin12(toUnicode(F.glyphs))));
+    await writeObj(F.ref, `<< /Type /Font /Subtype /Type0 /BaseFont /${base} /Encoding /Identity-H /DescendantFonts [${cid} 0 R] /ToUnicode ${cmap} 0 R >>`);
+  }
+  async function writeOutline(entries) {
+    const root = { ref: 0, level: -1, kids: [] };
+    const stack = [root];
+    for (const e of entries) {
+      if (!(e.page >= 1 && e.page <= pages)) continue;
+      const level = Math.max(0, Math.min(9, Number(e.level) || 0));
+      while (stack[stack.length - 1].level >= level) stack.pop();
+      const node2 = { ref: reserve(), level, kids: [], title: e.title, dest: `[${pageRefs[e.page - 1]} 0 R ${e.top == null ? "/Fit" : `/XYZ null ${num2(e.top)} null`}]` };
+      stack[stack.length - 1].kids.push(node2);
+      stack.push(node2);
+    }
+    if (!root.kids.length) return 0;
+    root.ref = reserve();
+    const count = (n) => n.kids.reduce((t, c) => t + 1 + count(c), 0);
+    const children = (n) => n.kids.length ? ` /First ${n.kids[0].ref} 0 R /Last ${n.kids[n.kids.length - 1].ref} 0 R /Count ${count(n)}` : "";
+    const write = async (n) => {
+      for (let i = 0; i < n.kids.length; i++) {
+        const c = n.kids[i];
+        await writeObj(c.ref, `<< /Title ${pdfText(c.title)} /Parent ${n.ref} 0 R /Dest ${c.dest}${i ? ` /Prev ${n.kids[i - 1].ref} 0 R` : ""}${i < n.kids.length - 1 ? ` /Next ${n.kids[i + 1].ref} 0 R` : ""}${children(c)} >>`);
+        await write(c);
+      }
+    };
+    await write(root);
+    await writeObj(root.ref, `<< /Type /Outlines${children(root)} >>`);
+    return root.ref;
+  }
+  return w;
+}
+function toUnicode(glyphs) {
+  const entries = [...glyphs].filter(([, t]) => t).sort((a, b) => a[0] - b[0]);
+  let body = "";
+  for (let i = 0; i < entries.length; i += 100) {
+    const chunk = entries.slice(i, i + 100);
+    body += `${chunk.length} beginbfchar
+${chunk.map(([id, t]) => `<${hex42(id)}> <${utf16(t)}>`).join("\n")}
+endbfchar
+`;
+  }
+  return `/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
+${body}endcmap
+CMapName currentdict /CMap defineresource pop
+end
+end
+`;
+}
+var utf16 = (t) => {
+  let h = "";
+  for (let i = 0; i < t.length; i++) h += hex42(t.charCodeAt(i));
+  return h;
+};
+var pdfText = (t) => `<feff${utf16(String(t ?? ""))}>`;
+var pdfDate = (d) => `(D:${d.toISOString().replace(/\D/g, "").slice(0, 14)}+00'00')`;
+function subsetTag(bytes) {
+  let h = 2166136261;
+  for (let i = 0; i < bytes.length; i++) h = Math.imul(h ^ bytes[i], 16777619);
+  let tag = "";
+  for (let i = 0; i < 6; i++) {
+    tag += String.fromCharCode(65 + (h >>> 0) % 26);
+    h = Math.imul(h ^ i, 16777619) >>> 0;
+  }
+  return tag;
+}
+function latin12(s) {
+  const B = (
+    /** @type {any} */
+    globalThis.Buffer
+  );
+  if (B) return B.from(s, "latin1");
+  const out = new Uint8Array(s.length);
+  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i);
+  return out;
+}
+async function writePagedPdf(plan2, opts, sink) {
+  const { fontStore } = opts;
+  if (opts.pdfa || opts.tagged) await fontStore.load(standIns(fontStore));
+  const w = createPdfStream(sink, { fontStore, subset: opts.subset, id: opts.id, signal: opts.signal });
+  const { info, pages } = (
+    /** @type {any} */
+    plan2
+  );
+  const tags = opts.tagged ? createStreamTagger(w, { maxElements: Number(opts.tagged.maxElements) || Infinity }) : null;
+  const env = paintEnv(w, fontStore, { drillBase: opts.drillBase, tags, embedAll: !!(opts.pdfa || tags) });
+  const { shaped } = env;
+  const pool = !tags && Number(opts.parallel) > 1 ? paintPool(Number(opts.parallel), fontStore, opts, info) : null;
+  let pi = -1;
+  const it = pages(pool ? { run: pool.run, parallel: pool.size } : {})[Symbol.asyncIterator]();
+  let pending = false;
+  try {
+    for (; ; ) {
+      opts.signal?.throwIfAborted();
+      pending = true;
+      const x = await raced(it.next(), opts.signal);
+      pending = false;
+      if (x.done) break;
+      const pg = x.value;
+      pi++;
+      const H = pg.height ?? info.height;
+      if (pg.deflated) {
+        for (const f of pg.embedded || []) env.embedded?.add(f);
+        if (pg.used) {
+          w.take(pg.used);
+          for (const [k, g] of pg.shaped) {
+            const m = env.shapedOf(k);
+            for (const [id, t] of g) if (!m.has(id)) m.set(id, t);
+          }
+        }
+        const annots2 = pg.annots.map((a) => a.replace(/@@P(\d+)@@/g, (_, i) => String(w.pageRef(Number(i)))));
+        await w.addPage({ width: pg.width ?? info.width, height: H, deflated: pg.deflated, annots: annots2 });
+        continue;
+      }
+      const { content, annots } = paintPage(pg, H, env);
+      await w.addPage({ width: pg.width ?? info.width, height: H, content, annots, extra: tags ? await tags.end(w.pageRef(pi)) : void 0 });
+    }
+  } finally {
+    if (pending) it.return?.(void 0)?.catch(() => {
+    });
+    else await it.return?.(void 0);
+    await pool?.close();
+  }
+  for (const [key, g] of shaped) w.addGlyphs(key, g);
+  const seen = /* @__PURE__ */ new Set();
+  const outline = [...info.bookmarks, ...info.headings].map((b, i) => ({ b, i })).sort((p, q) => p.b.page - q.b.page || (p.b.y ?? 0) - (q.b.y ?? 0) || p.i - q.i).map(({ b }) => b).filter((b) => {
+    const k = `${b.page}|${Math.round(b.y ?? 0)}|${b.label}`;
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  }).map((b) => ({ title: b.label, page: b.page, top: info.height - b.y + 4, level: b.level }));
+  const title = opts.title || "Report", when = new Date(Math.floor((opts.creationDate || /* @__PURE__ */ new Date()).getTime() / 1e3) * 1e3);
+  let catalog = tags ? await tags.finish({ lang: opts.tagged.lang }) : "";
+  if (opts.pdfa || tags) {
+    const xmp = new TextEncoder().encode(xmpPacket({ title, author: opts.author, stamp: when.toISOString().replace(".000Z", "Z"), pdfa: opts.pdfa ? tags ? "A" : "B" : null, ua: !!tags }));
+    catalog += ` /Metadata ${await w.object("<< /Type /Metadata /Subtype /XML >>", xmp)} 0 R`;
+  }
+  if (opts.pdfa) {
+    const icc = await w.object("<< /N 3 /Filter /FlateDecode >>", await deflate(opts.pdfa.icc));
+    catalog += ` /OutputIntents [${await w.object(`<< /Type /OutputIntent /S /GTS_PDFA1 /OutputConditionIdentifier (sRGB) /Info (sRGB IEC61966-2.1) /DestOutputProfile ${icc} 0 R >>`)} 0 R]`;
+  }
+  const res = await w.finish({ outline, catalog, info: { title, author: opts.author, creationDate: when } });
+  for (const x of env.embedded ? embeddedWarnings(env.embedded) : []) info.warnings.push(x);
+  if (tags && tags.count > TAGGED_LARGE) info.warnings.push(`The tagged PDF has ${tags.count.toLocaleString("en-US")} structure elements (${res.pages.toLocaleString("en-US")} pages): readers open it, but tools that load every object of a file (qpdf, pikepdf) may run out of memory on it. tagged.maxElements caps it.`);
+  return { pages: res.pages, warnings: info.warnings };
+}
+var lit = (v) => `(${String(v).replace(/[\\()]/g, "\\$&")})`;
+function coveredText(items, box) {
+  const lines = [];
+  for (const t of items) if (t.t === "text" && t.lines) {
+    for (const l of t.lines) if (l.text?.trim() && l.x >= box.x && l.x <= box.x + box.w && l.y >= box.y && l.y <= box.y + box.h) lines.push(l);
+  }
+  return lines.sort((a, b) => a.y - b.y || a.x - b.x).map((l) => l.text.trim()).join(" ");
+}
+function paintPage(pg, H, env) {
+  if (env.embedded) pg = embeddedPage(pg, env.font, env.embedded);
+  const annots = [];
+  const c = new Content(env.shared);
+  const { tags } = env;
+  if (tags) {
+    c.tagged = true;
+    c.artLines = true;
+    tags.page(pg.win ?? 0);
+  }
+  for (const it of pg.items) {
+    const mark = tags && it.t !== "line" && tags.open(it);
+    const inText = mark && it.t === "text" && !it.rotate && it.lines.every((l) => !l.runs) && !(it.clip && !insideClip(it, env.vmetrics(it.font)));
+    if (inText) {
+      if (!c.bt) {
+        c._s += "BT\n";
+        c.bt = true;
+        c.tx = 0;
+        c.ty = 0;
+      }
+      c._s += mark;
+    } else if (mark) {
+      c.et();
+      c.s += mark;
+    }
+    if (it.t !== "text" && it.t !== "line" || it.rotate) c.et();
+    if (it.rotate) {
+      const t = -it.rotate.a * Math.PI / 180, cs = Math.cos(t), sn = Math.sin(t);
+      const px = it.rotate.cx, py = H - it.rotate.cy;
+      c.q();
+      c.s += `${n4(cs)} ${n4(sn)} ${n4(-sn)} ${n4(cs)} ${n2(px - px * cs + py * sn)} ${n2(py - px * sn - py * cs)} cm
+`;
+    }
+    switch (it.t) {
+      case "rect": {
+        const fill = col(it.fill), stroke = col(it.stroke);
+        if (!fill && !stroke) break;
+        if (it.radius) throw new Error("rounded boxes do not stream yet");
+        c.paint(fill, stroke, it.strokeWidth || 1, it.dash);
+        const x = n2(it.x), y = n2(H - it.y - it.h), rw = n2(it.w), rh = n2(it.h);
+        c.s += (stroke && it.dash?.length ? `${x} ${y} m ${x} ${n2(y + rh)} l ${n2(x + rw)} ${n2(y + rh)} l ${n2(x + rw)} ${y} l h` : `${x} ${y} ${rw} ${rh} re`) + (fill && stroke ? " B\n" : fill ? " f\n" : " S\n");
+        break;
+      }
+      case "ellipse": {
+        const fill = col(it.fill), stroke = col(it.stroke);
+        if (!fill && !stroke) break;
+        c.paint(fill, stroke, it.strokeWidth || 1, it.dash);
+        const cx = it.cx, cy = H - it.cy, rx = it.rx, ry = it.ry, ox = rx * KAPPA, oy = ry * KAPPA;
+        c.s += `${n2(cx - rx)} ${n2(cy)} m ${n2(cx - rx)} ${n2(cy - oy)} ${n2(cx - ox)} ${n2(cy - ry)} ${n2(cx)} ${n2(cy - ry)} c ${n2(cx + ox)} ${n2(cy - ry)} ${n2(cx + rx)} ${n2(cy - oy)} ${n2(cx + rx)} ${n2(cy)} c ${n2(cx + rx)} ${n2(cy + oy)} ${n2(cx + ox)} ${n2(cy + ry)} ${n2(cx)} ${n2(cy + ry)} c ${n2(cx - ox)} ${n2(cy + ry)} ${n2(cx - rx)} ${n2(cy + oy)} ${n2(cx - rx)} ${n2(cy)} c h ${fill &&
+        stroke ? "B" : fill ? "f" : "S"}
+`;
+        break;
+      }
+      case "line": {
+        const st = col(it.stroke);
+        if (st) c.line(st, it.strokeWidth || 1, it.dash, it.x1, H - it.y1, it.x2, H - it.y2);
+        break;
+      }
+      case "text": {
+        const color = col(it.color) || BLACK;
+        const clipped = it.clip && !insideClip(it, env.vmetrics(it.font));
+        if (clipped) {
+          c.q();
+          c.s += `${n2(it.clip.x)} ${n2(H - it.clip.y - it.clip.h)} ${n2(it.clip.w)} ${n2(it.clip.h)} re W n
+`;
+        }
+        for (const l of it.lines) {
+          if (!l.runs) {
+            c.text(env.pf(it.font), it.size, color, l.x, H - l.y, env.literal(it.font, cleanText(l.text)));
+            continue;
+          }
+          for (const r of l.runs) {
+            const g = env.shapedOf(r.font), spans = /* @__PURE__ */ new WeakMap();
+            glyphText(r, env.font(r.font), g, spans);
+            if (r.text.trim()) drawRun(c, r, l.x + r.x, H - l.y, it.size, env.pf(r.font), color, spans.get(r), g);
+          }
+        }
+        if (clipped) c.Q();
+        break;
+      }
+      case "link": {
+        const rect = `[${[it.x, H - it.y - it.h, it.x + it.w, H - it.y].map(n2).join(" ")}]`;
+        const a = it.action;
+        const href = a?.type === "url" && safeUrl(a.href) ? a.href : a?.type === "drill" ? drillUrl(env.drillBase, a) : null;
+        const to = href ? `/A << /Type /Action /S /URI /URI ${lit(asciiUrl(href))} >>` : a?.type === "bookmark" && a.page ? `/Dest [${env.pageRef(a.page - 1)} 0 R /XYZ null ${n2(H - a.y + 4)} null]` : null;
+        if (!to) break;
+        if (!tags) {
+          annots.push(`<< /Type /Annot /Subtype /Link /F 4 /Rect ${rect} /Border [0 0 0] ${to} >>`);
+          break;
+        }
+        const ref = env.reserve(), key = tags.link(it, ref);
+        const say = coveredText(pg.items, it) || it.tip || href || (a.target ? `Go to ${a.target}` : `Go to page ${a.page}`);
+        annots.push({ ref, dict: `<< /Type /Annot /Subtype /Link /F 4 /Rect ${rect} /Border [0 0 0] ${to} /Contents ${pdfText(say)} /StructParent ${key} >>` });
+        break;
+      }
+      default:
+        throw new Error(`A ${it.t} item does not stream yet`);
+    }
+    if (it.rotate) c.Q();
+    if (inText) c._s += "EMC\n";
+    else if (mark) {
+      c.et();
+      c.s += "EMC\n";
+    }
+  }
+  c.et();
+  return { content: c.s, annots };
+}
+function paintEnv(w, fontStore, o = {}) {
+  const pfs = /* @__PURE__ */ new Map();
+  const shaped = /* @__PURE__ */ new Map();
+  const vm = /* @__PURE__ */ new Map();
+  return {
+    shared: { font: (f) => w.fontName(f.key), gs: (ca, CA) => w.gs(ca, CA), image: () => {
+      throw new Error("images do not stream yet");
+    } },
+    pf: (key) => {
+      let f = pfs.get(key);
+      if (!f) pfs.set(key, f = { key, embedder: { font: fontStore.get(key) } });
+      return f;
+    },
+    font: (key) => fontStore.get(key),
+    shaped,
+    shapedOf: (key) => {
+      let g = shaped.get(key);
+      if (!g) shaped.set(key, g = /* @__PURE__ */ new Map());
+      return g;
+    },
+    vmetrics: (key) => {
+      let m = vm.get(key);
+      if (!m) {
+        const f = fontStore.get(key), u = f?.unitsPerEm || 1e3;
+        vm.set(key, m = { asc: (f?.ascent ?? u) / u, desc: -(f?.descent ?? 0) / u });
+      }
+      return m;
+    },
+    literal: (key, text) => w.literal(key, text),
+    pageRef: o.pageRef || ((i) => w.pageRef(i)),
+    reserve: () => w.reserve(),
+    drillBase: o.drillBase,
+    tags: o.tags || null,
+    /** PDF/A, PDF/UA: standard fonts drawn in embedded stand-ins; the families that were @type {Set<string>|null} */
+    embedded: o.embedAll ? /* @__PURE__ */ new Set() : null
+  };
+}
+function paintPool(size, fontStore, opts, info) {
+  const wt = (
+    /** @type {any} */
+    globalThis.process?.getBuiltinModule?.("node:worker_threads")
+  );
+  if (!wt) return null;
+  let workers = [];
+  let seq = 0, turn = 0;
+  const waiting = /* @__PURE__ */ new Map();
+  const clean = (r) => {
+    if (!r) return r;
+    const { __i, ...o } = r;
+    return o;
+  };
+  const start = async () => {
+    const fonts = [...fontStore.bytes];
+    if (fontStore.shaper) fonts.push(["harfbuzz", await fontStore.loader("harfbuzz")]);
+    workers = Array.from({ length: size }, () => {
+      const w = new wt.Worker(new URL("./pdfstreamworker.js", import.meta.url), { workerData: { fonts } });
+      w.on("message", (m) => {
+        const p = waiting.get(m.id);
+        waiting.delete(m.id);
+        if (m.error) p.fail(Object.assign(new Error(m.error.message), { status: m.error.status, timeout: m.error.timeout }));
+        else p.ok(m);
+      });
+      w.on("error", (e) => {
+        for (const p of waiting.values()) p.fail(e);
+        waiting.clear();
+      });
+      return w;
+    });
+  };
+  let started = null;
+  const pick = ["parameters", "now", "timeZone", "state", "target", "deadline", "timeoutMs"];
+  return {
+    size,
+    /** @param {any} job */
+    async run(job) {
+      await (started || (started = start()));
+      const id = ++seq;
+      const pw = job.pageWindow;
+      const msg = {
+        id,
+        def: job.def,
+        rows: job.rows.map(clean),
+        keep: job.keep,
+        drillBase: opts.drillBase,
+        embedAll: !!opts.pdfa,
+        height: info.height,
+        opts: Object.fromEntries(pick.filter((k) => opts[k] !== void 0).map((k) => [k, opts[k]])),
+        pageWindow: { ...pw, first: clean(pw.first), cont: pw.cont.map((c) => c && { first: clean(c.first), before: c.before }) }
+      };
+      const r = await new Promise((ok, fail) => {
+        waiting.set(id, { ok, fail });
+        workers[turn++ % workers.length].postMessage(msg);
+      });
+      if (r.pages.length) {
+        r.pages[0].used = r.used;
+        r.pages[0].shaped = r.shaped;
+        r.pages[0].embedded = r.embedded;
+      }
+      return r;
+    },
+    async close() {
+      await Promise.all(workers.map((w) => w.terminate()));
+    }
+  };
+}
+
 // src/exporters/pdf.js
-var fontkit = (
-  /** @type {any} */
-  fontkitModule.default || fontkitModule
-);
 function exportPdf(model, fontStore, opt = {}) {
   return withDeadline(
     pdfOf(model, fontStore, opt),
@@ -1095,6 +2273,8 @@ function exportPdf(model, fontStore, opt = {}) {
   );
 }
 async function pdfOf(model, fontStore, opt) {
+  if (ownWriterFits(model, opt)) return ownWriter(model, fontStore, opt);
+  await loadPdfLib();
   const fixed = fixedDate(opt);
   const when = fixed ?? /* @__PURE__ */ new Date();
   const fileId = fixed ? await contentId(model, opt, when) : void 0;
@@ -1105,7 +2285,13 @@ async function pdfOf(model, fontStore, opt) {
   doc.setCreator("ReportWright");
   if (opt.author) doc.setAuthor(opt.author);
   setInfoDates(doc, when);
-  if (fileId) doc.context.trailerInfo.ID = doc.context.obj([PDFHexString5.of(fileId), PDFHexString5.of(fileId)]);
+  if (fileId) doc.context.trailerInfo.ID = doc.context.obj([PDFHexString.of(fileId), PDFHexString.of(fileId)]);
+  if (opt.pdfa || opt.tagged || model.pages.some((pg) => pg.items.some((i) => i.t === "field"))) await fontStore.load(standIns(fontStore));
+  if (opt.pdfa || opt.tagged) {
+    const families = /* @__PURE__ */ new Set();
+    model = { ...model, pages: model.pages.map((pg) => embeddedPage(pg, (k) => fontStore.get(k), families)) };
+    for (const w of embeddedWarnings(families)) opt.onWarning?.(w);
+  }
   const used = /* @__PURE__ */ new Map();
   const shaped = /* @__PURE__ */ new Map();
   const spans = /* @__PURE__ */ new WeakMap();
@@ -1146,6 +2332,13 @@ async function pdfOf(model, fontStore, opt) {
   for (const pg of model.pages) for (const it of pg.items) if (it.t === "field") fieldFonts.add(fieldFont(it));
   const fonts = /* @__PURE__ */ new Map();
   const font = async (key) => {
+    if (!fonts.has(key) && isStandard(key)) {
+      const f = fontStore.get(key);
+      fonts.set(key, { ref: doc.context.register(doc.context.obj(
+        /** @type {any} */
+        standardFontEntries(f)
+      )), embedder: { font: f, literalOf: (t) => standardLiteral(f, t), tjOf: () => null } });
+    }
     if (!fonts.has(key)) {
       const full = fontStore.bytes.get(key);
       let bytes = full;
@@ -1162,14 +2355,14 @@ async function pdfOf(model, fontStore, opt) {
         } catch {
         }
       }
-      const pf = await doc.embedFont(bytes, { subset: false, customName: bytes === full ? void 0 : `${subsetTag(bytes)}+${fontStore.get(key).postscriptName || "Font"}` });
+      const pf = await doc.embedFont(bytes, { subset: false, customName: bytes === full ? void 0 : `${subsetTag2(bytes)}+${fontStore.get(key).postscriptName || "Font"}` });
       plainEncoding(pf);
       if (glyphs) addGlyphs(pf, glyphs, !!opt.tagged);
       const file = bytes, e = (
         /** @type {any} */
         pf.embedder
       );
-      if (!e.isCFF()) e.embedFontStream = async (c) => c.register(PDFRawStream2.of(c.obj({ Filter: "FlateDecode", Length1: file.length }), await deflate(file)));
+      if (!e.isCFF()) e.embedFontStream = async (c) => c.register(PDFRawStream.of(c.obj({ Filter: "FlateDecode", Length1: file.length }), await deflate(file)));
       fonts.set(key, pf);
     }
     return fonts.get(key);
@@ -1210,7 +2403,7 @@ async function pdfOf(model, fontStore, opt) {
     if (!n) {
       n = `${kind[0]}${names.size + 1}`;
       names.set(key, n);
-      res.get(PDFName3.of(kind)).set(PDFName3.of(n), value());
+      res.get(PDFName.of(kind)).set(PDFName.of(n), value());
     }
     return n;
   };
@@ -1245,7 +2438,7 @@ async function pdfOf(model, fontStore, opt) {
     const H = pg.height ?? model.height;
     const p = doc.addPage([pg.width ?? model.width, H]);
     p.node.normalize();
-    p.node.set(PDFName3.of("Resources"), resRef);
+    p.node.set(PDFName.of("Resources"), resRef);
     const c = new Content(shared);
     if (tags) c.tagged = true;
     p.maybeEmbedGraphicsState = (o) => c.gsFor(o.opacity ?? 1, o.borderOpacity ?? 1);
@@ -1352,7 +2545,7 @@ async function pdfOf(model, fontStore, opt) {
           const form = doc.getForm();
           const f = await font(fieldFont(it));
           const name = uniqueName(it.name);
-          const box = { x: it.x, y: H - it.y - it.h, width: it.w, height: it.h, borderColor: rgb3(0.61, 0.64, 0.69), borderWidth: 0.75, backgroundColor: rgb3(1, 1, 1) };
+          const box = { x: it.x, y: H - it.y - it.h, width: it.w, height: it.h, borderColor: rgb(0.61, 0.64, 0.69), borderWidth: 0.75, backgroundColor: rgb(1, 1, 1) };
           let field;
           if (it.kind === "checkbox") {
             field = form.createCheckBox(name);
@@ -1409,7 +2602,8 @@ async function pdfOf(model, fontStore, opt) {
           if (it.required) field.enableRequired();
           if (it.readOnly) field.enableReadOnly();
           if (tags) {
-            field.acroField.dict.set(PDFName3.of("TU"), PDFHexString5.fromText(it.label || it.name || name));
+            if (!it.label) opt.onWarning?.(`Form field "${name}" has no label, so a screen reader announces its name; give it a label`);
+            field.acroField.dict.set(PDFName.of("TU"), PDFHexString.fromText(it.label || it.name || name));
             const w = field.acroField.getWidgets()[0];
             const ref2 = w && doc.context.getObjectRef(w.dict);
             if (ref2) tags.annot(pi, ii, ref2, "field");
@@ -1418,7 +2612,7 @@ async function pdfOf(model, fontStore, opt) {
         }
         case "link": {
           const rect = [it.x, H - it.y - it.h, it.x + it.w, H - it.y];
-          const text = tags ? coveredText(pg.items, it) : "";
+          const text = tags ? coveredText2(pg.items, it) : "";
           if (it.action?.type === "url" && safeUrl(it.action.href)) links.push({ page: p, rect, href: it.action.href, pi, ii, tip: it.tip, text });
           else if (it.action?.type === "drill") {
             const href = drillUrl(opt.drillBase, it.action);
@@ -1471,24 +2665,24 @@ async function pdfOf(model, fontStore, opt) {
     );
     if (own) ctx.delete(own);
     const ref = ctx.nextRef();
-    p.node.set(PDFName3.of("Contents"), ref);
-    contents.push(deflate(latin1(c.s)).then((z) => ctx.assign(ref, PDFRawStream2.of(ctx.obj({ Filter: "FlateDecode" }), z))));
+    p.node.set(PDFName.of("Contents"), ref);
+    contents.push(deflate(latin1(c.s)).then((z) => ctx.assign(ref, PDFRawStream.of(ctx.obj({ Filter: "FlateDecode" }), z))));
     if (NODE_ZLIB && contents.length > 8) await contents[contents.length - 9];
   }
   await Promise.all(contents);
   const pageH = (n) => model.pages[n - 1]?.height ?? model.height;
   const pages = doc.getPages();
-  const dest = (b) => pages[b.page - 1] && [pages[b.page - 1].ref, PDFName3.of("XYZ"), null, pageH(b.page) - b.y + 4, null];
+  const dest = (b) => pages[b.page - 1] && [pages[b.page - 1].ref, PDFName.of("XYZ"), null, pageH(b.page) - b.y + 4, null];
   for (const l of links) {
     const to = l.href ? { A: { Type: "Action", S: "URI", URI: pdfLiteral(asciiUrl(l.href)) } } : { Dest: dest(l.to) };
     if (!l.href && !to.Dest) continue;
     const annot = doc.context.obj({ Type: "Annot", Subtype: "Link", F: 4, Rect: l.rect, Border: [0, 0, 0], ...to });
-    if (tags) annot.set(PDFName3.of("Contents"), PDFHexString5.fromText(String(l.text || l.tip || l.href || "Link")));
+    if (tags) annot.set(PDFName.of("Contents"), PDFHexString.fromText(String(l.text || l.tip || l.href || "Link")));
     const ref = doc.context.register(annot);
     if (tags) tags.annot(l.pi, l.ii, ref, "link");
-    const annots = l.page.node.lookup(PDFName3.of("Annots"));
+    const annots = l.page.node.lookup(PDFName.of("Annots"));
     if (annots) annots.push(ref);
-    else l.page.node.set(PDFName3.of("Annots"), doc.context.obj([ref]));
+    else l.page.node.set(PDFName.of("Annots"), doc.context.obj([ref]));
   }
   const marks = outlineEntries(model);
   if (marks.length) addOutline(doc, marks, dest);
@@ -1505,7 +2699,44 @@ async function pdfOf(model, fontStore, opt) {
   }
   return doc.save({ updateFieldAppearances: false, ...opt.save || {} });
 }
-function coveredText(items, box) {
+function ownWriterFits(model, opt) {
+  if (opt.pdfa || opt.tagged || opt.encrypt || opt.prepare || opt.save || !model.pages.length) return false;
+  if ((model.pageStarts || []).some((i) => i > 0)) return false;
+  for (const pg of model.pages) {
+    if ((pg.height ?? model.height) !== model.height) return false;
+    for (const it of pg.items) {
+      if (it.t === "text") {
+        if (!isStandard(it.font) || it.lines.some((l) => l.runs)) return false;
+      } else if (it.t === "link") {
+        const a = it.action;
+        if (a?.type === "bookmark" && !(a.page >= 1 && a.page <= model.pages.length)) return false;
+      } else if (!(it.t === "line" || it.t === "ellipse" || it.t === "rect" && !it.radius)) return false;
+    }
+  }
+  return true;
+}
+async function ownWriter(model, fontStore, opt) {
+  const fixed = fixedDate(opt), when = fixed ?? /* @__PURE__ */ new Date();
+  const parts = [];
+  const info = { width: model.width, height: model.height, bookmarks: model.bookmarks || [], headings: model.headings || [], warnings: [] };
+  await writePagedPdf(
+    { info, pages: async function* () {
+      yield* model.pages;
+    } },
+    { fontStore, subset: opt.subset, id: fixed ? await contentId(model, opt, when) : void 0, title: opt.title, author: opt.author, creationDate: when, drillBase: opt.drillBase },
+    { write: (u8) => {
+      parts.push(u8);
+    } }
+  );
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let at = 0;
+  for (const p of parts) {
+    out.set(p, at);
+    at += p.length;
+  }
+  return out;
+}
+function coveredText2(items, box) {
   const lines = [];
   for (const t of items) if (t.t === "text" && t.lines) {
     for (const l of t.lines) if (l.text?.trim() && l.x >= box.x && l.x <= box.x + box.w && l.y >= box.y && l.y <= box.y + box.h) lines.push(l);
@@ -1527,11 +2758,11 @@ async function contentId(model, opt, when) {
 }
 function fieldFont(it) {
   for (const d of it.draw) if (d.t === "text") {
-    for (const l of d.lines) for (const r of l.runs || []) if (r.font !== it.font && r.text.trim()) return r.font;
+    for (const l of d.lines) for (const r of l.runs || []) if (r.font !== it.font && r.text.trim()) return embeddedFace(r.font);
   }
-  return it.font;
+  return embeddedFace(it.font);
 }
-var pdfLiteral = (s) => PDFString4.of(String(s).replace(/[\\()]/g, "\\$&"));
+var pdfLiteral = (s) => PDFString.of(String(s).replace(/[\\()]/g, "\\$&"));
 function plainEncoding(pf) {
   const e = pf.embedder, f = e.font, memo = /* @__PURE__ */ new Map();
   e.hexOf = (text) => {
@@ -1547,7 +2778,7 @@ function plainEncoding(pf) {
     }
     return hex2;
   };
-  e.encodeText = (text) => PDFHexString5.of(e.hexOf(text));
+  e.encodeText = (text) => PDFHexString.of(e.hexOf(text));
   e.widthOfTextAtSize = (text, size) => {
     let w = 0;
     for (const ch of text) w += f.glyphForCodePoint(
@@ -1556,8 +2787,8 @@ function plainEncoding(pf) {
     ).advanceWidth || 0;
     return w * size / f.unitsPerEm;
   };
-  const lit = /* @__PURE__ */ new Map();
-  const esc = (b) => b === 40 || b === 41 || b === 92 ? "\\" + String.fromCharCode(b) : b === 13 ? "\\r" : String.fromCharCode(b);
+  const lit2 = /* @__PURE__ */ new Map();
+  const esc3 = (b) => b === 40 || b === 41 || b === 92 ? "\\" + String.fromCharCode(b) : b === 13 ? "\\r" : String.fromCharCode(b);
   e.tjOf = (text) => {
     let out = "", cur = "", any = false;
     for (const ch of text) {
@@ -1583,10 +2814,10 @@ function plainEncoding(pf) {
         /** @type {number} */
         ch.codePointAt(0)
       );
-      let b = lit.get(cp);
+      let b = lit2.get(cp);
       if (b === void 0) {
         const id = f.glyphForCodePoint(cp).id;
-        lit.set(cp, b = esc(id >> 8) + esc(id & 255));
+        lit2.set(cp, b = esc3(id >> 8) + esc3(id & 255));
       }
       out += b;
     }
@@ -1624,7 +2855,7 @@ function pageLabels(doc, model) {
   const starts = [.../* @__PURE__ */ new Set([0, ...model.pageStarts || []])].filter((i) => i >= 0 && i < n).sort((a, b) => a - b);
   const ctx = doc.context;
   const nums = starts.flatMap((i) => [i, ctx.obj({ S: "D", St: 1 })]);
-  doc.catalog.set(PDFName3.of("PageLabels"), ctx.obj({ Nums: nums }));
+  doc.catalog.set(PDFName.of("PageLabels"), ctx.obj({ Nums: nums }));
 }
 function addOutline(doc, bookmarks, dest) {
   const ctx = doc.context;
@@ -1638,7 +2869,7 @@ function addOutline(doc, bookmarks, dest) {
     if (!Dest) continue;
     const level = Math.max(0, Math.min(9, Number(b.level) || 0));
     while (stack[stack.length - 1].level >= level) stack.pop();
-    const node2 = { ref: ctx.nextRef(), level, kids: [], Title: PDFHexString5.fromText(b.label), Dest };
+    const node2 = { ref: ctx.nextRef(), level, kids: [], Title: PDFHexString.fromText(b.label), Dest };
     stack[stack.length - 1].kids.push(node2);
     stack.push(node2);
   }
@@ -1651,15 +2882,15 @@ function addOutline(doc, bookmarks, dest) {
   });
   write(root);
   ctx.assign(root.ref, ctx.obj({ Type: "Outlines", ...children(root) }));
-  doc.catalog.set(PDFName3.of("Outlines"), root.ref);
-  doc.catalog.set(PDFName3.of("PageMode"), PDFName3.of("UseOutlines"));
+  doc.catalog.set(PDFName.of("Outlines"), root.ref);
+  doc.catalog.set(PDFName.of("PageMode"), PDFName.of("UseOutlines"));
 }
 function withPadding(font) {
   const out = new Uint8Array(font.length + 16);
   out.set(font);
   return out;
 }
-function subsetTag(bytes) {
+function subsetTag2(bytes) {
   let h = 2166136261;
   for (let i = 0; i < bytes.length; i++) h = Math.imul(h ^ bytes[i], 16777619);
   let tag = "";
@@ -1676,4 +2907,4 @@ function roundRect(x, y, w, h, r) {
 export {
   exportPdf
 };
-//# sourceMappingURL=chunk-PGP3QA6L.js.map
+//# sourceMappingURL=chunk-TZXEEVKE.js.map