@taloswork/ose-shared 0.1.11 → 0.1.13

package/skills/document/bin/deck-qa.cjs

@@ -9790,9 +9790,9 @@ var require_load = __commonJS({
 var require_lib3 = __commonJS({
   "node_modules/jszip/lib/index.js"(exports2, module2) {
     "use strict";
-    function JSZip5() {
-      if (!(this instanceof JSZip5)) {
-        return new JSZip5();
+    function JSZip7() {
+      if (!(this instanceof JSZip7)) {
+        return new JSZip7();
       }
       if (arguments.length) {
         throw new Error("The constructor with parameters has been removed in JSZip 3.0, please check the upgrade guide.");
@@ -9801,7 +9801,7 @@ var require_lib3 = __commonJS({
       this.comment = null;
       this.root = "";
       this.clone = function() {
-        var newObj = new JSZip5();
+        var newObj = new JSZip7();
         for (var i in this) {
           if (typeof this[i] !== "function") {
             newObj[i] = this[i];
@@ -9810,16 +9810,411 @@ var require_lib3 = __commonJS({
         return newObj;
       };
     }
-    JSZip5.prototype = require_object();
-    JSZip5.prototype.loadAsync = require_load();
-    JSZip5.support = require_support();
-    JSZip5.defaults = require_defaults();
-    JSZip5.version = "3.10.1";
-    JSZip5.loadAsync = function(content, options) {
-      return new JSZip5().loadAsync(content, options);
+    JSZip7.prototype = require_object();
+    JSZip7.prototype.loadAsync = require_load();
+    JSZip7.support = require_support();
+    JSZip7.defaults = require_defaults();
+    JSZip7.version = "3.10.1";
+    JSZip7.loadAsync = function(content, options) {
+      return new JSZip7().loadAsync(content, options);
     };
-    JSZip5.external = require_external();
-    module2.exports = JSZip5;
+    JSZip7.external = require_external();
+    module2.exports = JSZip7;
+  }
+});
+
+// packages/core/dist/document/pdf-encrypted.js
+var ENCRYPTED_PDF_MESSAGE, PdfEncryptedError;
+var init_pdf_encrypted = __esm({
+  "packages/core/dist/document/pdf-encrypted.js"() {
+    "use strict";
+    ENCRYPTED_PDF_MESSAGE = "PDF is password-protected (encrypted); decrypt first: pdf-ops decrypt <in> <password> <out>";
+    PdfEncryptedError = class extends Error {
+      constructor() {
+        super(ENCRYPTED_PDF_MESSAGE);
+        this.name = "PdfEncryptedError";
+      }
+    };
+  }
+});
+
+// packages/core/dist/document/pdf-extract.js
+var pdf_extract_exports = {};
+__export(pdf_extract_exports, {
+  analyzePdfDocument: () => analyzePdfDocument,
+  countVectorOperators: () => countVectorOperators,
+  decryptPdf: () => decryptPdf,
+  encryptPdf: () => encryptPdf,
+  extractPdfImages: () => extractPdfImages,
+  extractPdfTables: () => extractPdfTables,
+  extractPdfText: () => extractPdfText,
+  extractPdfTextLines: () => extractPdfTextLines,
+  pdfNeedsPassword: () => pdfNeedsPassword,
+  pngPixels: () => pngPixels,
+  renderPdfPages: () => renderPdfPages,
+  scanPdfSignals: () => scanPdfSignals,
+  textMathHint: () => textMathHint,
+  textTableHint: () => textTableHint
+});
+function loadMupdf() {
+  if (!_mupdf) {
+    const deps = process.env.TALOS_SKILL_DEPS;
+    const spec = deps ? (0, import_node_url.pathToFileURL)((0, import_node_path.join)(deps, "mupdf", "dist", "mupdf.js")).href : "mupdf";
+    _mupdf = import(spec);
+  }
+  return _mupdf;
+}
+function textMathHint(text) {
+  if (!text)
+    return false;
+  const hits = (text.match(MATH_CHARS) || []).length;
+  return hits >= 3 || hits / Math.max(text.length, 1) > 0.02;
+}
+function textTableHint(text) {
+  if (!text)
+    return false;
+  const gaps = (text.match(/ {2,}|\t/g) || []).length;
+  return gaps >= 6;
+}
+async function openDoc(bytes) {
+  const mupdf = await loadMupdf();
+  const doc = mupdf.Document.openDocument(bytes, "application/pdf");
+  if (doc.needsPassword())
+    throw new PdfEncryptedError();
+  if (doc.countPages() === 0) {
+    throw new Error("PDF has no readable pages (corrupt, encrypted, or empty)");
+  }
+  return { mupdf, doc };
+}
+async function analyzePdfDocument(bytes, options = {}) {
+  const wantText = options.text !== false;
+  const wantSignals = options.signals === true;
+  const { doc } = await openDoc(bytes);
+  const pageCount = doc.countPages();
+  const signals = [];
+  let out = "";
+  for (let i = 0; i < pageCount; i++) {
+    const page = doc.loadPage(i);
+    if (wantText) {
+      out += `
+[page ${i + 1}]
+${page.toStructuredText().asText()}`;
+    }
+    if (wantSignals) {
+      signals.push(pageSignalsFrom(page, i + 1));
+    }
+  }
+  return { text: wantText ? out.trim() : "", pageCount, signals };
+}
+async function extractPdfText(bytes) {
+  const { text, pageCount } = await analyzePdfDocument(bytes, { text: true });
+  return { text, pageCount };
+}
+function countVectorOperators(content) {
+  let ops = 0;
+  let curves = 0;
+  let fills = 0;
+  let i = 0;
+  const n = content.length;
+  while (i < n) {
+    const ch = content[i];
+    if (ch === "(") {
+      let depth = 1;
+      i++;
+      while (i < n && depth > 0) {
+        if (content[i] === "\\")
+          i++;
+        else if (content[i] === "(")
+          depth++;
+        else if (content[i] === ")")
+          depth--;
+        i++;
+      }
+      continue;
+    }
+    if (ch === "<" && content[i + 1] !== "<") {
+      while (i < n && content[i] !== ">")
+        i++;
+      i++;
+      continue;
+    }
+    if (ch === "I" && content[i + 1] === "D" && isDelimiter(content[i + 2])) {
+      const end = content.indexOf("EI", i + 2);
+      i = end === -1 ? n : end + 2;
+      continue;
+    }
+    if (!isDelimiter(ch)) {
+      const start = i;
+      while (i < n && !isDelimiter(content[i]))
+        i++;
+      const token = content.slice(start, i);
+      switch (token) {
+        case "m":
+        case "l":
+        case "re":
+          ops++;
+          break;
+        case "c":
+        case "v":
+        case "y":
+          ops++;
+          curves++;
+          break;
+        case "f":
+        case "F":
+        case "f*":
+          fills++;
+          break;
+        case "B":
+        case "B*":
+        case "b":
+        case "b*":
+          fills++;
+          break;
+        default:
+          break;
+      }
+      continue;
+    }
+    i++;
+  }
+  return { ops, curves, fills };
+}
+function isDelimiter(ch) {
+  return ch === void 0 || ch === " " || ch === "\n" || ch === "\r" || ch === "	" || ch === "\f" || ch === "\0" || ch === "[" || ch === "]" || ch === "/" || ch === "{" || ch === "}";
+}
+function pageContentStream(page) {
+  try {
+    const obj = page.getObject?.();
+    const contents = obj?.get?.("Contents");
+    if (!contents)
+      return "";
+    const streams = contents.isArray?.() && contents.get ? Array.from({ length: contents.length ?? 0 }, (_, i) => contents.get(i)) : [contents];
+    let out = "";
+    for (const stream of streams) {
+      const buf = stream?.readStream?.();
+      const bytes = buf?.asUint8Array?.();
+      if (bytes)
+        out += Buffer.from(bytes).toString("latin1");
+    }
+    return out;
+  } catch {
+    return "";
+  }
+}
+function pageSignalsFrom(page, pageNumber) {
+  const json = JSON.parse(page.toStructuredText("preserve-images").asJSON());
+  const blocks = json.blocks ?? [];
+  const text = blocks.flatMap((b) => (b.lines ?? []).map((l) => l.text ?? "")).join(" ");
+  const [x0, y0, x1, y1] = page.getBounds();
+  const pageArea = Math.max((x1 - x0) * (y1 - y0), 1);
+  const imgArea = blocks.filter((b) => b.type === "image").reduce((a, b) => a + Math.max((b.bbox?.w ?? 0) * (b.bbox?.h ?? 0), 0), 0);
+  const vector = countVectorOperators(pageContentStream(page));
+  return {
+    page: pageNumber,
+    textChars: text.trim().length,
+    imageCoverage: Math.min(imgArea / pageArea, 1),
+    vectorOps: vector.ops,
+    vectorCurves: vector.curves,
+    vectorFills: vector.fills,
+    mathHint: textMathHint(text),
+    tableHint: textTableHint(text)
+  };
+}
+async function scanPdfSignals(bytes) {
+  const { signals } = await analyzePdfDocument(bytes, { text: false, signals: true });
+  return signals;
+}
+function median(nums) {
+  if (!nums.length)
+    return 0;
+  const s = [...nums].sort((a, b) => a - b);
+  return s[Math.floor(s.length / 2)];
+}
+async function extractPdfTables(bytes, pageNum, minColumns = 2) {
+  const { doc } = await openDoc(bytes);
+  const total = doc.countPages();
+  const from = pageNum ? pageNum : 1;
+  const to = pageNum ? pageNum : total;
+  const out = [];
+  for (let p = from; p <= to; p++) {
+    if (p < 1 || p > total)
+      continue;
+    const json = JSON.parse(doc.loadPage(p - 1).toStructuredText().asJSON());
+    const cells = [];
+    for (const b of json.blocks ?? []) {
+      if (b.type === "image")
+        continue;
+      for (const l of b.lines ?? []) {
+        const text = (l.text ?? "").trim();
+        if (!text)
+          continue;
+        cells.push({ text, x: l.bbox?.x ?? 0, y: l.bbox?.y ?? 0, h: l.bbox?.h ?? 12 });
+      }
+    }
+    if (cells.length < 2)
+      continue;
+    const medH = median(cells.map((c) => c.h)) || 12;
+    const rowTol = Math.max(4, medH * 0.6);
+    const colTol = Math.max(6, medH * 0.9);
+    const byY = [...cells].sort((a, b) => a.y - b.y);
+    const rowGroups = [];
+    let rowRef = Number.NEGATIVE_INFINITY;
+    for (const c of byY) {
+      if (c.y - rowRef > rowTol) {
+        rowGroups.push([]);
+        rowRef = c.y;
+      }
+      rowGroups[rowGroups.length - 1].push(c);
+    }
+    const colRefs = [];
+    for (const x of cells.map((c) => c.x).sort((a, b) => a - b)) {
+      if (!colRefs.length || x - colRefs[colRefs.length - 1] > colTol)
+        colRefs.push(x);
+    }
+    const colIndex = (x) => {
+      let best = 0, bd = Infinity;
+      colRefs.forEach((r, i) => {
+        const d = Math.abs(x - r);
+        if (d < bd) {
+          bd = d;
+          best = i;
+        }
+      });
+      return best;
+    };
+    const rows = [];
+    for (const group of rowGroups) {
+      const arr = Array(colRefs.length).fill("");
+      for (const c of group.sort((a, b) => a.x - b.x)) {
+        const i = colIndex(c.x);
+        arr[i] = arr[i] ? `${arr[i]} ${c.text}` : c.text;
+      }
+      if (arr.filter((v) => v).length >= minColumns)
+        rows.push(arr);
+    }
+    if (rows.length)
+      out.push({ page: p, rows });
+  }
+  return out;
+}
+async function extractPdfTextLines(bytes) {
+  const { doc } = await openDoc(bytes);
+  const out = [];
+  for (let p = 1; p <= doc.countPages(); p++) {
+    const page = doc.loadPage(p - 1);
+    const [x0, y0, x1, y1] = page.getBounds();
+    const json = JSON.parse(page.toStructuredText().asJSON());
+    const lines = [];
+    for (const b of json.blocks ?? []) {
+      if (b.type === "image")
+        continue;
+      for (const l of b.lines ?? []) {
+        const text = l.text ?? "";
+        if (!text.trim() || !l.bbox)
+          continue;
+        lines.push({
+          x: l.bbox.x ?? 0,
+          y: l.bbox.y ?? 0,
+          w: l.bbox.w ?? 0,
+          h: l.bbox.h ?? 0,
+          size: l.font?.size ?? 12,
+          text
+        });
+      }
+    }
+    out.push({ page: p, width: x1 - x0, height: y1 - y0, lines });
+  }
+  return out;
+}
+async function renderPdfPages(bytes, pages, scale = 2, maxEdge) {
+  const { mupdf, doc } = await openDoc(bytes);
+  const total = doc.countPages();
+  const wanted = pages === "all" ? Array.from({ length: total }, (_, i) => i + 1) : pages;
+  const out = [];
+  for (const p of wanted) {
+    if (p < 1 || p > total)
+      continue;
+    const page = doc.loadPage(p - 1);
+    const [x0, y0, x1, y1] = page.getBounds();
+    const longest = Math.max(x1 - x0, y1 - y0);
+    const s = maxEdge && longest > 0 ? Math.min(scale, maxEdge / longest) : scale;
+    const pix = page.toPixmap(mupdf.Matrix.scale(s, s), mupdf.ColorSpace.DeviceRGB, false, true);
+    out.push({ page: p, png: pix.asPNG() });
+  }
+  return out;
+}
+async function pngPixels(png) {
+  const mupdf = await loadMupdf();
+  const pix = new mupdf.Image(png).toPixmap();
+  const width = pix.getWidth(), height = pix.getHeight();
+  const channels = pix.getStride() / width;
+  return { width, height, channels, data: pix.getPixels() };
+}
+async function extractPdfImages(bytes, pages) {
+  const { doc } = await openDoc(bytes);
+  const total = doc.countPages();
+  const wanted = pages && pages.length ? pages : Array.from({ length: total }, (_, i) => i + 1);
+  const images = [];
+  let skipped = 0;
+  for (const p of wanted) {
+    if (p < 1 || p > total)
+      continue;
+    const stext = doc.loadPage(p - 1).toStructuredText("preserve-images");
+    let index = 0;
+    stext.walk({
+      onImageBlock(bbox, _matrix, image) {
+        const slot = index++;
+        try {
+          const png = image.toPixmap().asPNG();
+          images.push({
+            page: p,
+            index: slot,
+            bbox: [bbox[0], bbox[1], bbox[2], bbox[3]],
+            width: image.getWidth(),
+            height: image.getHeight(),
+            png
+          });
+        } catch {
+          skipped++;
+        }
+      }
+    });
+  }
+  return { images, skipped };
+}
+async function encryptPdf(bytes, userPassword, ownerPassword) {
+  if (!userPassword)
+    throw new Error("a non-empty user password is required");
+  const { doc } = await openDoc(bytes);
+  const opts = `encrypt=aes-256,user-password=${userPassword},owner-password=${ownerPassword || userPassword}`;
+  return doc.saveToBuffer(opts).asUint8Array();
+}
+async function pdfNeedsPassword(bytes) {
+  const mupdf = await loadMupdf();
+  const doc = mupdf.Document.openDocument(bytes, "application/pdf");
+  return doc.needsPassword();
+}
+async function decryptPdf(bytes, password) {
+  const mupdf = await loadMupdf();
+  const doc = mupdf.Document.openDocument(bytes, "application/pdf");
+  if (doc.needsPassword()) {
+    if (doc.authenticatePassword(password) === 0)
+      throw new Error("wrong password");
+  }
+  if (doc.countPages() === 0)
+    throw new Error("PDF has no readable pages (corrupt or empty)");
+  return doc.saveToBuffer("encrypt=none").asUint8Array();
+}
+var import_node_path, import_node_url, _mupdf, MATH_CHARS;
+var init_pdf_extract = __esm({
+  "packages/core/dist/document/pdf-extract.js"() {
+    "use strict";
+    import_node_path = require("node:path");
+    import_node_url = require("node:url");
+    init_pdf_encrypted();
+    _mupdf = null;
+    MATH_CHARS = /[=∑∫√≤≥≠±∞πθλμσΩ×÷∂∇→←↔∈∉⊂⊃∀∃]/g;
   }
 });
 
@@ -12239,11 +12634,11 @@ var require_PDFName = __commonJS({
     };
     var ENFORCER = {};
     var pool = /* @__PURE__ */ new Map();
-    var PDFName = (
+    var PDFName2 = (
       /** @class */
       (function(_super) {
-        tslib_1.__extends(PDFName2, _super);
-        function PDFName2(enforcer, name) {
+        tslib_1.__extends(PDFName3, _super);
+        function PDFName3(enforcer, name) {
           var _this = this;
           if (enforcer !== ENFORCER)
             throw new errors_1.PrivateConstructorError("PDFName");
@@ -12257,7 +12652,7 @@ var require_PDFName = __commonJS({
           _this.encodedName = encodedName;
           return _this;
         }
-        PDFName2.prototype.asBytes = function() {
+        PDFName3.prototype.asBytes = function() {
           var bytes = [];
           var hex = "";
           var escaped = false;
@@ -12289,67 +12684,67 @@ var require_PDFName = __commonJS({
           }
           return new Uint8Array(bytes);
         };
-        PDFName2.prototype.decodeText = function() {
+        PDFName3.prototype.decodeText = function() {
           var bytes = this.asBytes();
           return String.fromCharCode.apply(String, Array.from(bytes));
         };
-        PDFName2.prototype.asString = function() {
+        PDFName3.prototype.asString = function() {
           return this.encodedName;
         };
-        PDFName2.prototype.value = function() {
+        PDFName3.prototype.value = function() {
           return this.encodedName;
         };
-        PDFName2.prototype.clone = function() {
+        PDFName3.prototype.clone = function() {
           return this;
         };
-        PDFName2.prototype.toString = function() {
+        PDFName3.prototype.toString = function() {
           return this.encodedName;
         };
-        PDFName2.prototype.sizeInBytes = function() {
+        PDFName3.prototype.sizeInBytes = function() {
           return this.encodedName.length;
         };
-        PDFName2.prototype.copyBytesInto = function(buffer, offset) {
+        PDFName3.prototype.copyBytesInto = function(buffer, offset) {
           offset += utils_1.copyStringIntoBuffer(this.encodedName, buffer, offset);
           return this.encodedName.length;
         };
-        PDFName2.of = function(name) {
+        PDFName3.of = function(name) {
           var decodedValue = decodeName(name);
           var instance = pool.get(decodedValue);
           if (!instance) {
-            instance = new PDFName2(ENFORCER, decodedValue);
+            instance = new PDFName3(ENFORCER, decodedValue);
             pool.set(decodedValue, instance);
           }
           return instance;
         };
-        PDFName2.Length = PDFName2.of("Length");
-        PDFName2.FlateDecode = PDFName2.of("FlateDecode");
-        PDFName2.Resources = PDFName2.of("Resources");
-        PDFName2.Font = PDFName2.of("Font");
-        PDFName2.XObject = PDFName2.of("XObject");
-        PDFName2.ExtGState = PDFName2.of("ExtGState");
-        PDFName2.Contents = PDFName2.of("Contents");
-        PDFName2.Type = PDFName2.of("Type");
-        PDFName2.Parent = PDFName2.of("Parent");
-        PDFName2.MediaBox = PDFName2.of("MediaBox");
-        PDFName2.Page = PDFName2.of("Page");
-        PDFName2.Annots = PDFName2.of("Annots");
-        PDFName2.TrimBox = PDFName2.of("TrimBox");
-        PDFName2.ArtBox = PDFName2.of("ArtBox");
-        PDFName2.BleedBox = PDFName2.of("BleedBox");
-        PDFName2.CropBox = PDFName2.of("CropBox");
-        PDFName2.Rotate = PDFName2.of("Rotate");
-        PDFName2.Title = PDFName2.of("Title");
-        PDFName2.Author = PDFName2.of("Author");
-        PDFName2.Subject = PDFName2.of("Subject");
-        PDFName2.Creator = PDFName2.of("Creator");
-        PDFName2.Keywords = PDFName2.of("Keywords");
-        PDFName2.Producer = PDFName2.of("Producer");
-        PDFName2.CreationDate = PDFName2.of("CreationDate");
-        PDFName2.ModDate = PDFName2.of("ModDate");
-        return PDFName2;
+        PDFName3.Length = PDFName3.of("Length");
+        PDFName3.FlateDecode = PDFName3.of("FlateDecode");
+        PDFName3.Resources = PDFName3.of("Resources");
+        PDFName3.Font = PDFName3.of("Font");
+        PDFName3.XObject = PDFName3.of("XObject");
+        PDFName3.ExtGState = PDFName3.of("ExtGState");
+        PDFName3.Contents = PDFName3.of("Contents");
+        PDFName3.Type = PDFName3.of("Type");
+        PDFName3.Parent = PDFName3.of("Parent");
+        PDFName3.MediaBox = PDFName3.of("MediaBox");
+        PDFName3.Page = PDFName3.of("Page");
+        PDFName3.Annots = PDFName3.of("Annots");
+        PDFName3.TrimBox = PDFName3.of("TrimBox");
+        PDFName3.ArtBox = PDFName3.of("ArtBox");
+        PDFName3.BleedBox = PDFName3.of("BleedBox");
+        PDFName3.CropBox = PDFName3.of("CropBox");
+        PDFName3.Rotate = PDFName3.of("Rotate");
+        PDFName3.Title = PDFName3.of("Title");
+        PDFName3.Author = PDFName3.of("Author");
+        PDFName3.Subject = PDFName3.of("Subject");
+        PDFName3.Creator = PDFName3.of("Creator");
+        PDFName3.Keywords = PDFName3.of("Keywords");
+        PDFName3.Producer = PDFName3.of("Producer");
+        PDFName3.CreationDate = PDFName3.of("CreationDate");
+        PDFName3.ModDate = PDFName3.of("ModDate");
+        return PDFName3;
       })(PDFObject_1.default)
     );
-    exports2.default = PDFName;
+    exports2.default = PDFName2;
   }
 });
 
@@ -12404,29 +12799,29 @@ var require_PDFDict = __commonJS({
     var PDFNull_1 = tslib_1.__importDefault(require_PDFNull());
     var PDFObject_1 = tslib_1.__importDefault(require_PDFObject());
     var CharCodes_1 = tslib_1.__importDefault(require_CharCodes());
-    var PDFDict = (
+    var PDFDict2 = (
       /** @class */
       (function(_super) {
-        tslib_1.__extends(PDFDict2, _super);
-        function PDFDict2(map, context) {
+        tslib_1.__extends(PDFDict3, _super);
+        function PDFDict3(map, context) {
           var _this = _super.call(this) || this;
           _this.dict = map;
           _this.context = context;
           return _this;
         }
-        PDFDict2.prototype.keys = function() {
+        PDFDict3.prototype.keys = function() {
           return Array.from(this.dict.keys());
         };
-        PDFDict2.prototype.values = function() {
+        PDFDict3.prototype.values = function() {
           return Array.from(this.dict.values());
         };
-        PDFDict2.prototype.entries = function() {
+        PDFDict3.prototype.entries = function() {
           return Array.from(this.dict.entries());
         };
-        PDFDict2.prototype.set = function(key, value) {
+        PDFDict3.prototype.set = function(key, value) {
           this.dict.set(key, value);
         };
-        PDFDict2.prototype.get = function(key, preservePDFNull) {
+        PDFDict3.prototype.get = function(key, preservePDFNull) {
           if (preservePDFNull === void 0) {
             preservePDFNull = false;
           }
@@ -12435,11 +12830,11 @@ var require_PDFDict = __commonJS({
             return void 0;
           return value;
         };
-        PDFDict2.prototype.has = function(key) {
+        PDFDict3.prototype.has = function(key) {
           var value = this.dict.get(key);
           return value !== void 0 && value !== PDFNull_1.default;
         };
-        PDFDict2.prototype.lookupMaybe = function(key) {
+        PDFDict3.prototype.lookupMaybe = function(key) {
           var _a;
           var types = [];
           for (var _i = 1; _i < arguments.length; _i++) {
@@ -12451,7 +12846,7 @@ var require_PDFDict = __commonJS({
             return void 0;
           return value;
         };
-        PDFDict2.prototype.lookup = function(key) {
+        PDFDict3.prototype.lookup = function(key) {
           var _a;
           var types = [];
           for (var _i = 1; _i < arguments.length; _i++) {
@@ -12463,13 +12858,13 @@ var require_PDFDict = __commonJS({
             return void 0;
           return value;
         };
-        PDFDict2.prototype.delete = function(key) {
+        PDFDict3.prototype.delete = function(key) {
           return this.dict.delete(key);
         };
-        PDFDict2.prototype.asMap = function() {
+        PDFDict3.prototype.asMap = function() {
           return new Map(this.dict);
         };
-        PDFDict2.prototype.uniqueKey = function(tag) {
+        PDFDict3.prototype.uniqueKey = function(tag) {
           if (tag === void 0) {
             tag = "";
           }
@@ -12480,8 +12875,8 @@ var require_PDFDict = __commonJS({
           }
           return key;
         };
-        PDFDict2.prototype.clone = function(context) {
-          var clone = PDFDict2.withContext(context || this.context);
+        PDFDict3.prototype.clone = function(context) {
+          var clone = PDFDict3.withContext(context || this.context);
           var entries = this.entries();
           for (var idx = 0, len = entries.length; idx < len; idx++) {
             var _a = entries[idx], key = _a[0], value = _a[1];
@@ -12489,7 +12884,7 @@ var require_PDFDict = __commonJS({
           }
           return clone;
         };
-        PDFDict2.prototype.toString = function() {
+        PDFDict3.prototype.toString = function() {
           var dictString = "<<\n";
           var entries = this.entries();
           for (var idx = 0, len = entries.length; idx < len; idx++) {
@@ -12499,7 +12894,7 @@ var require_PDFDict = __commonJS({
           dictString += ">>";
           return dictString;
         };
-        PDFDict2.prototype.sizeInBytes = function() {
+        PDFDict3.prototype.sizeInBytes = function() {
           var size = 5;
           var entries = this.entries();
           for (var idx = 0, len = entries.length; idx < len; idx++) {
@@ -12508,7 +12903,7 @@ var require_PDFDict = __commonJS({
           }
           return size;
         };
-        PDFDict2.prototype.copyBytesInto = function(buffer, offset) {
+        PDFDict3.prototype.copyBytesInto = function(buffer, offset) {
           var initialOffset = offset;
           buffer[offset++] = CharCodes_1.default.LessThan;
           buffer[offset++] = CharCodes_1.default.LessThan;
@@ -12525,16 +12920,16 @@ var require_PDFDict = __commonJS({
           buffer[offset++] = CharCodes_1.default.GreaterThan;
           return offset - initialOffset;
         };
-        PDFDict2.withContext = function(context) {
-          return new PDFDict2(/* @__PURE__ */ new Map(), context);
+        PDFDict3.withContext = function(context) {
+          return new PDFDict3(/* @__PURE__ */ new Map(), context);
         };
-        PDFDict2.fromMapWithContext = function(map, context) {
-          return new PDFDict2(map, context);
+        PDFDict3.fromMapWithContext = function(map, context) {
+          return new PDFDict3(map, context);
         };
-        return PDFDict2;
+        return PDFDict3;
       })(PDFObject_1.default)
     );
-    exports2.default = PDFDict;
+    exports2.default = PDFDict2;
   }
 });
 
@@ -12549,36 +12944,36 @@ var require_PDFStream = __commonJS({
     var PDFNumber_1 = tslib_1.__importDefault(require_PDFNumber());
     var PDFObject_1 = tslib_1.__importDefault(require_PDFObject());
     var CharCodes_1 = tslib_1.__importDefault(require_CharCodes());
-    var PDFStream = (
+    var PDFStream2 = (
       /** @class */
       (function(_super) {
-        tslib_1.__extends(PDFStream2, _super);
-        function PDFStream2(dict) {
+        tslib_1.__extends(PDFStream3, _super);
+        function PDFStream3(dict) {
           var _this = _super.call(this) || this;
           _this.dict = dict;
           return _this;
         }
-        PDFStream2.prototype.clone = function(_context) {
+        PDFStream3.prototype.clone = function(_context) {
           throw new errors_1.MethodNotImplementedError(this.constructor.name, "clone");
         };
-        PDFStream2.prototype.getContentsString = function() {
+        PDFStream3.prototype.getContentsString = function() {
           throw new errors_1.MethodNotImplementedError(this.constructor.name, "getContentsString");
         };
-        PDFStream2.prototype.getContents = function() {
+        PDFStream3.prototype.getContents = function() {
           throw new errors_1.MethodNotImplementedError(this.constructor.name, "getContents");
         };
-        PDFStream2.prototype.getContentsSize = function() {
+        PDFStream3.prototype.getContentsSize = function() {
           throw new errors_1.MethodNotImplementedError(this.constructor.name, "getContentsSize");
         };
-        PDFStream2.prototype.updateDict = function() {
+        PDFStream3.prototype.updateDict = function() {
           var contentsSize = this.getContentsSize();
           this.dict.set(PDFName_1.default.Length, PDFNumber_1.default.of(contentsSize));
         };
-        PDFStream2.prototype.sizeInBytes = function() {
+        PDFStream3.prototype.sizeInBytes = function() {
           this.updateDict();
           return this.dict.sizeInBytes() + this.getContentsSize() + 18;
         };
-        PDFStream2.prototype.toString = function() {
+        PDFStream3.prototype.toString = function() {
           this.updateDict();
           var streamString = this.dict.toString();
           streamString += "\nstream\n";
@@ -12586,7 +12981,7 @@ var require_PDFStream = __commonJS({
           streamString += "\nendstream";
           return streamString;
         };
-        PDFStream2.prototype.copyBytesInto = function(buffer, offset) {
+        PDFStream3.prototype.copyBytesInto = function(buffer, offset) {
           this.updateDict();
           var initialOffset = offset;
           offset += this.dict.copyBytesInto(buffer, offset);
@@ -12614,10 +13009,10 @@ var require_PDFStream = __commonJS({
           buffer[offset++] = CharCodes_1.default.m;
           return offset - initialOffset;
         };
-        return PDFStream2;
+        return PDFStream3;
       })(PDFObject_1.default)
     );
-    exports2.default = PDFStream;
+    exports2.default = PDFStream2;
   }
 });
 
@@ -12629,37 +13024,37 @@ var require_PDFRawStream = __commonJS({
     var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
     var PDFStream_1 = tslib_1.__importDefault(require_PDFStream());
     var utils_1 = require_utils3();
-    var PDFRawStream = (
+    var PDFRawStream2 = (
       /** @class */
       (function(_super) {
-        tslib_1.__extends(PDFRawStream2, _super);
-        function PDFRawStream2(dict, contents) {
+        tslib_1.__extends(PDFRawStream3, _super);
+        function PDFRawStream3(dict, contents) {
           var _this = _super.call(this, dict) || this;
           _this.contents = contents;
           return _this;
         }
-        PDFRawStream2.prototype.asUint8Array = function() {
+        PDFRawStream3.prototype.asUint8Array = function() {
           return this.contents.slice();
         };
-        PDFRawStream2.prototype.clone = function(context) {
-          return PDFRawStream2.of(this.dict.clone(context), this.contents.slice());
+        PDFRawStream3.prototype.clone = function(context) {
+          return PDFRawStream3.of(this.dict.clone(context), this.contents.slice());
         };
-        PDFRawStream2.prototype.getContentsString = function() {
+        PDFRawStream3.prototype.getContentsString = function() {
           return utils_1.arrayAsString(this.contents);
         };
-        PDFRawStream2.prototype.getContents = function() {
+        PDFRawStream3.prototype.getContents = function() {
           return this.contents;
         };
-        PDFRawStream2.prototype.getContentsSize = function() {
+        PDFRawStream3.prototype.getContentsSize = function() {
           return this.contents.length;
         };
-        PDFRawStream2.of = function(dict, contents) {
-          return new PDFRawStream2(dict, contents);
+        PDFRawStream3.of = function(dict, contents) {
+          return new PDFRawStream3(dict, contents);
         };
-        return PDFRawStream2;
+        return PDFRawStream3;
       })(PDFStream_1.default)
     );
-    exports2.default = PDFRawStream;
+    exports2.default = PDFRawStream2;
   }
 });
 
@@ -12674,11 +13069,11 @@ var require_PDFRef = __commonJS({
     var utils_1 = require_utils3();
     var ENFORCER = {};
     var pool = /* @__PURE__ */ new Map();
-    var PDFRef = (
+    var PDFRef2 = (
       /** @class */
       (function(_super) {
-        tslib_1.__extends(PDFRef2, _super);
-        function PDFRef2(enforcer, objectNumber, generationNumber) {
+        tslib_1.__extends(PDFRef3, _super);
+        function PDFRef3(enforcer, objectNumber, generationNumber) {
           var _this = this;
           if (enforcer !== ENFORCER)
             throw new errors_1.PrivateConstructorError("PDFRef");
@@ -12688,35 +13083,35 @@ var require_PDFRef = __commonJS({
           _this.tag = objectNumber + " " + generationNumber + " R";
           return _this;
         }
-        PDFRef2.prototype.clone = function() {
+        PDFRef3.prototype.clone = function() {
           return this;
         };
-        PDFRef2.prototype.toString = function() {
+        PDFRef3.prototype.toString = function() {
           return this.tag;
         };
-        PDFRef2.prototype.sizeInBytes = function() {
+        PDFRef3.prototype.sizeInBytes = function() {
           return this.tag.length;
         };
-        PDFRef2.prototype.copyBytesInto = function(buffer, offset) {
+        PDFRef3.prototype.copyBytesInto = function(buffer, offset) {
           offset += utils_1.copyStringIntoBuffer(this.tag, buffer, offset);
           return this.tag.length;
         };
-        PDFRef2.of = function(objectNumber, generationNumber) {
+        PDFRef3.of = function(objectNumber, generationNumber) {
           if (generationNumber === void 0) {
             generationNumber = 0;
           }
           var tag = objectNumber + " " + generationNumber + " R";
           var instance = pool.get(tag);
           if (!instance) {
-            instance = new PDFRef2(ENFORCER, objectNumber, generationNumber);
+            instance = new PDFRef3(ENFORCER, objectNumber, generationNumber);
             pool.set(tag, instance);
           }
           return instance;
         };
-        return PDFRef2;
+        return PDFRef3;
       })(PDFObject_1.default)
     );
-    exports2.default = PDFRef;
+    exports2.default = PDFRef2;
   }
 });
 
@@ -18354,14 +18749,14 @@ var require_decode = __commonJS({
     var LZWStream_1 = tslib_1.__importDefault(require_LZWStream());
     var RunLengthStream_1 = tslib_1.__importDefault(require_RunLengthStream());
     var Stream_1 = tslib_1.__importDefault(require_Stream());
-    var decodeStream = function(stream, encoding, params) {
+    var decodeStream = function(stream, encoding, params2) {
       if (encoding === PDFName_1.default.of("FlateDecode")) {
         return new FlateStream_1.default(stream);
       }
       if (encoding === PDFName_1.default.of("LZWDecode")) {
         var earlyChange = 1;
-        if (params instanceof PDFDict_1.default) {
-          var EarlyChange = params.lookup(PDFName_1.default.of("EarlyChange"));
+        if (params2 instanceof PDFDict_1.default) {
+          var EarlyChange = params2.lookup(PDFName_1.default.of("EarlyChange"));
           if (EarlyChange instanceof PDFNumber_1.default) {
             earlyChange = EarlyChange.asNumber();
           }
@@ -22243,11 +22638,11 @@ var require_svgPath = __commonJS({
       var args = [];
       var curArg = "";
       var foundDecimal = false;
-      var params = 0;
+      var params2 = 0;
       for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {
         var c = path_1[_i];
         if (parameters.has(c)) {
-          params = parameters.get(c);
+          params2 = parameters.get(c);
           if (cmd) {
             if (curArg.length > 0) {
               args[args.length] = +curArg;
@@ -22262,7 +22657,7 @@ var require_svgPath = __commonJS({
           if (curArg.length === 0) {
             continue;
           }
-          if (args.length === params) {
+          if (args.length === params2) {
             ret[ret.length] = { cmd, args };
             args = [+curArg];
             if (cmd === "M") {
@@ -22284,7 +22679,7 @@ var require_svgPath = __commonJS({
         }
       }
       if (curArg.length > 0) {
-        if (args.length === params) {
+        if (args.length === params2) {
           ret[ret.length] = { cmd, args };
           args = [+curArg];
           if (cmd === "M") {
@@ -25965,10 +26360,10 @@ var require_PDFDocument = __commonJS({
     var PDFEmbeddedFile_1 = tslib_1.__importDefault(require_PDFEmbeddedFile());
     var PDFJavaScript_1 = tslib_1.__importDefault(require_PDFJavaScript());
     var JavaScriptEmbedder_1 = tslib_1.__importDefault(require_JavaScriptEmbedder());
-    var PDFDocument2 = (
+    var PDFDocument3 = (
       /** @class */
       (function() {
-        function PDFDocument3(context, ignoreEncryption, updateMetadata) {
+        function PDFDocument4(context, ignoreEncryption, updateMetadata) {
           var _this = this;
           this.defaultWordBreaks = [" "];
           this.computePages = function() {
@@ -26007,7 +26402,7 @@ var require_PDFDocument = __commonJS({
           if (updateMetadata)
             this.updateInfoDict();
         }
-        PDFDocument3.load = function(pdf, options) {
+        PDFDocument4.load = function(pdf, options) {
           if (options === void 0) {
             options = {};
           }
@@ -26025,12 +26420,12 @@ var require_PDFDocument = __commonJS({
                   return [4, core_1.PDFParser.forBytesWithOptions(bytes, parseSpeed, throwOnInvalidObject, capNumbers).parseDocument()];
                 case 1:
                   context = _f.sent();
-                  return [2, new PDFDocument3(context, ignoreEncryption, updateMetadata)];
+                  return [2, new PDFDocument4(context, ignoreEncryption, updateMetadata)];
               }
             });
           });
         };
-        PDFDocument3.create = function(options) {
+        PDFDocument4.create = function(options) {
           if (options === void 0) {
             options = {};
           }
@@ -26043,14 +26438,14 @@ var require_PDFDocument = __commonJS({
               pageTreeRef = context.register(pageTree);
               catalog = core_1.PDFCatalog.withContextAndPages(context, pageTreeRef);
               context.trailerInfo.Root = context.register(catalog);
-              return [2, new PDFDocument3(context, false, updateMetadata)];
+              return [2, new PDFDocument4(context, false, updateMetadata)];
             });
           });
         };
-        PDFDocument3.prototype.registerFontkit = function(fontkit) {
+        PDFDocument4.prototype.registerFontkit = function(fontkit) {
           this.fontkit = fontkit;
         };
-        PDFDocument3.prototype.getForm = function() {
+        PDFDocument4.prototype.getForm = function() {
           var form = this.formCache.access();
           if (form.hasXFA()) {
             console.warn("Removing XFA form data as pdf-lib does not support reading or writing XFA");
@@ -26058,63 +26453,63 @@ var require_PDFDocument = __commonJS({
           }
           return form;
         };
-        PDFDocument3.prototype.getTitle = function() {
+        PDFDocument4.prototype.getTitle = function() {
           var title = this.getInfoDict().lookup(core_1.PDFName.Title);
           if (!title)
             return void 0;
           assertIsLiteralOrHexString(title);
           return title.decodeText();
         };
-        PDFDocument3.prototype.getAuthor = function() {
+        PDFDocument4.prototype.getAuthor = function() {
           var author = this.getInfoDict().lookup(core_1.PDFName.Author);
           if (!author)
             return void 0;
           assertIsLiteralOrHexString(author);
           return author.decodeText();
         };
-        PDFDocument3.prototype.getSubject = function() {
+        PDFDocument4.prototype.getSubject = function() {
           var subject = this.getInfoDict().lookup(core_1.PDFName.Subject);
           if (!subject)
             return void 0;
           assertIsLiteralOrHexString(subject);
           return subject.decodeText();
         };
-        PDFDocument3.prototype.getKeywords = function() {
+        PDFDocument4.prototype.getKeywords = function() {
           var keywords = this.getInfoDict().lookup(core_1.PDFName.Keywords);
           if (!keywords)
             return void 0;
           assertIsLiteralOrHexString(keywords);
           return keywords.decodeText();
         };
-        PDFDocument3.prototype.getCreator = function() {
+        PDFDocument4.prototype.getCreator = function() {
           var creator = this.getInfoDict().lookup(core_1.PDFName.Creator);
           if (!creator)
             return void 0;
           assertIsLiteralOrHexString(creator);
           return creator.decodeText();
         };
-        PDFDocument3.prototype.getProducer = function() {
+        PDFDocument4.prototype.getProducer = function() {
           var producer = this.getInfoDict().lookup(core_1.PDFName.Producer);
           if (!producer)
             return void 0;
           assertIsLiteralOrHexString(producer);
           return producer.decodeText();
         };
-        PDFDocument3.prototype.getCreationDate = function() {
+        PDFDocument4.prototype.getCreationDate = function() {
           var creationDate = this.getInfoDict().lookup(core_1.PDFName.CreationDate);
           if (!creationDate)
             return void 0;
           assertIsLiteralOrHexString(creationDate);
           return creationDate.decodeDate();
         };
-        PDFDocument3.prototype.getModificationDate = function() {
+        PDFDocument4.prototype.getModificationDate = function() {
           var modificationDate = this.getInfoDict().lookup(core_1.PDFName.ModDate);
           if (!modificationDate)
             return void 0;
           assertIsLiteralOrHexString(modificationDate);
           return modificationDate.decodeDate();
         };
-        PDFDocument3.prototype.setTitle = function(title, options) {
+        PDFDocument4.prototype.setTitle = function(title, options) {
           utils_1.assertIs(title, "title", ["string"]);
           var key = core_1.PDFName.of("Title");
           this.getInfoDict().set(key, core_1.PDFHexString.fromText(title));
@@ -26123,63 +26518,63 @@ var require_PDFDocument = __commonJS({
             prefs.setDisplayDocTitle(true);
           }
         };
-        PDFDocument3.prototype.setAuthor = function(author) {
+        PDFDocument4.prototype.setAuthor = function(author) {
           utils_1.assertIs(author, "author", ["string"]);
           var key = core_1.PDFName.of("Author");
           this.getInfoDict().set(key, core_1.PDFHexString.fromText(author));
         };
-        PDFDocument3.prototype.setSubject = function(subject) {
+        PDFDocument4.prototype.setSubject = function(subject) {
           utils_1.assertIs(subject, "author", ["string"]);
           var key = core_1.PDFName.of("Subject");
           this.getInfoDict().set(key, core_1.PDFHexString.fromText(subject));
         };
-        PDFDocument3.prototype.setKeywords = function(keywords) {
+        PDFDocument4.prototype.setKeywords = function(keywords) {
           utils_1.assertIs(keywords, "keywords", [Array]);
           var key = core_1.PDFName.of("Keywords");
           this.getInfoDict().set(key, core_1.PDFHexString.fromText(keywords.join(" ")));
         };
-        PDFDocument3.prototype.setCreator = function(creator) {
+        PDFDocument4.prototype.setCreator = function(creator) {
           utils_1.assertIs(creator, "creator", ["string"]);
           var key = core_1.PDFName.of("Creator");
           this.getInfoDict().set(key, core_1.PDFHexString.fromText(creator));
         };
-        PDFDocument3.prototype.setProducer = function(producer) {
+        PDFDocument4.prototype.setProducer = function(producer) {
           utils_1.assertIs(producer, "creator", ["string"]);
           var key = core_1.PDFName.of("Producer");
           this.getInfoDict().set(key, core_1.PDFHexString.fromText(producer));
         };
-        PDFDocument3.prototype.setLanguage = function(language) {
+        PDFDocument4.prototype.setLanguage = function(language) {
           utils_1.assertIs(language, "language", ["string"]);
           var key = core_1.PDFName.of("Lang");
           this.catalog.set(key, core_1.PDFString.of(language));
         };
-        PDFDocument3.prototype.setCreationDate = function(creationDate) {
+        PDFDocument4.prototype.setCreationDate = function(creationDate) {
           utils_1.assertIs(creationDate, "creationDate", [[Date, "Date"]]);
           var key = core_1.PDFName.of("CreationDate");
           this.getInfoDict().set(key, core_1.PDFString.fromDate(creationDate));
         };
-        PDFDocument3.prototype.setModificationDate = function(modificationDate) {
+        PDFDocument4.prototype.setModificationDate = function(modificationDate) {
           utils_1.assertIs(modificationDate, "modificationDate", [[Date, "Date"]]);
           var key = core_1.PDFName.of("ModDate");
           this.getInfoDict().set(key, core_1.PDFString.fromDate(modificationDate));
         };
-        PDFDocument3.prototype.getPageCount = function() {
+        PDFDocument4.prototype.getPageCount = function() {
           if (this.pageCount === void 0)
             this.pageCount = this.getPages().length;
           return this.pageCount;
         };
-        PDFDocument3.prototype.getPages = function() {
+        PDFDocument4.prototype.getPages = function() {
           return this.pageCache.access();
         };
-        PDFDocument3.prototype.getPage = function(index) {
+        PDFDocument4.prototype.getPage = function(index) {
           var pages = this.getPages();
           utils_1.assertRange(index, "index", 0, pages.length - 1);
           return pages[index];
         };
-        PDFDocument3.prototype.getPageIndices = function() {
+        PDFDocument4.prototype.getPageIndices = function() {
           return utils_1.range(0, this.getPageCount());
         };
-        PDFDocument3.prototype.removePage = function(index) {
+        PDFDocument4.prototype.removePage = function(index) {
           var pageCount = this.getPageCount();
           if (this.pageCount === 0)
             throw new errors_1.RemovePageFromEmptyDocumentError();
@@ -26187,11 +26582,11 @@ var require_PDFDocument = __commonJS({
           this.catalog.removeLeafNode(index);
           this.pageCount = pageCount - 1;
         };
-        PDFDocument3.prototype.addPage = function(page) {
+        PDFDocument4.prototype.addPage = function(page) {
           utils_1.assertIs(page, "page", ["undefined", [PDFPage_1.default, "PDFPage"], Array]);
           return this.insertPage(this.getPageCount(), page);
         };
-        PDFDocument3.prototype.insertPage = function(index, page) {
+        PDFDocument4.prototype.insertPage = function(index, page) {
           var pageCount = this.getPageCount();
           utils_1.assertRange(index, "index", 0, pageCount);
           utils_1.assertIs(page, "page", ["undefined", [PDFPage_1.default, "PDFPage"], Array]);
@@ -26209,13 +26604,13 @@ var require_PDFDocument = __commonJS({
           this.pageCount = pageCount + 1;
           return page;
         };
-        PDFDocument3.prototype.copyPages = function(srcDoc, indices) {
+        PDFDocument4.prototype.copyPages = function(srcDoc, indices) {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             var copier, srcPages, copiedPages, idx, len, srcPage, copiedPage, ref;
             return tslib_1.__generator(this, function(_a) {
               switch (_a.label) {
                 case 0:
-                  utils_1.assertIs(srcDoc, "srcDoc", [[PDFDocument3, "PDFDocument"]]);
+                  utils_1.assertIs(srcDoc, "srcDoc", [[PDFDocument4, "PDFDocument"]]);
                   utils_1.assertIs(indices, "indices", [Array]);
                   return [4, srcDoc.flush()];
                 case 1:
@@ -26234,13 +26629,13 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.copy = function() {
+        PDFDocument4.prototype.copy = function() {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             var pdfCopy, contentPages, idx, len;
             return tslib_1.__generator(this, function(_a) {
               switch (_a.label) {
                 case 0:
-                  return [4, PDFDocument3.create()];
+                  return [4, PDFDocument4.create()];
                 case 1:
                   pdfCopy = _a.sent();
                   return [4, pdfCopy.copyPages(this, this.getPageIndices())];
@@ -26276,7 +26671,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.addJavaScript = function(name, script) {
+        PDFDocument4.prototype.addJavaScript = function(name, script) {
           utils_1.assertIs(name, "name", ["string"]);
           utils_1.assertIs(script, "script", ["string"]);
           var embedder = JavaScriptEmbedder_1.default.for(script, name);
@@ -26284,7 +26679,7 @@ var require_PDFDocument = __commonJS({
           var javaScript = PDFJavaScript_1.default.of(ref, this, embedder);
           this.javaScripts.push(javaScript);
         };
-        PDFDocument3.prototype.attach = function(attachment, name, options) {
+        PDFDocument4.prototype.attach = function(attachment, name, options) {
           if (options === void 0) {
             options = {};
           }
@@ -26312,7 +26707,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.embedFont = function(font, options) {
+        PDFDocument4.prototype.embedFont = function(font, options) {
           if (options === void 0) {
             options = {};
           }
@@ -26355,7 +26750,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.embedStandardFont = function(font, customName) {
+        PDFDocument4.prototype.embedStandardFont = function(font, customName) {
           utils_1.assertIs(font, "font", ["string"]);
           if (!utils_1.isStandardFont(font)) {
             throw new TypeError("`font` must be one of type `StandardFonts`");
@@ -26366,7 +26761,7 @@ var require_PDFDocument = __commonJS({
           this.fonts.push(pdfFont);
           return pdfFont;
         };
-        PDFDocument3.prototype.embedJpg = function(jpg) {
+        PDFDocument4.prototype.embedJpg = function(jpg) {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             var bytes, embedder, ref, pdfImage;
             return tslib_1.__generator(this, function(_a) {
@@ -26385,7 +26780,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.embedPng = function(png) {
+        PDFDocument4.prototype.embedPng = function(png) {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             var bytes, embedder, ref, pdfImage;
             return tslib_1.__generator(this, function(_a) {
@@ -26404,7 +26799,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.embedPdf = function(pdf, indices) {
+        PDFDocument4.prototype.embedPdf = function(pdf, indices) {
           if (indices === void 0) {
             indices = [0];
           }
@@ -26417,14 +26812,14 @@ var require_PDFDocument = __commonJS({
                     "string",
                     Uint8Array,
                     ArrayBuffer,
-                    [PDFDocument3, "PDFDocument"]
+                    [PDFDocument4, "PDFDocument"]
                   ]);
                   utils_1.assertIs(indices, "indices", [Array]);
-                  if (!(pdf instanceof PDFDocument3)) return [3, 1];
+                  if (!(pdf instanceof PDFDocument4)) return [3, 1];
                   _a = pdf;
                   return [3, 3];
                 case 1:
-                  return [4, PDFDocument3.load(pdf)];
+                  return [4, PDFDocument4.load(pdf)];
                 case 2:
                   _a = _b.sent();
                   _b.label = 3;
@@ -26436,7 +26831,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.embedPage = function(page, boundingBox, transformationMatrix) {
+        PDFDocument4.prototype.embedPage = function(page, boundingBox, transformationMatrix) {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             var embeddedPage;
             return tslib_1.__generator(this, function(_a) {
@@ -26451,7 +26846,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.embedPages = function(pages, boundingBoxes, transformationMatrices) {
+        PDFDocument4.prototype.embedPages = function(pages, boundingBoxes, transformationMatrices) {
           if (boundingBoxes === void 0) {
             boundingBoxes = [];
           }
@@ -26501,7 +26896,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.flush = function() {
+        PDFDocument4.prototype.flush = function() {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             return tslib_1.__generator(this, function(_a) {
               switch (_a.label) {
@@ -26529,7 +26924,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.save = function(options) {
+        PDFDocument4.prototype.save = function(options) {
           if (options === void 0) {
             options = {};
           }
@@ -26559,7 +26954,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.saveAsBase64 = function(options) {
+        PDFDocument4.prototype.saveAsBase64 = function(options) {
           if (options === void 0) {
             options = {};
           }
@@ -26579,7 +26974,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.findPageForAnnotationRef = function(ref) {
+        PDFDocument4.prototype.findPageForAnnotationRef = function(ref) {
           var pages = this.getPages();
           for (var idx = 0, len = pages.length; idx < len; idx++) {
             var page = pages[idx];
@@ -26590,7 +26985,7 @@ var require_PDFDocument = __commonJS({
           }
           return void 0;
         };
-        PDFDocument3.prototype.embedAll = function(embeddables) {
+        PDFDocument4.prototype.embedAll = function(embeddables) {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             var idx, len;
             return tslib_1.__generator(this, function(_a) {
@@ -26616,7 +27011,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.updateInfoDict = function() {
+        PDFDocument4.prototype.updateInfoDict = function() {
           var pdfLib = "pdf-lib (https://github.com/Hopding/pdf-lib)";
           var now = /* @__PURE__ */ new Date();
           var info = this.getInfoDict();
@@ -26627,7 +27022,7 @@ var require_PDFDocument = __commonJS({
           if (!info.get(core_1.PDFName.of("CreationDate")))
             this.setCreationDate(now);
         };
-        PDFDocument3.prototype.getInfoDict = function() {
+        PDFDocument4.prototype.getInfoDict = function() {
           var existingInfo = this.context.lookup(this.context.trailerInfo.Info);
           if (existingInfo instanceof core_1.PDFDict)
             return existingInfo;
@@ -26635,15 +27030,15 @@ var require_PDFDocument = __commonJS({
           this.context.trailerInfo.Info = this.context.register(newInfo);
           return newInfo;
         };
-        PDFDocument3.prototype.assertFontkit = function() {
+        PDFDocument4.prototype.assertFontkit = function() {
           if (!this.fontkit)
             throw new errors_1.FontkitNotRegisteredError();
           return this.fontkit;
         };
-        return PDFDocument3;
+        return PDFDocument4;
       })()
     );
-    exports2.default = PDFDocument2;
+    exports2.default = PDFDocument3;
     function assertIsLiteralOrHexString(pdfObject) {
       if (!(pdfObject instanceof core_1.PDFHexString) && !(pdfObject instanceof core_1.PDFString)) {
         throw new core_1.UnexpectedObjectTypeError([core_1.PDFHexString, core_1.PDFString], pdfObject);
@@ -27584,7 +27979,6 @@ var require_cjs = __commonJS({
 // apps/admin/data/skills.lib/document/bin-src/deck-qa.mjs
 var import_node_child_process = require("node:child_process");
 var import_promises2 = require("node:fs/promises");
-var import_node_os = require("node:os");
 var import_node_path4 = require("node:path");
 var import_node_util = require("node:util");
 
@@ -27642,6 +28036,126 @@ async function slidePartsInOrder(zip) {
   return toParts(complete ? ordered : byNumber);
 }
 
+// packages/core/dist/document/png-decode.js
+var import_node_zlib = require("node:zlib");
+var SIG = [137, 80, 78, 71, 13, 10, 26, 10];
+var CHANNELS = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
+function decodePng(bytes) {
+  try {
+    if (bytes.length < 33 || SIG.some((b, i) => bytes[i] !== b))
+      return void 0;
+    const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let width = 0, height = 0, depth = 0, type = -1, interlace = 0;
+    let palette;
+    const idat = [];
+    for (let p = 8; p + 8 <= buf.length; ) {
+      const len = buf.readUInt32BE(p);
+      const kind = buf.toString("latin1", p + 4, p + 8);
+      const data = buf.subarray(p + 8, p + 8 + len);
+      if (kind === "IHDR") {
+        width = data.readUInt32BE(0);
+        height = data.readUInt32BE(4);
+        depth = data[8];
+        type = data[9];
+        interlace = data[12];
+      } else if (kind === "PLTE")
+        palette = data;
+      else if (kind === "IDAT")
+        idat.push(data);
+      else if (kind === "IEND")
+        break;
+      p += 12 + len;
+    }
+    const ch = CHANNELS[type];
+    if (!width || !height || depth !== 8 || interlace !== 0 || ch === void 0 || type === 3 && !palette)
+      return void 0;
+    const raw = (0, import_node_zlib.inflateSync)(Buffer.concat(idat));
+    const stride = width * ch;
+    if (raw.length < height * (stride + 1))
+      return void 0;
+    const cur = new Uint8Array(stride);
+    const prev = new Uint8Array(stride);
+    const rgb = new Uint8Array(width * height * 3);
+    for (let y = 0; y < height; y++) {
+      const off = y * (stride + 1);
+      const filter = raw[off];
+      for (let i = 0; i < stride; i++) {
+        const x = raw[off + 1 + i];
+        const a = i >= ch ? cur[i - ch] : 0;
+        const b = prev[i];
+        const c = i >= ch ? prev[i - ch] : 0;
+        let v;
+        switch (filter) {
+          case 0:
+            v = x;
+            break;
+          case 1:
+            v = x + a;
+            break;
+          case 2:
+            v = x + b;
+            break;
+          case 3:
+            v = x + (a + b >> 1);
+            break;
+          case 4: {
+            const pa = Math.abs(b - c), pb = Math.abs(a - c), pc = Math.abs(a + b - 2 * c);
+            v = x + (pa <= pb && pa <= pc ? a : pb <= pc ? b : c);
+            break;
+          }
+          default:
+            return void 0;
+        }
+        cur[i] = v & 255;
+      }
+      for (let px = 0; px < width; px++) {
+        const o = (y * width + px) * 3;
+        const s = px * ch;
+        if (type === 3) {
+          const k = cur[s] * 3;
+          rgb[o] = palette[k];
+          rgb[o + 1] = palette[k + 1];
+          rgb[o + 2] = palette[k + 2];
+        } else if (ch <= 2) {
+          rgb[o] = rgb[o + 1] = rgb[o + 2] = cur[s];
+        } else {
+          rgb[o] = cur[s];
+          rgb[o + 1] = cur[s + 1];
+          rgb[o + 2] = cur[s + 2];
+        }
+      }
+      prev.set(cur);
+    }
+    return { width, height, rgb };
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/core/dist/document/readable-type.js
+var MIN_FONT_PT = 10;
+var LABEL_MAX_CHARS = 24;
+var MIN_LABEL_FONT_PT = 8;
+function readableFloorPt(text) {
+  return [...text.trim()].length <= LABEL_MAX_CHARS ? MIN_LABEL_FONT_PT : MIN_FONT_PT;
+}
+
+// packages/core/dist/document/text-slack.js
+var SLACK_CJK_RE = /[\u3000-\u303F\u3400-\u9FFF\uF900-\uFAFF\uFF00-\uFFEF]/;
+var PCT = { single: { cjk: 0.22, latin: 0.16 }, multi: { cjk: 0.1, latin: 0.06 } };
+var FLOOR_EM = { cjk: 1, latin: 0.45 };
+function params(single, cjk) {
+  const script = cjk ? "cjk" : "latin";
+  return { pct: PCT[single ? "single" : "multi"][script], floor: FLOOR_EM[script] * (single ? 1 : 0.5) };
+}
+function unpaddedWidth(padded, fontSize, single, cjk) {
+  const { pct, floor } = params(single, cjk);
+  const floorAbs = floor * fontSize;
+  const viaPct = padded / (1 + pct);
+  return viaPct * pct >= floorAbs ? viaPct : Math.max(0, padded - floorAbs);
+}
+var CHART_TEXT_NAME = "talos-chart-text";
+
 // packages/core/dist/document/doc-design-lint.js
 var PLACEHOLDER_RE = /替换为|在这里写|占位|示例文本|Lorem ipsum/i;
 var CJK_TEXT_RE = /[぀-ヿ㐀-䶿一-鿿가-힯豈-﫿]/;
@@ -27782,7 +28296,7 @@ function lintSlideXml(slideXml, slideNumber, masterBg, expectedLang = detectDeck
       }
     }
   }
-  if (worst && !worst.onShapeFill && anyVisualShape)
+  if (worst && !worst.onShapeFill && (anyVisualShape || hasPic))
     worst = void 0;
   if (placeholder) {
     const snippet2 = placeholder.length > 24 ? `${placeholder.slice(0, 24)}\u2026` : placeholder;
@@ -27821,8 +28335,9 @@ function lintSlideXml(slideXml, slideNumber, masterBg, expectedLang = detectDeck
 var EMU_PER_INCH = 914400;
 var DEFAULT_CANVAS = { w: 12192e3, h: 6858e3 };
 var OFFCANVAS_TOL = EMU_PER_INCH / 10;
-var MIN_FONT_HUNDREDTHS = 1e3;
-var OVERLAP_RATIO = 0.5;
+var MIN_FONT_HUNDREDTHS = MIN_FONT_PT * 100;
+var CHART_TEXT_RE = new RegExp(`<p:cNvPr\\b[^>]*\\bname="${CHART_TEXT_NAME}\\b`);
+var OVERLAP_RATIO = 0.3;
 function firstBox(block) {
   const xf = /<(?:a|p):xfrm\b[^>]*>[\s\S]*?<\/(?:a|p):xfrm>/.exec(block);
   const scope = xf ? xf[0] : block;
@@ -27840,6 +28355,51 @@ function overlapArea(a, b) {
   const iy = Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
   return ix * iy;
 }
+var CJK_WIDE_RE = /[\u2E80-\u9FFF\uAC00-\uD7AF\uF900-\uFAFF\uFF00-\uFFEF]/;
+var EMU_PER_PT = 12700;
+function inkBox(block, box) {
+  let maxSz = 0;
+  let inkW = 0;
+  let lines = 0;
+  for (const para of block.match(/<a:p>[\s\S]*?<\/a:p>|<a:p\b[^>]*>[\s\S]*?<\/a:p>/g) ?? []) {
+    let paraW = 0;
+    let paraSz = 0;
+    for (const run of para.match(/<a:r>[\s\S]*?<\/a:r>/g) ?? []) {
+      const raw = /<a:t\b[^>]*>([\s\S]*?)<\/a:t>/.exec(run)?.[1];
+      if (raw === void 0)
+        continue;
+      const sz = +(/<a:rPr\b[^>]*\bsz="(\d+)"/.exec(run)?.[1] ?? 1800) / 100;
+      paraSz = Math.max(paraSz, sz);
+      for (const ch of unescXml(raw))
+        paraW += (CJK_WIDE_RE.test(ch) ? 1 : ch === " " ? 0.3 : 0.55) * sz * EMU_PER_PT;
+    }
+    if (!paraW)
+      continue;
+    maxSz = Math.max(maxSz, paraSz);
+    const paraLines = box.w > 0 ? Math.max(1, Math.ceil(paraW / box.w)) : 1;
+    lines += paraLines;
+    inkW = Math.max(inkW, Math.min(paraW, box.w));
+  }
+  if (!lines)
+    return void 0;
+  const paras = (block.match(/<a:p>[\s\S]*?<\/a:p>|<a:p\b[^>]*>[\s\S]*?<\/a:p>/g) ?? []).filter((p) => /<a:t\b[^>]*>[^<]*\S/.test(p));
+  if (paras.length === 1 && maxSz > 0) {
+    const lnSpc = /<a:lnSpc>\s*<a:spcPts\b[^>]*\bval="(\d+)"/.exec(block)?.[1];
+    const lineH = (lnSpc ? +lnSpc / 100 : maxSz * 1.3) * EMU_PER_PT;
+    const clamped = box.x + box.w >= DEFAULT_CANVAS.w - EMU_PER_PT;
+    if (box.h <= lineH * 1.5 && !clamped) {
+      const text = unescXml((block.match(/<a:t\b[^>]*>([\s\S]*?)<\/a:t>/g) ?? []).join(""));
+      lines = 1;
+      inkW = Math.min(inkW, unpaddedWidth(box.w, maxSz * EMU_PER_PT, true, SLACK_CJK_RE.test(text)));
+    }
+  }
+  const inkH = Math.min(box.h, lines * maxSz * 1.2 * EMU_PER_PT);
+  const algn = /<a:pPr\b[^>]*\balgn="(\w+)"/.exec(block)?.[1];
+  const anchor = /<a:bodyPr\b[^>]*\banchor="(\w+)"/.exec(block)?.[1];
+  const x = algn === "ctr" ? box.x + (box.w - inkW) / 2 : algn === "r" ? box.x + box.w - inkW : box.x;
+  const y = anchor === "ctr" ? box.y + (box.h - inkH) / 2 : anchor === "b" ? box.y + box.h - inkH : box.y;
+  return { x, y, w: inkW, h: inkH };
+}
 function lintSlideGeometry(slideXml, slideNumber, canvas = DEFAULT_CANVAS) {
   const findings = [];
   const blocks = slideXml.match(/<p:(?:sp|pic|graphicFrame|cxnSp)\b[^>]*>[\s\S]*?<\/p:(?:sp|pic|graphicFrame|cxnSp)>/g) ?? [];
@@ -27863,16 +28423,23 @@ function lintSlideGeometry(slideXml, slideNumber, canvas = DEFAULT_CANVAS) {
             worstOff = { by, edge };
         }
       }
-      if (hasText && box.w > 0 && box.h > 0)
-        textBoxes2.push(box);
+      if (hasText && box.w > 0 && box.h > 0) {
+        const ink = inkBox(b, box);
+        if (ink)
+          textBoxes2.push(ink);
+      }
     }
+    if (CHART_TEXT_RE.test(b))
+      continue;
     for (const run of b.match(/<a:r>[\s\S]*?<\/a:r>/g) ?? []) {
       const raw = /<a:t\b[^>]*>([\s\S]*?)<\/a:t>/.exec(run)?.[1];
       if (raw === void 0 || !unescXml(raw).trim())
         continue;
+      const text = unescXml(raw).trim();
       const sz = /<a:rPr\b[^>]*\bsz="(\d+)"/.exec(run)?.[1];
-      if (sz && +sz < MIN_FONT_HUNDREDTHS && (!smallest || +sz < smallest.sz)) {
-        smallest = { sz: +sz, text: unescXml(raw).trim() };
+      const floor = readableFloorPt(text) * 100;
+      if (sz && +sz < floor && (!smallest || +sz < smallest.sz)) {
+        smallest = { sz: +sz, text, floor };
       }
     }
   }
@@ -27888,7 +28455,7 @@ function lintSlideGeometry(slideXml, slideNumber, canvas = DEFAULT_CANVAS) {
     findings.push({
       slide: slideNumber,
       code: "tiny-font",
-      message: `text "${snippet2}" is ${(smallest.sz / 100).toFixed(0)}pt \u2014 below the ~10pt readable floor for a projected slide; enlarge it or cut the text`
+      message: `text "${snippet2}" is ${+(smallest.sz / 100).toFixed(1)}pt \u2014 below the ~${smallest.floor / 100}pt readable floor for ${smallest.floor < MIN_FONT_HUNDREDTHS ? "a short label" : "text"} on a projected slide; enlarge it or cut the text`
     });
   }
   let worstPair;
@@ -27913,6 +28480,110 @@ function lintSlideGeometry(slideXml, slideNumber, canvas = DEFAULT_CANVAS) {
   }
   return findings;
 }
+var BACKDROP_COVER = 0.98;
+var BACKDROP_FLOOR = 2;
+var BACKDROP_SAMPLES = 2500;
+var LIN = Array.from({ length: 256 }, (_, i) => {
+  const c = i / 255;
+  return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+});
+var lumRgb = (r, g, b) => 0.2126 * LIN[r] + 0.7152 * LIN[g] + 0.0722 * LIN[b];
+var ratioOf = (a, b) => (Math.max(a, b) + 0.05) / (Math.min(a, b) + 0.05);
+var hex2 = (n) => n.toString(16).padStart(2, "0").toUpperCase();
+var BLOCK_RE = /<p:(?:sp|pic|graphicFrame|cxnSp)\b[^>]*>[\s\S]*?<\/p:(?:sp|pic|graphicFrame|cxnSp)>/g;
+function backdropPicEmbed(slideXml, canvas = DEFAULT_CANVAS) {
+  const first = (slideXml.match(BLOCK_RE) ?? [])[0];
+  if (!first || !first.startsWith("<p:pic"))
+    return void 0;
+  const box = firstBox(first);
+  if (!box || box.x > canvas.w * (1 - BACKDROP_COVER) || box.y > canvas.h * (1 - BACKDROP_COVER))
+    return void 0;
+  if (box.w < canvas.w * BACKDROP_COVER || box.h < canvas.h * BACKDROP_COVER)
+    return void 0;
+  return /<a:blip\b[^>]*\br:embed="([^"]+)"/.exec(first)?.[1];
+}
+function lintBackdropContrast(slideXml, slideNumber, backdrop, canvas = DEFAULT_CANVAS) {
+  const blocks = slideXml.match(BLOCK_RE) ?? [];
+  const sx = backdrop.width / canvas.w;
+  const sy = backdrop.height / canvas.h;
+  const occluders = [];
+  let worst;
+  for (let bi = 1; bi < blocks.length; bi++) {
+    const b = blocks[bi];
+    const box = firstBox(b);
+    if (!box)
+      continue;
+    const txIdx = b.indexOf("<p:txBody>");
+    const spPr = txIdx >= 0 ? b.slice(0, txIdx) : b;
+    const prst = /<a:prstGeom\b[^>]*\bprst="([^"]+)"/.exec(spPr)?.[1];
+    const visual = !b.startsWith("<p:sp") || FILL_RE.test(spPr) || prst !== void 0 && prst !== "rect";
+    const hasText = txIdx >= 0 && /<a:t\b[^>]*>\s*\S/.test(b);
+    if (visual) {
+      occluders.push(box);
+      continue;
+    }
+    if (!hasText)
+      continue;
+    const ink = inkBox(b, box);
+    if (!ink || ink.w <= 0 || ink.h <= 0)
+      continue;
+    if (occluders.some((o2) => overlapArea(o2, ink) > 0))
+      continue;
+    let fg;
+    let alpha = 1;
+    let text = "";
+    for (const run of b.match(/<a:r>[\s\S]*?<\/a:r>/g) ?? []) {
+      const raw = /<a:t\b[^>]*>([\s\S]*?)<\/a:t>/.exec(run)?.[1];
+      if (raw === void 0 || !unescXml(raw).trim())
+        continue;
+      text += unescXml(raw);
+      if (fg)
+        continue;
+      const rPr = run.slice(0, Math.max(0, run.indexOf("</a:rPr>")));
+      fg = firstSrgb(rPr);
+      const a = /<a:srgbClr\b[^>]*>\s*<a:alpha\b[^>]*\bval="(\d+)"/.exec(rPr)?.[1];
+      if (fg && a)
+        alpha = Math.min(1, +a / 1e5);
+    }
+    if (!fg)
+      continue;
+    const x0 = Math.max(0, Math.floor(ink.x * sx));
+    const y0 = Math.max(0, Math.floor(ink.y * sy));
+    const x1 = Math.min(backdrop.width, Math.ceil((ink.x + ink.w) * sx));
+    const y1 = Math.min(backdrop.height, Math.ceil((ink.y + ink.h) * sy));
+    if (x1 <= x0 || y1 <= y0)
+      continue;
+    const step = Math.max(1, Math.floor(Math.sqrt((x1 - x0) * (y1 - y0) / BACKDROP_SAMPLES)));
+    const fr = parseInt(fg.slice(0, 2), 16), fgG = parseInt(fg.slice(2, 4), 16), fb = parseInt(fg.slice(4, 6), 16);
+    const fgLum = lumRgb(fr, fgG, fb);
+    const samples = [];
+    for (let y = y0; y < y1; y += step) {
+      for (let x = x0; x < x1; x += step) {
+        const o2 = (y * backdrop.width + x) * 3;
+        const r = backdrop.rgb[o2], g = backdrop.rgb[o2 + 1], bl = backdrop.rgb[o2 + 2];
+        const l = lumRgb(r, g, bl);
+        const tl = alpha >= 1 ? fgLum : lumRgb(Math.round(alpha * fr + (1 - alpha) * r), Math.round(alpha * fgG + (1 - alpha) * g), Math.round(alpha * fb + (1 - alpha) * bl));
+        samples.push([ratioOf(tl, l), o2]);
+      }
+    }
+    if (!samples.length)
+      continue;
+    samples.sort((p, q) => p[0] - q[0]);
+    const [ratio, o] = samples[samples.length >> 1];
+    if (ratio < BACKDROP_FLOOR && (!worst || ratio < worst.ratio)) {
+      const bg = hex2(backdrop.rgb[o]) + hex2(backdrop.rgb[o + 1]) + hex2(backdrop.rgb[o + 2]);
+      worst = { ratio, text: text.trim(), fg, bg };
+    }
+  }
+  if (!worst)
+    return [];
+  const snippet2 = worst.text.length > 24 ? `${worst.text.slice(0, 24)}\u2026` : worst.text;
+  return [{
+    slide: slideNumber,
+    code: "low-contrast-text",
+    message: `text "${snippet2}" is #${worst.fg} over the slide's rendered background (\u2248#${worst.bg} under it) \u2014 median contrast ${worst.ratio.toFixed(1)}:1, below the ${BACKDROP_FLOOR.toFixed(1)} floor \u2014 it can barely be seen; text over a photo or panel takes that surface's text colour (light on a dark photo/scrim), not the skin's page text colour`
+  }];
+}
 function canvasFromPresentation(xml) {
   if (!xml)
     return DEFAULT_CANVAS;
@@ -27920,6 +28591,26 @@ function canvasFromPresentation(xml) {
   const cy = /<p:sldSz\b[^>]*\bcy="(\d+)"/.exec(xml)?.[1];
   return cx && cy ? { w: +cx, h: +cy } : DEFAULT_CANVAS;
 }
+async function backdropRaster(zip, slideXml, relsPath, canvas) {
+  const rId = backdropPicEmbed(slideXml, canvas);
+  const rels = rId ? zip.file(relsPath) : null;
+  if (!rId || !rels)
+    return void 0;
+  const relsXml = await rels.async("string");
+  const rel = [...relsXml.matchAll(/<Relationship\b[^>]*>/g)].map((m) => m[0]).find((r) => new RegExp(`\\bId="${rId}"`).test(r));
+  const target = rel && /\bTarget="([^"]+)"/.exec(rel)?.[1];
+  if (!target || !/\.png$/i.test(target))
+    return void 0;
+  const parts = ["ppt", "slides"];
+  for (const seg of target.split("/")) {
+    if (seg === "..")
+      parts.pop();
+    else if (seg && seg !== ".")
+      parts.push(seg);
+  }
+  const media = zip.file(target.startsWith("/") ? target.slice(1) : parts.join("/"));
+  return media ? decodePng(await media.async("uint8array")) : void 0;
+}
 async function designLintPptx(bytes) {
   const zip = await import_jszip.default.loadAsync(Buffer.from(bytes));
   const findings = [];
@@ -27930,9 +28621,15 @@ async function designLintPptx(bytes) {
   const presFile = zip.file("ppt/presentation.xml");
   const canvas = canvasFromPresentation(presFile ? await presFile.async("string") : void 0);
   const lang = detectDeckLang();
-  for (const { position, path } of await slidePartsInOrder(zip)) {
+  for (const { position, path, relsPath } of await slidePartsInOrder(zip)) {
     const xml = await zip.file(path).async("string");
-    findings.push(...lintSlideXml(xml, position, masterBg, lang));
+    const own = lintSlideXml(xml, position, masterBg, lang);
+    findings.push(...own);
+    if (!own.some((f) => f.code === "low-contrast-text")) {
+      const backdrop = await backdropRaster(zip, xml, relsPath, canvas);
+      if (backdrop)
+        findings.push(...lintBackdropContrast(xml, position, backdrop, canvas));
+    }
     findings.push(...lintSlideGeometry(xml, position, canvas));
   }
   return { ok: findings.length === 0, findings };
@@ -27940,76 +28637,101 @@ async function designLintPptx(bytes) {
 
 // packages/core/dist/document/deck-render-check.js
 var import_jszip2 = __toESM(require_lib3(), 1);
+init_pdf_extract();
 
-// packages/core/dist/document/pdf-extract.js
-var import_node_path = require("node:path");
-var import_node_url = require("node:url");
-var _mupdf = null;
-function loadMupdf() {
-  if (!_mupdf) {
-    const deps = process.env.TALOS_SKILL_DEPS;
-    const spec = deps ? (0, import_node_url.pathToFileURL)((0, import_node_path.join)(deps, "mupdf", "dist", "mupdf.js")).href : "mupdf";
-    _mupdf = import(spec);
+// packages/core/dist/document/pdf-fonts.js
+var import_pdf_lib = __toESM(require_cjs(), 1);
+var CJK_RANGES = [
+  [11904, 12031],
+  [12288, 12351],
+  [12352, 12543],
+  [12800, 19903],
+  [19968, 40959],
+  [63744, 64255],
+  [65072, 65103],
+  [65280, 65519]
+];
+var isCjk = (u) => CJK_RANGES.some(([a, b]) => u >= a && u <= b);
+function toUnicodeHasCjk(cmap) {
+  for (const m of cmap.matchAll(/<([0-9A-Fa-f]{4,})>/g)) {
+    const hex = m[1];
+    for (let i = 0; i + 4 <= hex.length; i += 4)
+      if (isCjk(parseInt(hex.slice(i, i + 4), 16)))
+        return true;
   }
-  return _mupdf;
+  return false;
 }
-async function openDoc(bytes) {
-  const mupdf = await loadMupdf();
-  const doc = mupdf.Document.openDocument(bytes, "application/pdf");
-  if (doc.countPages() === 0) {
-    throw new Error("PDF has no readable pages (corrupt, encrypted, or empty)");
+function streamText(stream) {
+  try {
+    if (stream instanceof import_pdf_lib.PDFRawStream)
+      return Buffer.from((0, import_pdf_lib.decodePDFRawStream)(stream).decode()).toString("latin1");
+    if (stream instanceof import_pdf_lib.PDFStream)
+      return Buffer.from(stream.getContents()).toString("latin1");
+  } catch {
   }
-  return { mupdf, doc };
+  return "";
 }
-async function extractPdfTextLines(bytes) {
-  const { doc } = await openDoc(bytes);
+var nameOf = (v) => v instanceof import_pdf_lib.PDFName ? v.decodeText() : void 0;
+async function scanPdfType3Fonts(pdfBytes) {
+  const doc = await import_pdf_lib.PDFDocument.load(pdfBytes, { ignoreEncryption: true, updateMetadata: false, throwOnInvalidObject: false });
+  const ctx = doc.context;
+  const deref = (v) => v instanceof import_pdf_lib.PDFRef ? ctx.lookup(v) : v;
   const out = [];
-  for (let p = 1; p <= doc.countPages(); p++) {
-    const page = doc.loadPage(p - 1);
-    const [x0, y0, x1, y1] = page.getBounds();
-    const json = JSON.parse(page.toStructuredText().asJSON());
-    const lines = [];
-    for (const b of json.blocks ?? []) {
-      if (b.type === "image")
-        continue;
-      for (const l of b.lines ?? []) {
-        const text = l.text ?? "";
-        if (!text.trim() || !l.bbox)
-          continue;
-        lines.push({
-          x: l.bbox.x ?? 0,
-          y: l.bbox.y ?? 0,
-          w: l.bbox.w ?? 0,
-          h: l.bbox.h ?? 0,
-          size: l.font?.size ?? 12,
-          text
-        });
+  doc.getPages().forEach((page, i) => {
+    const seen = /* @__PURE__ */ new Set();
+    const visitResources = (res, depth) => {
+      const r = deref(res);
+      if (!(r instanceof import_pdf_lib.PDFDict) || depth > 8)
+        return;
+      const fonts = deref(r.get(import_pdf_lib.PDFName.of("Font")));
+      if (fonts instanceof import_pdf_lib.PDFDict) {
+        for (const [key, ref] of fonts.entries()) {
+          const font = deref(ref);
+          if (!(font instanceof import_pdf_lib.PDFDict) || seen.has(font))
+            continue;
+          seen.add(font);
+          if (nameOf(font.get(import_pdf_lib.PDFName.of("Subtype"))) !== "Type3")
+            continue;
+          const name = nameOf(font.get(import_pdf_lib.PDFName.of("BaseFont"))) ?? nameOf(font.get(import_pdf_lib.PDFName.of("Name"))) ?? key.decodeText();
+          out.push({ page: i + 1, name, cjk: toUnicodeHasCjk(streamText(deref(font.get(import_pdf_lib.PDFName.of("ToUnicode"))))) });
+        }
       }
-    }
-    out.push({ page: p, width: x1 - x0, height: y1 - y0, lines });
-  }
-  return out;
-}
-async function renderPdfPages(bytes, pages, scale = 2) {
-  const { mupdf, doc } = await openDoc(bytes);
-  const total = doc.countPages();
-  const wanted = pages === "all" ? Array.from({ length: total }, (_, i) => i + 1) : pages;
-  const out = [];
-  const matrix = mupdf.Matrix.scale(scale, scale);
-  for (const p of wanted) {
-    if (p < 1 || p > total)
-      continue;
-    const pix = doc.loadPage(p - 1).toPixmap(matrix, mupdf.ColorSpace.DeviceRGB, false, true);
-    out.push({ page: p, png: pix.asPNG() });
-  }
+      const xobjects = deref(r.get(import_pdf_lib.PDFName.of("XObject")));
+      if (xobjects instanceof import_pdf_lib.PDFDict) {
+        for (const [, ref] of xobjects.entries()) {
+          const xo = deref(ref);
+          if (!(xo instanceof import_pdf_lib.PDFStream) || seen.has(xo))
+            continue;
+          seen.add(xo);
+          if (nameOf(xo.dict.get(import_pdf_lib.PDFName.of("Subtype"))) === "Form")
+            visitResources(xo.dict.get(import_pdf_lib.PDFName.of("Resources")), depth + 1);
+        }
+      }
+    };
+    visitResources(page.node.Resources(), 0);
+  });
   return out;
 }
 
 // packages/core/dist/document/deck-render-check.js
+function type3Findings(fonts) {
+  const byPage = /* @__PURE__ */ new Map();
+  for (const f of fonts)
+    byPage.set(f.page, [...byPage.get(f.page) ?? [], f]);
+  return [...byPage].map(([slide, list]) => {
+    const cjk = list.some((f) => f.cjk);
+    return {
+      slide,
+      code: "render-type3-font",
+      message: `the Office render draws ${list.map((f) => f.name + (f.cjk ? " (CJK)" : "")).join(", ")} as a Type 3 font \u2014 ` + (cjk ? "LibreOffice could not embed the face it fell back to, and its Type 3 CJK glyphs paint nothing: that text is blank on the page" : "LibreOffice could not embed the face it fell back to (bitmap or empty glyphs)") + "; render through doc-convert (its font replacement table), never a bare soffice"
+    };
+  });
+}
 var OVERFLOW_PITCH = 0.5;
 var SIDE_TOL = 0.5;
 var HANG_TOL = 1.1;
 var HANGING_PUNCT = /[、，。；：！？）」』》,.;:!?)]$/;
+var NEAR_PITCHES = 3;
 var DEFAULT_PT = 18;
 var squash = (s) => s.replace(/\s+/g, "");
 var snippet = (s) => s.length > 24 ? `${s.slice(0, 24)}\u2026` : s;
@@ -28046,10 +28768,11 @@ function checkRenderedSlide(slideXml, slideNumber, canvas, page) {
   let worstSide;
   for (const line of page.lines) {
     const text = squash(line.text);
-    let candidates = boxes.filter((b) => b.text.includes(text));
+    const near = (b) => b.text.includes(text) && distance(b, line) <= NEAR_PITCHES * b.pitch;
+    let candidates = boxes.filter(near);
     const merged = !candidates.length && text.length > 1;
     if (merged)
-      candidates = boxes.filter((b) => b.text.includes(text.slice(1)));
+      candidates = boxes.filter((b) => b.text.includes(text.slice(1)) && distance(b, line) <= NEAR_PITCHES * b.pitch);
     if (!candidates.length)
       continue;
     const box = candidates.reduce((best, b) => distance(b, line) < distance(best, line) ? b : best);
@@ -28129,7 +28852,8 @@ async function checkRenderedDeck(pptxBytes, pdfBytes) {
   }
   const presXml = await zip.file("ppt/presentation.xml")?.async("string");
   const canvas = canvasFromPresentation(presXml);
-  const findings = [];
+  const type3Fonts = await scanPdfType3Fonts(pdfBytes);
+  const findings = type3Findings(type3Fonts);
   const charts = [];
   for (const { position, path } of slides) {
     const xml = await zip.file(path).async("string");
@@ -28137,16 +28861,55 @@ async function checkRenderedDeck(pptxBytes, pdfBytes) {
     if (/drawingml\/2006\/chart"/.test(xml))
       charts.push(position);
   }
+  findings.sort((a, b) => a.slide - b.slide);
   const review = [.../* @__PURE__ */ new Set([...findings.map((f) => f.slide), ...charts])].sort((a, b) => a - b);
-  return { findings, charts, review };
+  return { findings, charts, review, type3Fonts };
 }
 
+// apps/admin/data/skills.lib/document/bin-src/deck-qa.mjs
+init_pdf_extract();
+
 // apps/admin/data/skills.lib/document/bin-src/lib/check-pptx.mjs
 var import_node_path3 = require("node:path");
 
 // packages/core/dist/document/doc-validate.js
+var import_jszip5 = __toESM(require_lib3(), 1);
+var import_pdf_lib2 = __toESM(require_cjs(), 1);
+
+// packages/core/dist/document/pptx-notes.js
 var import_jszip3 = __toESM(require_lib3(), 1);
-var import_pdf_lib = __toESM(require_cjs(), 1);
+var REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var NOTES_SLIDE_REL = `${REL_NS}/notesSlide`;
+var NOTES_MASTER_REL = `${REL_NS}/notesMaster`;
+var SLIDE_REL = `${REL_NS}/slide`;
+async function notesKeynoteIssues(zip) {
+  const out = [];
+  for (const p of Object.keys(zip.files).filter((p2) => /^ppt\/notesSlides\/notesSlide\d+\.xml$/.test(p2)).sort()) {
+    const xml = await zip.file(p).async("string");
+    if (!/<p:clrMapOvr\b/.test(xml))
+      out.push(p);
+  }
+  return out;
+}
+async function unlistedNotesMaster(zip) {
+  const relsFile = zip.file("ppt/_rels/presentation.xml.rels");
+  const presFile = zip.file("ppt/presentation.xml");
+  if (!relsFile || !presFile)
+    return null;
+  const rel = new RegExp(`<Relationship\\b[^>]*Type="${NOTES_MASTER_REL}"[^>]*>`).exec(await relsFile.async("string"))?.[0];
+  const rid = rel ? /\bId="([^"]+)"/.exec(rel)?.[1] : void 0;
+  if (!rid)
+    return null;
+  return /<p:notesMasterId\b/.test(await presFile.async("string")) ? null : rid;
+}
+
+// packages/core/dist/document/docx-defaults.js
+var import_jszip4 = __toESM(require_lib3(), 1);
+function hasDefaultParagraphStyle(stylesXml) {
+  return [...stylesXml.matchAll(/<w:style\b[^>]*>/g)].some(([tag]) => /\bw:type="paragraph"/.test(tag) && /\bw:default="(1|true|on)"/.test(tag));
+}
+
+// packages/core/dist/document/doc-validate.js
 function looksLikePdf(bytes) {
   const head = Buffer.from(bytes.subarray(0, 1024)).toString("latin1");
   return head.includes("%PDF-");
@@ -28156,8 +28919,19 @@ async function validatePdf(bytes) {
   const warnings = [];
   let pages;
   try {
-    const doc = await import_pdf_lib.PDFDocument.load(bytes, { ignoreEncryption: true, throwOnInvalidObject: true, updateMetadata: false });
+    const doc = await import_pdf_lib2.PDFDocument.load(bytes, { ignoreEncryption: true, throwOnInvalidObject: true, updateMetadata: false });
     pages = doc.getPageCount();
+    if (doc.isEncrypted) {
+      const { pdfNeedsPassword: pdfNeedsPassword2 } = await Promise.resolve().then(() => (init_pdf_extract(), pdf_extract_exports));
+      if (await pdfNeedsPassword2(bytes).catch(() => true)) {
+        errors.push({
+          code: "pdf-encrypted",
+          message: "the PDF needs a password to open, so its content cannot be checked or rendered \u2014 validate (and render) the unencrypted file before `pdf-ops encrypt`; to inspect this one, `pdf-ops decrypt <in> <password> <out>` first"
+        });
+        return { ok: false, kind: "pdf", errors, warnings, pages };
+      }
+      warnings.push({ code: "pdf-encrypted", message: 'the PDF is encrypted with an owner password only: it opens without a password, but pdf-form / pdf-ops cannot edit it until `pdf-ops decrypt <in> "" <out>`' });
+    }
     if (pages === 0)
       errors.push({ code: "pdf-no-pages", message: "the PDF parses but has no pages" });
     else
@@ -28315,7 +29089,7 @@ async function validateOoxml(bytes) {
   const result = (kind) => ({ ok: errors.length === 0, kind, errors, warnings });
   let zip;
   try {
-    zip = await import_jszip3.default.loadAsync(Buffer.from(bytes));
+    zip = await import_jszip5.default.loadAsync(Buffer.from(bytes));
   } catch (e) {
     errors.push({ code: "zip-unreadable", message: `not a readable OOXML zip: ${e.message}` });
     return result("unknown");
@@ -28383,6 +29157,30 @@ async function validateOoxml(bytes) {
       }
     }
   }
+  if (root.kind === "pptx") {
+    const bad = await notesKeynoteIssues(zip);
+    if (bad.length) {
+      errors.push({
+        code: "notes-keynote",
+        part: bad[0],
+        message: `${bad.length} notes slide(s) lack <p:clrMapOvr> (${bad.slice(0, 3).join(", ")}${bad.length > 3 ? ", \u2026" : ""}) \u2014 Keynote refuses the whole file ("\u6587\u4EF6\u683C\u5F0F\u65E0\u6548"). Repair with \`pptx-notes <in.pptx> {} <out.pptx>\`; write notes with pptx-notes, never by hand`
+      });
+    }
+  }
+  if (root.kind === "pptx" && await unlistedNotesMaster(zip)) {
+    errors.push({
+      code: "notes-keynote",
+      part: "ppt/presentation.xml",
+      message: 'the notes master is not listed in <p:notesMasterIdLst> (python-pptx leaves it out) \u2014 Keynote refuses the whole file ("\u6587\u4EF6\u683C\u5F0F\u65E0\u6548"). Repair with `pptx-notes <in.pptx> {} <out.pptx>`'
+    });
+  }
+  if (root.kind === "docx" && has("word/styles.xml") && !hasDefaultParagraphStyle(await text("word/styles.xml"))) {
+    errors.push({
+      code: "docx-default-style",
+      part: "word/styles.xml",
+      message: 'no default paragraph style (w:default="1", usually "Normal") \u2014 Word fills the gap, but Pages lays every unstyled paragraph out like the one before it (a centred title turns the whole body huge and centred). Repair with `docx-defaults <in.docx> <out.docx>`; docx from doc-gen already has it'
+    });
+  }
   return result(root.kind);
 }
 
@@ -28390,7 +29188,7 @@ async function validateOoxml(bytes) {
 var import_node_path2 = require("node:path");
 var import_node_url2 = require("node:url");
 var import_promises = require("node:fs/promises");
-var import_jszip4 = __toESM(require_lib3(), 1);
+var import_jszip6 = __toESM(require_lib3(), 1);
 var _xmllint = null;
 function loadXmllint() {
   if (!_xmllint) {
@@ -28446,7 +29244,7 @@ function errText(e) {
 }
 async function validateOoxmlStrict(bytes, schemaDir) {
   const [{ validateXML }, schemas] = await Promise.all([loadXmllint(), loadSchemaSet(schemaDir)]);
-  const zip = await import_jszip4.default.loadAsync(Buffer.from(bytes));
+  const zip = await import_jszip6.default.loadAsync(Buffer.from(bytes));
   const checked = [];
   const skipped = [];
   const errors = [];
@@ -28528,16 +29326,17 @@ function printLint(result) {
 async function officeRender(deck, pdf, cacheDir) {
   const bin = (0, import_node_path4.join)((0, import_node_path4.dirname)(process.argv[1]), "doc-convert.cjs");
   try {
-    const { stdout } = await (0, import_node_util.promisify)(import_node_child_process.execFile)(process.execPath, [bin, deck, pdf, "--cache-dir", cacheDir], {
+    const { stdout } = await (0, import_node_util.promisify)(import_node_child_process.execFile)(process.execPath, [bin, deck, pdf, "--cache-dir", cacheDir, "--require-office"], {
       maxBuffer: 8 * 1024 * 1024
     });
     const engine = /\[([^\]]+)\]\s*$/.exec(stdout.trim())?.[1] ?? "unknown";
     return { engine, faithful: /libreoffice/i.test(engine), pdf };
   } catch (e) {
-    return { error: (e.stderr || e.message || String(e)).trim().split("\n").slice(-3).join(" ") };
+    const error = (e.stderr || e.message || String(e)).trim().split("\n").slice(-3).join(" ");
+    return { faithful: false, error, unavailable: e.code === 69 };
   }
 }
-async function finalSignOff(file, bytes, cacheDir) {
+async function finalSignOff(file, bytes, cacheDir, requireOffice) {
   const check = await checkPptx(bytes, { strict: true });
   if (!check.valid || check.strict?.ok === false) {
     process.stdout.write(JSON.stringify({ ok: false, valid: check.valid, errors: check.errors, strict: check.strict }) + "\n");
@@ -28554,6 +29353,7 @@ async function finalSignOff(file, bytes, cacheDir) {
     const rendered = await checkRenderedDeck(bytes, pdfBytes).catch((e) => die(`render check failed: ${e.message}`));
     findings = [...findings, ...rendered.findings].sort((a, b) => a.slide - b.slide);
     ({ review, charts } = rendered);
+    office.type3Fonts = rendered.type3Fonts;
     if (review.length) {
       for (const r of await renderPdfPages(new Uint8Array(pdfBytes), review, 1)) {
         const path = (0, import_node_path4.join)((0, import_node_path4.dirname)(office.pdf), `${stem}.office_p${r.page}.png`);
@@ -28562,13 +29362,19 @@ async function finalSignOff(file, bytes, cacheDir) {
       }
     }
   }
-  const result = { ok: findings.length === 0, valid: true, strict: check.strict, findings, office, review, charts, previews };
+  const blocked = Boolean(office.error) && (!office.unavailable || requireOffice);
+  const result = { ok: findings.length === 0 && !blocked, valid: true, strict: check.strict, findings, office, review, charts, previews };
   process.stdout.write(JSON.stringify(result, null, 1) + "\n");
+  if (office.error && !office.unavailable) {
+    die(`the Office render failed (${office.error}) \u2014 not signing off on a Chromium reconstruction instead; rerun deck-qa --final`);
+  }
+  if (office.error && requireOffice) die(`--require-office: no LibreOffice render is possible here (${office.error})`);
+  if (office.type3Fonts?.length) {
+    process.stderr.write(`deck-qa: the Office render draws ${office.type3Fonts.length} Type 3 font(s) (${[...new Set(office.type3Fonts.map((f) => f.name))].join(", ")}) \u2014 text set in them may be blank; see the render-type3-font findings
+`);
+  }
   if (office.error) {
     process.stderr.write(`deck-qa: no Office render (${office.error}) \u2014 the HTML preview is the only visual check; say so when delivering
-`);
-  } else if (!office.faithful) {
-    process.stderr.write(`deck-qa: rendered with ${office.engine}, not LibreOffice \u2014 no Office layout to check; the HTML preview stands
 `);
   } else {
     process.stderr.write(review.length ? `deck-qa: look at ${previews.length} slide image(s) in "previews"; every other slide is as the HTML preview showed
@@ -28580,21 +29386,24 @@ async function main() {
   const asJson = args.includes("--json");
   const final = args.includes("--final");
   const rendered = flagValue(args, "--rendered");
-  const cacheDir = flagValue(args, "--cache-dir") ?? process.env.TALOS_OFFICE_CACHE_DIR ?? (0, import_node_path4.join)((0, import_node_os.tmpdir)(), "talos-office-cache");
   const valued = /* @__PURE__ */ new Set(["--rendered", "--cache-dir"]);
   const file = args.find((a, i) => !a.startsWith("--") && !valued.has(args[i - 1]));
-  const usage = "usage: deck-qa <file.pptx> [--json] [--rendered <office.pdf> | --final [--cache-dir <dir>]]";
+  const cacheDir = flagValue(args, "--cache-dir") ?? (process.env.TALOS_OFFICE_CACHE_DIR || void 0) ?? (file ? (0, import_node_path4.join)((0, import_node_path4.dirname)(file), ".office-cache") : void 0);
+  const requireOffice = args.includes("--require-office");
+  const usage = "usage: deck-qa <file.pptx> [--json] [--rendered <office.pdf> | --final [--cache-dir <dir>] [--require-office]]";
   if (!file) die(usage, 64);
+  if (/\.html?$/i.test(file)) die("deck-qa checks the exported .pptx, not the HTML. While authoring: `html2pptx deck.html --preview-dir <dir> --style <id>` (previews to look at); the lint runs on every export \u2014 `html2pptx deck.html out.pptx --style <id>` prints it as `qa`. Sign off once with `deck-qa out.pptx --final`.", 64);
   if (!/\.pptx$/i.test(file)) die("deck-qa only lints .pptx decks", 64);
   if (rendered && !/\.pdf$/i.test(rendered)) die("--rendered takes the .pdf doc-convert wrote for this deck", 64);
   if (final && rendered) die("--final renders the deck itself; drop --rendered", 64);
+  if (requireOffice && !final) die("--require-office only applies to --final", 64);
   let bytes;
   try {
     bytes = await (0, import_promises2.readFile)(file);
   } catch (e) {
     die(`cannot read ${file}: ${e.message}`, 66);
   }
-  if (final) return finalSignOff(file, new Uint8Array(bytes), cacheDir);
+  if (final) return finalSignOff(file, new Uint8Array(bytes), cacheDir, requireOffice);
   let result;
   try {
     result = await designLintPptx(bytes);
@@ -28615,7 +29424,7 @@ async function main() {
       die(`render check failed: ${e.message}`);
     }
     const findings = [...result.findings, ...check.findings].sort((a, b) => a.slide - b.slide);
-    result = { ok: findings.length === 0, findings, charts: check.charts, review: check.review };
+    result = { ok: findings.length === 0, findings, charts: check.charts, review: check.review, type3Fonts: check.type3Fonts };
   }
   if (asJson) {
     process.stdout.write(JSON.stringify(result) + "\n");