docling.rs-wasm 0.50.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Artem Kustikov
+
+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/README.md

@@ -0,0 +1,77 @@
+# docling.rs-wasm
+
+[docling.rs](https://github.com/docling-project/docling.rs) compiled to
+WebAssembly: convert **DOCX, HTML, XLSX, PPTX, CSV, AsciiDoc, EPUB, ODF,
+Markdown, WebVTT, Email, MHTML, JATS, USPTO, XBRL, LaTeX, JSON, DocLang — and
+the embedded text layer of PDFs** — to Markdown / docling JSON / DocLang XML
+**entirely in the browser**. No server; the file never leaves the page.
+
+~1.9 MB gzipped, no models needed for any of the above. Scanned PDFs and
+images additionally work through the in-browser ML pipeline (RT-DETR layout +
+PP-OCRv3 + TableFormer via [ONNX Runtime Web](https://www.npmjs.com/package/onnxruntime-web))
+once you provide the models — see the
+[full docs](https://github.com/docling-project/docling.rs/tree/master/crates/docling-wasm#readme)
+and the [live demo](https://docling-project.github.io/docling.rs/).
+
+## Bundlers (Vite, webpack, …)
+
+```js
+import { convert, supported_extensions } from "docling.rs-wasm";
+
+const file = input.files[0];
+const bytes = new Uint8Array(await file.arrayBuffer());
+const markdown = convert(bytes, file.name, "md");
+const json     = convert(bytes, file.name, "json");
+const withPics = convert(bytes, file.name, "md", "embedded"); // data: URIs
+```
+
+(The bundler target loads the wasm as a module import — Vite needs no config;
+webpack 5 needs `experiments.asyncWebAssembly = true`.)
+
+## No bundler (plain `<script type="module">`)
+
+```js
+import init, { convert } from "docling.rs-wasm/web";
+await init(); // fetches docling_wasm_bg.wasm next to the JS
+
+const markdown = convert(bytes, file.name, "md");
+```
+
+## API
+
+```ts
+convert(
+  bytes: Uint8Array,
+  filename: string,                        // extension drives format detection
+  to?: "md" | "json" | "doclang",          // default "md"
+  images?: "placeholder" | "embedded",     // default "placeholder", Markdown only
+  max_pages?: number,                      // convert only the first N PDF pages
+): string
+supported_extensions(): string             // JSON array, e.g. for <input accept=…>
+version(): string
+```
+
+Structured digital-PDF conversion (`DigitalConverter`: headings, lists,
+tables, pictures via the layout model), scanned-document OCR
+(`ScannedConverter`) and TableFormer table structure are exported too — they
+need ONNX Runtime Web sessions on the JS side; the
+[crate README](https://github.com/docling-project/docling.rs/tree/master/crates/docling-wasm#readme)
+has the complete wiring, and the
+[demo page source](https://github.com/docling-project/docling.rs/tree/master/crates/docling-wasm/www)
+is a working reference.
+
+## Tauri / Electron
+
+The package runs in any webview as-is — but in a Tauri app you usually want
+the **native** pipeline in the Rust backend instead (full OCR, TableFormer,
+GPU, no wasm limits). See
+[“Tauri and other desktop shells”](https://github.com/docling-project/docling.rs/tree/master/crates/docling-wasm#tauri-and-other-desktop-shells)
+in the crate README.
+
+## Related packages
+
+- [`docling.rs`](https://www.npmjs.com/package/docling.rs) — native Node.js /
+  Bun bindings with the full ML pipeline (use this on servers).
+- [`docling.rs-cuda`](https://www.npmjs.com/package/docling.rs-cuda) — the
+  same with CUDA execution providers.
+- [`docling-rs`](https://pypi.org/project/docling-rs/) — Python wheel.

package/bundler/docling_wasm.d.ts

@@ -0,0 +1,132 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A digital PDF being converted page by page. Construct it from the file's
+ * bytes (the text layer is parsed once, in Rust), then feed the rasterized
+ * pages in order.
+ */
+export class DigitalConverter {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * [`add_page`](Self::add_page) with TableFormer for the table regions whose
+     * geometric reconstruction looks unreliable.
+     */
+    addPageTf(index: number, rgba: Uint8Array, px_w: number, px_h: number, scale: number, layout: any, tf: any, rec?: any | null): Promise<void>;
+    /**
+     * Convert page `index` (0-based) given its rendered bitmap: layout
+     * detection plus geometric tables. `scale` is the raster's pixels per PDF
+     * point (2.0 for pdf.js `{scale: 2}`). With `rec` (and a dictionary at
+     * construction), embedded raster pictures that carry no text cells are
+     * OCR'd — the text a digital page's images hide from its text layer.
+     */
+    add_page(index: number, rgba: Uint8Array, px_w: number, px_h: number, scale: number, layout: any, rec?: any | null): Promise<void>;
+    /**
+     * Assemble the converted pages into a document and render it as `"md"`
+     * (default), `"json"` or `"doclang"`, with `images` picking how pictures
+     * render in Markdown. Resets the converter.
+     */
+    finish(name: string, to?: string | null, images?: string | null): string;
+    /**
+     * Parse the PDF's text layer. Fails when there is none — the caller should
+     * fall back to the scanned pipeline, exactly as the demo page does.
+     * `dict` (optional) is the recognition dictionary text; with it and a
+     * `RecSession` on `add_page`, embedded raster pictures get OCR'd too.
+     */
+    constructor(bytes: Uint8Array, dict?: string | null);
+    /**
+     * Pages the text parser found.
+     */
+    page_count(): number;
+    /**
+     * Install the recognition dictionary after construction — the host probes
+     * the text layer first (the constructor throws on a scan) and only then
+     * fetches the recognition model + dictionary.
+     */
+    setDict(dict: string): void;
+}
+
+/**
+ * Multi-page scanned-document converter (lite profile). Feed pages in
+ * order, then [`finish`](Self::finish) — cross-page paragraph continuations
+ * merge exactly like the native pipeline.
+ */
+export class ScannedConverter {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Convert one page with TableFormer (#157 stage 3): table regions get the
+     * ONNX table-structure model + docling's cell matcher instead of the
+     * geometric reconstruction. `tf` is the JS-side session over the encoder /
+     * decoder / bbox graphs.
+     */
+    addPageTf(rgba: Uint8Array, px_w: number, px_h: number, scale: number, layout: any, rec: any, tf: any): Promise<void>;
+    /**
+     * Convert one page (lite profile — geometric tables): `rgba` is the
+     * rendered bitmap (canvas ImageData), `scale` its pixels-per-PDF-point
+     * (2.0 for pdf.js `{scale: 2}`; 1.0 for a standalone image).
+     */
+    add_page(rgba: Uint8Array, px_w: number, px_h: number, scale: number, layout: any, rec: any): Promise<void>;
+    /**
+     * Assemble the accumulated pages into the final document and render it
+     * as `"md"` (default), `"json"` or `"doclang"` — the same three the
+     * declarative [`crate::convert`] entry point offers. `images` picks how
+     * cropped figures render in Markdown (`"placeholder"` | `"embedded"`),
+     * like [`crate::convert`]. Resets the converter.
+     */
+    finish(name: string, to?: string | null, images?: string | null): string;
+    /**
+     * `dict` is the recognition dictionary text (`en_dict.txt` for the
+     * default English model).
+     */
+    constructor(dict: string);
+    /**
+     * Number of pages converted so far (progress display).
+     */
+    page_count(): number;
+}
+
+/**
+ * Convert a document (as bytes + filename, the extension drives format
+ * detection) to `to`: `"md"` (Markdown, default), `"json"` (docling-core's
+ * `DoclingDocument` wire format, schema 1.10.0) or `"doclang"` (docling's
+ * DocLang XML serialization).
+ *
+ * `images` controls how pictures render in Markdown — `"placeholder"`
+ * (default) or `"embedded"` (base64 data URIs), the same option
+ * docling-serve exposes. `max_pages` converts only a PDF's first N pages
+ * (issue #80's window, first pinned to 1); other formats ignore it.
+ */
+export function convert(bytes: Uint8Array, filename: string, to?: string | null, images?: string | null, max_pages?: number | null): string;
+
+/**
+ * One-shot scanned-image conversion through the full lite profile (layout +
+ * OCR + assembly) — the browser counterpart of the native image path
+ * (a standalone image is its own page at scale 1).
+ */
+export function convert_scanned_image(bytes: Uint8Array, name: string, dict: string, layout: any, rec: any, to?: string | null, images?: string | null): Promise<string>;
+
+/**
+ * OCR a scanned image entirely in the browser: `bytes` is the image file
+ * (PNG/JPEG/…), `dict` the recognition dictionary text (`en_dict.txt` for
+ * the default English model), `session` the JS inference wrapper. Returns
+ * Markdown (default) or docling JSON per `to`, one paragraph per recognized
+ * line.
+ */
+export function ocr_image(bytes: Uint8Array, dict: string, session: any, to?: string | null): Promise<string>;
+
+export function start(): void;
+
+/**
+ * The file extensions this build can convert, as a JSON string array —
+ * handy for an `<input accept=…>` filter. PDF converts via its embedded
+ * text layer (`pdf-text`); the remaining ML formats (images, audio, METS)
+ * are excluded: they are not compiled into the wasm build.
+ */
+export function supported_extensions(): string;
+
+/**
+ * The docling.rs version this module was built from.
+ */
+export function version(): string;

package/bundler/docling_wasm.js

@@ -0,0 +1,9 @@
+/* @ts-self-types="./docling_wasm.d.ts" */
+import * as wasm from "./docling_wasm_bg.wasm";
+import { __wbg_set_wasm } from "./docling_wasm_bg.js";
+
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();
+export {
+    DigitalConverter, ScannedConverter, convert, convert_scanned_image, ocr_image, start, supported_extensions, version
+} from "./docling_wasm_bg.js";