@taloswork/ose-shared 0.1.11 → 0.1.12

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

@@ -9823,6 +9823,393 @@ var require_lib3 = __commonJS({
   }
 });
 
+// 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,
+  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 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;
+  }
+});
+
 // node_modules/pdf-lib/node_modules/tslib/tslib.es6.js
 var tslib_es6_exports = {};
 __export(tslib_es6_exports, {
@@ -12239,11 +12626,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 +12644,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 +12676,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 +12791,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 +12822,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 +12838,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 +12850,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 +12867,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 +12876,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 +12886,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 +12895,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 +12912,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 +12936,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 +12973,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 +13001,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 +13016,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 +13061,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 +13075,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 +18741,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 +22630,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 +22649,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 +22671,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 +26352,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 +26394,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 +26412,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 +26430,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 +26445,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 +26510,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 +26574,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 +26596,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 +26621,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 +26663,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 +26671,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 +26699,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.embedFont = function(font, options) {
+        PDFDocument4.prototype.embedFont = function(font, options) {
           if (options === void 0) {
             options = {};
           }
@@ -26355,7 +26742,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 +26753,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 +26772,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 +26791,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 +26804,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 +26823,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 +26838,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 +26888,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 +26916,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.save = function(options) {
+        PDFDocument4.prototype.save = function(options) {
           if (options === void 0) {
             options = {};
           }
@@ -26559,7 +26946,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.saveAsBase64 = function(options) {
+        PDFDocument4.prototype.saveAsBase64 = function(options) {
           if (options === void 0) {
             options = {};
           }
@@ -26579,7 +26966,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 +26977,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 +27003,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 +27014,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 +27022,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 +27971,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 +28028,118 @@ 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/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 +28280,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;
@@ -27822,7 +28320,10 @@ 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 LABEL_MAX_CHARS = 24;
+var MIN_LABEL_FONT_HUNDREDTHS = 800;
+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 +28341,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 +28409,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 = [...text].length <= LABEL_MAX_CHARS ? MIN_LABEL_FONT_HUNDREDTHS : MIN_FONT_HUNDREDTHS;
+      if (sz && +sz < floor && (!smallest || +sz < smallest.sz)) {
+        smallest = { sz: +sz, text, floor };
       }
     }
   }
@@ -27888,7 +28441,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 +28466,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 +28577,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 +28607,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 +28623,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 +28754,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 +28838,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 +28847,20 @@ 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_jszip3 = __toESM(require_lib3(), 1);
-var import_pdf_lib = __toESM(require_cjs(), 1);
+var import_pdf_lib2 = __toESM(require_cjs(), 1);
 function looksLikePdf(bytes) {
   const head = Buffer.from(bytes.subarray(0, 1024)).toString("latin1");
   return head.includes("%PDF-");
@@ -28156,8 +28870,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
@@ -28528,16 +29253,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 +29280,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 +29289,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 +29313,23 @@ 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 (!/\.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 +29350,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");