@2018kguo/recto 0.0.0-stage → 0.1.0

package/dist/sha256.js

@@ -0,0 +1,78 @@
+// Synchronous SHA-256 (FIPS 180-4), for assets the engine asks for from inside a call, where
+// crypto.subtle's promise cannot be awaited (and crypto.subtle does not exist at all on a
+// page served over plain http). Node's own is faster, and Node has one.
+const K = new Uint32Array([
+    0x42_8a_2f_98, 0x71_37_44_91, 0xb5_c0_fb_cf, 0xe9_b5_db_a5, 0x39_56_c2_5b,
+    0x59_f1_11_f1, 0x92_3f_82_a4, 0xab_1c_5e_d5, 0xd8_07_aa_98, 0x12_83_5b_01,
+    0x24_31_85_be, 0x55_0c_7d_c3, 0x72_be_5d_74, 0x80_de_b1_fe, 0x9b_dc_06_a7,
+    0xc1_9b_f1_74, 0xe4_9b_69_c1, 0xef_be_47_86, 0x0f_c1_9d_c6, 0x24_0c_a1_cc,
+    0x2d_e9_2c_6f, 0x4a_74_84_aa, 0x5c_b0_a9_dc, 0x76_f9_88_da, 0x98_3e_51_52,
+    0xa8_31_c6_6d, 0xb0_03_27_c8, 0xbf_59_7f_c7, 0xc6_e0_0b_f3, 0xd5_a7_91_47,
+    0x06_ca_63_51, 0x14_29_29_67, 0x27_b7_0a_85, 0x2e_1b_21_38, 0x4d_2c_6d_fc,
+    0x53_38_0d_13, 0x65_0a_73_54, 0x76_6a_0a_bb, 0x81_c2_c9_2e, 0x92_72_2c_85,
+    0xa2_bf_e8_a1, 0xa8_1a_66_4b, 0xc2_4b_8b_70, 0xc7_6c_51_a3, 0xd1_92_e8_19,
+    0xd6_99_06_24, 0xf4_0e_35_85, 0x10_6a_a0_70, 0x19_a4_c1_16, 0x1e_37_6c_08,
+    0x27_48_77_4c, 0x34_b0_bc_b5, 0x39_1c_0c_b3, 0x4e_d8_aa_4a, 0x5b_9c_ca_4f,
+    0x68_2e_6f_f3, 0x74_8f_82_ee, 0x78_a5_63_6f, 0x84_c8_78_14, 0x8c_c7_02_08,
+    0x90_be_ff_fa, 0xa4_50_6c_eb, 0xbe_f9_a3_f7, 0xc6_71_78_f2,
+]);
+const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+export function sha256Hex(bytes) {
+    const node = globalThis.process?.getBuiltinModule?.("node:crypto");
+    if (node) {
+        return node.createHash("sha256").update(bytes).digest("hex");
+    }
+    const bitLength = bytes.byteLength * 8;
+    const padded = new Uint8Array(((bytes.byteLength + 9 + 63) >> 6) << 6);
+    padded.set(bytes);
+    padded[bytes.byteLength] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.byteLength - 8, Math.floor(bitLength / 2 ** 32));
+    view.setUint32(padded.byteLength - 4, bitLength >>> 0);
+    const h = new Uint32Array([
+        0x6a_09_e6_67, 0xbb_67_ae_85, 0x3c_6e_f3_72, 0xa5_4f_f5_3a, 0x51_0e_52_7f,
+        0x9b_05_68_8c, 0x1f_83_d9_ab, 0x5b_e0_cd_19,
+    ]);
+    const w = new Uint32Array(64);
+    for (let block = 0; block < padded.byteLength; block += 64) {
+        for (let i = 0; i < 16; i++) {
+            w[i] = view.getUint32(block + i * 4);
+        }
+        for (let i = 16; i < 64; i++) {
+            const w15 = w[i - 15] ?? 0;
+            const w2 = w[i - 2] ?? 0;
+            const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ (w15 >>> 3);
+            const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ (w2 >>> 10);
+            w[i] = (w[i - 16] ?? 0) + s0 + (w[i - 7] ?? 0) + s1;
+        }
+        let a = h[0] ?? 0;
+        let b = h[1] ?? 0;
+        let c = h[2] ?? 0;
+        let d = h[3] ?? 0;
+        let e = h[4] ?? 0;
+        let f = h[5] ?? 0;
+        let g = h[6] ?? 0;
+        let hh = h[7] ?? 0;
+        for (let i = 0; i < 64; i++) {
+            const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const choice = (e & f) ^ (~e & g);
+            const t1 = (hh + s1 + choice + (K[i] ?? 0) + (w[i] ?? 0)) >>> 0;
+            const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const majority = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (s0 + majority) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        const next = [a, b, c, d, e, f, g, hh];
+        for (let i = 0; i < 8; i++) {
+            h[i] = (h[i] ?? 0) + (next[i] ?? 0);
+        }
+    }
+    return Array.from(h, (x) => x.toString(16).padStart(8, "0")).join("");
+}

package/dist/text-items.d.ts

@@ -0,0 +1,49 @@
+import { type PdfAnnotation, type PdfPageInfo, type PdfPageText } from "./document.ts";
+export declare const NOT_TEXT = -1;
+/**
+ * The char as text, or NOT_TEXT for a zero-width break hint. The engine marks a
+ * hyphen it reads as a line-end hyphenation with U+0002 (the page shows a
+ * hyphen); a no-break space reads as a space. Some PDFs put a soft hyphen
+ * after every hard one ("anti-\u00adIL5"): kept, it splits the word for search.
+ */
+export declare function visibleCodepoint(code: number, previous?: number): number;
+/** One text item, in the viewer frame with y up. */
+export type PdfTextItem = {
+    str: string;
+    /** Logical char order and word break, independent of painted boxes. */
+    flow?: {
+        index: number;
+        breakBefore: "none" | "space" | "line";
+    };
+    /** The item's origin: its start on the baseline. */
+    x: number;
+    y: number;
+    /** Advance along the reading direction, and the em across it. */
+    width: number;
+    height: number;
+    /** Counter-clockwise reading direction; absent when upright. */
+    direction?: 90 | 180 | 270;
+};
+export declare function textItems(page: Pick<PdfPageText, "count" | "codepoints" | "flags" | "boxes" | "angles" | "fontIds" | "fontSizes" | "runIds" | "runs">, info: Pick<PdfPageInfo, "width" | "height" | "rotation">): PdfTextItem[];
+/**
+ * Text that annotations show and the page's content stream does not: a
+ * FreeText's /Contents and a text or choice field's value, as pdf.js
+ * exposes them (`textContent` on getAnnotations). Each line becomes an item
+ * filling its share of the annotation's rect, in the same frame as
+ * `textItems`. `read` lists the annotations (by index) turned into items,
+ * so a caller can tell glyphs it read from glyphs it did not.
+ */
+export declare function annotationTextItems(annotations: readonly PdfAnnotationText[], info: Pick<PdfPageInfo, "height">): {
+    items: PdfTextItem[];
+    read: Set<number>;
+};
+/** What an annotation shows as text: a FreeText's /Contents, a text or choice field's value. */
+export declare function annotationShownText(annotation: PdfAnnotationText): string;
+/**
+ * Everything an annotation shows as text, for an extractor: what
+ * `annotationShownText` reads, else the text its appearance paints (a
+ * stamp's words, a list box's options).
+ */
+export declare function annotationPaintedText(annotation: PdfAnnotationText & Pick<PdfAnnotation, "appearanceText">): string;
+type PdfAnnotationText = Pick<PdfAnnotation, "subtype" | "box" | "contents" | "field">;
+export {};

package/dist/text-items.js

@@ -0,0 +1,272 @@
+// A page's text as pdf.js-style text items (getTextContent's `str`, origin,
+// width along the line, height across it, reading direction), made from
+// the engine's chars, for code written against pdf.js text items.
+//
+// Items split at font changes, line breaks, gaps wider than 0.6 em, and
+// baseline shifts over 0.25 em. Word breaks come from the reading plan,
+// not loose glyph boxes: those are ink bounds, not character advances.
+// Logical order and word breaks survive item splits in `flow`.
+//
+// Each item's baseline and em come from its text object (origin and
+// matrix, `PdfPageText.runs`), as pdf.js's do; a char's box is the
+// fallback. Coordinates: the viewer frame with y up (x right, y = page
+// height - viewer y). An item's direction is the way its chars read in
+// that frame, so text on a /Rotate 90 page that reads sideways to the
+// viewer is laid out in its own frame.
+//
+// Data-oriented: one pass over the reading order's index column; the only
+// objects made are the items returned.
+import { ANNOT_SUBTYPE, } from "./document.js";
+import { BREAK_LINE, BREAK_SPACE, isInvisibleCodepoint, readingOrder, } from "./reading-order.js";
+const SPACE_IN_FLOW_MAX_FACTOR = 0.6;
+const VERTICAL_SHIFT_RATIO = 0.25;
+/** Share of the em below the baseline in the layout's box rule (1 - GLYPH_ASCENT). */
+const DESCENT_SHARE = 0.2;
+const HYPHEN_MARK = 0x02;
+const HYPHEN = 0x2d;
+/** Quarter turns clockwise in the viewer frame that a char reads along. */
+function viewerTurn(rotation, angle) {
+    const degrees = rotation - (angle * 180) / Math.PI;
+    return ((Math.round(degrees / 90) % 4) + 4) % 4;
+}
+/** The token direction (counter-clockwise, y up) of a clockwise viewer turn. */
+const DIRECTION_OF_TURN = [0, 270, 180, 90];
+function isSpaceCode(code) {
+    return (code === 0x20 ||
+        code === 0xa0 ||
+        (code >= 0x09 && code <= 0x0d) ||
+        code === 0x30_00 ||
+        (code >= 0x20_00 && code <= 0x20_0a));
+}
+export const NOT_TEXT = -1;
+const DASHES = new Set([HYPHEN, 0x20_10, 0x20_11, 0x20_13, 0x20_14]);
+/**
+ * The char as text, or NOT_TEXT for a zero-width break hint. The engine marks a
+ * hyphen it reads as a line-end hyphenation with U+0002 (the page shows a
+ * hyphen); a no-break space reads as a space. Some PDFs put a soft hyphen
+ * after every hard one ("anti-\u00adIL5"): kept, it splits the word for search.
+ */
+export function visibleCodepoint(code, previous = 0) {
+    if (code === HYPHEN_MARK) {
+        // A line-end soft hyphen right after a hard one ("anti-" U+0002): the
+        // page shows one hyphen.
+        return DASHES.has(previous) ? NOT_TEXT : HYPHEN;
+    }
+    if (code === 0xa0) {
+        return 0x20;
+    }
+    return isInvisibleCodepoint(code) ? NOT_TEXT : code;
+}
+export function textItems(page, info) {
+    const { codepoints, boxes, angles, fontIds, fontSizes, runIds, runs } = page;
+    const plan = readingOrder(page, info);
+    const height = info.height;
+    const tokens = [];
+    // The open item, as scalars (no per-char objects).
+    let open = false;
+    let str = "";
+    let direction = 0;
+    let font = -1;
+    let size = 0;
+    let em = 1;
+    // Reading frame: `along` grows in the reading direction, `across` is the
+    // baseline offset; the item's start, end and baseline.
+    let startAlong = 0;
+    let endAlong = 0;
+    let baseline = 0;
+    let previousStart = 0;
+    let previousEnd = 0;
+    let flowIndex = 0;
+    let breakBefore = "none";
+    /** A space glyph since the last char. */
+    let sawSpace = false;
+    const flush = () => {
+        if (open && str.trim().length > 0) {
+            // The run's origin (its start on the baseline) back in token space.
+            const [x, y] = direction === 0
+                ? [startAlong, baseline]
+                : direction === 90
+                    ? [-baseline, startAlong]
+                    : direction === 180
+                        ? [-startAlong, -baseline]
+                        : [baseline, -startAlong];
+            tokens.push({
+                str,
+                flow: { index: flowIndex, breakBefore },
+                x,
+                y,
+                width: Math.max(0, endAlong - startAlong),
+                height: em,
+                ...(direction === 0 ? {} : { direction: direction }),
+            });
+        }
+        open = false;
+        str = "";
+    };
+    for (let k = 0; k < plan.length; k++) {
+        const i = plan.order[k] ?? 0;
+        const code = codepoints[i] ?? 0;
+        const lineBreak = plan.breaks[k] === BREAK_LINE;
+        if (lineBreak) {
+            flush();
+            sawSpace = false;
+        }
+        // The engine's own word break (a generated space, from glyph origins and
+        // advances) counts like a space glyph: a char box can be wider than its
+        // advance (a bullet, a bold face), and then the box gap alone hides it.
+        if (plan.breaks[k] === BREAK_SPACE) {
+            sawSpace = true;
+        }
+        if (isSpaceCode(code)) {
+            sawSpace = true;
+            continue;
+        }
+        const visible = visibleCodepoint(code, k > 0 ? (codepoints[plan.order[k - 1] ?? 0] ?? 0) : 0);
+        if (visible === NOT_TEXT) {
+            continue;
+        }
+        const vx = boxes[4 * i] ?? 0;
+        const vy = boxes[4 * i + 1] ?? 0;
+        const vw = boxes[4 * i + 2] ?? 0;
+        const vh = boxes[4 * i + 3] ?? 0;
+        // The char's box in token space (y up).
+        const x0 = vx;
+        const x1 = vx + vw;
+        const y0 = height - (vy + vh);
+        const y1 = height - vy;
+        const turn = viewerTurn(info.rotation, angles[i] ?? 0);
+        const dir = DIRECTION_OF_TURN[turn] ?? 0;
+        // Along/across extents for this direction, and the char's em.
+        let a0;
+        let a1;
+        let charBaseline;
+        let charEm;
+        if (dir === 0) {
+            [a0, a1] = [x0, x1];
+            charEm = y1 - y0;
+            charBaseline = y0 + DESCENT_SHARE * charEm;
+        }
+        else if (dir === 90) {
+            [a0, a1] = [y0, y1];
+            charEm = x1 - x0;
+            charBaseline = -(x1 - DESCENT_SHARE * charEm);
+        }
+        else if (dir === 180) {
+            [a0, a1] = [-x1, -x0];
+            charEm = y1 - y0;
+            charBaseline = -(y1 - DESCENT_SHARE * charEm);
+        }
+        else {
+            [a0, a1] = [-y1, -y0];
+            charEm = x1 - x0;
+            charBaseline = x0 + DESCENT_SHARE * charEm;
+        }
+        // The run's baseline and drawn size where the engine gives them (the text
+        // object's origin and matrix); the box's split is the fallback.
+        const run = runIds[i] ?? -1;
+        const runEm = run >= 0 ? (runs.ems[run] ?? 0) : 0;
+        if (runEm > 0) {
+            const ox = runs.origins[2 * run] ?? 0;
+            const oy = height - (runs.origins[2 * run + 1] ?? 0);
+            charEm = runEm;
+            charBaseline = dir === 0 ? oy : dir === 90 ? -ox : dir === 180 ? -oy : ox;
+        }
+        charEm = Math.max(charEm, 0.01);
+        const charFont = fontIds[i] ?? -1;
+        const charSize = fontSizes[i] ?? 0;
+        let joinWithSpace = false;
+        // Logical RTL chars move backwards. Compare adjacent glyphs, not the
+        // growing item's right edge, and retain the union as its geometry.
+        const advance = Math.max(a0 - previousEnd, previousStart - a1);
+        if (open) {
+            const sameRun = dir === direction && charFont === font && charSize === size;
+            const shift = Math.abs(charBaseline - baseline);
+            if (!sameRun ||
+                shift > VERTICAL_SHIFT_RATIO * em ||
+                advance > SPACE_IN_FLOW_MAX_FACTOR * em) {
+                flush();
+            }
+            else if (sawSpace) {
+                // A space glyph in the stream is a word break even where the font's
+                // char boxes overlap it (pdf.js measures the glyph's advance).
+                joinWithSpace = true;
+            }
+        }
+        if (!open) {
+            open = true;
+            flowIndex = k;
+            breakBefore = lineBreak ? "line" : sawSpace ? "space" : "none";
+            direction = dir;
+            font = charFont;
+            size = charSize;
+            em = charEm;
+            startAlong = a0;
+            endAlong = a1;
+            baseline = charBaseline;
+        }
+        if (joinWithSpace) {
+            str += " ";
+        }
+        sawSpace = false;
+        str += String.fromCodePoint(visible);
+        endAlong = Math.max(endAlong, a1);
+        startAlong = Math.min(startAlong, a0);
+        previousStart = a0;
+        previousEnd = a1;
+    }
+    flush();
+    return tokens;
+}
+/**
+ * Text that annotations show and the page's content stream does not: a
+ * FreeText's /Contents and a text or choice field's value, as pdf.js
+ * exposes them (`textContent` on getAnnotations). Each line becomes an item
+ * filling its share of the annotation's rect, in the same frame as
+ * `textItems`. `read` lists the annotations (by index) turned into items,
+ * so a caller can tell glyphs it read from glyphs it did not.
+ */
+export function annotationTextItems(annotations, info) {
+    const items = [];
+    const read = new Set();
+    for (const [index, annotation] of annotations.entries()) {
+        const lines = annotationShownText(annotation)
+            .split(/\r\n|\r|\n/u)
+            .filter((line) => line.trim().length > 0);
+        if (lines.length === 0) {
+            continue;
+        }
+        const { x, y, width, height } = annotation.box;
+        const top = info.height - y;
+        const lineHeight = Math.max(height / lines.length, 1);
+        for (const [i, line] of lines.entries()) {
+            items.push({
+                str: line,
+                x,
+                y: top - lineHeight * (i + 1) + lineHeight * DESCENT_SHARE,
+                width: Math.max(width, 0),
+                height: lineHeight,
+            });
+        }
+        read.add(index);
+    }
+    return { items, read };
+}
+/** What an annotation shows as text: a FreeText's /Contents, a text or choice field's value. */
+export function annotationShownText(annotation) {
+    if (annotation.subtype === ANNOT_SUBTYPE.freeText) {
+        return annotation.contents;
+    }
+    if (annotation.field &&
+        (annotation.field.type === "Tx" || annotation.field.type === "Ch")) {
+        return annotation.field.value;
+    }
+    return "";
+}
+/**
+ * Everything an annotation shows as text, for an extractor: what
+ * `annotationShownText` reads, else the text its appearance paints (a
+ * stamp's words, a list box's options).
+ */
+export function annotationPaintedText(annotation) {
+    return annotationShownText(annotation).trim() || annotation.appearanceText;
+}

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@2018kguo/recto",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "A PDF engine for JavaScript: text with boxes, page objects, annotations and rendering, in Rust compiled to WebAssembly.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/2018kguo/recto.git",
+    "directory": "js"
+  },
+  "keywords": [
+    "pdf",
+    "pdf-parser",
+    "pdf-renderer",
+    "text-extraction",
+    "webassembly"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "wasm"
+  ],
+  "scripts": {
+    "build": "sh ../scripts/build-wasm.sh && npm run build:ts",
+    "build:ts": "tsc -p .",
+    "prepack": "npm run build",
+    "test": "node --test --test-concurrency=2 test/*.test.ts",
+    "typecheck": "tsc -p . --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "pdf-lib": "1.17.1",
+    "pdfjs-dist": "4.10.38",
+    "publint": "0.3.15",
+    "typescript": "5.9.3"
+  }
+}