docling.rs 0.20.0

package/README.md

@@ -0,0 +1,257 @@
+# docling.rs (Node.js / Bun bindings)
+
+Native [Node.js](https://nodejs.org) / [Bun](https://bun.sh) bindings for
+[docling.rs](https://github.com/artiz/docling.rs) — a Rust port of
+[docling](https://github.com/docling-project/docling). Convert Markdown, HTML,
+DOCX, PPTX, XLSX, EPUB, ODF, LaTeX, email, PDF, images and more into a unified
+`DoclingDocument`, and export it as **Markdown** or docling-core **JSON**.
+
+Built with [napi-rs](https://napi.rs), so it ships a real native addon (`.node`)
+that loads in both Node.js and Bun (Bun implements N-API) — the same binary, no
+rebuild between runtimes.
+
+## Install
+
+Released versions ship **prebuilt** native binaries, so no Rust toolchain is
+needed to use the package:
+
+```bash
+npm install docling.rs   # or: bun add docling.rs
+```
+
+Prebuilt platforms: Linux x64 / arm64 (glibc) and Windows x64. (macOS isn't
+prebuilt — build from source, see below.) The right binary is pulled in
+automatically as a platform-specific `optionalDependency` (`docling.rs-<triple>`). Releases are published to npm by
+manually running the `npm publish` workflow
+(`.github/workflows/npm-publish.yml`) — by default it builds the latest master
+(the workspace version); optionally pass a release tag to build that instead.
+Decoupled from the crates.io release.
+
+## Build from source
+
+This package lives in the docling.rs Cargo workspace and can also build the
+addon from Rust source — needed for local development or an unsupported
+platform. You need a Rust toolchain (1.82+) and Node.js 14+ (or Bun).
+
+```bash
+cd crates/docling-node
+npm install          # installs @napi-rs/cli
+npm run build        # release build → docling.rs.<platform>.node + native.js/.d.ts
+# npm run build:debug  # faster, unoptimized
+```
+
+> The addon statically links the ONNX runtime used by the PDF/image pipeline, so
+> the built `.node` is large. Declarative formats (Markdown, HTML, DOCX, …) don't
+> touch it; only PDF/image conversion loads the ML models (downloaded on first
+> use, like the CLI).
+
+## Quick start
+
+```js
+import { convertFile, convert, DocumentConverter } from 'docling.rs'
+
+// Convert a file — format detected from the extension.
+const { content } = convertFile('report.docx')
+console.log(content) // Markdown
+
+// Convert in-memory bytes (e.g. an upload) — pass the format explicitly.
+const md = convert({ name: 'notes', data: Buffer.from('# Hi\n'), format: 'md' })
+
+// docling-core JSON instead of Markdown.
+const json = convertFile('report.docx', { to: 'json' })
+
+// Reuse a converter across many documents.
+const converter = new DocumentConverter({ strict: true })
+const a = converter.convert({ name: 'a.md', data: Buffer.from('# A\n') })
+```
+
+CommonJS works too: `const { convertFile } = require('docling.rs')`.
+
+### Async (off the event loop)
+
+Conversion is CPU-bound; the `*Async` variants run it on the libuv thread pool
+so the event loop stays free. Prefer these for PDF/image and for servers.
+
+```js
+import { convertFileAsync } from 'docling.rs'
+
+const res = await convertFileAsync('paper.pdf', { to: 'json' })
+```
+
+### Streaming Markdown
+
+`streamFileMarkdown` yields Markdown chunks in document order as conversion
+progresses. For PDF (whose pages convert in parallel) output starts flowing
+before the whole document is done; concatenating the chunks reproduces the
+buffered `content` byte-for-byte.
+
+```js
+import { streamFileMarkdown } from 'docling.rs'
+
+for await (const chunk of streamFileMarkdown('paper.pdf')) {
+  process.stdout.write(chunk)
+}
+```
+
+### PDF / images: getting the ML models
+
+Declarative formats (Markdown, HTML, DOCX, XLSX, …) are pure Rust and need
+nothing. The **PDF/image** path needs native assets that are *not* bundled in the
+addon — pdfium plus the ONNX models (layout, OCR, TableFormer). Converting a
+PDF/image/METS input **throws** until they're on disk. Fetch them with a
+one-liner from your app's directory (where you'll `npm install docling.rs`):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/artiz/docling.rs/master/scripts/download_dependencies.sh | sh
+```
+
+```js
+import { convertFileAsync } from 'docling.rs'
+
+const res = await convertFileAsync('paper.pdf', { to: 'markdown' }) // ✅ works
+```
+
+`scripts/download_dependencies.sh` fetches everything from this repo's
+[GitHub Releases](https://github.com/artiz/docling.rs/releases) straight into
+`./models` and `./.pdfium` — which this package (and the Rust CLI) look for by
+default, relative to the process's current directory, so no env vars or setup
+call are needed afterwards:
+
+| Asset | Destination |
+| --- | --- |
+| **pdfium** | `.pdfium/lib/libpdfium.so` |
+| **layout** (`layout_heron.onnx`) | `models/layout_heron.onnx` |
+| **OCR** rec model + dictionary | `models/ocr_rec.onnx`, `models/ppocr_keys_v1.txt` |
+| **TableFormer** | `models/tableformer/{encoder,decoder,bbox}.onnx` |
+
+> **layout + TableFormer are PyTorch→ONNX exports**
+> (`docling-project/docling-layout-heron`, Apache-2.0;
+> `docling-project/docling-models`, CDLA-Permissive-2.0/Apache-2.0 — see
+> [`MODELS_NOTICE.md`](../../MODELS_NOTICE.md) for full attribution), not
+> docling.rs's own weights — docling.rs hosts the converted `.onnx` as a
+> GitHub Release purely so you don't need a local Python/torch toolchain.
+> pdfium and the OCR model are re-hosted, unmodified, from their own public
+> releases, on the same host for convenience.
+>
+> Run it from wherever your app lives — the script only writes to `./models`
+> and `./.pdfium` under the current directory, e.g. in a container build step:
+> ```bash
+> cd /path/to/your/app && curl -fsSL https://raw.githubusercontent.com/artiz/docling.rs/master/scripts/download_dependencies.sh | sh
+> ```
+>
+> To use your own export/host instead, point the env vars at it directly:
+> `DOCLING_LAYOUT_ONNX`, `DOCLING_OCR_REC_ONNX`, `DOCLING_OCR_DICT`,
+> `DOCLING_TABLEFORMER_{ENCODER,DECODER,BBOX}`, `PDFIUM_DYNAMIC_LIB_PATH` — an
+> env var always wins over the `./models` / `./.pdfium` default.
+
+```js
+checkDependencies() // { home, pdfium, layout, ocr, tableformer, ready, missing }
+```
+
+### Reusing a warm `Pipeline` (many PDFs)
+
+The one-shot `convertFile` / `convertFileAsync` rebuild the pipeline — reloading
+every ONNX model — on each call. To convert many PDFs/images, reuse a `Pipeline`
+so the models load **once**:
+
+```js
+import { Pipeline } from 'docling.rs'
+
+const pipeline = new Pipeline({ strict: true })
+for (const path of pdfPaths) {
+  const { content } = pipeline.convertFile(path, { to: 'markdown' }) // warm models
+}
+```
+
+`Pipeline` handles `pdf` and `image` inputs (the ML pipeline) and is synchronous
+— reuse one instance behind a job queue.
+
+### Images
+
+Pick how pictures render in Markdown with `imageMode`:
+
+```js
+// Inline, self-contained: ![Image](data:image/png;base64,…)
+convertFile('slides.pptx', { imageMode: 'embedded' })
+
+// Referenced: links + the image bytes to write yourself.
+const res = convertFile('slides.pptx', { imageMode: 'referenced', artifactsDir: 'assets' })
+for (const img of res.images) {
+  await fs.writeFile(img.path, img.data) // e.g. assets/image_000000.png
+}
+```
+
+JSON output always embeds extracted images as data URIs.
+
+## API
+
+### Functions
+
+| Function | Returns | Notes |
+| --- | --- | --- |
+| `convertFile(path, options?)` | `ConvertResult` | Detects format from the extension. |
+| `convert(input, options?)` | `ConvertResult` | In-memory bytes (`{ name, data, format? }`). |
+| `convertFileAsync(path, options?)` | `Promise<ConvertResult>` | Off the event loop. |
+| `convertAsync(input, options?)` | `Promise<ConvertResult>` | Off the event loop. |
+| `streamFileMarkdown(path, options?)` | `AsyncGenerator<string>` | Markdown chunks in document order. |
+| `supportedFormats()` | `string[]` | Supported input format ids. |
+| `formatFromName(name)` | `string \| null` | Detect a format id from a filename/extension. |
+| `checkDependencies(options?)` | `DependencyStatus` | Report which PDF/image deps are present. |
+
+`Pipeline` is the reusable warm PDF/image converter: `new Pipeline(converterOptions)`
+then `convertFile` / `convert`.
+
+`DocumentConverter` is the reusable form: `new DocumentConverter(converterOptions)`
+then `convert` / `convertFile` / `convertFileAsync` / `convertAsync` /
+`convertFileStreaming`. Converter config (`strict`, `fetchImages`,
+`allowedFormats`) is set once on the constructor; output options (`to`,
+`imageMode`, `artifactsDir`) are per call.
+
+### Options
+
+- `to`: `"markdown"` (default) or `"json"`.
+- `imageMode`: `"placeholder"` (default), `"embedded"`, or `"referenced"`.
+- `artifactsDir`: directory name used in `referenced` links (default `"artifacts"`).
+- `strict`: cleaner, more conformant Markdown instead of docling's byte-for-byte
+  legacy output (Markdown only).
+- `fetchImages`: for HTML/EPUB, resolve and embed external `<img src>`. Off by
+  default; fetches http(s) URLs over the network — enable only for trusted input.
+- `allowedFormats`: restrict the converter to these format ids/extensions.
+
+### `ConvertResult`
+
+```ts
+interface ConvertResult {
+  content: string          // Markdown or JSON, per `to`
+  format: string           // detected input format id
+  status: string           // "success" | "partial_success" | "failure"
+  inputName: string
+  images: { path: string; data: Buffer }[] // for the `referenced` image mode
+}
+```
+
+Full TypeScript types are generated into `index.d.ts` / `native.d.ts`.
+
+## Examples
+
+The [`examples/`](examples) folder is a self-contained project that depends on
+the published `docling.rs` package — `npm install` there, then run any of them:
+
+```bash
+cd examples
+npm install
+node node-basic.mjs        # ESM: file, bytes, JSON, reuse
+bun run bun-basic.ts       # Bun + TypeScript: async + streaming
+node pdf-pipeline.mjs       # warm Pipeline for PDFs (run scripts/download_dependencies.sh first)
+```
+
+- [`examples/node-basic.mjs`](examples/node-basic.mjs) — Node.js (ESM): file, bytes, JSON, reuse.
+- [`examples/bun-basic.ts`](examples/bun-basic.ts) — Bun + TypeScript, with async and streaming.
+- [`examples/pdf-pipeline.mjs`](examples/pdf-pipeline.mjs) — warm `Pipeline` for PDFs.
+
+The smoke test exercises the locally-built addon instead: `npm run build` once at
+the package root, then `node test/smoke.mjs` (or `bun test/smoke.mjs`).
+
+## License
+
+MIT, same as the rest of docling.rs.

package/deps.js

@@ -0,0 +1,188 @@
+// Dependency *resolution* for the PDF/image ML pipeline.
+//
+// The declarative backends (Markdown, HTML, DOCX, XLSX, …) are pure Rust and
+// need nothing. The PDF/image path needs native assets that are NOT bundled in
+// the addon (they're large and licensed separately from docling.rs's own MIT
+// code):
+//
+//   - libpdfium            (PDF text extraction + page rasterization) — required for PDF
+//   - RT-DETR layout model (models/layout_heron.onnx)                 — required for PDF & image
+//   - PP-OCR rec + dict    (models/ocr_rec.onnx, ppocr_keys_v1.txt)   — used for pages with no text layer
+//   - TableFormer          (models/tableformer/{encoder,decoder,bbox}.onnx) — optional; geometric fallback otherwise
+//
+// This module does NOT download anything — `scripts/download_dependencies.sh`
+// does that, fetching everything from this repo's GitHub Releases straight
+// into `./models` and `./.pdfium` (see MODELS_NOTICE.md for attribution: the
+// layout model and TableFormer are PyTorch→ONNX exports of docling-project's
+// own models, re-hosted here as a convenience). This module just resolves
+// where those files (or an explicit `DOCLING_*` / `PDFIUM_DYNAMIC_LIB_PATH`
+// override) should live, reports whether they're present, and wires the
+// matching env vars in-process so the native pipeline finds them — mirroring
+// the CWD-relative defaults already baked into the Rust pipeline itself, so a
+// plain `convertFileAsync(...)` call needs no explicit setup once
+// `download_dependencies.sh` has run.
+
+'use strict'
+
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+
+// Formats whose conversion requires the ML models + native libs above.
+const ML_FORMATS = new Set(['pdf', 'image', 'mets_gbs'])
+
+// pdfium's shared-library filename, by platform.
+function pdfiumLibName() {
+  switch (process.platform) {
+    case 'linux':
+      return 'libpdfium.so'
+    case 'darwin':
+      return 'libpdfium.dylib'
+    case 'win32':
+      return 'pdfium.dll'
+    default:
+      throw new Error(`unsupported platform for pdfium: ${process.platform}/${process.arch}`)
+  }
+}
+
+/**
+ * Resolve the install home directory (absolute), and which `pdfium/`-vs-
+ * `.pdfium/` layout it uses. Precedence: an explicit `dir` > `$DOCLING_RS_HOME`
+ * > the current directory, *if* it already has a local `models/` or `.pdfium/`
+ * (the layout `scripts/download_dependencies.sh` and `scripts/pdf_setup.sh`
+ * both produce, and the one the native Rust pipeline's own env-var-less
+ * defaults already resolve — `models/layout_heron.onnx`, `.pdfium/lib/…` —
+ * relative to *its* CWD) > `~/.cache/docling.rs`. This lets a plain
+ * `convertFileAsync(...)` call succeed with zero setup (no env vars) whenever
+ * the app is run from a directory that already has the dependencies
+ * downloaded next to it.
+ */
+function homeDir(dir) {
+  if (dir) return { home: path.resolve(dir), dotPdfium: false }
+  if (process.env.DOCLING_RS_HOME) return { home: path.resolve(process.env.DOCLING_RS_HOME), dotPdfium: false }
+  const cwd = process.cwd()
+  const hasLocal =
+    fs.existsSync(path.join(cwd, 'models', 'layout_heron.onnx')) ||
+    fs.existsSync(path.join(cwd, '.pdfium', 'lib', pdfiumLibName()))
+  if (hasLocal) return { home: cwd, dotPdfium: true }
+  return { home: path.join(os.homedir(), '.cache', 'docling.rs'), dotPdfium: false }
+}
+
+/**
+ * The resolved on-disk location of each dependency: an existing `DOCLING_*` /
+ * `PDFIUM_DYNAMIC_LIB_PATH` environment variable wins (so a local Python export
+ * is honored), else the path under the install home directory.
+ */
+function resolvePaths(dir) {
+  const { home, dotPdfium } = homeDir(dir)
+  const models = path.join(home, 'models')
+
+  const pdfiumLibDir =
+    process.env.PDFIUM_DYNAMIC_LIB_PATH || path.join(home, dotPdfium ? '.pdfium' : 'pdfium', 'lib')
+  return {
+    home,
+    models,
+    pdfiumLibDir,
+    pdfiumLib: path.join(pdfiumLibDir, pdfiumLibName()),
+    layout: process.env.DOCLING_LAYOUT_ONNX || path.join(models, 'layout_heron.onnx'),
+    ocrRec: process.env.DOCLING_OCR_REC_ONNX || path.join(models, 'ocr_rec.onnx'),
+    ocrDict: process.env.DOCLING_OCR_DICT || path.join(models, 'ppocr_keys_v1.txt'),
+    tfEncoder:
+      process.env.DOCLING_TABLEFORMER_ENCODER || path.join(models, 'tableformer', 'encoder.onnx'),
+    tfDecoder:
+      process.env.DOCLING_TABLEFORMER_DECODER || path.join(models, 'tableformer', 'decoder.onnx'),
+    tfBbox: process.env.DOCLING_TABLEFORMER_BBOX || path.join(models, 'tableformer', 'bbox.onnx'),
+  }
+}
+
+/**
+ * Report which dependencies are present on disk. `ready` is true when the
+ * minimum for PDF (pdfium + layout) is present.
+ */
+function checkDependencies(options = {}) {
+  const p = resolvePaths(options.dir)
+  const has = (f) => fs.existsSync(f)
+  const status = {
+    home: p.home,
+    pdfium: has(p.pdfiumLib),
+    layout: has(p.layout),
+    ocr: has(p.ocrRec) && has(p.ocrDict),
+    tableformer: has(p.tfEncoder) && has(p.tfDecoder) && has(p.tfBbox),
+  }
+  status.ready = status.pdfium && status.layout
+  status.missing = [
+    !status.pdfium && 'pdfium',
+    !status.layout && 'layout_heron.onnx',
+  ].filter(Boolean)
+  return status
+}
+
+/** Point the current process at installed assets (so the native pipeline finds them). */
+function exportEnv(p) {
+  if (fs.existsSync(p.pdfiumLib)) process.env.PDFIUM_DYNAMIC_LIB_PATH = p.pdfiumLibDir
+  if (fs.existsSync(p.layout)) process.env.DOCLING_LAYOUT_ONNX = p.layout
+  if (fs.existsSync(p.ocrRec)) process.env.DOCLING_OCR_REC_ONNX = p.ocrRec
+  if (fs.existsSync(p.ocrDict)) process.env.DOCLING_OCR_DICT = p.ocrDict
+  if (fs.existsSync(p.tfEncoder)) process.env.DOCLING_TABLEFORMER_ENCODER = p.tfEncoder
+  if (fs.existsSync(p.tfDecoder)) process.env.DOCLING_TABLEFORMER_DECODER = p.tfDecoder
+  if (fs.existsSync(p.tfBbox)) process.env.DOCLING_TABLEFORMER_BBOX = p.tfBbox
+}
+
+/**
+ * A copy-pasteable next step, shown when a PDF/image/METS conversion is
+ * attempted without the dependencies on disk.
+ */
+function downloadGuide() {
+  return [
+    'Run this once from your app\'s directory (fetches pdfium + the ONNX',
+    'models — layout, OCR, TableFormer — from this repo\'s GitHub Releases',
+    'straight into ./models and ./.pdfium, which this package looks for by',
+    'default; no env vars needed afterwards):',
+    '',
+    '  curl -fsSL https://raw.githubusercontent.com/artiz/docling.rs/master/scripts/download_dependencies.sh | sh',
+    '',
+    'or, from a checkout of the repo:',
+    '',
+    '  scripts/download_dependencies.sh',
+    '',
+    'TableFormer is optional (tables fall back to geometric reconstruction',
+    'without it). To use your own export/host instead, point the DOCLING_*',
+    'env vars at it directly: DOCLING_LAYOUT_ONNX, DOCLING_OCR_REC_ONNX,',
+    'DOCLING_OCR_DICT, DOCLING_TABLEFORMER_{ENCODER,DECODER,BBOX},',
+    'PDFIUM_DYNAMIC_LIB_PATH — see MODELS_NOTICE.md for licensing.',
+    '',
+    'Declarative formats (md, html, docx, xlsx, …) need none of this — only',
+    'PDF, image and METS conversion do.',
+  ].join('\n')
+}
+
+/**
+ * Throw a clear, actionable error if `format` needs the ML pipeline but its
+ * dependencies aren't installed. Called before ML conversions; also wires up
+ * the `DOCLING_*` / `PDFIUM_DYNAMIC_LIB_PATH` env vars for whatever is present,
+ * so a checkout with `scripts/download_dependencies.sh` already run just works.
+ */
+function assertMlReady(format, dir) {
+  if (!ML_FORMATS.has(format)) return
+  const p = resolvePaths(dir)
+  exportEnv(p)
+  const status = checkDependencies({ dir })
+  // Image needs layout (+OCR), but not pdfium; PDF/METS need both.
+  const needPdfium = format !== 'image'
+  const missing = [!status.layout && 'layout_heron.onnx', needPdfium && !status.pdfium && 'pdfium'].filter(
+    Boolean,
+  )
+  if (missing.length === 0) return
+  throw new Error(
+    `Converting '${format}' requires the PDF/ML dependencies, which are not installed: ` +
+      `${missing.join(', ')}.\n\n${downloadGuide()}`,
+  )
+}
+
+module.exports = {
+  ML_FORMATS,
+  checkDependencies,
+  assertMlReady,
+  resolvePaths,
+  exportEnv,
+}

package/index.d.ts

@@ -0,0 +1,97 @@
+// Public type surface for the `docling.rs` npm package. Re-exports the native
+// binding's option/result types and unguarded functions, and declares the
+// JS-wrapped classes, the dependency API, and the streaming helper.
+
+import type {
+  ConverterOptions,
+  OutputOptions,
+  ConvertOptions,
+  ConvertInput,
+  ConvertResult,
+} from './native'
+
+export type { ConverterOptions, OutputOptions, ConvertOptions, ConvertInput, ConvertResult }
+
+// Format helpers pass straight through from the native binding.
+export { supportedFormats, formatFromName } from './native'
+
+/** Callback form used by the native streaming API (prefer {@link streamFileMarkdown}). */
+export type StreamCallback = (err: Error | null, chunk: string | undefined | null) => void
+
+/** Convert a file on disk (format detected from the extension). Throws for PDF/image/METS if deps aren't installed. */
+export declare function convertFile(path: string, options?: ConvertOptions | null): ConvertResult
+/** Convert in-memory bytes. Throws for PDF/image/METS if deps aren't installed. */
+export declare function convert(input: ConvertInput, options?: ConvertOptions | null): ConvertResult
+/** Async (Promise) file conversion, off the event loop. Rejects for PDF/image/METS if deps aren't installed. */
+export declare function convertFileAsync(path: string, options?: ConvertOptions | null): Promise<ConvertResult>
+/** Async (Promise) bytes conversion, off the event loop. */
+export declare function convertAsync(input: ConvertInput, options?: ConvertOptions | null): Promise<ConvertResult>
+
+/** A reusable converter holding config (strict / fetchImages / allowedFormats). */
+export declare class DocumentConverter {
+  constructor(options?: ConverterOptions | null)
+  convertFile(path: string, options?: OutputOptions | null): ConvertResult
+  convert(input: ConvertInput, options?: OutputOptions | null): ConvertResult
+  convertFileAsync(path: string, options?: OutputOptions | null): Promise<ConvertResult>
+  convertAsync(input: ConvertInput, options?: OutputOptions | null): Promise<ConvertResult>
+  convertFileStreaming(path: string, callback: StreamCallback, options?: OutputOptions | null): void
+}
+
+/**
+ * A reusable PDF/image pipeline that keeps the ONNX models loaded across calls.
+ * Use instead of the per-call functions when converting many PDFs/images — the
+ * one-shot path reloads every model each call. Handles `pdf` and `image` inputs.
+ */
+export declare class Pipeline {
+  constructor(options?: ConverterOptions | null)
+  convertFile(path: string, options?: OutputOptions | null): ConvertResult
+  convert(input: ConvertInput, options?: OutputOptions | null): ConvertResult
+}
+
+// --- dependency provisioning (PDF/image ML pipeline) -----------------------
+
+/** Where installed dependencies live and which are present. */
+export interface DependencyStatus {
+  /** Install home directory. */
+  home: string
+  /** libpdfium present. */
+  pdfium: boolean
+  /** Layout model (layout_heron.onnx) present. */
+  layout: boolean
+  /** OCR model + dictionary present. */
+  ocr: boolean
+  /** TableFormer encoder/decoder/bbox present. */
+  tableformer: boolean
+  /** True when the minimum for PDF (pdfium + layout) is present. */
+  ready: boolean
+  /** Human-readable list of the missing required assets. */
+  missing: string[]
+}
+
+/**
+ * Report which PDF/image dependencies are present on disk. Fetch them with
+ * `scripts/download_dependencies.sh` (see the package README) — this function
+ * only reports status, it does not download anything.
+ */
+export declare function checkDependencies(options?: { dir?: string }): DependencyStatus
+
+// --- streaming --------------------------------------------------------------
+
+/** Options for {@link streamFileMarkdown} (converter config + streamable output). */
+export interface StreamOptions {
+  strict?: boolean
+  fetchImages?: boolean
+  allowedFormats?: string[]
+  imageMode?: 'placeholder' | 'embedded'
+  artifactsDir?: string
+}
+
+/**
+ * Stream a file's Markdown in chunks, in document order, as conversion
+ * progresses — the win for PDF, whose pages convert in parallel. Concatenating
+ * the chunks reproduces the buffered `convertFile(path).content` byte-for-byte.
+ */
+export declare function streamFileMarkdown(
+  filePath: string,
+  options?: StreamOptions,
+): AsyncGenerator<string, void, unknown>

package/index.js

@@ -0,0 +1,172 @@
+// Public entry point for the `docling.rs` npm package.
+//
+// Wraps the native N-API binding (loaded by `native.js`, which picks the right
+// prebuilt `.node` for the host platform) with two things:
+//   1. dependency guards — converting a PDF/image/METS input throws a clear
+//      error unless the ML models + pdfium are on disk (see
+//      scripts/download_dependencies.sh);
+//   2. a `streamFileMarkdown` async generator over Markdown chunks.
+//
+// Works in Node.js and Bun (Bun implements N-API).
+
+'use strict'
+
+const native = require('./native.js')
+const { checkDependencies, assertMlReady } = require('./deps.js')
+
+// Resolve the format id of an input for the ML guard. Uses the native
+// extension→format map; falls back to an explicitly-passed format string.
+function mlFormatOf(name, format) {
+  if (format) {
+    return native.formatFromName(`x.${String(format).replace(/^\./, '')}`) || String(format)
+  }
+  return native.formatFromName(name || '') || ''
+}
+
+// --- guarded one-shot functions --------------------------------------------
+
+function convertFile(path, options) {
+  assertMlReady(mlFormatOf(path))
+  return native.convertFile(path, options)
+}
+
+function convert(input, options) {
+  assertMlReady(mlFormatOf(input && input.name, input && input.format))
+  return native.convert(input, options)
+}
+
+// async so a guard failure surfaces as a rejected promise, not a sync throw.
+async function convertFileAsync(path, options) {
+  assertMlReady(mlFormatOf(path))
+  return native.convertFileAsync(path, options)
+}
+
+async function convertAsync(input, options) {
+  assertMlReady(mlFormatOf(input && input.name, input && input.format))
+  return native.convertAsync(input, options)
+}
+
+// --- guarded classes --------------------------------------------------------
+
+class DocumentConverter {
+  constructor(options) {
+    this._inner = new native.DocumentConverter(options)
+  }
+
+  convertFile(path, options) {
+    assertMlReady(mlFormatOf(path))
+    return this._inner.convertFile(path, options)
+  }
+
+  convert(input, options) {
+    assertMlReady(mlFormatOf(input && input.name, input && input.format))
+    return this._inner.convert(input, options)
+  }
+
+  async convertFileAsync(path, options) {
+    assertMlReady(mlFormatOf(path))
+    return this._inner.convertFileAsync(path, options)
+  }
+
+  async convertAsync(input, options) {
+    assertMlReady(mlFormatOf(input && input.name, input && input.format))
+    return this._inner.convertAsync(input, options)
+  }
+
+  convertFileStreaming(path, callback, options) {
+    assertMlReady(mlFormatOf(path))
+    return this._inner.convertFileStreaming(path, callback, options)
+  }
+}
+
+// The warm PDF/image pipeline is inherently ML — always guarded.
+class Pipeline {
+  constructor(options) {
+    this._inner = new native.Pipeline(options)
+  }
+
+  convertFile(path, options) {
+    assertMlReady(mlFormatOf(path))
+    return this._inner.convertFile(path, options)
+  }
+
+  convert(input, options) {
+    assertMlReady(mlFormatOf(input && input.name, input && input.format))
+    return this._inner.convert(input, options)
+  }
+}
+
+// --- streaming --------------------------------------------------------------
+
+/**
+ * Stream a file's Markdown in chunks, in document order, as conversion
+ * progresses — the win for PDF, whose pages convert in parallel.
+ *
+ * Yields each Markdown chunk; concatenating every chunk reproduces the buffered
+ * `convertFile(path).content` byte-for-byte.
+ *
+ * @param {string} filePath
+ * @param {object} [options]
+ * @returns {AsyncGenerator<string, void, unknown>}
+ */
+async function* streamFileMarkdown(filePath, options = {}) {
+  assertMlReady(mlFormatOf(filePath))
+  const { strict, fetchImages, allowedFormats, imageMode, artifactsDir } = options
+  const converter = new native.DocumentConverter({ strict, fetchImages, allowedFormats })
+
+  // Bridge the native (err, chunk) callback into an async generator. Chunks are
+  // delivered on the event loop (via a threadsafe function); a null chunk ends
+  // the stream, a non-null err ends it with a throw.
+  const queue = []
+  let done = false
+  let failure = null
+  let notify = null
+  const wake = () => {
+    if (notify) {
+      const n = notify
+      notify = null
+      n()
+    }
+  }
+
+  converter.convertFileStreaming(
+    filePath,
+    (err, chunk) => {
+      if (err) {
+        failure = err
+        done = true
+      } else if (chunk === null || chunk === undefined) {
+        done = true
+      } else {
+        queue.push(chunk)
+      }
+      wake()
+    },
+    { imageMode, artifactsDir },
+  )
+
+  while (true) {
+    if (queue.length > 0) {
+      yield queue.shift()
+      continue
+    }
+    if (failure) throw failure
+    if (done) return
+    await new Promise((resolve) => {
+      notify = resolve
+    })
+  }
+}
+
+// --- exports (explicit, so ESM named imports work in Node and Bun) ----------
+
+module.exports.convert = convert
+module.exports.convertFile = convertFile
+module.exports.convertAsync = convertAsync
+module.exports.convertFileAsync = convertFileAsync
+module.exports.DocumentConverter = DocumentConverter
+module.exports.Pipeline = Pipeline
+module.exports.streamFileMarkdown = streamFileMarkdown
+module.exports.checkDependencies = checkDependencies
+module.exports.supportedFormats = native.supportedFormats
+module.exports.formatFromName = native.formatFromName

package/native.d.ts

@@ -0,0 +1,157 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+/** Config for a reusable [`DocumentConverter`]. */
+export interface ConverterOptions {
+  /**
+   * Emit cleaner, more conformant Markdown (code-fence languages preserved,
+   * no inline-run spacing artifacts) instead of docling's byte-for-byte
+   * legacy output. Markdown only. Default `false`.
+   */
+  strict?: boolean
+  /**
+   * For HTML/EPUB, resolve external `<img src>` (data: URIs, local files,
+   * http(s) URLs, EPUB entries) and embed the bytes. Off by default; when on,
+   * http(s) URLs are fetched over the network — enable only for trusted input.
+   */
+  fetchImages?: boolean
+  /**
+   * Restrict the converter to these formats (ids like `"md"`, `"pdf"`, or
+   * extensions like `".html"`); anything else is rejected. Default: accept all.
+   */
+  allowedFormats?: Array<string>
+}
+/** Per-call output options (how to render the converted document). */
+export interface OutputOptions {
+  /** `"markdown"` (default) or `"json"` (docling-core DoclingDocument wire format). */
+  to?: string
+  /**
+   * Picture handling for Markdown: `"placeholder"` (default), `"embedded"`
+   * (base64 data URIs inline), or `"referenced"` (returns image files in
+   * `images`). Ignored for JSON, which always embeds images as data URIs.
+   */
+  imageMode?: string
+  /** Directory name used in `referenced` image links. Default `"artifacts"`. */
+  artifactsDir?: string
+}
+/**
+ * All options for the one-shot module-level functions (converter config +
+ * output options in a single object).
+ */
+export interface ConvertOptions {
+  strict?: boolean
+  fetchImages?: boolean
+  allowedFormats?: Array<string>
+  to?: string
+  imageMode?: string
+  artifactsDir?: string
+}
+/** In-memory input for [`DocumentConverter::convert`] / [`convert`]. */
+export interface ConvertInput {
+  /** Logical document name (used as the docling document name). */
+  name: string
+  /** Raw file bytes. */
+  data: Buffer
+  /**
+   * Format id or extension (e.g. `"md"`, `"pdf"`, `".html"`). Omit to infer
+   * from an extension on `name`.
+   */
+  format?: string
+}
+/** One extracted image file, returned for the `referenced` image mode. */
+export interface ImageArtifact {
+  /** Path relative to the Markdown file (e.g. `"artifacts/image_000000.png"`). */
+  path: string
+  /** The image bytes to write at `path`. */
+  data: Buffer
+}
+/** The result of a conversion. */
+export interface ConvertResult {
+  /** The rendered document: Markdown or JSON, per `to`. */
+  content: string
+  /** Detected input format id (e.g. `"md"`, `"pdf"`). */
+  format: string
+  /** `"success"`, `"partial_success"`, or `"failure"`. */
+  status: string
+  /** The document name. */
+  inputName: string
+  /**
+   * For the `referenced` image mode, the image files to write next to the
+   * Markdown; empty otherwise.
+   */
+  images: Array<ImageArtifact>
+}
+/**
+ * Convert a file on disk. Detects the format from the extension and (for
+ * HTML/EPUB image fetching) resolves relative `<img src>` against the file's
+ * directory.
+ */
+export declare function convertFile(path: string, options?: ConvertOptions | undefined | null): ConvertResult
+/** Convert in-memory bytes. */
+export declare function convert(input: ConvertInput, options?: ConvertOptions | undefined | null): ConvertResult
+/**
+ * Async (Promise-returning) [`convert_file`]. The CPU-bound work runs on the
+ * libuv thread pool, keeping the event loop free — use this for PDF/image.
+ */
+export declare function convertFileAsync(path: string, options?: ConvertOptions | undefined | null): Promise<ConvertResult>
+/** Async (Promise-returning) [`convert`]. */
+export declare function convertAsync(input: ConvertInput, options?: ConvertOptions | undefined | null): Promise<ConvertResult>
+/** The list of supported input format ids. */
+export declare function supportedFormats(): Array<string>
+/**
+ * Detect a format id from a filename or extension (e.g. `"report.pdf"` →
+ * `"pdf"`). Returns `null` for unknown extensions.
+ */
+export declare function formatFromName(name: string): string | null
+/**
+ * A reusable converter. Holds config (strict / fetch-images / allowed formats)
+ * so you can convert many documents without re-parsing options each time —
+ * the analogue of the Rust `DocumentConverter`.
+ */
+export declare class DocumentConverter {
+  constructor(options?: ConverterOptions | undefined | null)
+  /** Convert a file on disk (sync). */
+  convertFile(path: string, options?: OutputOptions | undefined | null): ConvertResult
+  /** Convert in-memory bytes (sync). */
+  convert(input: ConvertInput, options?: OutputOptions | undefined | null): ConvertResult
+  /** Async (Promise-returning) file conversion (runs off the event loop). */
+  convertFileAsync(path: string, options?: OutputOptions | undefined | null): Promise<ConvertResult>
+  /** Async (Promise-returning) bytes conversion (runs off the event loop). */
+  convertAsync(input: ConvertInput, options?: OutputOptions | undefined | null): Promise<ConvertResult>
+  /**
+   * Stream a file's Markdown in chunks, in document order, as conversion
+   * progresses (the headline win for PDF, whose pages convert in parallel).
+   *
+   * `callback` is invoked as `(err, chunk)`: once per Markdown chunk with
+   * `chunk` a string, once with `chunk === null` at the end, or once with a
+   * non-null `err` on failure. Only `placeholder` / `embedded` image modes
+   * stream; `referenced` is rejected. Prefer the `streamFileMarkdown`
+   * async-generator wrapper in JS over calling this directly.
+   */
+  convertFileStreaming(path: string, callback: (err: Error | null, arg: string | undefined | null) => any, options?: OutputOptions | undefined | null): void
+}
+/**
+ * A reusable PDF/image pipeline that keeps the ONNX models (layout, OCR,
+ * TableFormer) loaded across calls — the analogue of the Rust `Pipeline`. Use
+ * this instead of the per-call `convertFile` when converting many PDFs/images:
+ * the one-shot functions rebuild the pipeline (reloading every model) each
+ * call, whereas this loads them once.
+ *
+ * Handles `pdf` and `image` inputs (the ML pipeline). Models load lazily on
+ * first use, so constructing a `Pipeline` is cheap; the first conversion pays
+ * the model-load cost. Synchronous and single-threaded — reuse one instance
+ * for a sequence of documents (e.g. behind a job queue).
+ */
+export declare class Pipeline {
+  /**
+   * Construct the pipeline. Only `strict` is read (cleaner Markdown);
+   * `fetchImages` / `allowedFormats` don't apply to the PDF/image pipeline.
+   */
+  constructor(options?: ConverterOptions | undefined | null)
+  /** Convert a PDF or image file, reusing the warm models. */
+  convertFile(path: string, options?: OutputOptions | undefined | null): ConvertResult
+  /** Convert PDF or image bytes, reusing the warm models. */
+  convert(input: ConvertInput, options?: OutputOptions | undefined | null): ConvertResult
+}

package/native.js

@@ -0,0 +1,322 @@
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'docling-rs.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./docling-rs.android-arm64.node')
+          } else {
+            nativeBinding = require('docling.rs-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'docling-rs.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./docling-rs.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('docling.rs-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'docling-rs.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./docling-rs.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('docling.rs-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'docling-rs.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./docling-rs.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('docling.rs-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'docling-rs.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./docling-rs.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('docling.rs-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'docling-rs.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./docling-rs.darwin-universal.node')
+      } else {
+        nativeBinding = require('docling.rs-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'docling-rs.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./docling-rs.darwin-x64.node')
+          } else {
+            nativeBinding = require('docling.rs-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'docling-rs.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./docling-rs.darwin-arm64.node')
+          } else {
+            nativeBinding = require('docling.rs-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'docling-rs.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./docling-rs.freebsd-x64.node')
+      } else {
+        nativeBinding = require('docling.rs-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'docling-rs.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./docling-rs.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('docling.rs-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'docling-rs.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./docling-rs.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('docling.rs-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'docling-rs.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./docling-rs.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('docling.rs-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'docling-rs.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./docling-rs.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('docling.rs-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'docling-rs.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./docling-rs.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('docling.rs-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'docling-rs.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./docling-rs.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('docling.rs-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'docling-rs.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./docling-rs.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('docling.rs-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'docling-rs.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./docling-rs.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('docling.rs-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'docling-rs.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./docling-rs.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('docling.rs-linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { convertFile, convert, convertFileAsync, convertAsync, DocumentConverter, Pipeline, supportedFormats, formatFromName } = nativeBinding
+
+module.exports.convertFile = convertFile
+module.exports.convert = convert
+module.exports.convertFileAsync = convertFileAsync
+module.exports.convertAsync = convertAsync
+module.exports.DocumentConverter = DocumentConverter
+module.exports.Pipeline = Pipeline
+module.exports.supportedFormats = supportedFormats
+module.exports.formatFromName = formatFromName

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "docling.rs",
+  "version": "0.20.0",
+  "description": "Node.js / Bun bindings for docling.rs — a Rust port of docling. Convert Markdown, HTML, DOCX, PPTX, XLSX, PDF, images and more into a unified DoclingDocument (Markdown or docling-core JSON).",
+  "keywords": [
+    "docling",
+    "document",
+    "pdf",
+    "markdown",
+    "docx",
+    "converter",
+    "napi",
+    "bun"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/artiz/docling.rs.git",
+    "directory": "crates/docling-node"
+  },
+  "homepage": "https://github.com/artiz/docling.rs",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./index.js"
+    }
+  },
+  "napi": {
+    "name": "docling-rs",
+    "triples": {
+      "defaults": false,
+      "additional": [
+        "x86_64-unknown-linux-gnu",
+        "aarch64-unknown-linux-gnu",
+        "x86_64-pc-windows-msvc"
+      ]
+    }
+  },
+  "engines": {
+    "node": ">= 14"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "deps.js",
+    "native.js",
+    "native.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "napi build --platform --release --strip --js native.js --dts native.d.ts",
+    "build:debug": "napi build --platform --js native.js --dts native.d.ts",
+    "artifacts": "napi artifacts",
+    "prepublishOnly": "napi prepublish -t npm --skip-gh-release",
+    "version": "napi version",
+    "test": "node test/smoke.mjs",
+    "example": "npm --prefix examples install && node examples/node-basic.mjs",
+    "example:bun": "npm --prefix examples install && bun run examples/bun-basic.ts"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^2.18.4"
+  },
+  "optionalDependencies": {
+    "docling.rs-linux-x64-gnu": "0.20.0",
+    "docling.rs-linux-arm64-gnu": "0.20.0",
+    "docling.rs-win32-x64-msvc": "0.20.0"
+  }
+}