gutterpress 0.11.17-alpha.2 → 0.11.17-alpha.4

package/dist/index-ht1bcqdd.js

@@ -0,0 +1,493 @@
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/lib/black-text-gray.ts
+var MAX_CHANNEL = 0.12;
+var MAX_SPREAD = 0.04;
+function isNearBlack([r, g, b]) {
+  const max = Math.max(r, g, b);
+  return max <= MAX_CHANNEL && max - Math.min(r, g, b) <= MAX_SPREAD;
+}
+var WS = new Set([0, 9, 10, 12, 13, 32]);
+var DELIM = new Set("()<>[]{}/%".split("").map((c) => c.charCodeAt(0)));
+function* tokenize(s) {
+  let i = 0;
+  const n = s.length;
+  while (i < n) {
+    const c = s.charCodeAt(i);
+    if (WS.has(c)) {
+      i++;
+      continue;
+    }
+    const start = i;
+    if (c === 37) {
+      while (i < n && s[i] !== `
+` && s[i] !== "\r")
+        i++;
+      continue;
+    }
+    if (c === 40) {
+      let depth = 0;
+      while (i < n) {
+        const d = s[i++];
+        if (d === "\\")
+          i++;
+        else if (d === "(")
+          depth++;
+        else if (d === ")" && --depth === 0)
+          break;
+      }
+      yield { text: s.slice(start, i), start, end: i, op: false };
+      continue;
+    }
+    if (c === 60 && s[i + 1] === "<") {
+      i += 2;
+      yield { text: "<<", start, end: i, op: false };
+      continue;
+    }
+    if (c === 62 && s[i + 1] === ">") {
+      i += 2;
+      yield { text: ">>", start, end: i, op: false };
+      continue;
+    }
+    if (c === 60) {
+      while (i < n && s[i] !== ">")
+        i++;
+      i++;
+      yield { text: s.slice(start, i), start, end: i, op: false };
+      continue;
+    }
+    if (c === 91 || c === 93 || c === 62 || c === 123 || c === 125 || c === 41) {
+      i++;
+      yield { text: s[start], start, end: i, op: false };
+      continue;
+    }
+    i++;
+    while (i < n && !WS.has(s.charCodeAt(i)) && !DELIM.has(s.charCodeAt(i)))
+      i++;
+    const text = s.slice(start, i);
+    const isOperand = c === 47 || /^[+-]?(\d+\.?\d*|\.\d+)$/.test(text);
+    yield { text, start, end: i, op: !isOperand };
+    if (text === "ID") {
+      const m = /\sEI(?=\s|$)/g;
+      m.lastIndex = i;
+      const hit = m.exec(s);
+      i = hit ? hit.index + hit[0].length : n;
+    }
+  }
+}
+var LARGE_TEXT_PT = 24;
+var SIZE_EPS = 0.05;
+var area = (m) => Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
+
+class TextScale {
+  ctm;
+  font = 0;
+  tm = 1;
+  stack = [];
+  constructor(ctm) {
+    this.ctm = ctm;
+  }
+  get unit() {
+    return this.ctm;
+  }
+  get size() {
+    return this.font * this.tm * this.ctm;
+  }
+  op(op, nums) {
+    switch (op) {
+      case "q":
+        this.stack.push([this.ctm, this.font]);
+        return false;
+      case "Q": {
+        const p = this.stack.pop();
+        if (p)
+          [this.ctm, this.font] = p;
+        return true;
+      }
+      case "cm":
+        if (nums.length === 6)
+          this.ctm *= area(nums);
+        return true;
+      case "BT":
+        this.tm = 1;
+        return true;
+      case "Tm":
+        if (nums.length === 6)
+          this.tm = area(nums);
+        return true;
+      case "Tf":
+        this.font = Math.abs(nums[nums.length - 1] ?? 0) || 0;
+        return true;
+    }
+    return false;
+  }
+}
+function rewriteBlackText(src, ctx = {}) {
+  let fill = null;
+  let stroke = null;
+  const stack = [];
+  const scale = new TextScale(ctx.baseScale ?? 1);
+  let inText = false;
+  let fillDirty = false;
+  let strokeDirty = false;
+  const spans = [];
+  let lastOp = "";
+  let rect = null;
+  const edits = [];
+  let operands = [];
+  const rgbOf = () => {
+    if (operands.length !== 3)
+      return null;
+    const v = operands.map((t) => Number(t.text));
+    return v.some((x) => Number.isNaN(x)) ? null : { rgb: v, raw: operands.map((t) => t.text).join(" ") };
+  };
+  const isSmall = () => scale.size <= LARGE_TEXT_PT + SIZE_EPS;
+  let fillIns = null;
+  let strokeIns = null;
+  const syncOne = (colour, dirty, ins, at, gray, op) => {
+    if (!colour || !isNearBlack(colour.rgb))
+      return [dirty, ins];
+    const small = isSmall();
+    if (small && !dirty) {
+      const e = { start: at, end: at, text: ` ${gray}` };
+      edits.push(e);
+      return [true, e];
+    }
+    if (!small && dirty) {
+      if (ins)
+        ins.text = "";
+      else
+        edits.push({ start: at, end: at, text: ` ${colour.raw} ${op}` });
+      return [false, null];
+    }
+    return [dirty, ins];
+  };
+  const sync = (at) => {
+    [fillDirty, fillIns] = syncOne(fill, fillDirty, fillIns, at, "0 g", "rg");
+    [strokeDirty, strokeIns] = syncOne(stroke, strokeDirty, strokeIns, at, "0 G", "RG");
+  };
+  const flush = (s) => {
+    for (const r of s.rects) {
+      if (r.thickness > 0.2 * s.maxSmall)
+        continue;
+      edits.push({ start: r.start, end: r.start, text: "q 0 g " }, { start: r.end, end: r.end, text: " Q" });
+    }
+  };
+  for (const t of tokenize(src)) {
+    if (!t.op) {
+      operands.push(t);
+      continue;
+    }
+    const op = t.text;
+    const nums = operands.map((o) => Number(o.text));
+    const sizeMayHaveChanged = scale.op(op, nums);
+    switch (op) {
+      case "q":
+        stack.push([fill, stroke]);
+        break;
+      case "Q": {
+        const p = stack.pop();
+        if (p)
+          [fill, stroke] = p;
+        break;
+      }
+      case "BT":
+        inText = true;
+        fillDirty = strokeDirty = false;
+        fillIns = strokeIns = null;
+        sync(t.end);
+        break;
+      case "Tf":
+      case "Tm":
+        if (inText && sizeMayHaveChanged)
+          sync(t.end);
+        break;
+      case "ET":
+        if (inText) {
+          let ins = "";
+          if (fillDirty && fill)
+            ins += `${fill.raw} rg `;
+          if (strokeDirty && stroke)
+            ins += `${stroke.raw} RG `;
+          if (ins)
+            edits.push({ start: t.start, end: t.start, text: ins });
+        }
+        inText = false;
+        fillIns = strokeIns = null;
+        break;
+      case "rg":
+      case "RG": {
+        const c = rgbOf();
+        const isFill = op === "rg";
+        if (isFill)
+          fill = c;
+        else
+          stroke = c;
+        if (inText && c && isNearBlack(c.rgb) && isSmall()) {
+          edits.push({ start: operands[0].start, end: t.end, text: isFill ? "0 g" : "0 G" });
+          if (isFill)
+            fillDirty = true;
+          else
+            strokeDirty = true;
+        } else if (inText) {
+          if (isFill)
+            fillDirty = false;
+          else
+            strokeDirty = false;
+        }
+        break;
+      }
+      case "g":
+      case "k":
+      case "sc":
+      case "scn":
+      case "cs":
+        fill = null;
+        if (inText)
+          fillDirty = false;
+        break;
+      case "G":
+      case "K":
+      case "SC":
+      case "SCN":
+      case "CS":
+        stroke = null;
+        if (inText)
+          strokeDirty = false;
+        break;
+      case "Do": {
+        const name = operands[operands.length - 1]?.text;
+        if (name?.startsWith("/"))
+          ctx.onDo?.(name.slice(1), scale.unit);
+        break;
+      }
+      case "BDC":
+      case "BMC":
+        spans.push({ hasSmall: false, maxSmall: 0, rects: [] });
+        break;
+      case "EMC": {
+        const s = spans.pop();
+        if (!s)
+          break;
+        const parent = spans[spans.length - 1];
+        if (s.hasSmall)
+          flush(s);
+        else
+          parent?.rects.push(...s.rects);
+        if (parent && s.hasSmall) {
+          parent.hasSmall = true;
+          parent.maxSmall = Math.max(parent.maxSmall, s.maxSmall);
+        }
+        break;
+      }
+      case "Tj":
+      case "TJ":
+      case "'":
+      case '"': {
+        fillIns = strokeIns = null;
+        const span = spans[spans.length - 1];
+        if (span && inText && isSmall()) {
+          span.hasSmall = true;
+          span.maxSmall = Math.max(span.maxSmall, scale.size);
+        }
+        break;
+      }
+      case "re":
+        rect = !inText && fill && isNearBlack(fill.rgb) && operands.length === 4 && nums.every((x) => !Number.isNaN(x)) ? { start: operands[0].start, thickness: Math.min(Math.abs(nums[2]), Math.abs(nums[3])) * scale.unit } : null;
+        break;
+      case "f":
+      case "F":
+      case "f*":
+        if (rect && lastOp === "re")
+          spans[spans.length - 1]?.rects.push({ ...rect, end: t.end });
+        break;
+    }
+    lastOp = op;
+    operands = [];
+  }
+  return applyEdits(src, edits);
+}
+function applyEdits(s, edits) {
+  if (!edits.length)
+    return s;
+  edits.sort((a, b) => a.start - b.start);
+  let out = "";
+  let pos = 0;
+  for (const e of edits) {
+    out += s.slice(pos, e.start) + e.text;
+    pos = e.end;
+  }
+  return out + s.slice(pos);
+}
+function isRichBlack(c) {
+  const [cy, m, y, k] = c;
+  const lo = Math.min(cy, m, y);
+  return k >= 0.7 && lo >= 0.3 && Math.max(cy, m, y) - lo <= 0.25;
+}
+function countRichBlackText(src, ctx = {}) {
+  const scale = new TextScale(ctx.baseScale ?? 1);
+  let fill = null;
+  const stack = [];
+  let count = 0;
+  let operands = [];
+  for (const t of tokenize(src)) {
+    if (!t.op) {
+      operands.push(t);
+      continue;
+    }
+    const op = t.text;
+    const nums = operands.map((o) => Number(o.text));
+    scale.op(op, nums);
+    switch (op) {
+      case "q":
+        stack.push(fill);
+        break;
+      case "Q":
+        if (stack.length)
+          fill = stack.pop() ?? null;
+        break;
+      case "k":
+        fill = nums.length === 4 && !nums.some(Number.isNaN) ? nums : null;
+        break;
+      case "sc":
+      case "scn":
+        fill = nums.length === 4 && !nums.some(Number.isNaN) ? nums : null;
+        break;
+      case "g":
+      case "rg":
+      case "cs":
+        fill = null;
+        break;
+      case "Do": {
+        const name = operands[operands.length - 1]?.text;
+        if (name?.startsWith("/"))
+          ctx.onDo?.(name.slice(1), scale.unit);
+        break;
+      }
+      case "Tj":
+      case "TJ":
+      case "'":
+      case '"':
+        if (fill && isRichBlack(fill) && scale.size <= LARGE_TEXT_PT + SIZE_EPS)
+          count++;
+        break;
+    }
+    operands = [];
+  }
+  return count;
+}
+async function visitContent(doc, visit) {
+  const { PDFName, PDFRawStream, PDFArray, PDFRef, PDFDict, decodePDFRawStream } = await import("pdf-lib");
+  const ctx = doc.context;
+  const SKIP = ["Filter", "DecodeParms", "Length"].map((k) => PDFName.of(k));
+  let changed = false;
+  const decode = (s) => {
+    try {
+      return Buffer.from(decodePDFRawStream(s).decode()).toString("latin1");
+    } catch {
+      return null;
+    }
+  };
+  const replace = (ref, old, text) => {
+    const entries = {};
+    for (const [k, v] of old.dict.entries())
+      if (!SKIP.includes(k))
+        entries[k.decodeText()] = v;
+    ctx.assign(ref, ctx.flateStream(Buffer.from(text, "latin1"), entries));
+    changed = true;
+  };
+  const formScale = new Map;
+  const formPages = new Map;
+  const formMatrixScale = (form) => {
+    const m = form.dict.lookupMaybe(PDFName.of("Matrix"), PDFArray);
+    const nums = m?.asArray().map((n) => Number(n.toString()));
+    return nums?.length === 6 && !nums.some(Number.isNaN) ? area(nums) : 1;
+  };
+  const pages = doc.getPages();
+  for (let p = 0;p < pages.length; p++) {
+    const page = pages[p];
+    const contents = page.node.Contents();
+    const refs = [];
+    if (contents instanceof PDFArray) {
+      for (let i = 0;i < contents.size(); i++) {
+        const r = contents.get(i);
+        if (r instanceof PDFRef)
+          refs.push(r);
+      }
+    } else if (contents instanceof PDFRawStream) {
+      const r = page.node.get(PDFName.of("Contents"));
+      if (r instanceof PDFRef)
+        refs.push(r);
+    }
+    const streams = refs.map((r) => ctx.lookup(r));
+    if (!refs.length || !streams.every((s) => s instanceof PDFRawStream))
+      continue;
+    const parts = streams.map((s) => decode(s));
+    if (parts.some((q) => q === null))
+      continue;
+    const joined = parts.join(`
+`);
+    const xobjects = page.node.Resources()?.lookupMaybe(PDFName.of("XObject"), PDFDict);
+    const next = visit(joined, {
+      baseScale: 1,
+      pages: [p + 1],
+      onDo: (name, scale) => {
+        const ref = xobjects?.get(PDFName.of(name));
+        const form = ref instanceof PDFRef ? ctx.lookup(ref) : undefined;
+        if (!(ref instanceof PDFRef) || !(form instanceof PDFRawStream))
+          return;
+        if (form.dict.get(PDFName.of("Subtype")) !== PDFName.of("Form"))
+          return;
+        const at = scale * formMatrixScale(form);
+        formScale.set(ref.tag, Math.min(formScale.get(ref.tag) ?? Infinity, at));
+        (formPages.get(ref.tag) ?? formPages.set(ref.tag, new Set).get(ref.tag)).add(p + 1);
+      }
+    });
+    if (next === joined)
+      continue;
+    replace(refs[0], streams[0], next);
+    page.node.set(PDFName.of("Contents"), refs[0]);
+  }
+  for (const [ref, obj] of ctx.enumerateIndirectObjects()) {
+    if (!(obj instanceof PDFRawStream))
+      continue;
+    if (obj.dict.get(PDFName.of("Subtype")) !== PDFName.of("Form"))
+      continue;
+    const text = decode(obj);
+    if (text === null)
+      continue;
+    const next = visit(text, {
+      baseScale: formScale.get(ref.tag) ?? 0,
+      pages: [...formPages.get(ref.tag) ?? []]
+    });
+    if (next !== text)
+      replace(ref, obj, next);
+  }
+  return changed;
+}
+async function blackTextToGray(pdf) {
+  const { PDFDocument } = await import("pdf-lib");
+  const doc = await PDFDocument.load(pdf, { updateMetadata: false });
+  const changed = await visitContent(doc, (src, info) => rewriteBlackText(src, info));
+  return changed ? doc.save({ updateFieldAppearances: false }) : pdf;
+}
+async function findRichBlackText(pdf) {
+  const { PDFDocument } = await import("pdf-lib");
+  const doc = await PDFDocument.load(pdf, { updateMetadata: false });
+  let runs = 0;
+  const pages = new Set;
+  await visitContent(doc, (src, info) => {
+    const n = countRichBlackText(src, info);
+    if (n) {
+      runs += n;
+      for (const p of info.pages)
+        pages.add(p);
+    }
+    return src;
+  });
+  return { runs, pages: [...pages].sort((a, b) => a - b) };
+}
+
+export { LARGE_TEXT_PT, rewriteBlackText, countRichBlackText, blackTextToGray, findRichBlackText };