@uurtech/jdf-cli 0.1.24 → 0.1.26

package/dist/index.js

@@ -640,6 +640,38 @@ function rgbToHex(r, g, b) {
   const h = (n) => clampByte(n).toString(16).padStart(2, "0");
   return `#${h(r)}${h(g)}${h(b)}`;
 }
+function averageStops(stops) {
+  if (!Array.isArray(stops) || stops.length === 0) return null;
+  let r = 0, g = 0, b = 0, n = 0;
+  for (const st of stops) {
+    const css = Array.isArray(st) ? st[1] : null;
+    const m = typeof css === "string" && css.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+    if (!m) continue;
+    r += parseInt(m[1], 16);
+    g += parseInt(m[2], 16);
+    b += parseInt(m[3], 16);
+    n++;
+  }
+  return n ? rgbToHex(r / n, g / n, b / n) : null;
+}
+function patternToColor(page, arg) {
+  if (!Array.isArray(arg)) return null;
+  if (arg[0] === "TilingPattern") {
+    const c = arg[1];
+    return Array.isArray(c) && c.length >= 3 ? rgbToHex(c[0], c[1], c[2]) : null;
+  }
+  if (arg[0] === "Shading") {
+    const id = arg[1];
+    try {
+      const store = typeof id === "string" && id.startsWith("g_") ? page.commonObjs : page.objs;
+      if (typeof store?.has === "function" && !store.has(id)) return null;
+      const ir = store.get(id);
+      if (Array.isArray(ir) && ir[0] === "RadialAxial") return averageStops(ir[3]);
+    } catch {
+    }
+  }
+  return null;
+}
 function multiplyCtm(a, b) {
   return [
     a[0] * b[0] + a[1] * b[2],
@@ -658,7 +690,7 @@ async function walkOps(page, OPS, viewport) {
     const [vx, vy] = viewport.convertToViewportPoint(x, y);
     return { x: vx, y: vy };
   };
-  const opList = await page.getOperatorList();
+  const opList = await page.getOperatorList({ annotationMode: annotationModeDisable });
   const fnArr = opList.fnArray;
   const argsArr = opList.argsArray;
   const gs = {
@@ -668,15 +700,38 @@ async function walkOps(page, OPS, viewport) {
     lineWidth: 1,
     fillAlpha: 1,
     strokeAlpha: 1,
-    textRenderingMode: 0
+    textRenderingMode: 0,
+    // Text state (PDF 9.3) — needed to know where each showText lands.
+    fontSize: 0,
+    charSpacing: 0,
+    wordSpacing: 0,
+    hscale: 1,
+    leading: 0,
+    rise: 0
   };
+  const snapshot = () => ({ ...gs, ctm: [...gs.ctm] });
   const stack = [];
-  const textColors = [];
-  const textOpacities = [];
-  const textRenderingModes = [];
+  const textOps = [];
   const shapes = [];
   const imagePositions = [];
-  let textIdx = 0;
+  let tm = [1, 0, 0, 1, 0, 0];
+  let tlm = [1, 0, 0, 1, 0, 0];
+  function pushImage(name, ctm, inline, maskFill) {
+    const corners = [tx(ctm, 0, 0), tx(ctm, 1, 0), tx(ctm, 1, 1), tx(ctm, 0, 1)];
+    const vpCorners = corners.map((p) => toViewport(p.x, p.y));
+    const xs = vpCorners.map((p) => p.x), ys = vpCorners.map((p) => p.y);
+    const minX = Math.min(...xs), maxX = Math.max(...xs);
+    const minY = Math.min(...ys), maxY = Math.max(...ys);
+    imagePositions.push({
+      name,
+      x: minX * PT_TO_MM,
+      y: minY * PT_TO_MM,
+      w: (maxX - minX) * PT_TO_MM,
+      h: (maxY - minY) * PT_TO_MM,
+      inline,
+      maskFill
+    });
+  }
   let pathSegments = [];
   let pathRect = null;
   let pathStart = null;
@@ -798,10 +853,51 @@ async function walkOps(page, OPS, viewport) {
     const fn = fnArr[i];
     const args = argsArr[i] || [];
     if (fn === OPS.save) {
-      stack.push({ ctm: [...gs.ctm], fill: gs.fill, stroke: gs.stroke, lineWidth: gs.lineWidth, fillAlpha: gs.fillAlpha, strokeAlpha: gs.strokeAlpha, textRenderingMode: gs.textRenderingMode });
+      stack.push(snapshot());
     } else if (fn === OPS.restore) {
       const s = stack.pop();
       if (s) Object.assign(gs, s);
+    } else if (fn === OPS.paintFormXObjectBegin) {
+      stack.push(snapshot());
+      const matrix = args[0];
+      if (Array.isArray(matrix) && matrix.length === 6) gs.ctm = multiplyCtm(matrix, gs.ctm);
+    } else if (fn === OPS.paintFormXObjectEnd) {
+      const s = stack.pop();
+      if (s) Object.assign(gs, s);
+    } else if (fn === OPS.beginText) {
+      tm = [1, 0, 0, 1, 0, 0];
+      tlm = [1, 0, 0, 1, 0, 0];
+    } else if (fn === OPS.setTextMatrix) {
+      tm = [...args];
+      tlm = [...tm];
+    } else if (fn === OPS.moveText) {
+      tlm = multiplyCtm([1, 0, 0, 1, args[0], args[1]], tlm);
+      tm = [...tlm];
+    } else if (fn === OPS.setLeadingMoveText) {
+      gs.leading = -args[1];
+      tlm = multiplyCtm([1, 0, 0, 1, args[0], args[1]], tlm);
+      tm = [...tlm];
+    } else if (fn === OPS.nextLine) {
+      tlm = multiplyCtm([1, 0, 0, 1, 0, -gs.leading], tlm);
+      tm = [...tlm];
+    } else if (fn === OPS.setLeading) {
+      gs.leading = args[0];
+    } else if (fn === OPS.setFont) {
+      gs.fontSize = typeof args[1] === "number" ? args[1] : gs.fontSize;
+    } else if (fn === OPS.setCharSpacing) {
+      gs.charSpacing = args[0];
+    } else if (fn === OPS.setWordSpacing) {
+      gs.wordSpacing = args[0];
+    } else if (fn === OPS.setHScale) {
+      gs.hscale = (args[0] ?? 100) / 100;
+    } else if (fn === OPS.setTextRise) {
+      gs.rise = args[0];
+    } else if (fn === OPS.setFillColorN) {
+      const c = patternToColor(page, args[0]);
+      if (c) gs.fill = c;
+    } else if (fn === OPS.setStrokeColorN) {
+      const c = patternToColor(page, args[0]);
+      if (c) gs.stroke = c;
     } else if (fn === OPS.transform) {
       gs.ctm = multiplyCtm(args, gs.ctm);
     } else if (fn === OPS.setFillRGBColor) {
@@ -835,11 +931,23 @@ async function walkOps(page, OPS, viewport) {
           else if (key === "CA") gs.strokeAlpha = val;
         }
       }
-    } else if (fn === OPS.showText || fn === OPS.showSpacedText || fn === OPS.nextLineShowText || fn === OPS.nextLineSetSpacingShowText) {
-      textColors[textIdx] = gs.fill;
-      textOpacities[textIdx] = gs.fillAlpha;
-      textRenderingModes[textIdx] = gs.textRenderingMode;
-      textIdx++;
+    } else if (fn === OPS.showText) {
+      const trm = multiplyCtm(tm, gs.ctm);
+      const origin = tx(trm, 0, gs.rise);
+      const vp = toViewport(origin.x, origin.y);
+      const scale = Math.hypot(trm[2], trm[3]) || 1;
+      textOps.push({ x: vp.x, y: vp.y, fontSize: gs.fontSize * scale, fill: gs.fill, alpha: gs.fillAlpha, mode: gs.textRenderingMode });
+      let advance = 0;
+      const glyphs = Array.isArray(args[0]) ? args[0] : [];
+      for (const g of glyphs) {
+        if (typeof g === "number") {
+          advance += -g / 1e3 * gs.fontSize * gs.hscale;
+        } else if (g && typeof g === "object") {
+          const w = typeof g.width === "number" ? g.width : 0;
+          advance += (w / 1e3 * gs.fontSize + gs.charSpacing + (g.isSpace ? gs.wordSpacing : 0)) * gs.hscale;
+        }
+      }
+      tm = multiplyCtm([1, 0, 0, 1, advance, 0], tm);
     } else if (fn === OPS.rectangle) {
       const [x, y, w, h] = args;
       const p1 = tx(gs.ctm, x, y);
@@ -903,56 +1011,124 @@ async function walkOps(page, OPS, viewport) {
       pathRect = null;
       pathStart = null;
       pathLast = null;
-    } else if (fn === OPS.paintImageXObject || fn === OPS.paintImageMaskXObject || fn === OPS.paintInlineImageXObject) {
-      const name = args[0];
-      const c = gs.ctm;
-      const corners = [tx(c, 0, 0), tx(c, 1, 0), tx(c, 1, 1), tx(c, 0, 1)];
-      const vpCorners = corners.map((p) => toViewport(p.x, p.y));
-      const xs = vpCorners.map((p) => p.x), ys = vpCorners.map((p) => p.y);
-      const minX = Math.min(...xs), maxX = Math.max(...xs);
-      const minY = Math.min(...ys), maxY = Math.max(...ys);
-      imagePositions.push({
-        name,
-        x: minX * PT_TO_MM,
-        y: minY * PT_TO_MM,
-        w: (maxX - minX) * PT_TO_MM,
-        h: (maxY - minY) * PT_TO_MM
-      });
+    } else if (fn === OPS.paintImageXObject) {
+      pushImage(String(args[0]), gs.ctm);
+    } else if (fn === OPS.paintImageXObjectRepeat) {
+      const [name, scaleX, scaleY, positions] = args;
+      if (Array.isArray(positions)) {
+        for (let k = 0; k + 1 < positions.length; k += 2) {
+          pushImage(String(name), multiplyCtm([scaleX, 0, 0, scaleY, positions[k], positions[k + 1]], gs.ctm));
+        }
+      }
+    } else if (fn === OPS.paintInlineImageXObject) {
+      const img = args[0];
+      if (img && typeof img === "object") pushImage(`inline-${imagePositions.length}`, gs.ctm, img);
+    } else if (fn === OPS.paintImageMaskXObject) {
+      const img = args[0];
+      if (img && typeof img === "object") pushImage(`mask-${imagePositions.length}`, gs.ctm, img, gs.fill);
+    } else if (fn === OPS.paintImageMaskXObjectRepeat) {
+      const [img, scaleX, skewX, skewY, scaleY, positions] = args;
+      if (img && typeof img === "object" && Array.isArray(positions)) {
+        for (let k = 0; k + 1 < positions.length; k += 2) {
+          pushImage(`mask-${imagePositions.length}`, multiplyCtm([scaleX, skewX, skewY, scaleY, positions[k], positions[k + 1]], gs.ctm), img, gs.fill);
+        }
+      }
+    } else if (fn === OPS.paintImageMaskXObjectGroup) {
+      const group = args[0];
+      if (Array.isArray(group)) {
+        for (const img of group) {
+          if (img && typeof img === "object" && Array.isArray(img.transform)) {
+            pushImage(`mask-${imagePositions.length}`, multiplyCtm(img.transform, gs.ctm), img, gs.fill);
+          }
+        }
+      }
     }
   }
-  return { textColors, textOpacities, textRenderingModes, shapes, imagePositions };
+  return { textOps, shapes, imagePositions };
 }
 async function extractImages(page, positions, runtime, dataUrlCache) {
+  const resolveObj = (id) => new Promise((resolve) => {
+    let settled2 = false;
+    const timer = setTimeout(() => done(null), 250);
+    const done = (v) => {
+      if (settled2) return;
+      settled2 = true;
+      clearTimeout(timer);
+      resolve(v);
+    };
+    try {
+      const store = id.startsWith("g_") ? page.commonObjs : page.objs;
+      store.get(id, (img) => done(img));
+    } catch {
+      try {
+        page.objs.get(id, (img) => done(img));
+      } catch {
+        done(null);
+      }
+    }
+  });
+  const maskToRgba = (data, width, height, fill) => {
+    const m = fill.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+    const r = m ? parseInt(m[1], 16) : 0, g = m ? parseInt(m[2], 16) : 0, b = m ? parseInt(m[3], 16) : 0;
+    const out = new Uint8ClampedArray(width * height * 4);
+    const rowBytes = width + 7 >> 3;
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const byte = data[y * rowBytes + (x >> 3)] ?? 255;
+        const bit = byte >> 7 - (x & 7) & 1;
+        const o = (y * width + x) * 4;
+        out[o] = r;
+        out[o + 1] = g;
+        out[o + 2] = b;
+        out[o + 3] = bit ? 0 : 255;
+      }
+    }
+    return out;
+  };
+  const encode = async (imgObj, maskFill) => {
+    if (!imgObj || !imgObj.width || !imgObj.height) return null;
+    let data = imgObj.data;
+    if (typeof data === "string") data = (await resolveObj(data))?.data ?? null;
+    if (maskFill) {
+      if (!data) return null;
+      return runtime.encodePng(imgObj.width, imgObj.height, 3, maskToRgba(data, imgObj.width, imgObj.height, maskFill));
+    }
+    if (data) {
+      let kind = imgObj.kind || 0;
+      if (!kind) {
+        const px = imgObj.width * imgObj.height;
+        if (data.length === px * 4) kind = 3;
+        else if (data.length === px * 3) kind = 2;
+        else if (data.length === (imgObj.width + 7 >> 3) * imgObj.height) kind = 1;
+      }
+      return runtime.encodePng(imgObj.width, imgObj.height, kind, data);
+    }
+    if (imgObj.bitmap) {
+      try {
+        const { canvas, context } = runtime.createCanvas(imgObj.width, imgObj.height);
+        context.drawImage(imgObj.bitmap, 0, 0);
+        if (typeof canvas.toDataURL === "function") return canvas.toDataURL("image/png");
+        if (typeof canvas.toBuffer === "function") return `data:image/png;base64,${canvas.toBuffer("image/png").toString("base64")}`;
+      } catch {
+      }
+    }
+    return null;
+  };
   const tasks = positions.map(async (pos) => {
+    if (pos.inline) {
+      const dataUrl2 = await encode(pos.inline, pos.maskFill);
+      return dataUrl2 ? { pos, dataUrl: dataUrl2 } : null;
+    }
     if (dataUrlCache.has(pos.name)) {
       return { pos, dataUrl: dataUrlCache.get(pos.name) };
     }
     let imgObj = null;
     try {
-      imgObj = await new Promise((resolve) => {
-        let settled2 = false;
-        const timer = setTimeout(() => done(null), 250);
-        const done = (v) => {
-          if (settled2) return;
-          settled2 = true;
-          clearTimeout(timer);
-          resolve(v);
-        };
-        try {
-          page.objs.get(pos.name, (img) => done(img));
-        } catch {
-          try {
-            page.commonObjs.get(pos.name, (img) => done(img));
-          } catch {
-            done(null);
-          }
-        }
-      });
+      imgObj = await resolveObj(pos.name);
     } catch {
       imgObj = null;
     }
-    if (!imgObj || !imgObj.data || !imgObj.width || !imgObj.height) return null;
-    const dataUrl = runtime.encodePng(imgObj.width, imgObj.height, imgObj.kind || 0, imgObj.data);
+    const dataUrl = await encode(imgObj);
     if (!dataUrl) return null;
     dataUrlCache.set(pos.name, dataUrl);
     return { pos, dataUrl };
@@ -960,7 +1136,20 @@ async function extractImages(page, positions, runtime, dataUrlCache) {
   const settled = await Promise.all(tasks);
   return settled.filter((x) => x !== null);
 }
-async function extractLinks(page, viewport) {
+async function resolveDestPage(doc, dest) {
+  try {
+    let d = dest;
+    if (typeof d === "string") d = await doc.getDestination(d);
+    if (Array.isArray(d) && d[0] != null) {
+      if (typeof d[0] === "number") return d[0];
+      const idx = await doc.getPageIndex(d[0]);
+      if (typeof idx === "number") return idx;
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function extractLinks(doc, page, viewport) {
   const out = [];
   let annots = [];
   try {
@@ -989,7 +1178,9 @@ async function extractLinks(page, viewport) {
       h: (yMax - yMin) * PT_TO_MM
     };
     const url = a.url || a.unsafeUrl;
-    out.push({ rectMm, url });
+    const destPage = url ? void 0 : await resolveDestPage(doc, a.dest);
+    if (!url && destPage == null) continue;
+    out.push({ rectMm, url, destPage });
   }
   return out;
 }
@@ -1045,26 +1236,62 @@ async function extractFormWidgets(page, viewport) {
 async function flattenOutline(doc, outline) {
   if (!outline) return [];
   const out = [];
-  async function walk(items) {
+  async function walk(items, depth) {
     for (const item of items) {
-      try {
-        let dest = item.dest;
-        if (typeof dest === "string") {
-          dest = await doc.getDestination(dest);
-        }
-        if (Array.isArray(dest) && dest[0]) {
-          const ref = dest[0];
-          const idx = await doc.getPageIndex(ref);
-          if (typeof idx === "number") out.push({ title: item.title, pageIndex: idx });
-        }
-      } catch {
+      const idx = await resolveDestPage(doc, item.dest);
+      if (idx != null && typeof item.title === "string" && item.title.trim()) {
+        out.push({ title: item.title.trim(), pageIndex: idx, depth });
       }
-      if (item.items?.length) await walk(item.items);
+      if (item.items?.length) await walk(item.items, depth + 1);
     }
   }
-  await walk(outline);
+  await walk(outline, 1);
   return out;
 }
+var normTitle = (s) => s.toLowerCase().replace(/[\s\u00a0]+/g, " ").replace(/[^\p{L}\p{N} ]/gu, "").trim();
+function applyOutline(pages, outline) {
+  for (const entry of outline) {
+    const page = pages[entry.pageIndex];
+    if (!page) continue;
+    const want = normTitle(entry.title);
+    if (!want) continue;
+    let best = null;
+    let bestScore = 0;
+    for (const el of page.elements) {
+      if (el.type !== "text") continue;
+      const have = normTitle(el.content || "");
+      if (!have) continue;
+      let score = 0;
+      if (have === want) score = 3;
+      else if (have.startsWith(want) || want.startsWith(have)) score = 2;
+      else if (have.length >= 6 && want.includes(have)) score = 1;
+      if (score > bestScore || score === bestScore && best && score > 0 && (el.position?.y ?? 0) < (best.position?.y ?? 0)) {
+        best = el;
+        bestScore = score;
+      }
+    }
+    if (best && bestScore > 0) {
+      const level = Math.min(6, Math.max(1, entry.depth));
+      if (!best.heading) best.heading = level;
+      best.tocEntry = entry.title;
+      best.tocLevel = level;
+    }
+  }
+}
+function pdfDateToIso(v) {
+  if (typeof v !== "string") return void 0;
+  const m = v.match(/^D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?([Zz+-])?(\d{2})?'?(\d{2})?/);
+  if (!m) {
+    const t2 = Date.parse(v);
+    return Number.isFinite(t2) ? new Date(t2).toISOString() : void 0;
+  }
+  const [, Y, Mo = "01", D = "01", h = "00", mi = "00", s = "00", sign, oh = "00", om = "00"] = m;
+  const tz = !sign || sign === "Z" || sign === "z" ? "Z" : `${sign}${oh}:${om}`;
+  const iso = `${Y}-${Mo}-${D}T${h}:${mi}:${s}${tz}`;
+  const t = Date.parse(iso);
+  return Number.isFinite(t) ? new Date(t).toISOString() : void 0;
+}
+var annotationModeDisable = 0;
 async function importPdfToJdf(source, title, runtime, options = {}) {
   const pdfjs = options.pdfjs || runtime.pdfjs;
   if (!pdfjs) {
@@ -1085,7 +1312,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
   } else {
     data = source;
   }
-  const doc = await pdfjs.getDocument({
+  const loadingTask = pdfjs.getDocument({
     data,
     // The runtime adapter declares whether it supports a real Web Worker.
     // We don't sniff `typeof Worker` here because Node 22+ exposes a global
@@ -1094,15 +1321,55 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
     // newer Node. Browser entry leaves this unset (= false = real worker
     // via GlobalWorkerOptions.workerSrc); node entry sets `true`.
     disableWorker: runtime.disableWorker === true,
-    isEvalSupported: false
-  }).promise;
+    isEvalSupported: false,
+    // Keep going past malformed content streams instead of failing the page.
+    stopAtErrors: false,
+    // Force the classic pixel-array image path on every host so the reader
+    // (WKWebView has OffscreenCanvas) and the CLI produce identical PNGs.
+    isOffscreenCanvasSupported: false,
+    password: options.password,
+    // Standard-14 font metrics + CJK CMaps: without these PDF.js falls back
+    // to guesses for non-embedded fonts and logs a warning per page.
+    ...runtime.standardFontDataUrl ? { standardFontDataUrl: runtime.standardFontDataUrl } : {},
+    ...runtime.cMapUrl ? { cMapUrl: runtime.cMapUrl, cMapPacked: true } : {}
+  });
+  let passwordTried = typeof options.password === "string";
+  loadingTask.onPassword = (updatePassword, reason) => {
+    const retry = reason === 2 || passwordTried;
+    if (!options.onPassword) {
+      updatePassword(new Error(retry ? "[@jdf/pdf-import] Wrong password for encrypted PDF" : "[@jdf/pdf-import] PDF is password-protected \u2014 pass `password`"));
+      return;
+    }
+    passwordTried = true;
+    options.onPassword(retry).then((pw) => {
+      if (pw == null) updatePassword(new Error("[@jdf/pdf-import] Password entry cancelled"));
+      else updatePassword(pw);
+    }).catch((e) => updatePassword(e instanceof Error ? e : new Error(String(e))));
+  };
+  let doc;
+  try {
+    doc = await loadingTask.promise;
+  } catch (e) {
+    if (e?.name === "PasswordException") {
+      const msg = /no password/i.test(e.message || "") ? "PDF is password-protected \u2014 pass a password (CLI: --password)" : e.message || "PDF is password-protected";
+      throw new Error(`[@jdf/pdf-import] ${msg}`);
+    }
+    throw e;
+  }
   const pages = [];
   const imageResources = {};
   let imgCounter = 0;
   const dataUrlCache = /* @__PURE__ */ new Map();
   const resourceKeyByName = /* @__PURE__ */ new Map();
-  const outline = await doc.getOutline().catch(() => null);
-  await flattenOutline(doc, outline);
+  const outline = await flattenOutline(doc, await doc.getOutline().catch(() => null));
+  let pdfInfo = null;
+  let pdfMetadata = null;
+  try {
+    const md = await doc.getMetadata();
+    pdfInfo = md?.info ?? null;
+    pdfMetadata = md?.metadata ?? null;
+  } catch {
+  }
   for (let pi = 1; pi <= doc.numPages; pi++) {
     let findLinkForRun2 = function(r) {
       const cx = r.x + r.width / 2;
@@ -1124,7 +1391,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
     } catch {
     }
     const ops = await walkOps(page, OPS, viewport);
-    const links = await extractLinks(page, viewport);
+    const links = await extractLinks(doc, page, viewport);
     const formWidgets = await extractFormWidgets(page, viewport);
     const textContent = await page.getTextContent({ disableCombineTextItems: false });
     const items = textContent.items;
@@ -1167,9 +1434,53 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       const n = typeof v === "number" ? v : Number(v);
       return Number.isFinite(n) ? n : fallback;
     };
-    items.forEach((it, idx) => {
+    const opBins = /* @__PURE__ */ new Map();
+    for (const op of ops.textOps) {
+      const key = `${Math.round(op.x)},${Math.round(op.y)}`;
+      const arr = opBins.get(key);
+      if (arr) arr.push(op);
+      else opBins.set(key, [op]);
+    }
+    const findOp = (x, y, fontSize) => {
+      let best = null;
+      let bestD = Infinity;
+      const bx = Math.round(x), by = Math.round(y);
+      for (let dy = -1; dy <= 1; dy++) {
+        for (let dx = -1; dx <= 1; dx++) {
+          const arr = opBins.get(`${bx + dx},${by + dy}`);
+          if (!arr) continue;
+          for (const op of arr) {
+            const d = Math.hypot(op.x - x, op.y - y);
+            if (d < bestD) {
+              bestD = d;
+              best = op;
+            }
+          }
+        }
+      }
+      if (best) return best;
+      const tol = Math.max(2, fontSize * 0.6);
+      for (const op of ops.textOps) {
+        if (Math.abs(op.y - y) > tol) continue;
+        const d = Math.abs(op.x - x) + Math.abs(op.y - y) * 4;
+        if (d < bestD) {
+          bestD = d;
+          best = op;
+        }
+      }
+      if (best) return best;
+      for (const op of ops.textOps) {
+        const d = Math.hypot(op.x - x, op.y - y);
+        if (d < bestD) {
+          bestD = d;
+          best = op;
+        }
+      }
+      return bestD < 40 ? best : null;
+    };
+    const keepInvisible = options.invisibleText !== "drop";
+    items.forEach((it) => {
       if (!it.str || !it.str.length) return;
-      if ((ops.textRenderingModes[idx] ?? 0) === 3) return;
       const tr = it.transform;
       const fontSize = safeNum(Math.hypot(safeNum(tr?.[2], 0), safeNum(tr?.[3], 0)), 0) || safeNum(it.height, 0) || 10;
       const baseX = safeNum(tr?.[4], 0);
@@ -1177,6 +1488,11 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       const conv = viewport.convertToViewportPoint(baseX, baseY);
       const vx = safeNum(conv?.[0], 0);
       const vy = safeNum(conv?.[1], 0);
+      const op = findOp(vx, vy, fontSize);
+      const mode = op?.mode ?? 0;
+      if (mode === 7) return;
+      const invisible = mode === 3;
+      if (invisible && !keepInvisible) return;
       const ascent = it.height ? safeNum(it.height, fontSize) * 0.78 : fontSize * 0.78;
       const yTop = vy - ascent;
       const w = safeNum(it.width, 0);
@@ -1188,8 +1504,8 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         fontName: it.fontName,
         width: safeNum(w * PT_TO_MM, 0),
         height: safeNum((it.height || fontSize) * PT_TO_MM, fontSize * PT_TO_MM),
-        color: ops.textColors[idx] || "#000000",
-        opacity: safeNum(ops.textOpacities[idx], 1)
+        color: op?.fill || "#000000",
+        opacity: invisible ? 0 : safeNum(op?.alpha, 1)
       });
     });
     runs.sort((a, b) => a.y - b.y || a.x - b.x);
@@ -1332,14 +1648,36 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       elements
     });
   }
+  applyOutline(pages, outline);
+  const meta = {
+    title,
+    pageSize: pages[0]?.pageSize || "A4",
+    unit: "mm",
+    margins: { top: 0, right: 0, bottom: 0, left: 0 }
+  };
+  if (pdfInfo) {
+    if (typeof pdfInfo.Author === "string" && pdfInfo.Author.trim()) meta.author = pdfInfo.Author.trim();
+    const created = pdfDateToIso(pdfInfo.CreationDate);
+    const modified = pdfDateToIso(pdfInfo.ModDate);
+    if (created) meta.created = created;
+    if (modified) meta.modified = modified;
+    if (typeof pdfInfo.Keywords === "string") {
+      const kws = pdfInfo.Keywords.split(/[,;]+/).map((k) => k.trim()).filter(Boolean);
+      if (kws.length) meta.keywords = kws;
+    }
+    if (typeof pdfInfo.Language === "string" && pdfInfo.Language.trim()) meta.language = pdfInfo.Language.trim();
+  }
+  if (!meta.language && pdfMetadata && typeof pdfMetadata.get === "function") {
+    try {
+      const lang = pdfMetadata.get("dc:language");
+      const first = Array.isArray(lang) ? lang[0] : lang;
+      if (typeof first === "string" && first.trim()) meta.language = first.trim();
+    } catch {
+    }
+  }
   const result = {
     $jdf: "1.0.0",
-    meta: {
-      title,
-      pageSize: pages[0]?.pageSize || "A4",
-      unit: "mm",
-      margins: { top: 0, right: 0, bottom: 0, left: 0 }
-    },
+    meta,
     pages
   };
   if (Object.keys(imageResources).length > 0) {
@@ -1351,27 +1689,31 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
 // ../../packages/jdf-pdf-import/src/node.ts
 var pdfjsModule = null;
 var pdfjsLoadPromise = null;
+var pdfjsAssetDirs = null;
 async function loadNodePdfJs() {
   if (pdfjsModule) return pdfjsModule;
   if (pdfjsLoadPromise) return pdfjsLoadPromise;
   pdfjsLoadPromise = (async () => {
     const { createRequire } = await import('module');
     const require_ = createRequire(import.meta.url);
-    const origWarn = console.warn;
-    console.warn = (...args) => {
-      if (typeof args[0] === "string" && args[0].includes("legacy")) return;
-      origWarn.apply(console, args);
+    const origLog = console.log;
+    console.log = (...args) => {
+      if (typeof args[0] === "string" && args[0].includes("`legacy` build")) return;
+      origLog.apply(console, args);
     };
     let lib;
     try {
       lib = await import('pdfjs-dist/build/pdf.mjs');
     } finally {
-      console.warn = origWarn;
+      console.log = origLog;
     }
     const workerPath = require_.resolve("pdfjs-dist/build/pdf.worker.mjs");
     if (lib.GlobalWorkerOptions) {
       lib.GlobalWorkerOptions.workerSrc = workerPath;
     }
+    const { dirname, join } = await import('path');
+    const pkgDir = dirname(dirname(workerPath));
+    pdfjsAssetDirs = { standardFontDataUrl: join(pkgDir, "standard_fonts") + "/", cMapUrl: join(pkgDir, "cmaps") + "/" };
     pdfjsModule = lib;
     return lib;
   })();
@@ -1382,6 +1724,10 @@ async function loadCanvas() {
   if (canvasModule) return canvasModule;
   try {
     canvasModule = await import('@napi-rs/canvas');
+    const g = globalThis;
+    if (typeof g.DOMMatrix === "undefined" && canvasModule.DOMMatrix) g.DOMMatrix = canvasModule.DOMMatrix;
+    if (typeof g.Path2D === "undefined" && canvasModule.Path2D) g.Path2D = canvasModule.Path2D;
+    if (typeof g.ImageData === "undefined" && canvasModule.ImageData) g.ImageData = canvasModule.ImageData;
     return canvasModule;
   } catch (err) {
     throw new Error(
@@ -1433,6 +1779,7 @@ async function importPdfToJdf2(source, title, options = {}) {
   const runtime = {
     pdfjs,
     disableWorker: true,
+    ...pdfjsAssetDirs ?? {},
     createCanvas(width, height) {
       const canvas = canvasMod.createCanvas(width, height);
       const context = canvas.getContext("2d");
@@ -1457,7 +1804,10 @@ async function importPdf(inputPath, outputPath, options = {}) {
   console.log(`Importing: ${input}`);
   const title = path2.basename(input, path2.extname(input));
   const t0 = Date.now();
-  const doc = await importPdfToJdf2(input, title);
+  const doc = await importPdfToJdf2(input, title, {
+    password: options.password,
+    invisibleText: options.dropInvisibleText ? "drop" : "keep"
+  });
   console.log(`Parsed in ${((Date.now() - t0) / 1e3).toFixed(1)}s \u2014 ${doc.pages.length} page(s)`);
   let output;
   if (outputPath) {
@@ -2048,7 +2398,7 @@ The CLI exists for these workflows:
 
 Usage:
   jdf validate <file.jdf>
-  jdf convert  <file.{pdf,json,md}> [-o output.{jdf,jdfx}] [--json]
+  jdf convert  <file.{pdf,json,md}> [-o output.{jdf,jdfx}] [--json] [--password PW] [--drop-invisible-text]
   jdf chunk    <file.{jdf,jdfx}> [--strategy section|element|fixed] [--format jsonl|json|inline] [--max-tokens N] [-o out]
   jdf embed    <file.{jdf,jdfx}> [--provider ollama|openai] [--model NAME] [--strategy \u2026] [--incremental] [-o out]
   jdf --help
@@ -2063,6 +2413,11 @@ Flags:
   -o, --output <path>   Explicit output path
       --json            convert: force pure JSON .jdf output (inline base64
                         instead of a .jdfx zip bundle)
+      --password <pw>   convert(pdf): password for an encrypted PDF
+      --drop-invisible-text
+                        convert(pdf): omit invisible (OCR-layer) text; by
+                        default it is kept with opacity 0 so RAG / search
+                        still see the words of a scanned PDF
       --strategy <s>    chunk/embed: section (default) | element | fixed
       --format <f>      chunk: jsonl (default) | json | inline
       --max-tokens <n>  chunk/embed: soft cap per chunk (default 512)
@@ -2084,7 +2439,7 @@ Examples:
   jdf embed report.jdf                          # local embeddings via Ollama (auto-setup)
   jdf embed report.jdf --provider openai --incremental
 `;
-var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["help", "h", "json", "verbose", "skip-validate", "incremental", "no-auto-start"]);
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["help", "h", "json", "verbose", "skip-validate", "incremental", "no-auto-start", "drop-invisible-text"]);
 function parseArgs(argv) {
   const positional = [];
   const flags = {};
@@ -2164,7 +2519,11 @@ async function main() {
           await importMarkdown(input, output);
           process.exit(0);
         } else if (lower.endsWith(".pdf")) {
-          await importPdf(input, output, { forceJson });
+          await importPdf(input, output, {
+            forceJson,
+            password: typeof flags.password === "string" ? flags.password : void 0,
+            dropInvisibleText: flags["drop-invisible-text"] === true
+          });
           process.exit(0);
         } else if (lower.endsWith(".json")) {
           await importJson(input, output, { forceJson });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uurtech/jdf-cli",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "Command-line tool for the JDF (JSON Document Format) — validate and convert documents.",
   "license": "MIT",
   "author": "Ugur Kazdal",