Skip to content

A fast, helpful, and open-source document parser

add screenshot rendering to pdfium and lit

Logan Markewich1a71554f89d4
diff --git a/cli/parse.ts b/cli/parse.ts
index 5b72400..8b6a225 100644
--- a/cli/parse.ts
+++ b/cli/parse.ts
@@ -46,6 +46,7 @@ interface ScreenshotCommandOptions {
dpi?: string;
format?: string;
password?: string;
+ experimental?: boolean;
config?: string;
quiet?: boolean;
}
@@ -234,6 +235,7 @@ program
.option("--dpi <dpi>", "DPI for rendering", DEFAULT_DPI.toString())
.option("--format <format>", "Image format: png|jpg", DEFAULT_SCREENSHOT_FORMAT)
.option("--password <password>", "Password for encrypted/protected documents")
+ .option("--experimental", "Use experimental Rust-based PDF engine")
.option("--config <file>", "Config file (JSON)")
.option("-q, --quiet", "Suppress progress output")
.action(async (file: string, options: ScreenshotCommandOptions) => {
@@ -263,6 +265,7 @@ program
...config,
dpi: parseInt(options.dpi || DEFAULT_DPI.toString()),
password: options.password,
+ experimental: options.experimental || false,
};
// Parse target pages
diff --git a/packages/rust/Cargo.lock b/packages/rust/Cargo.lock
index 3a40404..b0d79dd 100644
--- a/packages/rust/Cargo.lock
+++ b/packages/rust/Cargo.lock
@@ -67,6 +67,12 @@ dependencies = [
"windows-sys 0.61.2",
]
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
[[package]]
name = "base64"
version = "0.22.1"
@@ -99,6 +105,18 @@ version = "2.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
[[package]]
name = "bytes"
version = "1.11.1"
@@ -212,6 +230,15 @@ dependencies = [
"windows-sys 0.61.2",
]
+[[package]]
+name = "fdeflate"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+dependencies = [
+ "simd-adler32",
+]
+
[[package]]
name = "filetime"
version = "0.2.27"
@@ -278,6 +305,19 @@ version = "1.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+[[package]]
+name = "image"
+version = "0.25.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "moxcms",
+ "num-traits",
+ "png",
+]
+
[[package]]
name = "is_terminal_polyfill"
version = "1.70.2"
@@ -338,6 +378,7 @@ name = "liteparse-rs"
version = "0.1.0"
dependencies = [
"clap",
+ "image",
"pdfium",
"pdfium-sys",
"serde",
@@ -372,6 +413,16 @@ dependencies = [
"simd-adler32",
]
+[[package]]
+name = "moxcms"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"
+dependencies = [
+ "num-traits",
+ "pxfm",
+]
+
[[package]]
name = "nom"
version = "7.1.3"
@@ -382,6 +433,15 @@ dependencies = [
"minimal-lexical",
]
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
[[package]]
name = "once_cell"
version = "1.21.4"
@@ -423,6 +483,19 @@ version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+[[package]]
+name = "png"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
+dependencies = [
+ "bitflags",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
[[package]]
name = "prettyplease"
version = "0.2.37"
@@ -442,6 +515,12 @@ dependencies = [
"unicode-ident",
]
+[[package]]
+name = "pxfm"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f"
+
[[package]]
name = "quote"
version = "1.0.45"
diff --git a/packages/rust/crates/liteparse/Cargo.toml b/packages/rust/crates/liteparse/Cargo.toml
index 051f909..b041979 100644
--- a/packages/rust/crates/liteparse/Cargo.toml
+++ b/packages/rust/crates/liteparse/Cargo.toml
@@ -5,6 +5,7 @@ edition = "2024"
[dependencies]
clap = { version = "4.5.55", features = ["derive"] }
+image = { version = "0.25", default-features = false, features = ["png"] }
pdfium = { path = "../pdfium" }
pdfium-sys = { path = "../pdfium-sys" }
serde = { version = "1.0.228", features = ["derive"] }
diff --git a/packages/rust/crates/liteparse/src/lib.rs b/packages/rust/crates/liteparse/src/lib.rs
index e01f64a..48262d5 100644
--- a/packages/rust/crates/liteparse/src/lib.rs
+++ b/packages/rust/crates/liteparse/src/lib.rs
@@ -1,3 +1,4 @@
pub mod extract;
pub mod projection;
+pub mod render;
pub mod types;
\ No newline at end of file
diff --git a/packages/rust/crates/liteparse/src/main.rs b/packages/rust/crates/liteparse/src/main.rs
index 3811ef2..27ae92e 100644
--- a/packages/rust/crates/liteparse/src/main.rs
+++ b/packages/rust/crates/liteparse/src/main.rs
@@ -1,6 +1,7 @@
use clap::{Parser, Subcommand, Args};
use liteparse_rs::extract;
use liteparse_rs::projection;
+use liteparse_rs::render;
#[derive(Parser, Debug)]
@@ -16,6 +17,12 @@ enum Commands {
Extract(PdfCommand),
/// Parse a PDF file: extract + grid projection, output projected pages as JSON
Parse(PdfCommand),
+ /// Render a page to a PNG screenshot (file output)
+ Screenshot(ScreenshotCommand),
+ /// Render a page to PNG and write to stdout
+ ScreenshotStdout(ScreenshotStdoutCommand),
+ /// Extract embedded image bounding boxes from a page
+ ImageBounds(PdfCommand),
}
@@ -30,6 +37,40 @@ struct PdfCommand {
page_num: Option<u32>,
}
+#[derive(Args, Debug)]
+struct ScreenshotCommand {
+ /// Specify the path to the PDF file
+ #[arg(long)]
+ pdf_path: String,
+
+ /// Target page number (1-based)
+ #[arg(long)]
+ page_num: u32,
+
+ /// Output PNG file path
+ #[arg(long)]
+ output: String,
+
+ /// DPI for rendering (default: 150)
+ #[arg(long, default_value = "150")]
+ dpi: f32,
+}
+
+#[derive(Args, Debug)]
+struct ScreenshotStdoutCommand {
+ /// Specify the path to the PDF file
+ #[arg(long)]
+ pdf_path: String,
+
+ /// Target page number (1-based)
+ #[arg(long)]
+ page_num: u32,
+
+ /// DPI for rendering (default: 150)
+ #[arg(long, default_value = "150")]
+ dpi: f32,
+}
+
fn main() -> Result<(), Box<dyn std::error::Error>> {
let cli = Cli::parse();
@@ -54,6 +95,15 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
t3.duration_since(t0).as_secs_f64() * 1000.0,
);
}
+ Commands::Screenshot(cmd) => {
+ render::screenshot(&cmd.pdf_path, cmd.page_num, cmd.dpi, &cmd.output)?;
+ }
+ Commands::ScreenshotStdout(cmd) => {
+ render::screenshot_to_stdout(&cmd.pdf_path, cmd.page_num, cmd.dpi)?;
+ }
+ Commands::ImageBounds(cmd) => {
+ render::image_bounds(&cmd.pdf_path, cmd.page_num)?;
+ }
}
Ok(())
diff --git a/packages/rust/crates/liteparse/src/render.rs b/packages/rust/crates/liteparse/src/render.rs
new file mode 100644
index 0000000..9302c7d
--- /dev/null
+++ b/packages/rust/crates/liteparse/src/render.rs
@@ -0,0 +1,101 @@
+use image::{ImageBuffer, Rgba};
+use pdfium::Library;
+use serde::Serialize;
+
+/// Render a single page to a PNG file.
+pub fn screenshot(
+ pdf_path: &str,
+ page_num: u32,
+ dpi: f32,
+ output_path: &str,
+) -> Result<(), Box<dyn std::error::Error>> {
+ let lib = Library::init();
+ let document = lib.load_document(pdf_path, None)?;
+ let page = document.page((page_num - 1) as i32)?;
+ let bitmap = page.render(dpi)?;
+
+ let width = bitmap.width() as u32;
+ let height = bitmap.height() as u32;
+ let rgba = bitmap.to_rgba();
+
+ let img: ImageBuffer<Rgba<u8>, Vec<u8>> =
+ ImageBuffer::from_raw(width, height, rgba)
+ .ok_or("failed to create image buffer")?;
+
+ img.save(output_path)?;
+ eprintln!(
+ "[rust-bin] rendered page {} at {dpi} DPI → {output_path} ({width}×{height})",
+ page_num
+ );
+
+ Ok(())
+}
+
+/// Render a single page and write raw PNG bytes to stdout.
+pub fn screenshot_to_stdout(
+ pdf_path: &str,
+ page_num: u32,
+ dpi: f32,
+) -> Result<(), Box<dyn std::error::Error>> {
+ let lib = Library::init();
+ let document = lib.load_document(pdf_path, None)?;
+ let page = document.page((page_num - 1) as i32)?;
+ let bitmap = page.render(dpi)?;
+
+ let width = bitmap.width() as u32;
+ let height = bitmap.height() as u32;
+ let rgba = bitmap.to_rgba();
+
+ let encoder = image::codecs::png::PngEncoder::new(std::io::stdout().lock());
+ use image::ImageEncoder;
+ encoder.write_image(&rgba, width, height, image::ColorType::Rgba8.into())?;
+
+ Ok(())
+}
+
+#[derive(Debug, Serialize)]
+struct ImageBoundsOutput {
+ x: f32,
+ y: f32,
+ width: f32,
+ height: f32,
+}
+
+/// Extract image bounding boxes and print as JSON to stdout.
+pub fn image_bounds(
+ pdf_path: &str,
+ page_num: Option<u32>,
+) -> Result<(), Box<dyn std::error::Error>> {
+ let lib = Library::init();
+ let document = lib.load_document(pdf_path, None)?;
+ let page_count = document.page_count();
+
+ for page_index in 0..page_count {
+ if let Some(target) = page_num {
+ if page_index as u32 + 1 != target {
+ continue;
+ }
+ }
+
+ let page = document.page(page_index)?;
+ let bounds = page.image_bounds(25.0, 0.9);
+
+ let output: Vec<ImageBoundsOutput> = bounds
+ .iter()
+ .map(|b| ImageBoundsOutput {
+ x: b.x,
+ y: b.y,
+ width: b.width,
+ height: b.height,
+ })
+ .collect();
+
+ let json = serde_json::json!({
+ "page_number": page_index + 1,
+ "images": output,
+ });
+ println!("{}", serde_json::to_string(&json)?);
+ }
+
+ Ok(())
+}
diff --git a/packages/rust/crates/pdfium/src/bitmap.rs b/packages/rust/crates/pdfium/src/bitmap.rs
new file mode 100644
index 0000000..429457d
--- /dev/null
+++ b/packages/rust/crates/pdfium/src/bitmap.rs
@@ -0,0 +1,91 @@
+use crate::error::PdfiumError;
+
+pub struct Bitmap {
+ handle: pdfium_sys::FPDF_BITMAP,
+}
+
+impl Bitmap {
+ /// Wrap an existing FPDF_BITMAP handle (takes ownership, will destroy on drop).
+ ///
+ /// # Safety
+ /// The handle must be a valid, non-null bitmap that the caller owns.
+ pub unsafe fn from_handle(handle: pdfium_sys::FPDF_BITMAP) -> Self {
+ Bitmap { handle }
+ }
+
+ /// Create a new BGRA bitmap with the given dimensions.
+ pub fn new(width: i32, height: i32) -> Result<Self, PdfiumError> {
+ let handle = unsafe {
+ pdfium_sys::FPDFBitmap_CreateEx(
+ width,
+ height,
+ pdfium_sys::FPDFBitmap_BGRA as i32,
+ std::ptr::null_mut(),
+ 0, // stride=0 lets pdfium choose
+ )
+ };
+ if handle.is_null() {
+ return Err(PdfiumError::OperationFailed);
+ }
+ Ok(Bitmap { handle })
+ }
+
+ pub fn handle(&self) -> pdfium_sys::FPDF_BITMAP {
+ self.handle
+ }
+
+ pub fn width(&self) -> i32 {
+ unsafe { pdfium_sys::FPDFBitmap_GetWidth(self.handle) }
+ }
+
+ pub fn height(&self) -> i32 {
+ unsafe { pdfium_sys::FPDFBitmap_GetHeight(self.handle) }
+ }
+
+ pub fn stride(&self) -> i32 {
+ unsafe { pdfium_sys::FPDFBitmap_GetStride(self.handle) }
+ }
+
+ /// Fill a rectangle with an ARGB color (0xAARRGGBB).
+ pub fn fill_rect(&self, left: i32, top: i32, width: i32, height: i32, color: u64) {
+ unsafe {
+ pdfium_sys::FPDFBitmap_FillRect(self.handle, left, top, width, height, color);
+ }
+ }
+
+ /// Get the raw pixel buffer as a byte slice.
+ /// Format is BGRA, row-major, with `stride()` bytes per row.
+ pub fn buffer(&self) -> &[u8] {
+ let ptr = unsafe { pdfium_sys::FPDFBitmap_GetBuffer(self.handle) };
+ let len = (self.stride() * self.height()) as usize;
+ unsafe { std::slice::from_raw_parts(ptr as *const u8, len) }
+ }
+
+ /// Convert the BGRA buffer to RGBA in a new Vec.
+ pub fn to_rgba(&self) -> Vec<u8> {
+ let width = self.width() as usize;
+ let height = self.height() as usize;
+ let stride = self.stride() as usize;
+ let src = self.buffer();
+ let mut rgba = Vec::with_capacity(width * height * 4);
+
+ for y in 0..height {
+ let row = &src[y * stride..y * stride + width * 4];
+ for pixel in row.chunks_exact(4) {
+ // BGRA -> RGBA
+ rgba.push(pixel[2]); // R
+ rgba.push(pixel[1]); // G
+ rgba.push(pixel[0]); // B
+ rgba.push(pixel[3]); // A
+ }
+ }
+
+ rgba
+ }
+}
+
+impl Drop for Bitmap {
+ fn drop(&mut self) {
+ unsafe { pdfium_sys::FPDFBitmap_Destroy(self.handle) };
+ }
+}
diff --git a/packages/rust/crates/pdfium/src/document.rs b/packages/rust/crates/pdfium/src/document.rs
index a807185..b7ed348 100644
--- a/packages/rust/crates/pdfium/src/document.rs
+++ b/packages/rust/crates/pdfium/src/document.rs
@@ -17,6 +17,7 @@ impl Document {
}
Ok(Page {
handle,
+ doc_handle: self.handle,
_doc: std::marker::PhantomData,
})
}
diff --git a/packages/rust/crates/pdfium/src/lib.rs b/packages/rust/crates/pdfium/src/lib.rs
index 17b5ab0..6c11eaf 100644
--- a/packages/rust/crates/pdfium/src/lib.rs
+++ b/packages/rust/crates/pdfium/src/lib.rs
@@ -4,10 +4,12 @@ mod library;
mod document;
mod page;
mod text_page;
+mod bitmap;
pub use error::PdfiumError;
pub use types::*;
pub use library::Library;
pub use document::Document;
-pub use page::Page;
+pub use page::{Page, ImageBounds};
pub use text_page::{TextPage, TextChar, TextCharIter};
+pub use bitmap::Bitmap;
diff --git a/packages/rust/crates/pdfium/src/page.rs b/packages/rust/crates/pdfium/src/page.rs
index 05dff8d..7e324e1 100644
--- a/packages/rust/crates/pdfium/src/page.rs
+++ b/packages/rust/crates/pdfium/src/page.rs
@@ -1,11 +1,23 @@
use std::marker::PhantomData;
+use crate::bitmap::Bitmap;
use crate::document::Document;
use crate::error::PdfiumError;
use crate::text_page::TextPage;
+/// Bounding box of an embedded image object on a page.
+/// Coordinates are in PDF points with top-left origin (Y-down).
+#[derive(Debug, Clone, Copy)]
+pub struct ImageBounds {
+ pub x: f32,
+ pub y: f32,
+ pub width: f32,
+ pub height: f32,
+}
+
pub struct Page<'doc> {
pub(crate) handle: pdfium_sys::FPDF_PAGE,
+ pub(crate) doc_handle: pdfium_sys::FPDF_DOCUMENT,
pub(crate) _doc: PhantomData<&'doc Document>,
}
@@ -32,6 +44,121 @@ impl Page<'_> {
_page: PhantomData,
})
}
+
+ /// Render the page to a BGRA bitmap at the given DPI.
+ pub fn render(&self, dpi: f32) -> Result<Bitmap, PdfiumError> {
+ let scale = dpi / 72.0;
+ let width = (self.width() * scale).round() as i32;
+ let height = (self.height() * scale).round() as i32;
+
+ let bitmap = Bitmap::new(width, height)?;
+
+ // Fill with white (ARGB: 0xFFFFFFFF)
+ bitmap.fill_rect(0, 0, width, height, 0xFFFFFFFF);
+
+ let flags = (pdfium_sys::FPDF_ANNOT | pdfium_sys::FPDF_PRINTING) as i32;
+
+ unsafe {
+ pdfium_sys::FPDF_RenderPageBitmap(
+ bitmap.handle(),
+ self.handle,
+ 0, // start_x
+ 0, // start_y
+ width, // size_x
+ height, // size_y
+ 0, // rotation
+ flags,
+ );
+ }
+
+ Ok(bitmap)
+ }
+
+ /// Extract bounding boxes of embedded image objects on this page.
+ /// Returns coordinates in viewport space (Y-down, top-left origin) in PDF points.
+ /// Filters out images smaller than `min_size_pt` and images covering more than
+ /// `max_page_coverage` fraction of the page.
+ pub fn image_bounds(&self, min_size_pt: f32, max_page_coverage: f32) -> Vec<ImageBounds> {
+ let page_width = self.width();
+ let page_height = self.height();
+ let obj_count = unsafe { pdfium_sys::FPDFPage_CountObjects(self.handle) };
+ let mut results = Vec::new();
+
+ for i in 0..obj_count {
+ let obj = unsafe { pdfium_sys::FPDFPage_GetObject(self.handle, i) };
+ if obj.is_null() {
+ continue;
+ }
+
+ let obj_type = unsafe { pdfium_sys::FPDFPageObj_GetType(obj) };
+ if obj_type != pdfium_sys::FPDF_PAGEOBJ_IMAGE as i32 {
+ continue;
+ }
+
+ let mut left: f32 = 0.0;
+ let mut bottom: f32 = 0.0;
+ let mut right: f32 = 0.0;
+ let mut top: f32 = 0.0;
+ let ok = unsafe {
+ pdfium_sys::FPDFPageObj_GetBounds(obj, &mut left, &mut bottom, &mut right, &mut top)
+ };
+ if ok == 0 {
+ continue;
+ }
+
+ let w = right - left;
+ let h = top - bottom;
+
+ if w < min_size_pt || h < min_size_pt {
+ continue;
+ }
+ if w > page_width * max_page_coverage && h > page_height * max_page_coverage {
+ continue;
+ }
+
+ // Convert from PDF coords (bottom-left origin) to viewport (top-left origin)
+ results.push(ImageBounds {
+ x: left,
+ y: page_height - top,
+ width: w,
+ height: h,
+ });
+ }
+
+ results
+ }
+
+ /// Get the rendered bitmap of a specific embedded image object by index.
+ /// The index corresponds to the order from iterating page objects (image objects only).
+ pub fn render_image_object(&self, image_obj_index: usize) -> Result<Bitmap, PdfiumError> {
+ let obj_count = unsafe { pdfium_sys::FPDFPage_CountObjects(self.handle) };
+ let mut image_idx = 0usize;
+
+ for i in 0..obj_count {
+ let obj = unsafe { pdfium_sys::FPDFPage_GetObject(self.handle, i) };
+ if obj.is_null() {
+ continue;
+ }
+ let obj_type = unsafe { pdfium_sys::FPDFPageObj_GetType(obj) };
+ if obj_type != pdfium_sys::FPDF_PAGEOBJ_IMAGE as i32 {
+ continue;
+ }
+
+ if image_idx == image_obj_index {
+ let bmp_handle = unsafe {
+ pdfium_sys::FPDFImageObj_GetRenderedBitmap(self.doc_handle, self.handle, obj)
+ };
+ if bmp_handle.is_null() {
+ return Err(PdfiumError::OperationFailed);
+ }
+ // Wrap in our Bitmap (which will call Destroy on drop)
+ return Ok(unsafe { Bitmap::from_handle(bmp_handle) });
+ }
+ image_idx += 1;
+ }
+
+ Err(PdfiumError::OperationFailed)
+ }
}
impl Drop for Page<'_> {
diff --git a/src/core/parser.ts b/src/core/parser.ts
index 39c5f31..aa1b5f8 100644
--- a/src/core/parser.ts
+++ b/src/core/parser.ts
@@ -319,8 +319,12 @@ export class LiteParse {
const results: ScreenshotResult[] = [];
const pages = pageNumbers || Array.from({ length: totalPages }, (_, i) => i + 1);
- const renderer = new PdfiumRenderer();
- await renderer.loadDocument(pdfInput, this.config.password);
+ const useRustRenderer = this.config.experimental && this.pdfEngine instanceof LiteParseRsEngine;
+
+ const renderer = useRustRenderer ? null : new PdfiumRenderer();
+ if (renderer) {
+ await renderer.loadDocument(pdfInput, this.config.password);
+ }
try {
for (const pageNum of pages) {
@@ -330,7 +334,10 @@ export class LiteParse {
}
log(`Rendering page ${pageNum}...`);
- const imageBuffer = await renderer.renderPageToBuffer(pdfInput, pageNum, this.config.dpi);
+
+ const imageBuffer = useRustRenderer
+ ? await this.pdfEngine.renderPageImage(doc, pageNum, this.config.dpi, this.config.password)
+ : await renderer!.renderPageToBuffer(pdfInput, pageNum, this.config.dpi);
const pageData = await this.pdfEngine.extractPage(doc, pageNum, { extractImages: false });
@@ -342,7 +349,9 @@ export class LiteParse {
});
}
} finally {
- await renderer.close();
+ if (renderer) {
+ await renderer.close();
+ }
await this.pdfEngine.close(doc);
if (needsCleanup && cleanupPath) {
diff --git a/src/engines/pdf/liteparse-rs.ts b/src/engines/pdf/liteparse-rs.ts
index ad29682..54d3cad 100644
--- a/src/engines/pdf/liteparse-rs.ts
+++ b/src/engines/pdf/liteparse-rs.ts
@@ -148,12 +148,31 @@ export class LiteParseRsEngine implements PdfEngine {
async renderPageImage(
_doc: PdfDocument,
- _pageNum: number,
- _dpi: number,
+ pageNum: number,
+ dpi: number,
_password?: string
): Promise<Buffer> {
- // TODO: implement page rendering in the Rust CLI
- throw new Error("renderPageImage is not yet implemented in liteparse-rs");
+ const rustDoc = _doc as RustPdfDocument;
+ const args = [
+ "screenshot-stdout",
+ "--pdf-path",
+ rustDoc._filePath,
+ "--page-num",
+ String(pageNum),
+ "--dpi",
+ String(dpi),
+ ];
+
+ try {
+ const result = await execFileAsync(BINARY_PATH, args, {
+ maxBuffer: 100 * 1024 * 1024, // 100 MB
+ encoding: "buffer" as BufferEncoding,
+ });
+ return Buffer.from(result.stdout as unknown as Buffer);
+ } catch (err: unknown) {
+ const message = err instanceof Error ? err.message : String(err);
+ throw new Error(`liteparse-rs screenshot failed: ${message}`);
+ }
}
async close(_doc: PdfDocument): Promise<void> {