@2018kguo/recto 0.0.0-stage → 0.1.0

package/dist/document.js

@@ -0,0 +1,300 @@
+// One open PDF. Every coordinate this returns is in the viewer's frame: PDF points, top-left
+// origin, with /Rotate and the crop box applied.
+import { PdfError } from "./errors.js";
+/** `PdfPageText.flags` bit: a space or line break the engine inferred; not in the content stream. */
+export const CHAR_GENERATED = 1;
+/** `PdfPageText.flags` bit: the glyph has no Unicode mapping, so its text is unreadable. */
+export const CHAR_UNMAPPED = 2;
+/** Entry `i` of a `boxes` column. */
+export function boxAt(boxes, i) {
+    return {
+        x: boxes[4 * i] ?? 0,
+        y: boxes[4 * i + 1] ?? 0,
+        width: boxes[4 * i + 2] ?? 0,
+        height: boxes[4 * i + 3] ?? 0,
+    };
+}
+/** The text of chars `first..last` (inclusive). */
+export function charsText(page, first, last) {
+    let out = "";
+    for (let i = first; i <= last; i++) {
+        out += String.fromCodePoint(page.codepoints[i] ?? 0xff_fd);
+    }
+    return out;
+}
+/** Segment kinds, in the low bits of `PdfPathSegments.kinds`. */
+export const SEGMENT_LINE = 0;
+export const SEGMENT_BEZIER = 1;
+export const SEGMENT_MOVE = 2;
+/** `PdfPathSegments.kinds` bit: the segment closes its subpath. */
+export const SEGMENT_CLOSE = 4;
+/**
+ * `PdfPathSegments.kinds` bit on a move: its subpath is a rectangle drawn by
+ * `re` (pdf.js counts only those as rectangles).
+ */
+export const SEGMENT_RECT = 8;
+/** `paths.flags` bits. */
+export const PATH_FILL = 1;
+export const PATH_STROKE = 2;
+export const ANNOT_SUBTYPE = {
+    text: 1,
+    link: 2,
+    freeText: 3,
+    stamp: 13,
+    widget: 20,
+};
+const DEFAULT_MAX_HEIGHT = 4096;
+const MAX_DIMENSION = 16_384;
+/** What a call into the instance threw, as what the caller should see. */
+export function engineFailure(instance, error) {
+    if (error instanceof PdfError) {
+        return error;
+    }
+    // An exhausted call stack in WebAssembly is a RangeError, and leaves the instance in the
+    // same unknown state as a trap. The argument checks that throw RangeError run before any call.
+    if (error instanceof WebAssembly.RuntimeError || error instanceof RangeError) {
+        instance.dead = true;
+        return new PdfError("crash", `the engine crashed: ${error.message}`, error);
+    }
+    const code = error?.code;
+    if (typeof code === "string") {
+        return new PdfError(code, error.message);
+    }
+    return error;
+}
+/** Runs `read` over an object wasm-bindgen allocated, freeing it even if `read` throws. */
+function consume(owned, read) {
+    try {
+        return read(owned);
+    }
+    finally {
+        owned.free();
+    }
+}
+function toText(t) {
+    return consume(t, () => {
+        const fontFlags = t.fontFlags;
+        const fontWeights = t.fontWeights;
+        const fontEmbedded = t.fontEmbedded;
+        const fontAscents = t.fontAscents;
+        const fontDescents = t.fontDescents;
+        const fonts = t.fontNames.map((name, i) => ({
+            name,
+            flags: fontFlags[i] ?? 0,
+            weight: fontWeights[i] ?? 0,
+            embedded: fontEmbedded[i] === 1,
+            ascent: fontAscents[i] ?? 0,
+            descent: fontDescents[i] ?? 0,
+        }));
+        const wordFirstChar = t.wordFirstChar;
+        const runEms = t.runEms;
+        return {
+            text: t.text,
+            count: t.count,
+            codepoints: t.codepoints,
+            boxes: t.boxes,
+            fontSizes: t.fontSizes,
+            tfSizes: t.tfSizes,
+            truncated: t.truncated,
+            angles: t.angles,
+            fills: t.fills,
+            fontIds: t.fontIds,
+            flags: t.flags,
+            fonts,
+            words: {
+                count: wordFirstChar.length,
+                firstChar: wordFirstChar,
+                lastChar: t.wordLastChar,
+                boxes: t.wordBoxes,
+            },
+            runIds: t.runIds,
+            runs: { count: runEms.length, origins: t.runOrigins, ems: runEms },
+        };
+    });
+}
+function toObjects(o) {
+    return consume(o, () => {
+        const imageBoxes = o.imageBoxes;
+        const pathFlags = o.pathFlags;
+        const segmentKinds = o.segmentKinds;
+        return {
+            textObjects: o.textObjects,
+            truncated: o.truncated,
+            images: {
+                count: imageBoxes.length / 4,
+                boxes: imageBoxes,
+                pixels: o.imagePixels,
+            },
+            paths: {
+                count: pathFlags.length,
+                boxes: o.pathBoxes,
+                flags: pathFlags,
+                start: o.pathStart,
+            },
+            segments: {
+                count: segmentKinds.length,
+                points: o.segmentPoints,
+                kinds: segmentKinds,
+            },
+        };
+    });
+}
+function toAnnotations(a) {
+    return consume(a, () => {
+        const subtypes = a.subtypes;
+        const boxes = a.boxes;
+        const contents = a.contents;
+        const hasField = a.hasField;
+        const fieldTypes = a.fieldTypes;
+        const fieldValues = a.fieldValues;
+        const objects = a.appearanceObjects;
+        const textObjects = a.appearanceTextObjects;
+        const text = a.appearanceText;
+        const out = [];
+        for (let i = 0; i < a.count; i++) {
+            out.push({
+                subtype: subtypes[i] ?? 0,
+                box: boxAt(boxes, i),
+                contents: contents[i] ?? "",
+                field: hasField[i] === 1
+                    ? { type: fieldTypes[i] ?? "", value: fieldValues[i] ?? "" }
+                    : null,
+                appearanceObjects: objects[i] ?? 0,
+                appearanceTextObjects: textObjects[i] ?? 0,
+                appearanceText: text[i] ?? "",
+            });
+        }
+        return out;
+    });
+}
+export class RectoDocument {
+    pageCount;
+    #closed = false;
+    #doc;
+    #instance;
+    /** A ranged read's failure, thrown by the call whose fetch it failed. */
+    #fetchFailure;
+    constructor(instance, doc, fetchFailure = () => null) {
+        this.#instance = instance;
+        this.#doc = doc;
+        this.#fetchFailure = fetchFailure;
+        this.pageCount = doc.pageCount;
+        instance.openDocuments += 1;
+    }
+    #check(index) {
+        if (this.#closed) {
+            throw new PdfError("closed", "this document is closed");
+        }
+        if (!(Number.isInteger(index) && index >= 0 && index < this.pageCount)) {
+            throw new RangeError(`page ${index} is out of range (0..${this.pageCount - 1})`);
+        }
+        if (this.#instance.failure) {
+            throw this.#instance.failure;
+        }
+        if (this.#instance.dead) {
+            throw new PdfError("crash", "the engine crashed earlier on this thread; open the document again");
+        }
+    }
+    #call(fn) {
+        let result;
+        try {
+            result = fn();
+        }
+        catch (error) {
+            // A failed fetch or asset surfaces inside the engine as some other error.
+            const failure = this.#instance.failure ?? this.#fetchFailure();
+            if (failure && !(error instanceof WebAssembly.RuntimeError)) {
+                throw failure;
+            }
+            throw engineFailure(this.#instance, error);
+        }
+        // Or as a page that reads short: blank text must not pass for the page's text.
+        const failure = this.#instance.failure ?? this.#fetchFailure();
+        if (failure) {
+            throw failure;
+        }
+        return result;
+    }
+    pageInfo(index) {
+        this.#check(index);
+        return this.#call(() => {
+            const [width = 0, height = 0, rotation = 0] = this.#doc.pageInfo(index);
+            return { width, height, rotation: rotation };
+        });
+    }
+    text(index) {
+        this.#check(index);
+        return this.#call(() => toText(this.#doc.pageText(index)));
+    }
+    objects(index) {
+        this.#check(index);
+        return this.#call(() => toObjects(this.#doc.objects(index)));
+    }
+    outline() {
+        if (this.#closed) {
+            throw new PdfError("closed", "this document is closed");
+        }
+        return this.#call(() => {
+            const top = [];
+            // The open item at each level; an item's parent is the last one a level up.
+            const open = [];
+            for (const [title, url, level, page] of this.#doc.outline()) {
+                const item = { title, page, url: url || null, children: [] };
+                (level === 0 ? top : (open[level - 1]?.children ?? top)).push(item);
+                open[level] = item;
+            }
+            return top;
+        });
+    }
+    annotations(index) {
+        this.#check(index);
+        return this.#call(() => toAnnotations(this.#doc.annotations(index)));
+    }
+    scan(index) {
+        this.#check(index);
+        return this.#call(() => consume(this.#doc.scan(index), (scan) => ({
+            text: toText(scan.takeText()),
+            objects: toObjects(scan.takeObjects()),
+            annotations: toAnnotations(scan.takeAnnotations()),
+        })));
+    }
+    textAndAnnotations(index) {
+        this.#check(index);
+        return this.#call(() => consume(this.#doc.textAndAnnotations(index), (scan) => ({
+            text: toText(scan.takeText()),
+            annotations: toAnnotations(scan.takeAnnotations()),
+        })));
+    }
+    render(index, options) {
+        this.#check(index);
+        const maxHeight = options.maxHeight ?? DEFAULT_MAX_HEIGHT;
+        if (!(options.width > 0 && options.width <= MAX_DIMENSION) ||
+            !(maxHeight > 0)) {
+            throw new RangeError(`render width must be in 1..${MAX_DIMENSION} and maxHeight above 0`);
+        }
+        return this.#call(() => consume(this.#doc.render(index, options.width, maxHeight), (page) => ({
+            width: page.width,
+            height: page.height,
+            truncated: page.truncated,
+            rgba: page.takeRgba(),
+        })));
+    }
+    close() {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        this.#instance.openDocuments -= 1;
+        if (!this.#instance.dead) {
+            this.#doc.free();
+        }
+        this.#instance.onClose?.();
+    }
+    [Symbol.dispose]() {
+        this.close();
+    }
+}
+// A browser without Symbol.dispose yet: tools that lower `using` look for this one instead.
+Object.defineProperty(RectoDocument.prototype, Symbol.for("Symbol.dispose"), {
+    value: RectoDocument.prototype.close,
+});

package/dist/engine.d.ts

@@ -0,0 +1,54 @@
+import { type AssetName } from "./assets.ts";
+import { type PdfDocument } from "./document.ts";
+import { type PdfRangedDocument, type PdfRangedOpenOptions, type PdfRangeSource } from "./ranged.ts";
+export type PdfEngineOptions = {
+    /**
+     * The directory holding the package's wasm/ files, for setups that move the package
+     * without them (a bundler that does not rewrite `new URL`, a CDN). A URL in a browser; a
+     * path or file: URL in Node. Defaults to the package's own wasm/ directory.
+     */
+    assetBase?: string | URL;
+    /** Past this much linear memory, the instance is dropped when its last document closes, or
+     * replaced at the next open if one is still open. Default 512 MiB. */
+    recycleAboveBytes?: number;
+    /**
+     * Where a thread can't read a file synchronously (a page's main thread, a service worker), the
+     * assets are fetched while the engine is created: by default all of them, 5.6 MB. Name fewer to
+     * fetch less, and a document that needs one you left out fails with `missing-asset`. Ignored
+     * where assets can be read when needed.
+     */
+    preloadAssets?: Exclude<AssetName, "recto.wasm">[];
+};
+export type PdfOpenOptions = {
+    password?: string;
+    /** Checked before the open. */
+    signal?: AbortSignal;
+};
+export type PdfEngineStats = {
+    heapBytes: number;
+    /** Increments every time the instance is replaced. heapBytes is 0 while there is none. */
+    generation: number;
+    openDocuments: number;
+};
+/** One instance per thread is enough; several documents can be open on it. */
+export interface PdfEngine {
+    /**
+     * Opens a PDF held in memory. The bytes are copied before this returns its promise, so the
+     * caller may reuse, change or transfer its buffer straight away, without waiting for it.
+     */
+    open(bytes: Uint8Array | ArrayBuffer, options?: PdfOpenOptions): Promise<PdfDocument>;
+    /**
+     * Opens a PDF read by byte range, fetching only what the engine parses. Every read of it
+     * can block this thread for a network round trip; see `timeoutMs`.
+     */
+    openRanged(source: PdfRangeSource, options?: PdfRangedOpenOptions): Promise<PdfRangedDocument>;
+    stats(): PdfEngineStats;
+}
+export declare function createPdfEngine(options?: PdfEngineOptions): Promise<PdfEngine>;
+/**
+ * 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 declare function openPdf(bytes: Uint8Array | ArrayBuffer, options?: PdfOpenOptions): Promise<PdfDocument>;

package/dist/engine.js

@@ -0,0 +1,205 @@
+// 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 as soon as its last document closes; documents still open on an instance keep it.
+import { createGlue } from "../wasm/recto.gen.mjs";
+import { assetBaseUrl, canReadSync, fontFromBundle, loadAssetSync, loadWasm, preloadAssets, } 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 DEFAULT_RECYCLE_ABOVE_BYTES = 512 * 1024 * 1024;
+/** The wasm, verified and compiled once per thread, per location. */
+const compiled = new Map();
+function compile(base) {
+    const key = base?.href ?? "";
+    let module = compiled.get(key);
+    if (!module) {
+        module = loadWasm(base).then((bytes) => WebAssembly.compile(bytes).catch((error) => {
+            throw new PdfError("missing-asset", `recto could not compile recto.wasm: ${String(error)}. A Content-Security-Policy must allow 'wasm-unsafe-eval'.`, error);
+        }));
+        module.catch(() => compiled.delete(key));
+        compiled.set(key, module);
+    }
+    return module;
+}
+async function instantiate(generation, base) {
+    const module = await compile(base);
+    // 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();
+    const exports = glue.initSync({ module });
+    const instance = {
+        glue,
+        memory: exports.memory,
+        generation,
+        openDocuments: 0,
+        dead: 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 retire the
+    // instance so the next open tries again.
+    glue.setAssetLoader((index) => {
+        try {
+            if (index === CMAPS_ASSET) {
+                return loadAssetSync("cmaps.brotli", base);
+            }
+            if (index === CJK_FONT_ASSET) {
+                return loadAssetSync("cjk-fallback.ttf", base);
+            }
+            return fontFromBundle(loadAssetSync("fonts.bin", base), index);
+        }
+        catch (error) {
+            instance.dead = true;
+            instance.failure = error;
+            return;
+        }
+    });
+    return instance;
+}
+/**
+ * A copy of the caller's bytes, taken before anything asynchronous, so the buffer is theirs
+ * again the moment the call returns its promise. (The engine then copies them into WebAssembly
+ * memory, so the file is held twice for the length of the open.)
+ */
+function ownedBytes(input) {
+    if (ArrayBuffer.isView(input)) {
+        return new Uint8Array(input.buffer, input.byteOffset, input.byteLength).slice();
+    }
+    // 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).slice();
+    }
+    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;
+    constructor(instance, base, recycleAboveBytes) {
+        this.#instance = instance;
+        this.#generation = instance.generation;
+        this.#base = base;
+        this.#recycleAboveBytes = recycleAboveBytes;
+        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 &&
+                instance.memory.buffer.byteLength > this.#recycleAboveBytes) {
+                this.#instance = null;
+            }
+        };
+    }
+    async #live() {
+        const current = this.#instance;
+        if (current && !current.dead && current.memory.buffer.byteLength <= this.#recycleAboveBytes) {
+            return current;
+        }
+        this.#starting ??= instantiate(this.#generation + 1, this.#base).finally(() => {
+            this.#starting = null;
+        });
+        const started = await this.#starting;
+        this.#generation = started.generation;
+        this.#instance = started;
+        this.#watch(started);
+        return started;
+    }
+    // Async only so a bad argument rejects; everything up to the copy runs synchronously.
+    async open(input, options = {}) {
+        return await this.openOwned(ownedBytes(input), options);
+    }
+    /** `bytes` is this call's own: getting an instance can take an await. */
+    async openOwned(bytes, options) {
+        throwIfAborted(options.signal);
+        const instance = await this.#live();
+        let doc;
+        try {
+            doc = new RectoDocument(instance, new instance.glue.Document(bytes, options.password ?? null));
+        }
+        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;
+        };
+        let doc;
+        try {
+            doc = new RectoDocument(instance, instance.glue.Document.openRanged(loader.length, loader.chunkBytes, read, options.password ?? null), () => 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.#instance?.openDocuments ?? 0,
+        };
+    }
+}
+export async function createPdfEngine(options = {}) {
+    return await createEngine(options);
+}
+async function createEngine(options) {
+    const base = assetBaseUrl(options.assetBase);
+    if (!canReadSync()) {
+        await preloadAssets(base, options.preloadAssets ?? ["fonts.bin", "cmaps.brotli", "cjk-fallback.ttf"]);
+    }
+    return new RectoEngine(await instantiate(0, base), base, options.recycleAboveBytes ?? DEFAULT_RECYCLE_ABOVE_BYTES);
+}
+let shared = 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 = {}) {
+    const owned = ownedBytes(bytes);
+    if (!shared) {
+        const starting = createEngine({});
+        shared = starting;
+        // 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,34 @@
+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`. */
+ | "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;
+    constructor(code: PdfErrorCode, message: string, cause?: unknown);
+}

package/dist/errors.js

@@ -0,0 +1,11 @@
+// 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;
+    constructor(code, message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "PdfError";
+        this.code = code;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+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 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 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";

package/dist/index.js

@@ -0,0 +1,10 @@
+// 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";

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;