@2018kguo/recto 0.0.0-stage → 0.3.0

package/dist/engine.js

@@ -0,0 +1,383 @@
+// The per-thread engine: owns one WebAssembly instance and replaces it when it trapped or
+// its memory grew past the recycle mark (WebAssembly memory never shrinks). Past the mark, the
+// instance goes once nothing has been open on it for a moment, and a document still open on an
+// instance keeps it.
+import { PINS } from "../wasm/pins.mjs";
+import { createGlue, PART_TABLE } from "../wasm/recto.gen.mjs";
+import { assetBaseUrl, canReadSync, STANDARD_FONTS, compileWasm, loadAssetSync, preloadAssets, readCheckedSync, } from "./assets.js";
+import { engineFailure, RectoDocument, } from "./document.js";
+import { PdfError } from "./errors.js";
+import { ownedSource, startRangeLoader, } from "./ranged.js";
+const CJK_FONT_ASSET = 14;
+const CMAPS_ASSET = 15;
+const PARTS = ["recto-render.wasm", "recto-more.wasm", "recto-rare.wasm"];
+const ALL_ASSETS = [...STANDARD_FONTS, "cmaps.deflate", "cjk-fallback.ttf"];
+/**
+ * Past this, an open with another document still open gets a new instance. Chosen from
+ * bench/results/recycle.json: retiring at each close made a repeated large file slow.
+ */
+const IDLE_RECYCLE_ABOVE_BYTES = 64 * 1024 * 1024;
+const DEFAULT_RECYCLE_ABOVE_BYTES = 512 * 1024 * 1024;
+const IDLE_MS = 1000;
+/** Each wasm, verified and compiled once per thread, per location. */
+const compiling = new Map();
+const compiled = new Map();
+const moduleKey = (name, base) => `${name} ${base?.href ?? ""}`;
+function compile(name, base) {
+    const key = moduleKey(name, base);
+    let module = compiling.get(key);
+    if (!module) {
+        module = compileWasm(name, base);
+        module.then((done) => compiled.set(key, done), () => compiling.delete(key));
+        compiling.set(key, module);
+    }
+    return module;
+}
+/** A part, from inside a synchronous call. Hashed before it's compiled; this is the only way in but `compile`. */
+function partModule(name, base, hash) {
+    const key = moduleKey(name, base);
+    let module = compiled.get(key);
+    if (!module) {
+        module = new WebAssembly.Module(readCheckedSync(name, base, hash));
+        compiled.set(key, module);
+    }
+    return module;
+}
+/** An instance's own SHA-256, for an asset it needs: faster than JavaScript's in a cold browser. */
+export function hashOn(instance) {
+    return (bytes) => {
+        // A function the hash itself runs may be in a part, and that part's check can't use this hash.
+        if (instance.dead || hashing.has(instance)) {
+            return null;
+        }
+        hashing.add(instance);
+        try {
+            return Array.from(instance.glue.sha256(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+        }
+        finally {
+            hashing.delete(instance);
+        }
+    };
+}
+const hashing = new WeakSet();
+function instantiate(generation, base, module, documents = { open: 0 }) {
+    const parts = new Set();
+    // A function of a part that isn't loaded yet: load it, then make the call this was meant to be. A
+    // failure unwinds the engine's frames with its state half-done, so no call can follow on this
+    // instance. What was open on it reopens on another, at its next call.
+    const placeholders = (name) => new Proxy({}, {
+        get: (_, slot) => (...args) => {
+            try {
+                instance.loadPart(name);
+            }
+            catch (error) {
+                instance.abandoned = true;
+                throw error;
+            }
+            const table = exports[PART_TABLE];
+            return table.get(Number(slot))(...args);
+        },
+    });
+    // Each instance gets its own glue closure (scripts/package-wasm.mjs), so a retired
+    // instance and its memory are collected with it.
+    const glue = createGlue({
+        "part.recto-render": placeholders("recto-render.wasm"),
+        "part.recto-more": placeholders("recto-more.wasm"),
+        "part.recto-rare": placeholders("recto-rare.wasm"),
+    }, 
+    // Something never closed, freed by the collector. Nothing can run on an abandoned instance, which goes
+    // whole; and a free that needs a part it can't get has nobody to tell, and mustn't be an uncaught error.
+    (free) => {
+        if (instance.abandoned || instance.dead) {
+            return;
+        }
+        try {
+            free();
+        }
+        catch {
+            instance.abandoned = true;
+        }
+    });
+    const exports = glue.initSync({ module });
+    const instance = {
+        glue,
+        loadPart(name) {
+            if (!parts.has(name)) {
+                // Its table entries replace its placeholders.
+                new WebAssembly.Instance(partModule(name, base, hashOn(instance)), { primary: exports });
+                parts.add(name);
+            }
+        },
+        memory: exports.memory,
+        startBytes: exports.memory.buffer.byteLength,
+        generation,
+        openDocuments: 0,
+        documents,
+        dead: false,
+        abandoned: false,
+        failure: undefined,
+    };
+    // The engine asks for a built-in font (0..13), the CJK fallback or its predefined CMaps
+    // the first time a document needs one. It reads a throw as a missing asset, which would
+    // be blank text, so keep the error for the call in progress to rethrow, and leave the instance
+    // so the next call tries again.
+    glue.setAssetLoader((index) => {
+        try {
+            if (index === CMAPS_ASSET) {
+                return loadAssetSync("cmaps.deflate", base, hashOn(instance));
+            }
+            if (index === CJK_FONT_ASSET) {
+                return loadAssetSync("cjk-fallback.ttf", base, hashOn(instance));
+            }
+            return loadAssetSync(STANDARD_FONTS[index], base, hashOn(instance));
+        }
+        catch (error) {
+            instance.abandoned = true;
+            instance.failure = error;
+            return;
+        }
+    });
+    return instance;
+}
+function bytesOf(input) {
+    if (ArrayBuffer.isView(input)) {
+        return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    }
+    // Not instanceof: an ArrayBuffer from another realm (a test runner's sandbox) is just as good.
+    if (Object.prototype.toString.call(input) === "[object ArrayBuffer]") {
+        return new Uint8Array(input);
+    }
+    throw new TypeError("expected the PDF's bytes as a Uint8Array, Buffer or ArrayBuffer");
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw new PdfError("aborted", "the signal was aborted", signal.reason);
+    }
+}
+class RectoEngine {
+    #instance;
+    #generation;
+    #starting = null;
+    #base;
+    #recycleAboveBytes;
+    /** Past this, an instance with a document open takes no other. */
+    #idleAboveBytes;
+    /** Whether an instance that grew goes once nothing has been open on it for IDLE_MS: the default. */
+    #dropWhenIdle;
+    #idle;
+    /** Across every instance: a document that moved, or stayed on an old one, still counts. */
+    #documents;
+    constructor(instance, base, recycleAboveBytes) {
+        this.#instance = instance;
+        this.#generation = instance.generation;
+        this.#base = base;
+        this.#recycleAboveBytes = recycleAboveBytes ?? DEFAULT_RECYCLE_ABOVE_BYTES;
+        this.#idleAboveBytes = recycleAboveBytes ?? IDLE_RECYCLE_ABOVE_BYTES;
+        this.#dropWhenIdle = recycleAboveBytes === undefined;
+        this.#documents = instance.documents;
+        this.#watch(instance);
+    }
+    /** Memory only comes back with the instance, so don't keep one past the mark with nothing on it. */
+    #watch(instance) {
+        instance.onClose = () => {
+            if (this.#instance !== instance || instance.openDocuments > 0) {
+                return;
+            }
+            const bytes = instance.memory.buffer.byteLength;
+            if (bytes > this.#recycleAboveBytes) {
+                this.#instance = null;
+            }
+            else if (this.#dropWhenIdle ? bytes > instance.startBytes : bytes > this.#idleAboveBytes) {
+                clearTimeout(this.#idle);
+                this.#idle = setTimeout(() => {
+                    // Node's fired timer keeps its callback, and with it the instance.
+                    this.#idle = undefined;
+                    if (this.#instance === instance && instance.openDocuments === 0) {
+                        this.#instance = null;
+                    }
+                }, IDLE_MS);
+                // Not a reason for Node to stay running.
+                this.#idle.unref?.();
+            }
+        };
+    }
+    /** Whether a new document can go on this instance. */
+    #usable(instance) {
+        if (!instance || instance.dead || instance.abandoned) {
+            return false;
+        }
+        const bytes = instance.memory.buffer.byteLength;
+        return bytes <= this.#idleAboveBytes || (bytes <= this.#recycleAboveBytes && instance.openDocuments === 0);
+    }
+    #ready() {
+        return this.#usable(this.#instance) ? this.#instance : null;
+    }
+    async #live() {
+        const current = this.#instance;
+        if (this.#usable(current)) {
+            return current;
+        }
+        this.#starting ??= compile("recto.wasm", this.#base)
+            .then((module) => instantiate(this.#generation + 1, this.#base, module, this.#documents))
+            .finally(() => {
+            this.#starting = null;
+        });
+        const started = await this.#starting;
+        this.#adopt(started);
+        return started;
+    }
+    #adopt(instance) {
+        this.#generation = instance.generation;
+        this.#instance = instance;
+        this.#watch(instance);
+    }
+    /** An instance for a document to reopen on, its own having been abandoned. Synchronous: every call is. */
+    #another() {
+        const current = this.#instance;
+        if (this.#usable(current)) {
+            return current;
+        }
+        // Compiled already: it's what the abandoned instance ran.
+        const instance = instantiate(this.#generation + 1, this.#base, compiled.get(moduleKey("recto.wasm", this.#base)), this.#documents);
+        this.#adopt(instance);
+        return instance;
+    }
+    // Async only so a bad argument rejects; everything up to the copy runs synchronously.
+    async open(input, options = {}) {
+        // With an instance ready, the bytes go into its memory before the first await, and that's
+        // the copy the promise needs: no second one of what may be a large file.
+        const ready = this.#ready();
+        const bytes = bytesOf(input);
+        if (ready) {
+            throwIfAborted(options.signal);
+            return this.#openOn(ready, bytes, options);
+        }
+        return await this.openOwned(bytes.slice(), options);
+    }
+    /** `bytes` is this call's own: getting an instance can take an await. */
+    async openOwned(bytes, options) {
+        throwIfAborted(options.signal);
+        return this.#openOn(await this.#live(), bytes, options);
+    }
+    #openOn(instance, bytes, options) {
+        const password = options.password ?? null;
+        let doc;
+        try {
+            // Where the file is, read now: an abandoned instance may run nothing.
+            let opened = new instance.glue.Document(bytes, password);
+            let pointer = opened.filePointer();
+            const length = opened.fileLength();
+            doc = new RectoDocument(instance, opened, (_, oldInstance) => {
+                const next = this.#another();
+                // The file goes straight from the old heap to the new one.
+                opened = new next.glue.Document(new Uint8Array(oldInstance.memory.buffer, pointer, length), password);
+                pointer = opened.filePointer();
+                return { instance: next, doc: opened };
+            });
+        }
+        catch (error) {
+            throw engineFailure(instance, error);
+        }
+        if (instance.failure) {
+            throw instance.failure;
+        }
+        return doc;
+    }
+    async openRanged(source, options = {}) {
+        if (!canReadSync()) {
+            throw new PdfError("wrong-thread", "a ranged read blocks its thread on the network, which this thread can't do. Open it in a " +
+                'dedicated Web Worker: new Worker(new URL("./pdf-worker.js", import.meta.url), { type: "module" }).');
+        }
+        const owned = ownedSource(source);
+        const instance = await this.#live();
+        const loader = startRangeLoader(owned, options);
+        const read = (offset, length) => {
+            const out = new Uint8Array(length);
+            return loader.read(offset, out) ? out : undefined;
+        };
+        const password = options.password ?? null;
+        let doc;
+        try {
+            doc = new RectoDocument(instance, instance.glue.Document.openRanged(loader.length, loader.chunkBytes, read, password), () => {
+                // Nothing is fetched twice: the loader keeps what it read.
+                const next = this.#another();
+                return {
+                    instance: next,
+                    doc: next.glue.Document.openRanged(loader.length, loader.chunkBytes, read, password),
+                };
+            }, () => loader.failure);
+        }
+        catch (error) {
+            if (loader.failure && !(error instanceof WebAssembly.RuntimeError)) {
+                throw loader.failure;
+            }
+            throw engineFailure(instance, error);
+        }
+        if (loader.failure) {
+            doc.close();
+            throw loader.failure;
+        }
+        return Object.assign(doc, { stats: () => loader.stats() });
+    }
+    stats() {
+        return {
+            heapBytes: this.#instance?.memory.buffer.byteLength ?? 0,
+            generation: this.#generation,
+            openDocuments: this.#documents.open,
+        };
+    }
+}
+export async function createPdfEngine(options = {}) {
+    return await createEngine(options);
+}
+async function createEngine(options) {
+    const base = assetBaseUrl(options.assetBase);
+    const canRead = canReadSync();
+    for (const asset of options.preloadAssets ?? []) {
+        if (asset !== "cmaps.brotli" && asset !== "fonts.bin" && !Object.hasOwn(PINS, asset)) {
+            const accepted = [...Object.keys(PINS), "cmaps.brotli", "fonts.bin"].join(", ");
+            throw new TypeError(`preloadAssets does not know ${JSON.stringify(asset)}. It takes: ${accepted}`);
+        }
+    }
+    // cmaps.brotli is the old name of cmaps.deflate, and fonts.bin of all the fonts together.
+    const names = (options.preloadAssets ?? (canRead ? [] : ALL_ASSETS)).flatMap((asset) => asset === "cmaps.brotli" ? "cmaps.deflate" : asset === "fonts.bin" ? STANDARD_FONTS : asset);
+    const isPart = (name) => PARTS.includes(name);
+    const files = names.filter((name) => name !== "recto.wasm" && !isPart(name));
+    // With no way to read a part from inside a call, all of them now, always: nothing listed can take
+    // away the ability to draw.
+    const [module] = await Promise.all([
+        compile("recto.wasm", base),
+        ...(canRead ? names.filter(isPart) : PARTS).map((part) => compile(part, base)),
+        preloadAssets(base, files),
+    ]);
+    return new RectoEngine(instantiate(0, base, module), base, options.recycleAboveBytes);
+}
+let shared = null;
+let sharedReady = null;
+/**
+ * Opens a PDF on this thread's shared engine:
+ *
+ *   await using doc = await openPdf(bytes);
+ *   doc.pageCount; doc.text(0); doc.render(0, { width: 1024 });
+ */
+export async function openPdf(bytes, options = {}) {
+    if (sharedReady) {
+        return sharedReady.open(bytes, options);
+    }
+    // Getting the engine takes an await: the buffer has to be the caller's again before it.
+    const owned = bytesOf(bytes).slice();
+    if (!shared) {
+        const starting = createEngine({});
+        shared = starting;
+        starting.then((engine) => {
+            sharedReady = engine;
+        }, () => { });
+        // A failure is not kept: the next call tries again.
+        starting.catch(() => {
+            if (shared === starting) {
+                shared = null;
+            }
+        });
+    }
+    return await (await shared).openOwned(owned, options);
+}

package/dist/errors.d.ts

@@ -0,0 +1,36 @@
+export type PdfErrorCode = 
+/** Not a PDF the engine can open: garbage, truncated, a broken xref. */
+"invalid-file"
+/** The file is encrypted and no password was given. */
+ | "password-required"
+/** The file is encrypted and the password given does not open it. */
+ | "wrong-password"
+/** A valid file the engine cannot read: a security handler other than Standard (e.g. DRM). */
+ | "unsupported"
+/** The `signal` passed to the call was aborted. */
+ | "aborted"
+/**
+ * The WebAssembly instance trapped. The process is fine: documents open on that instance
+ * fail with this code, and the next open gets a fresh instance.
+ */
+ | "crash"
+/** The document was closed. */
+ | "closed"
+/** The wasm or a font or CMap asset is missing, unreadable, or not this build's. */
+ | "missing-asset"
+/** Called somewhere it cannot run: a page's main thread, a service worker. */
+ | "wrong-thread"
+/** A ranged read failed: the network, an HTTP error, or a server's bad Range answer. */
+ | "fetch-failed"
+/** A ranged read waited longer than `timeoutMs`, or passed `totalTimeoutMs`. */
+ | "timeout"
+/** A ranged read would pass `maxBytes`, or the file is past what a ranged read can hold. */
+ | "too-large"
+/** Any other refusal: a page with no area, a render too large to allocate. */
+ | "failed";
+export declare class PdfError extends Error {
+    readonly code: PdfErrorCode;
+    /** On `fetch-failed`, the HTTP status of the answer it objects to. Undefined if the server never answered. */
+    readonly status: number | undefined;
+    constructor(code: PdfErrorCode, message: string, cause?: unknown, status?: number);
+}

package/dist/errors.js

@@ -0,0 +1,14 @@
+// Every failure the engine reports is a PdfError with a `code`, so a caller can branch
+// without matching strings. A bad argument (a page out of range, a render size of 0) is a
+// plain RangeError or TypeError instead: that is a bug to fix, not a condition to handle.
+export class PdfError extends Error {
+    code;
+    /** On `fetch-failed`, the HTTP status of the answer it objects to. Undefined if the server never answered. */
+    status;
+    constructor(code, message, cause, status) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "PdfError";
+        this.code = code;
+        this.status = status;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { ANNOT_SUBTYPE, boxAt, CHAR_GENERATED, CHAR_UNMAPPED, charsText, PATH_FILL, PATH_STROKE, type PdfAnnotation, type PdfBitmap, type PdfBox, type PdfDocument, type PdfFont, type PdfOutlineItem, type PdfPageInfo, type PdfPageObjects, type PdfPageText, type PdfPathSegments, type PdfRenderAsyncOptions, type PdfRenderOptions, type PdfTextRuns, type PdfWords, SEGMENT_BEZIER, SEGMENT_CLOSE, SEGMENT_LINE, SEGMENT_MOVE, SEGMENT_RECT, } from "./document.ts";
+export { createPdfEngine, openPdf, type PdfEngine, type PdfEngineOptions, type PdfEngineStats, type PdfOpenOptions, } from "./engine.ts";
+export { PdfError, type PdfErrorCode } from "./errors.ts";
+export type { PdfPool, PdfPoolDocument, PdfPoolOpenOptions, PdfPoolOptions } from "./pool.ts";
+export { type PageBox, rasterMeasures, showsGlyphs, vectorMeasures, } from "./page-measures.ts";
+export type { PdfRangedDocument, PdfRangedOpenOptions, PdfRangedStats, PdfRangeSource, } from "./ranged.ts";
+export { BREAK_LINE, BREAK_NONE, BREAK_SPACE, readingOrder, type ReadingOrder, } from "./reading-order.ts";
+export { annotationPaintedText, annotationShownText, annotationTextItems, NOT_TEXT, type PdfTextItem, textItems, visibleCodepoint, } from "./text-items.ts";
+/**
+ * Runs a document's pages across worker threads:
+ *
+ *   using pool = await createPdfPool();
+ *   await using doc = await pool.open(bytes);
+ *   const pages = await Promise.all(Array.from({ length: doc.pageCount }, (_, i) => doc.text(i)));
+ *
+ * Loaded only when called, so a program that doesn't use it doesn't download it.
+ */
+export declare function createPdfPool(options?: import("./pool.ts").PdfPoolOptions): Promise<import("./pool.ts").PdfPool>;

package/dist/index.js

@@ -0,0 +1,23 @@
+// A PDF engine: Rust compiled to WebAssembly behind a small, synchronous API.
+//
+//   await using doc = await openPdf(bytes);
+//   doc.pageCount; doc.text(0); doc.render(0, { width: 1024 });
+export { ANNOT_SUBTYPE, boxAt, CHAR_GENERATED, CHAR_UNMAPPED, charsText, PATH_FILL, PATH_STROKE, SEGMENT_BEZIER, SEGMENT_CLOSE, SEGMENT_LINE, SEGMENT_MOVE, SEGMENT_RECT, } from "./document.js";
+export { createPdfEngine, openPdf, } from "./engine.js";
+export { PdfError } from "./errors.js";
+export { rasterMeasures, showsGlyphs, vectorMeasures, } from "./page-measures.js";
+export { BREAK_LINE, BREAK_NONE, BREAK_SPACE, readingOrder, } from "./reading-order.js";
+export { annotationPaintedText, annotationShownText, annotationTextItems, NOT_TEXT, textItems, visibleCodepoint, } from "./text-items.js";
+/**
+ * Runs a document's pages across worker threads:
+ *
+ *   using pool = await createPdfPool();
+ *   await using doc = await pool.open(bytes);
+ *   const pages = await Promise.all(Array.from({ length: doc.pageCount }, (_, i) => doc.text(i)));
+ *
+ * Loaded only when called, so a program that doesn't use it doesn't download it.
+ */
+export async function createPdfPool(options = {}) {
+    const { startPool } = await import("./pool.js");
+    return startPool(options);
+}

package/dist/page-measures.d.ts

@@ -0,0 +1,34 @@
+import { type PdfPageObjects } from "./document.ts";
+/** left/top/right/bottom, top < bottom (viewer frame). */
+export type PageBox = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+/**
+ * The raster measures over a page's image objects: the largest image's
+ * share of the page and the summed share (overlaps count twice).
+ */
+export declare function rasterMeasures(images: PdfPageObjects["images"], pageArea: number): {
+    largestImageRatio: number;
+    rasterCoverageRatio: number;
+};
+/**
+ * Over a page's painted path objects: the line segments that move in both
+ * x and y by more than 0.01 plus curves (a cubic is three Bezier points,
+ * counted once), the union box of the paths that have any, and the
+ * rectangles of filled paths (four-sided axis-aligned subpaths, implicitly
+ * closed by fill; `re` is stored that way, so m/l/l/l rectangles count too).
+ */
+export declare function vectorMeasures(objects: Pick<PdfPageObjects, "paths" | "segments">): {
+    chartSegmentCount: number;
+    chartSegmentBounds: PageBox | null;
+    filledRectangles: PageBox[];
+};
+/** Whether a page's text layer shows glyphs (non-space or unmapped chars). */
+export declare function showsGlyphs(text: {
+    count: number;
+    codepoints: Uint32Array;
+    flags: Uint8Array;
+}): boolean;

package/dist/page-measures.js

@@ -0,0 +1,166 @@
+// What a page paints, measured over its page objects and chars: raster
+// coverage, vector chart segments and filled rectangles, and whether the
+// text layer shows glyphs. A caller applies its own thresholds to these. Boxes are in the viewer frame.
+import { CHAR_GENERATED, CHAR_UNMAPPED, PATH_FILL, SEGMENT_BEZIER, SEGMENT_LINE, SEGMENT_MOVE, SEGMENT_RECT, } from "./document.js";
+/** pdf.js's lineTo test: a chart segment moves in both axes by more than this. */
+const CHART_SEGMENT_MIN_DELTA = 0.01;
+const AXIS_TOLERANCE = 0.01;
+/**
+ * The raster measures over a page's image objects: the largest image's
+ * share of the page and the summed share (overlaps count twice).
+ */
+export function rasterMeasures(images, pageArea) {
+    let largest = 0;
+    let total = 0;
+    for (let k = 0; k < images.count; k++) {
+        const area = Math.max(0, images.boxes[4 * k + 2] ?? 0) *
+            Math.max(0, images.boxes[4 * k + 3] ?? 0);
+        largest = Math.max(largest, area);
+        total += area;
+    }
+    return {
+        largestImageRatio: pageArea > 0 ? largest / pageArea : 0,
+        rasterCoverageRatio: pageArea > 0 ? total / pageArea : 0,
+    };
+}
+/** The axis-aligned box of a filled four-sided subpath, or null. */
+function rectangleOf(points, kinds, from, to) {
+    // MOVE then three or four LINEs (the fourth returning to the start).
+    const lines = to - from - 1;
+    if (lines !== 3 && lines !== 4) {
+        return null;
+    }
+    for (let s = from + 1; s < to; s++) {
+        if (((kinds[s] ?? 0) & 3) !== SEGMENT_LINE) {
+            return null;
+        }
+    }
+    const sx = points[2 * from] ?? 0;
+    const sy = points[2 * from + 1] ?? 0;
+    if (lines === 4 &&
+        (Math.abs((points[2 * (to - 1)] ?? 0) - sx) > AXIS_TOLERANCE ||
+            Math.abs((points[2 * (to - 1) + 1] ?? 0) - sy) > AXIS_TOLERANCE)) {
+        return null;
+    }
+    let left = Infinity;
+    let right = -Infinity;
+    let top = Infinity;
+    let bottom = -Infinity;
+    let previousHorizontal = null;
+    // Fill closes the last edge even without `h`. Alternating nonzero edges
+    // reject backtracking paths whose bounding box has area but fill does not.
+    for (let s = from; s < from + 4; s++) {
+        const x = points[2 * s] ?? 0;
+        const y = points[2 * s + 1] ?? 0;
+        const next = s === from + 3 ? from : s + 1;
+        const dx = Math.abs((points[2 * next] ?? 0) - x);
+        const dy = Math.abs((points[2 * next + 1] ?? 0) - y);
+        const horizontal = dy <= AXIS_TOLERANCE && dx > AXIS_TOLERANCE;
+        const vertical = dx <= AXIS_TOLERANCE && dy > AXIS_TOLERANCE;
+        if ((!horizontal && !vertical) || previousHorizontal === horizontal) {
+            return null;
+        }
+        left = Math.min(left, x);
+        right = Math.max(right, x);
+        top = Math.min(top, y);
+        bottom = Math.max(bottom, y);
+        previousHorizontal = horizontal;
+    }
+    return right - left > 0 && bottom - top > 0
+        ? { left, top, right, bottom }
+        : null;
+}
+/**
+ * Over a page's painted path objects: the line segments that move in both
+ * x and y by more than 0.01 plus curves (a cubic is three Bezier points,
+ * counted once), the union box of the paths that have any, and the
+ * rectangles of filled paths (four-sided axis-aligned subpaths, implicitly
+ * closed by fill; `re` is stored that way, so m/l/l/l rectangles count too).
+ */
+export function vectorMeasures(objects) {
+    const { paths, segments } = objects;
+    const { points, kinds } = segments;
+    let chartSegmentCount = 0;
+    let chartSegmentBounds = null;
+    const filledRectangles = [];
+    for (let p = 0; p < paths.count; p++) {
+        const from = paths.start[p] ?? 0;
+        const to = paths.start[p + 1] ?? from;
+        const filled = ((paths.flags[p] ?? 0) & PATH_FILL) !== 0;
+        let pathChartSegments = 0;
+        let beziers = 0;
+        let subpathStart = from;
+        for (let s = from; s <= to; s++) {
+            const kind = (kinds[s] ?? 0) & 3;
+            if (s === to || kind === SEGMENT_MOVE) {
+                // pdf.js counts only `re` rectangles, and so does this.
+                const drawnByRe = ((kinds[subpathStart] ?? 0) & SEGMENT_RECT) !== 0;
+                if (filled && s > subpathStart) {
+                    const rect = drawnByRe
+                        ? rectangleOf(points, kinds, subpathStart, s)
+                        : null;
+                    if (rect) {
+                        filledRectangles.push(rect);
+                    }
+                    const dx = (points[2 * (s - 1)] ?? 0) - (points[2 * subpathStart] ?? 0);
+                    const dy = (points[2 * (s - 1) + 1] ?? 0) -
+                        (points[2 * subpathStart + 1] ?? 0);
+                    if (Math.abs(dx) > CHART_SEGMENT_MIN_DELTA &&
+                        Math.abs(dy) > CHART_SEGMENT_MIN_DELTA) {
+                        pathChartSegments += 1;
+                    }
+                }
+                subpathStart = s;
+                continue;
+            }
+            if (kind === SEGMENT_BEZIER) {
+                beziers += 1;
+                continue;
+            }
+            if (kind === SEGMENT_LINE && s > from) {
+                const dx = (points[2 * s] ?? 0) - (points[2 * s - 2] ?? 0);
+                const dy = (points[2 * s + 1] ?? 0) - (points[2 * s - 1] ?? 0);
+                if (Math.abs(dx) > CHART_SEGMENT_MIN_DELTA &&
+                    Math.abs(dy) > CHART_SEGMENT_MIN_DELTA) {
+                    pathChartSegments += 1;
+                }
+            }
+        }
+        // A cubic is three Bezier points.
+        pathChartSegments += Math.ceil(beziers / 3);
+        if (pathChartSegments > 0) {
+            chartSegmentCount += pathChartSegments;
+            const x = paths.boxes[4 * p] ?? 0;
+            const y = paths.boxes[4 * p + 1] ?? 0;
+            const box = {
+                left: x,
+                top: y,
+                right: x + (paths.boxes[4 * p + 2] ?? 0),
+                bottom: y + (paths.boxes[4 * p + 3] ?? 0),
+            };
+            chartSegmentBounds = chartSegmentBounds
+                ? {
+                    left: Math.min(chartSegmentBounds.left, box.left),
+                    top: Math.min(chartSegmentBounds.top, box.top),
+                    right: Math.max(chartSegmentBounds.right, box.right),
+                    bottom: Math.max(chartSegmentBounds.bottom, box.bottom),
+                }
+                : box;
+        }
+    }
+    return { chartSegmentCount, chartSegmentBounds, filledRectangles };
+}
+/** Whether a page's text layer shows glyphs (non-space or unmapped chars). */
+export function showsGlyphs(text) {
+    for (let i = 0; i < text.count; i++) {
+        const flags = text.flags[i] ?? 0;
+        if (flags & CHAR_GENERATED) {
+            continue;
+        }
+        if (flags & CHAR_UNMAPPED ||
+            String.fromCodePoint(text.codepoints[i] ?? 0x20).trim().length > 0) {
+            return true;
+        }
+    }
+    return false;
+}