@2018kguo/recto 0.0.0-stage → 0.1.0

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;
+}

package/dist/ranged.d.ts

@@ -0,0 +1,88 @@
+import { PdfError } from "./errors.ts";
+import type { PdfDocument } from "./document.ts";
+/**
+ * Where a ranged document's bytes come from: an HTTP(S) URL, or bytes in memory (copied, so
+ * the caller may reuse the buffer).
+ */
+export type PdfRangeSource = string | URL | Uint8Array;
+export type PdfRangedOpenOptions = {
+    password?: string;
+    /** Smallest fetch and the cache's unit, above 0. Default 64 KiB. */
+    chunkBytes?: number;
+    /** Fail (code "too-large") rather than fetch more than this in total. Default 64 MiB. */
+    maxBytes?: number;
+    /**
+     * Checked before the open and before every fetch. The thread is blocked during a fetch, so
+     * an abort cannot interrupt one; `timeoutMs` bounds that.
+     */
+    signal?: AbortSignal;
+    /** How long one fetch round may block the thread (code "timeout"). Default 30 s. */
+    timeoutMs?: number;
+};
+export type PdfRangedStats = {
+    /** Bytes received from the source, across every request. */
+    bytesFetched: number;
+    requests: number;
+    /** Fetch rounds (round trips); a round's requests run in parallel. */
+    rounds: number;
+    /** The engine's reads, and the bytes they asked for: the parse work. */
+    reads: number;
+    readBytes: number;
+    /** The file's full size, from the first response. */
+    fileBytes: number;
+};
+/** A document opened over byte ranges. Use and close it like any other. */
+export type PdfRangedDocument = PdfDocument & {
+    stats(): PdfRangedStats;
+};
+type Range = {
+    start: number;
+    end: number;
+};
+type Answer = {
+    start: number;
+    bytes: Uint8Array;
+    length: number;
+    etag: string | null;
+};
+/** Fetches `ranges`; `limit` is how many bytes may still arrive. */
+type Fetch = (ranges: Range[], timeoutMs: number, limit: number) => Answer[];
+/** Fetched chunks of one file and the policy for fetching more. */
+declare class RangeLoader {
+    #private;
+    length: number;
+    readonly chunkBytes: number;
+    /** Set once a fetch failed; every later read fails and every call throws it. */
+    failure: PdfError | null;
+    constructor(fetch: Fetch, options: {
+        chunkBytes: number;
+        maxBytes: number;
+        timeoutMs: number;
+        signal: AbortSignal | undefined;
+    });
+    stats(): PdfRangedStats;
+    /** Fetches chunks `firstChunk..endChunk`, keeping only those not held yet. */
+    fetchChunks(firstChunk: number, endChunk: number): void;
+    /**
+     * The `startxref` offset in the fetched last chunk, if it names one. Null for a linearized
+     * file, whose trailer points at the first-page section near the head.
+     */
+    startxref(): number | null;
+    /**
+     * Copies [offset, offset + out.length) into `out`, fetching what is missing first. On a
+     * failed fetch it records the failure and fails the read; the call that made it then
+     * throws the failure.
+     */
+    read(offset: number, out: Uint8Array): boolean;
+}
+/**
+ * Starts a ranged read of `source`: the head, then (for a larger file) the tail and its last
+ * cross-reference section. Blocks while it fetches.
+ */
+export declare function startRangeLoader(source: string | Uint8Array, options?: PdfRangedOpenOptions): RangeLoader;
+/**
+ * The caller's source in a form that stays valid across an await: bytes copied, a URL as an
+ * absolute http(s) string. Runs before anything asynchronous.
+ */
+export declare function ownedSource(source: PdfRangeSource): string | Uint8Array;
+export {};