@ryanyahya/opendoc 0.4.0

package/node_modules/@formepdf/core/dist/layout.js

@@ -0,0 +1,240 @@
+/**
+ * Stable accessor helpers for the layout tree returned by
+ * `renderDocumentWithLayout()`.
+ *
+ * These helpers exist for one specific reason: the raw `ElementInfo` /
+ * `LayoutInfo` shape is documented but the documentation is not a
+ * contract, and it has drifted from runtime twice now. Consumers that
+ * hard-code invariants like "the text lives on `TextLine` children,
+ * not the parent `Text`" break silently every time an internal refactor
+ * shifts them.
+ *
+ * The helpers in this module encapsulate those invariants once, in a
+ * narrow, deliberately-maintained surface. Each helper corresponds to
+ * one of the layout-time transforms documented on `ElementInfo`. When
+ * an invariant changes in the engine, this file is where you update it
+ * — the runtime-conformance test (`tests/layout-shape.test.ts`) catches
+ * engine drift; helper tests (`tests/layout-helpers.test.ts`) catch
+ * drift in the helpers themselves.
+ *
+ * **Prefer these helpers to raw tree walking unless you specifically
+ * need raw shape access** (e.g. custom snapshot comparison, structural
+ * analysis the helpers don't cover).
+ */
+function normalizeRoot(root) {
+    if (Array.isArray(root)) {
+        // ElementInfo[] or PageInfo[]
+        if (root.length === 0)
+            return [];
+        if ('elements' in root[0]) {
+            // PageInfo[]
+            return root.flatMap((p) => p.elements);
+        }
+        return root;
+    }
+    if ('pages' in root)
+        return root.pages.flatMap((p) => p.elements); // LayoutInfo
+    if ('elements' in root)
+        return root.elements; // PageInfo
+    return [root]; // ElementInfo
+}
+// ── Traversal ──────────────────────────────────────────────────────
+/**
+ * Depth-first walk of every node in `root`, calling `cb` for each.
+ *
+ * `path` is a human-readable string identifying where in the tree the
+ * node lives (e.g. `"[0].children[2]"` for the third child of the first
+ * root element). Useful for building error messages; ignore if you
+ * don't need it.
+ *
+ * Callbacks that return `false` skip descent into that node's children.
+ * Any other return (including `void`) descends normally.
+ */
+export function walkElements(root, cb) {
+    const roots = normalizeRoot(root);
+    const stack = [];
+    // Reverse-push so we process in source order.
+    for (let i = roots.length - 1; i >= 0; i--) {
+        stack.push({ node: roots[i], path: `[${i}]` });
+    }
+    while (stack.length > 0) {
+        const { node, path } = stack.pop();
+        const skip = cb(node, path) === false;
+        if (skip)
+            continue;
+        for (let i = node.children.length - 1; i >= 0; i--) {
+            stack.push({ node: node.children[i], path: `${path}.children[${i}]` });
+        }
+    }
+}
+/**
+ * Every node in `root` for which `predicate` returns truthy. Order is
+ * depth-first, source-order.
+ */
+export function findElements(root, predicate) {
+    const hits = [];
+    walkElements(root, (node, path) => {
+        if (predicate(node, path))
+            hits.push(node);
+    });
+    return hits;
+}
+/**
+ * First node in `root` for which `predicate` returns truthy, or `null`
+ * if none. Order is depth-first, source-order. Stops as soon as a match
+ * is found (does not descend into the match's children).
+ */
+export function findFirstElement(root, predicate) {
+    let hit = null;
+    walkElements(root, (node, path) => {
+        if (hit !== null)
+            return false;
+        if (predicate(node, path)) {
+            hit = node;
+            return false;
+        }
+    });
+    return hit;
+}
+// ── Text access ────────────────────────────────────────────────────
+/**
+ * Every `TextLine` leaf descendant of `node`, in source order. If
+ * `node` is itself a `TextLine`, returns `[node]`.
+ *
+ * This is the load-bearing helper: it encapsulates the invariant that
+ * text lives on `TextLine` children, never on the parent `Text` block.
+ */
+export function getTextLines(node) {
+    if (node.nodeType === 'TextLine')
+        return [node];
+    const lines = [];
+    walkElements(node.children, (n) => {
+        if (n.nodeType === 'TextLine') {
+            lines.push(n);
+            return false; // TextLines don't nest further; skip descent
+        }
+    });
+    return lines;
+}
+/**
+ * Concatenated text of every `TextLine` descendant of `node`, joined
+ * with `"\n"`. If `node` is itself a `TextLine`, returns its own text.
+ *
+ * Lines are joined with newlines rather than spaces because the layout
+ * engine may have wrapped a single JSX string across multiple lines,
+ * and preserving that structure is more useful than silently smushing
+ * or space-joining. If you want a flat string, `.replace(/\n/g, ' ')`
+ * the result.
+ *
+ * Returns `""` if no `TextLine` descendants exist.
+ */
+export function getNodeText(node) {
+    const lines = getTextLines(node);
+    return lines
+        .map((l) => (typeof l.textContent === 'string' ? l.textContent : ''))
+        .join('\n');
+}
+// ── Structural queries encapsulating layout-time transforms ────────
+/**
+ * If `node` is a heading (`H1`–`H6`), returns the numeric level (1–6).
+ * Returns `null` otherwise.
+ *
+ * Encapsulates the invariant that headings render as six discriminated
+ * nodeTypes (`H1`, `H2`, …) rather than a generic `Heading` node with a
+ * separate `level` field.
+ */
+export function getHeadingLevel(node) {
+    const nt = node.nodeType;
+    if (nt === 'H1')
+        return 1;
+    if (nt === 'H2')
+        return 2;
+    if (nt === 'H3')
+        return 3;
+    if (nt === 'H4')
+        return 4;
+    if (nt === 'H5')
+        return 5;
+    if (nt === 'H6')
+        return 6;
+    return null;
+}
+/**
+ * Every `TableRow` under `parent`, looking through `Table` wrapper nodes.
+ *
+ * Since engine 0.14, `<Table>` emits a `Table` container element per page
+ * fragment with the rows nested inside it. Pass the containing `page`
+ * (or the parent `View` that held the `<Table>` in JSX) as `parent` —
+ * or a `Table` element directly. Loose sibling rows (the pre-0.14 shape)
+ * are still returned for compatibility with stored layouts.
+ *
+ * Returns rows in source order.
+ */
+export function getTableRows(parent) {
+    const kids = 'elements' in parent ? parent.elements : parent.children;
+    const rows = [];
+    for (const k of kids) {
+        if (k.nodeType === 'TableRow')
+            rows.push(k);
+        else if (k.nodeType === 'Table') {
+            rows.push(...k.children.filter((c) => c.nodeType === 'TableRow'));
+        }
+    }
+    return rows;
+}
+/**
+ * The `FixedHeader` and `FixedFooter` nodes on `page`. Encapsulates the
+ * invariant that `<Fixed position="header">` and `<Fixed position="footer">`
+ * produce two distinct nodeTypes rather than a shared `Fixed` node with
+ * a `position` field.
+ *
+ * Both arrays may be empty. Multiple entries in either array indicate
+ * repeating fixed regions (e.g. when the same `<Fixed>` repeats across
+ * page breaks — the layout may emit one node per occurrence).
+ */
+export function getFixedRegions(page) {
+    const header = [];
+    const footer = [];
+    for (const el of page.elements) {
+        if (el.nodeType === 'FixedHeader')
+            header.push(el);
+        else if (el.nodeType === 'FixedFooter')
+            footer.push(el);
+    }
+    return { header, footer };
+}
+/**
+ * Every `ListItem` child of a `List` node. Returns `[]` if `list` is
+ * not a `List` (silently — no throw, so this composes cleanly with
+ * `.flatMap`).
+ */
+export function getListItems(list) {
+    if (list.nodeType !== 'List')
+        return [];
+    return list.children.filter((c) => c.nodeType === 'ListItem');
+}
+/**
+ * Rendered text of the marker (`Lbl`) child of a `ListItem` — e.g.
+ * `"1."` for the first item of an `<OrderedList>`, `"•"` for an
+ * `<UnorderedList>` item. Returns `null` if `item` is not a `ListItem`
+ * or has no `Lbl` child.
+ *
+ * Encapsulates the invariant that list markers are separate `Lbl`
+ * children of each `ListItem` rather than a field on `ListItem` itself.
+ */
+export function getListItemMarker(item) {
+    if (item.nodeType !== 'ListItem')
+        return null;
+    const lbl = item.children.find((c) => c.nodeType === 'Lbl');
+    if (!lbl)
+        return null;
+    return getNodeText(lbl);
+}
+// ── Node-type narrowing utility ────────────────────────────────────
+/**
+ * Type-guard for narrowing to a specific `ElementNodeType`. Useful for
+ * `.filter(isNodeType('TableRow'))` chains.
+ */
+export function isNodeType(nodeType) {
+    return (node) => node.nodeType === nodeType;
+}

package/node_modules/@formepdf/core/dist/shared/browserHelpers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Helpers shared between the browser entry (`src/browser.ts`, backed by
+ * the wasm-pack `--target bundler` build) and the worker entry
+ * (`src/worker.ts`, backed by `--target web`). The two entries differ
+ * only in how the WASM module gets instantiated; everything from
+ * font/image URL resolution through embedded-JSON extraction is the
+ * same and lives here.
+ *
+ * Strictly browser/edge primitives: `fetch`, `btoa`, `TextDecoder`,
+ * `DecompressionStream`. No Node-only APIs.
+ */
+export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
+export declare function resolveFonts(doc: Record<string, unknown>): Promise<void>;
+export declare function resolveImages(doc: Record<string, unknown>): Promise<void>;
+/**
+ * Extract embedded JSON data from a Forme-generated PDF using browser-
+ * native DecompressionStream (no node:zlib needed).
+ */
+export declare function extractDataFromPdf(pdfBytes: Uint8Array): Promise<unknown | null>;

package/node_modules/@formepdf/core/dist/shared/browserHelpers.js

@@ -0,0 +1,128 @@
+/**
+ * Helpers shared between the browser entry (`src/browser.ts`, backed by
+ * the wasm-pack `--target bundler` build) and the worker entry
+ * (`src/worker.ts`, backed by `--target web`). The two entries differ
+ * only in how the WASM module gets instantiated; everything from
+ * font/image URL resolution through embedded-JSON extraction is the
+ * same and lives here.
+ *
+ * Strictly browser/edge primitives: `fetch`, `btoa`, `TextDecoder`,
+ * `DecompressionStream`. No Node-only APIs.
+ */
+export function uint8ArrayToBase64(bytes) {
+    // Browser-native: binary string → btoa
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+export async function resolveFonts(doc) {
+    const fonts = doc.fonts;
+    if (!fonts?.length)
+        return;
+    for (const font of fonts) {
+        if (font.src instanceof Uint8Array) {
+            font.src = uint8ArrayToBase64(font.src);
+        }
+        else if (typeof font.src === 'string' && !font.src.startsWith('data:')) {
+            // In the browser, non-data-URI strings are treated as URLs
+            const res = await fetch(font.src);
+            if (!res.ok)
+                throw new Error(`Failed to fetch font: ${font.src} (${res.status})`);
+            const buf = new Uint8Array(await res.arrayBuffer());
+            font.src = uint8ArrayToBase64(buf);
+        }
+        // data URIs pass through as-is (engine extracts base64 portion)
+    }
+}
+export async function resolveImages(doc) {
+    const children = doc.children;
+    if (!children?.length)
+        return;
+    for (const child of children) {
+        await resolveImagesInNode(child);
+    }
+}
+async function resolveImagesInNode(node) {
+    const kind = node.kind;
+    if (kind?.type === 'Image' && typeof kind.src === 'string') {
+        const src = kind.src;
+        if (src.startsWith('http://') || src.startsWith('https://')) {
+            const res = await fetch(src);
+            if (!res.ok)
+                throw new Error(`Failed to fetch image: ${src} (${res.status})`);
+            const contentType = res.headers.get('content-type') || 'image/png';
+            const buf = new Uint8Array(await res.arrayBuffer());
+            kind.src = `data:${contentType};base64,${uint8ArrayToBase64(buf)}`;
+        }
+    }
+    const children = node.children;
+    if (children?.length) {
+        for (const child of children) {
+            await resolveImagesInNode(child);
+        }
+    }
+}
+/**
+ * Extract embedded JSON data from a Forme-generated PDF using browser-
+ * native DecompressionStream (no node:zlib needed).
+ */
+export async function extractDataFromPdf(pdfBytes) {
+    const text = new TextDecoder('latin1').decode(pdfBytes);
+    const fsMatch = text.match(/\/F\s*\(forme-data\.json\)/);
+    if (!fsMatch)
+        return null;
+    const fsStart = fsMatch.index;
+    const fsRegion = text.slice(Math.max(0, fsStart - 200), fsStart + 200);
+    const efMatch = fsRegion.match(/\/EF\s*<<\s*\/F\s+(\d+)\s+0\s+R\s*>>/);
+    if (!efMatch)
+        return null;
+    const streamObjId = efMatch[1];
+    const objPattern = new RegExp(streamObjId + '\\s+0\\s+obj\\b');
+    const objMatch = text.match(objPattern);
+    if (!objMatch)
+        return null;
+    const objStart = objMatch.index;
+    const streamKeyword = text.indexOf('stream', objStart);
+    if (streamKeyword === -1)
+        return null;
+    let streamDataStart = streamKeyword + 6;
+    if (pdfBytes[streamDataStart] === 0x0d)
+        streamDataStart++;
+    if (pdfBytes[streamDataStart] === 0x0a)
+        streamDataStart++;
+    const endstreamPos = text.indexOf('\nendstream', streamDataStart);
+    if (endstreamPos === -1)
+        return null;
+    const compressedBytes = pdfBytes.slice(streamDataStart, endstreamPos);
+    const objRegion = text.slice(objStart, streamKeyword);
+    const isCompressed = objRegion.includes('/FlateDecode');
+    let jsonBytes;
+    if (isCompressed) {
+        const ds = new DecompressionStream('deflate');
+        const writer = ds.writable.getWriter();
+        writer.write(compressedBytes);
+        writer.close();
+        const reader = ds.readable.getReader();
+        const chunks = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            chunks.push(value);
+        }
+        const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+        jsonBytes = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            jsonBytes.set(chunk, offset);
+            offset += chunk.length;
+        }
+    }
+    else {
+        jsonBytes = compressedBytes;
+    }
+    const jsonString = new TextDecoder('utf-8').decode(jsonBytes);
+    return JSON.parse(jsonString);
+}

package/node_modules/@formepdf/core/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@formepdf/core",
+  "version": "0.20.1-opendoc.3",
+  "description": "WASM-powered PDF rendering engine for Forme",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./layout": {
+      "types": "./dist/layout.d.ts",
+      "import": "./dist/layout.js"
+    }
+  },
+  "dependencies": {
+    "@formepdf/react": "0.20.1"
+  },
+  "peerDependencies": {
+    "react": "^18 || ^19"
+  },
+  "files": [
+    "dist/",
+    "pkg-node/"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/formepdf/forme",
+    "directory": "packages/core"
+  }
+}

package/node_modules/@formepdf/core/pkg-node/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daniel Molitor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@formepdf/core/pkg-node/README.md

@@ -0,0 +1,84 @@
+# forme-pdf
+
+A page-native PDF rendering engine written in Rust. Layout happens **into** pages, not onto an infinite canvas that gets sliced afterward — so page breaks, table headers, and flex layout all work correctly across pages.
+
+`cargo add forme-pdf` installs the crate. The library name is `forme`:
+
+```rust
+use forme::{render_json, Document, FormeError};
+```
+
+## Features
+
+- **Page-native layout** — flexbox, tables, and text reflow with real page boundary awareness
+- **CSS-like styling** — flexbox (`row`/`column`, `wrap`, `grow`/`shrink`), CSS Grid, absolute positioning
+- **Text** — OpenType shaping, Knuth-Plass line breaking, hyphenation (35+ languages), BiDi, per-character font fallback
+- **Tables** — automatic header repetition on page breaks, column spans
+- **Images** — JPEG, PNG, WebP (embedded or data URI)
+- **SVG** — inline SVG rendering (rect, circle, line, path, arc)
+- **Charts** — BarChart, LineChart, PieChart, AreaChart, DotPlot (engine-native, no JS)
+- **QR codes & barcodes** — vector rendering (Code128, Code39, EAN13, EAN8, Codabar)
+- **Canvas** — arbitrary vector drawing via a Canvas-like API
+- **Watermarks** — rotated text behind page content
+- **AcroForms** — fillable PDF forms (TextField, Checkbox, Dropdown, RadioButton) with form flattening
+- **PDF/UA-1** — accessibility compliance with structure tree, tab order, role map, artifact tagging
+- **PDF/A** — archival compliance (PDF/A-2b, PDF/A-2a) with full font embedding and XMP metadata
+- **Digital signatures** — PKCS#7 detached signatures with X.509 certificates
+- **Templates** — expression language for dynamic documents (`$ref`, `$each`, `$if`)
+- **WASM** — compiles to WebAssembly for browser and serverless use
+
+## Quick start
+
+```rust
+use forme::{render_json, FormeError};
+
+fn main() -> Result<(), FormeError> {
+    let json = r#"{
+        "pages": [{ "size": "A4" }],
+        "children": [{
+            "kind": "text",
+            "content": "Hello from Forme!",
+            "style": { "fontSize": 24, "margin": { "top": 72, "left": 72 } }
+        }]
+    }"#;
+
+    let pdf_bytes = render_json(json)?;
+    std::fs::write("hello.pdf", pdf_bytes).unwrap();
+    Ok(())
+}
+```
+
+## API
+
+### Rendering
+
+| Function | Description |
+|----------|-------------|
+| `render(&Document)` | Render a document struct to PDF bytes |
+| `render_json(&str)` | Parse JSON and render to PDF bytes |
+| `render_with_layout(&Document)` | Render and return PDF bytes + layout metadata |
+| `render_json_with_layout(&str)` | Parse JSON, render, and return PDF bytes + layout metadata |
+| `render_template(&str, &str)` | Evaluate a template with data, then render |
+| `render_template_with_layout(&str, &str)` | Evaluate a template with data, render, and return PDF bytes + layout metadata |
+
+### PDF Operations
+
+| Function | Description |
+|----------|-------------|
+| `merge_pdfs(&[&[u8]])` | Combine multiple PDFs into one |
+| `certify_pdf(&[u8], &str, &str, ...)` | Apply a PKCS#7 digital signature to an existing PDF |
+| `redact_pdf(&[u8], &[RedactionRegion])` | Redact regions from a PDF (removes underlying text) |
+| `redact_text(&[u8], &[TextSearchRedaction])` | Find text by pattern and redact matching regions |
+| `find_text_regions(&[u8], &[TextSearchPattern])` | Find text regions in a PDF without redacting |
+
+All functions return `Result<Vec<u8>, FormeError>` (or a tuple with `LayoutInfo` for the `_with_layout` variants).
+
+## Documentation
+
+- [Full docs](https://docs.formepdf.com) — component reference, styling guide, examples
+- [API reference](https://docs.rs/forme-pdf) — Rust API docs
+- [GitHub](https://github.com/formepdf/forme) — source, issues, JSX/TypeScript packages
+
+## License
+
+MIT

package/node_modules/@formepdf/core/pkg-node/forme.d.ts

@@ -0,0 +1,39 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Certify PDF bytes with an X.509 certificate (PKCS#7 detached signature).
+ */
+export function certify_pdf(pdf_bytes: Uint8Array, config_json: string): Uint8Array;
+
+/**
+ * Find text regions matching patterns in a PDF.
+ * Returns JSON string of Vec<RedactionRegion>.
+ */
+export function find_text_regions(pdf_bytes: Uint8Array, patterns_json: string): string;
+
+export function init_panic_hook(): void;
+
+/**
+ * Merge multiple PDFs into a single document.
+ * Accepts a JSON array of base64-encoded PDF strings.
+ */
+export function merge_pdfs(pdfs_json: string): Uint8Array;
+
+/**
+ * Redact regions of a PDF by overlaying opaque rectangles.
+ */
+export function redact_pdf(pdf_bytes: Uint8Array, redactions_json: string): Uint8Array;
+
+/**
+ * Redact text matching patterns from a PDF.
+ */
+export function redact_text(pdf_bytes: Uint8Array, patterns_json: string): Uint8Array;
+
+export function render_pdf(json: string): Uint8Array;
+
+export function render_pdf_with_layout(json: string): any;
+
+export function render_template_pdf(template_json: string, data_json: string): Uint8Array;
+
+export function render_template_pdf_with_layout(template_json: string, data_json: string): any;