@doccloak/core 0.13.0 → 0.15.0

package/dist/pdf/coverage.js

@@ -0,0 +1,193 @@
+/**
+ * @doccloak/core/pdf - text in a scan that its OCR layer does not have (T238).
+ *
+ * A scan page is redacted through its OCR text layer: what the layer does not
+ * hold (a table the OCR could not read, a stamp, a margin note) cannot be
+ * found, so it stays in the picture. This module finds such places so the
+ * reader can say so. It works on the rendered page: ink is grouped into
+ * letter-sized shapes, shapes that no OCR glyph box covers are grouped into
+ * lines, and a line of several such shapes is text the layer does not have.
+ * Rules, frames, signatures and pictures are larger than letters and never
+ * count; single marks (a page number, a tick) are too short to form a line.
+ */
+/** A pixel is ink when its luminance is below this fraction of the paper's. */
+const INK_LUMINANCE = 0.6;
+/** Letter-sized: height within these multiples of the page's OCR text size (em, in pixels). */
+const SHAPE_MIN_HEIGHT = 0.25;
+const SHAPE_MAX_HEIGHT = 1.6;
+const SHAPE_MAX_WIDTH = 2.5;
+/** A shape counts as covered when this share of its box lies under an OCR glyph box. */
+const COVERED_SHARE = 0.3;
+/** Shapes join a line when their centres are this close vertically and the gap between them this small (em). */
+const LINE_SAME_ROW = 0.45;
+const LINE_MAX_GAP = 1.2;
+/** A line needs this many shapes and this width (em): a short word, never a lone mark or the tip of a covered word. */
+const LINE_MIN_SHAPES = 5;
+const LINE_MIN_WIDTH = 2;
+/**
+ * Lines of text-like ink in `rgba` (width x height, RGBA) that none of
+ * `ocrBoxes` covers. `emPx` is the page's typical OCR text size in pixels.
+ */
+export function findTextWithoutOcr(rgba, width, height, ocrBoxes, emPx) {
+    if (!(emPx >= 4) || width <= 0 || height <= 0)
+        return [];
+    const n = width * height;
+    const paper = paperLuminance(rgba, n);
+    const ink = new Uint8Array(n);
+    for (let i = 0; i < n; i++) {
+        const lum = 0.2126 * rgba[i * 4] + 0.7152 * rgba[i * 4 + 1] + 0.0722 * rgba[i * 4 + 2];
+        if (lum < paper * INK_LUMINANCE)
+            ink[i] = 1;
+    }
+    // Coverage: every OCR glyph box, grown by a third of an em (layers sit a little off the print).
+    const covered = new Uint8Array(n);
+    const grow = Math.round(emPx / 3);
+    for (const b of ocrBoxes) {
+        const x0 = Math.max(0, Math.floor(b.x0) - grow);
+        const x1 = Math.min(width, Math.ceil(b.x1) + grow);
+        const y0 = Math.max(0, Math.floor(b.y0) - grow);
+        const y1 = Math.min(height, Math.ceil(b.y1) + grow);
+        for (let y = y0; y < y1; y++)
+            covered.fill(1, y * width + x0, y * width + x1);
+    }
+    const shapes = letterShapes(ink, covered, width, height, emPx);
+    return groupLines(shapes, emPx);
+}
+/** Median luminance of a sample of pixels: the paper, on any page that is mostly paper. */
+function paperLuminance(rgba, n) {
+    const sample = [];
+    const step = Math.max(1, Math.floor(n / 20000));
+    for (let i = 0; i < n; i += step)
+        sample.push(0.2126 * rgba[i * 4] + 0.7152 * rgba[i * 4 + 1] + 0.0722 * rgba[i * 4 + 2]);
+    sample.sort((a, b) => a - b);
+    return sample[sample.length >> 1] || 255;
+}
+/** Connected ink components (4-neighbour) that are letter-sized and not covered by the OCR layer. */
+function letterShapes(ink, covered, width, height, emPx) {
+    const label = new Int32Array(width * height);
+    const out = [];
+    const stack = [];
+    let next = 0;
+    for (let start = 0; start < ink.length; start++) {
+        if (!ink[start] || label[start])
+            continue;
+        next++;
+        label[start] = next;
+        stack.push(start);
+        let x0 = width, y0 = height, x1 = 0, y1 = 0, count = 0, under = 0;
+        while (stack.length > 0) {
+            const p = stack.pop();
+            const x = p % width;
+            const y = (p - x) / width;
+            count++;
+            if (covered[p])
+                under++;
+            if (x < x0)
+                x0 = x;
+            if (x > x1)
+                x1 = x;
+            if (y < y0)
+                y0 = y;
+            if (y > y1)
+                y1 = y;
+            if (x > 0 && ink[p - 1] && !label[p - 1]) {
+                label[p - 1] = next;
+                stack.push(p - 1);
+            }
+            if (x < width - 1 && ink[p + 1] && !label[p + 1]) {
+                label[p + 1] = next;
+                stack.push(p + 1);
+            }
+            if (y > 0 && ink[p - width] && !label[p - width]) {
+                label[p - width] = next;
+                stack.push(p - width);
+            }
+            if (y < height - 1 && ink[p + width] && !label[p + width]) {
+                label[p + width] = next;
+                stack.push(p + width);
+            }
+        }
+        const h = y1 - y0 + 1;
+        const w = x1 - x0 + 1;
+        if (h < SHAPE_MIN_HEIGHT * emPx || h > SHAPE_MAX_HEIGHT * emPx || w > SHAPE_MAX_WIDTH * emPx)
+            continue;
+        if (count < 3 || under / count >= COVERED_SHARE)
+            continue;
+        out.push({ x0, y0, x1: x1 + 1, y1: y1 + 1, cx: (x0 + x1) / 2, cy: (y0 + y1) / 2 });
+    }
+    return out;
+}
+/** Shapes on one row, each close to the next, as lines; only lines of LINE_MIN_SHAPES or more. */
+function groupLines(shapes, emPx) {
+    const sorted = [...shapes].sort((a, b) => a.cy - b.cy || a.x0 - b.x0);
+    const rows = [];
+    for (const s of sorted) {
+        const row = rows.find((r) => Math.abs(r[0].cy - s.cy) <= LINE_SAME_ROW * emPx);
+        if (row)
+            row.push(s);
+        else
+            rows.push([s]);
+    }
+    const lines = [];
+    for (const row of rows) {
+        row.sort((a, b) => a.x0 - b.x0);
+        let run = [];
+        const flush = () => {
+            const x0 = Math.min(...run.map((s) => s.x0));
+            const x1 = Math.max(...run.map((s) => s.x1));
+            if (run.length >= LINE_MIN_SHAPES && x1 - x0 >= LINE_MIN_WIDTH * emPx) {
+                lines.push({ x0, y0: Math.min(...run.map((s) => s.y0)), x1, y1: Math.max(...run.map((s) => s.y1)), shapes: run.length });
+            }
+            run = [];
+        };
+        for (const s of row) {
+            if (run.length > 0 && s.x0 - run[run.length - 1].x1 > LINE_MAX_GAP * emPx)
+                flush();
+            run.push(s);
+        }
+        flush();
+    }
+    return lines;
+}
+/**
+ * Pixel boxes of every OCR glyph on `page` (runs marked `ocr`; with `allText`, every glyph of the
+ * page's text layer), from 0.3 em below the baseline to 0.9 em above it, through the render
+ * transform [a b c d e f]; and the median glyph size in pixels (the page's text size, the scale
+ * every rule above is measured in).
+ */
+export function ocrGlyphBoxes(runs, page, transform, allText = false) {
+    const [a, b, c, d, e, f] = transform;
+    const scale = Math.hypot(a, b) || 1;
+    const boxes = [];
+    const chars = [];
+    const sizes = [];
+    for (const run of runs) {
+        if (run.page !== page || run.space || (!allText && !run.ocr))
+            continue;
+        const exLen = Math.hypot(run.emX[0], run.emX[1]) || 1;
+        const eyLen = Math.hypot(run.emY[0], run.emY[1]) || 1;
+        const ux = run.emX[0] / exLen;
+        const uy = run.emX[1] / exLen;
+        const vx = run.emY[0] / eyLen;
+        const vy = run.emY[1] / eyLen;
+        const k = exLen / (run.local.fontSize * run.local.hscale || 1);
+        for (const g of run.glyphs) {
+            if (g.unicode.trim() === '')
+                continue;
+            const w = g.advance * k;
+            const xs = [];
+            const ys = [];
+            for (const [along, up] of [[0, -0.3], [w, -0.3], [w, 0.9], [0, 0.9]]) {
+                const x = g.x + ux * along + vx * up * g.fontSize;
+                const y = g.y + uy * along + vy * up * g.fontSize;
+                xs.push(a * x + c * y + e);
+                ys.push(b * x + d * y + f);
+            }
+            boxes.push({ x0: Math.min(...xs), y0: Math.min(...ys), x1: Math.max(...xs), y1: Math.max(...ys) });
+            chars.push(g.unicode);
+            sizes.push(g.fontSize * scale);
+        }
+    }
+    sizes.sort((p, q) => p - q);
+    return { boxes, chars, emPx: sizes[sizes.length >> 1] ?? 0 };
+}

package/dist/pdf/extract.d.ts

@@ -17,7 +17,7 @@ import type { PDFContext } from './objects.js';
 import { PDFDict, PDFRef, PDFStream } from './objects.js';
 import type { ContentOp } from './lexer.js';
 import type { LoadedFont } from './fonts.js';
-import type { GlyphRun, PdfPageInfo, RemovedPart } from './types.js';
+import type { ExtraOcrPage, GlyphRun, PdfPageInfo, RemovedPart } from './types.js';
 import type { UnredactablePart } from '../dom/errors.js';
 import type { OracleDocument } from './oracle.js';
 /** One content stream we may rewrite: page contents (joined) or a form XObject. */
@@ -56,6 +56,8 @@ export interface PageRecord {
     /** Our decoder's runs and text of a raster-only page (kept for blacking out with our geometry too). */
     ownRuns?: GlyphRun[];
     ownText?: string;
+    /** Highest effective resolution of the images drawn on the page (pixels per inch; 0 without images). */
+    imageDpi: number;
 }
 export interface PdfModel {
     bytes: Uint8Array;
@@ -87,6 +89,12 @@ export interface ExtractOptions {
      * taken from the oracle (so detection still sees what a viewer shows).
      */
     oracle?: OracleDocument;
+    /**
+     * Text DocCloak read itself where a scan page's OCR layer had none (readPdf's recognizeText): its
+     * words join the page as hidden OCR runs after the page's own text, so the reader and the writer
+     * build the same flat text from the same bytes.
+     */
+    extraOcr?: ExtraOcrPage[];
 }
 export declare const DEFAULT_MAX_BYTES: number;
 export declare const DEFAULT_MAX_PAGES = 500;

package/dist/pdf/extract.js

@@ -13,7 +13,7 @@
  * never modified.
  */
 import { PDFDocument } from '@cantoo/pdf-lib';
-import { PDFArray, PDFDict, PDFName, PDFNumber, PDFRef, PDFStream, StreamDecodeError, decodeStream, getArray, getDict, getName, getNumber, getStream, inheritedPageValue, itemsOf, numbersOf, pageContentStreams, pageResources, refKey, resolve, stringText, } from "./objects.js";
+import { PDFArray, PDFDict, PDFName, PDFNumber, PDFRef, PDFStream, StreamDecodeError, decodeStream, getArray, getBool, getDict, getName, getNumber, getStream, inheritedPageValue, itemsOf, numbersOf, pageContentStreams, pageResources, refKey, resolve, stringText, } from "./objects.js";
 import { lexContent, TEXT_SHOW_OPS } from "./lexer.js";
 import { StateMachine, adjustmentAdvance, apply, glyphAdvance, initialState, mul, matrixFromOperands } from "./textstate.js";
 import { loadFont } from "./fonts.js";
@@ -92,11 +92,12 @@ export async function extractPdf(bytes, options = {}) {
             index: p,
             dict: pageDict,
             ref: pageRef,
-            info: { index: p, width, height, rotate, hasImages: false, imageOnly: false, textStart: text.length, textEnd: text.length },
+            info: { index: p, width, height, rotate, hasImages: false, imageOnly: false, ocrText: false, textStart: text.length, textEnd: text.length },
             streams: [],
             issues: [],
             hiddenGlyphs: 0,
             oracleText: false,
+            imageDpi: 0,
         };
         model.pages.push(record);
         const pageTextStart = text.length;
@@ -143,8 +144,11 @@ export async function extractPdf(bytes, options = {}) {
         if (glyphCount > maxGlyphs) {
             throw new UnsupportedDocumentError('too-large', `PDF holds more than ${maxGlyphs} glyphs; the limit protects the host's memory`, [String(glyphCount)]);
         }
+        walker.markOcrText(runs, pageRunStart);
         record.info.hasImages = walker.sawImage;
         record.info.imageOnly = walker.sawImage && walker.visibleGlyphs === 0;
+        record.info.ocrText = walker.ocrGlyphs > 0;
+        record.imageDpi = walker.imageDpi();
         let oracleGarbage = false;
         if (options.oracle && !record.hostile) {
             let items = null;
@@ -186,16 +190,30 @@ export async function extractPdf(bytes, options = {}) {
                     appendOracleRuns(p, items, runs, text);
                     if (items.some((it) => it.str.trim() !== ''))
                         record.info.imageOnly = false;
+                    // The oracle's runs replace ours and carry no OCR marks: the page is blacked out as a raster-only page.
+                    record.info.ocrText = false;
                 }
             }
         }
+        const extra = options.extraOcr?.find((x) => x.page === p);
+        if (extra && !record.oracleText && extra.lines.length > 0) {
+            record.info.ocrReadWords = appendExtraOcrRuns(p, extra.lines, runs, text);
+            // A picture without any text layer, read whole by DocCloak's OCR: from here on a scan with an
+            // OCR layer (its values are painted over in the picture), not a page left as it is.
+            if (extra.whole && record.info.imageOnly && record.info.ocrReadWords > 0)
+                record.info.ocrText = true;
+        }
         record.info.textEnd = text.length;
-        if (record.info.imageOnly) {
+        if (record.info.imageOnly && record.info.ocrText) {
+            // A scan with an OCR text layer: detection reads the layer, and the writer paints the
+            // placeholders into the picture where the layer says the values are.
+        }
+        else if (record.info.imageOnly) {
             unredactable.push({
                 part: `page ${p + 1}`,
                 kind: 'scanned-page',
                 label: record.hiddenGlyphs > 0
-                    ? `page ${p + 1} is a scanned image with a hidden OCR text layer: the text layer is redacted, the picture keeps the original`
+                    ? `page ${p + 1} is a scanned image with a hidden text layer that is not over the picture: the text layer is redacted, the picture keeps the original`
                     : `page ${p + 1} is an image without a text layer (scanned page); its content cannot be redacted`,
             });
         }
@@ -217,7 +235,7 @@ export async function extractPdf(bytes, options = {}) {
         text.pageBreak();
     }
     const removed = scanDocumentLevelParts(ctx, doc, model, warnings);
-    const plainText = text.toString();
+    const plainText = ocrRulesAsSpaces(text.toString(), runs);
     aggregatePageParts(unredactable);
     // Reading-order insertion can put a later operator's text before an earlier one's: keep the
     // runs in flat-text order (the writer's segment mapping relies on it).
@@ -233,6 +251,29 @@ export async function extractPdf(bytes, options = {}) {
         model,
     };
 }
+/** Characters an OCR reads off a table's vertical rules. */
+const OCR_RULE = /^[|¦]$/;
+/**
+ * In OCR text a table's vertical rules read as "|", often glued to a cell's word ("|Kraków"), and
+ * the detector then misses the word. Those characters read as spaces in the flat text, one for one,
+ * so every offset still maps to its glyph (the glyphs, and the layer written for a painted page,
+ * keep what the OCR read).
+ */
+function ocrRulesAsSpaces(plain, runs) {
+    let units = null;
+    for (const run of runs) {
+        if (!run.ocr)
+            continue;
+        run.glyphs.forEach((g, i) => {
+            const at = run.textOffsets[i];
+            if (!OCR_RULE.test(g.unicode) || at === undefined || at < 0 || plain[at] !== g.unicode)
+                return;
+            units ?? (units = plain.split(''));
+            units[at] = ' ';
+        });
+    }
+    return units ? units.join('') : plain;
+}
 /** pdf.js `view`: the CropBox clipped to the MediaBox (defaults to US Letter when absent). */
 function pageBox(mediaBox, cropBox) {
     const m = mediaBox.length === 4 ? mediaBox : [0, 0, 612, 792];
@@ -544,13 +585,68 @@ function appendOracleRuns(page, items, runs, text) {
         });
     });
 }
-/* ------------------------------------------------------------------ */
-/* Content walker                                                      */
-/* ------------------------------------------------------------------ */
+/**
+ * Runs for text DocCloak read with its own OCR (one run per word, one glyph per letter, in user
+ * space), after the page's own text: a blank line, then each line's words. They are hidden OCR text
+ * with no stream behind them (`oracle`), so the writer paints them and never edits a stream for
+ * them. Returns the number of words.
+ */
+function appendExtraOcrRuns(page, lines, runs, text) {
+    let count = 0;
+    text.append('\n\n');
+    lines.forEach((line, li) => {
+        line.forEach((word, wi) => {
+            if (wi > 0)
+                text.append(' ');
+            const glyphs = [];
+            const textOffsets = [];
+            const advances = [];
+            const start = text.length;
+            let along = 0;
+            for (const g of word.glyphs) {
+                textOffsets.push(text.length);
+                text.append(g.unicode);
+                glyphs.push({ code: -1, codeLength: 0, unicode: g.unicode, width: word.size > 0 ? (g.advance / word.size) * 1000 : 0, advance: g.advance, x: g.x, y: g.y, fontSize: word.size, item: 0, byteOffset: 0 });
+                advances.push(along);
+                along += g.advance;
+            }
+            runs.push({
+                page,
+                streamKey: `ocr:p${page}`,
+                opIndex: count,
+                fontName: '',
+                fontKey: '',
+                glyphs,
+                renderMode: 3,
+                hidden: true,
+                ocr: true,
+                textOffsets,
+                textStart: start,
+                textEnd: text.length,
+                emX: [word.dir[0] * word.size, word.dir[1] * word.size],
+                emY: [word.up[0] * word.size, word.up[1] * word.size],
+                local: { ctm: [1, 0, 0, 1, 0, 0], tm: [1, 0, 0, 1, 0, 0], tlm: [1, 0, 0, 1, 0, 0], fontSize: word.size, charSpacing: 0, wordSpacing: 0, hscale: 1, leading: 0, rise: 0, advances },
+                oracle: true,
+            });
+            count++;
+        });
+        if (li < lines.length - 1)
+            text.append('\n');
+    });
+    return count;
+}
+/** Constant alpha below this paints nothing a reader can see. */
+const MIN_VISIBLE_ALPHA = 0.02;
 class Walker {
     constructor(model, page, runs, text, box) {
         this.sawImage = false;
         this.visibleGlyphs = 0;
+        /** Glyphs of text hidden over an image (an OCR layer), counted by markOcrText. */
+        this.ocrGlyphs = 0;
+        this.images = [];
+        /** Paint order of text runs and images on this page (text drawn before an opaque image is covered by it). */
+        this.order = 0;
+        this.runOrder = new Map();
         this.undecodableGlyphs = 0;
         /** A composite font without a usable CMap/ToUnicode showed text: pdf.js's reading of it is a guess (glyph ids), never trusted. */
         this.unreadableCompositeFont = false;
@@ -569,6 +665,13 @@ class Walker {
         const { ctx } = this.model;
         const fontsDict = getDict(ctx, stream.resources, 'Font');
         const resolveFont = (name) => loadFont(ctx, fontsDict, name, this.model.fonts);
+        const statesDict = getDict(ctx, stream.resources, 'ExtGState');
+        const resolveGState = (name) => {
+            const d = resolve(ctx, statesDict?.get(PDFName.of(name)));
+            if (!(d instanceof PDFDict))
+                return undefined;
+            return { fillAlpha: getNumber(ctx, d, 'ca'), strokeAlpha: getNumber(ctx, d, 'CA') };
+        };
         const sm = new StateMachine(base);
         // Text can also live in tiling pattern cells and soft-mask groups of this stream's resources.
         this.walkAuxiliary(stream, base, depth, active);
@@ -582,17 +685,19 @@ class Walker {
             if (TEXT_SHOW_OPS.has(op.op)) {
                 // ' and " move to the next line (and set spacing) before showing.
                 if (op.op === "'" || op.op === '"')
-                    sm.update(op, resolveFont);
+                    sm.update(op, resolveFont, resolveGState);
                 this.show(stream, i, op, sm, resolveFont);
                 continue;
             }
             if (op.op === 'Do') {
-                sm.update(op, resolveFont);
+                sm.update(op, resolveFont, resolveGState);
                 this.doXObject(stream, op, sm, depth, active);
                 continue;
             }
             if (op.op === 'BI') {
                 this.sawImage = true;
+                // Inline images are small (the format caps them at 4 KB in practice): placed, never trusted as opaque.
+                this.placeImage(sm, 0, 0, false);
                 continue;
             }
             if (op.op === 'd0' || op.op === 'd1') {
@@ -601,7 +706,62 @@ class Walker {
             if (op.op === 'sh') {
                 // Shading is drawing, not text; nothing to do.
             }
-            sm.update(op, resolveFont);
+            sm.update(op, resolveFont, resolveGState);
+        }
+    }
+    /** Record an image painted at the current CTM (it fills the unit square of image space). */
+    placeImage(sm, widthPx, heightPx, opaque) {
+        const m = sm.state.ctm;
+        const corners = [apply(m, 0, 0), apply(m, 1, 0), apply(m, 0, 1), apply(m, 1, 1)];
+        const xs = corners.map((c) => c[0]);
+        const ys = corners.map((c) => c[1]);
+        // Pixels per inch along each image axis: the axis spans |row| user units (1/72 in).
+        const alongX = Math.hypot(m[0], m[1]) / 72;
+        const alongY = Math.hypot(m[2], m[3]) / 72;
+        const dpi = Math.max(alongX > 0 ? widthPx / alongX : 0, alongY > 0 ? heightPx / alongY : 0);
+        this.images.push({
+            x0: Math.min(...xs), y0: Math.min(...ys), x1: Math.max(...xs), y1: Math.max(...ys),
+            dpi: Number.isFinite(dpi) ? dpi : 0,
+            opaque: opaque && sm.state.fillAlpha >= 1,
+            order: this.order++,
+        });
+    }
+    /** Highest effective resolution of the images on the page. */
+    imageDpi() {
+        let dpi = 0;
+        for (const im of this.images)
+            dpi = Math.max(dpi, im.dpi);
+        return dpi;
+    }
+    /**
+     * After the walk: text hidden over an image is an OCR layer (`ocr`), the reading of what the
+     * picture shows. Text painted BEFORE an opaque image that covers it is hidden too ("text under
+     * the page image", another common OCR layout), so it counts as hidden and as OCR text.
+     */
+    markOcrText(runs, from) {
+        if (this.images.length === 0)
+            return;
+        for (let r = from; r < runs.length; r++) {
+            const run = runs[r];
+            if (run.space || run.oracle)
+                continue;
+            const order = this.runOrder.get(run) ?? -1;
+            const shown = run.glyphs.filter((g) => g.unicode.trim() !== '');
+            if (shown.length === 0)
+                continue;
+            const within = (im) => shown.filter((g) => glyphInside(im, g, run)).length * 2 >= shown.length;
+            if (!run.hidden) {
+                if (!this.images.some((im) => im.opaque && im.order > order && within(im)))
+                    continue;
+                run.hidden = true;
+                this.visibleGlyphs -= shown.length;
+                this.page.hiddenGlyphs += run.glyphs.length;
+            }
+            else if (!this.images.some(within)) {
+                continue;
+            }
+            run.ocr = true;
+            this.ocrGlyphs += shown.length;
         }
     }
     /**
@@ -707,6 +867,10 @@ class Walker {
         const subtype = getName(ctx, xobj.dict, 'Subtype');
         if (subtype === 'Image') {
             this.sawImage = true;
+            const d = xobj.dict;
+            const masked = getBool(ctx, d, 'ImageMask') === true || d.get(PDFName.of('SMask')) !== undefined
+                || d.get(PDFName.of('Mask')) !== undefined || (getNumber(ctx, d, 'SMaskInData') ?? 0) !== 0;
+            this.placeImage(sm, getNumber(ctx, d, 'Width') ?? 0, getNumber(ctx, d, 'Height') ?? 0, !masked);
             return;
         }
         if (subtype !== 'Form')
@@ -755,6 +919,8 @@ class Walker {
         inner.text = { ...sm.state.text };
         inner.fillLuminance = sm.state.fillLuminance;
         inner.strokeLuminance = sm.state.strokeLuminance;
+        inner.fillAlpha = sm.state.fillAlpha;
+        inner.strokeAlpha = sm.state.strokeAlpha;
         active.add(key);
         this.walk(record, inner, depth + 1, active);
         active.delete(key);
@@ -817,9 +983,14 @@ class Walker {
         const emY = [trm0[2], trm0[3]];
         const hiddenByMode = t.renderMode === 3 || t.renderMode === 7;
         const hiddenByColor = t.renderMode === 0 && sm.state.fillLuminance !== null && sm.state.fillLuminance > 0.97;
+        // Fully transparent paint (ExtGState /ca, /CA): the OCR layer of many scanners.
+        const fills = [0, 2, 4, 6].includes(t.renderMode);
+        const strokes = [1, 2, 5, 6].includes(t.renderMode);
+        const hiddenByAlpha = (fills || strokes)
+            && (!fills || sm.state.fillAlpha < MIN_VISIBLE_ALPHA) && (!strokes || sm.state.strokeAlpha < MIN_VISIBLE_ALPHA);
         const sizeUser = Math.hypot(trm0[2], trm0[3]);
         const tiny = sizeUser < 0.5;
-        const hidden = hiddenByMode || hiddenByColor || tiny;
+        const hidden = hiddenByMode || hiddenByColor || hiddenByAlpha || tiny;
         const glyphs = [];
         const textOffsets = [];
         let advanceSoFar = 0; // unscaled text-space x from the run start
@@ -898,8 +1069,18 @@ class Walker {
             ...(this.space ? { space: this.space } : {}),
         };
         this.runs.push(run);
+        this.runOrder.set(run, this.order++);
     }
 }
+/** True when the middle of glyph `g` (half an advance along, a third of an em up) lies inside `b`. */
+function glyphInside(b, g, run) {
+    const exLen = Math.hypot(run.emX[0], run.emX[1]) || 1;
+    const eyLen = Math.hypot(run.emY[0], run.emY[1]) || 1;
+    const w = g.advance * (exLen / (run.local.fontSize * run.local.hscale || 1));
+    const x = g.x + (run.emX[0] / exLen) * (w / 2) + (run.emY[0] / eyLen) * (g.fontSize / 3);
+    const y = g.y + (run.emX[1] / exLen) * (w / 2) + (run.emY[1] / eyLen) * (g.fontSize / 3);
+    return insideBox(b, x, y);
+}
 /**
  * Consecutive pages with the same kind of problem collapse into one part ("pages 2-22"), so a
  * document whose body font is unreadable shows one line to consent to, not one per page.