@llamaindex/liteparse 2.13.1 → 2.14.0

package/dist/lib.js

@@ -1,347 +1,678 @@
-import { native, } from "./native.js";
-// ---------------------------------------------------------------------------
-// LiteParse class
-// ---------------------------------------------------------------------------
-export class LiteParse {
-    _native;
-    _config;
-    constructor(userConfig = {}) {
-        const nativeConfig = {
-            ocrLanguage: userConfig.ocrLanguage,
-            ocrEnabled: userConfig.ocrEnabled,
-            ocrServerUrl: userConfig.ocrServerUrl,
-            ocrServerHeaders: userConfig.ocrServerHeaders,
-            tessdataPath: userConfig.tessdataPath,
-            maxPages: userConfig.maxPages,
-            targetPages: userConfig.targetPages,
-            extractScreenshots: userConfig.extractScreenshots,
-            continueOnPageError: userConfig.continueOnPageError,
-            dpi: userConfig.dpi,
-            outputFormat: userConfig.outputFormat,
-            imageMode: userConfig.imageMode,
-            extractImages: userConfig.extractImages,
-            imageOutputDir: userConfig.imageOutputDir,
-            extractLinks: userConfig.extractLinks,
-            keepHeadersFooters: userConfig.keepHeadersFooters,
-            extractAnnotations: userConfig.extractAnnotations,
-            extractFormFields: userConfig.extractFormFields,
-            extractStructureTree: userConfig.extractStructureTree,
-            extractBlocks: userConfig.extractBlocks,
-            extractXfaPackets: userConfig.extractXfaPackets,
-            extractDocumentMetadata: userConfig.extractDocumentMetadata,
-            extractContentBounds: userConfig.extractContentBounds,
-            detectScreenshotRects: userConfig.detectScreenshotRects,
-            renderFormFields: userConfig.renderFormFields,
-            preserveVerySmallText: userConfig.preserveVerySmallText,
-            password: userConfig.password,
-            quiet: userConfig.quiet,
-            numWorkers: userConfig.numWorkers,
-            ocrFailureFatal: userConfig.ocrFailureFatal,
-            ocrHedgeDelaysMs: userConfig.ocrHedgeDelaysMs,
-            emitWordBoxes: userConfig.emitWordBoxes,
-            extractTextMetadata: userConfig.extractTextMetadata,
-            cropBox: userConfig.cropBox,
-            skipDiagonalText: userConfig.skipDiagonalText,
-            includeComplexity: userConfig.includeComplexity,
-            extractVectorGraphics: userConfig.extractVectorGraphics,
-        };
-        this._native = new native.LiteParse(nativeConfig);
-        // Read back the resolved config from the native side
-        const resolved = this._native.config;
-        this._config = {
-            ocrLanguage: resolved.ocrLanguage ?? "eng",
-            ocrEnabled: resolved.ocrEnabled ?? true,
-            ocrServerUrl: resolved.ocrServerUrl ?? undefined,
-            ocrServerHeaders: resolved.ocrServerHeaders ?? undefined,
-            tessdataPath: resolved.tessdataPath ?? undefined,
-            maxPages: resolved.maxPages ?? 1000,
-            targetPages: resolved.targetPages ?? undefined,
-            extractScreenshots: resolved.extractScreenshots ?? false,
-            continueOnPageError: resolved.continueOnPageError ?? false,
-            dpi: resolved.dpi ?? 150,
-            outputFormat: resolved.outputFormat ?? "json",
-            imageMode: resolved.imageMode ?? "placeholder",
-            extractImages: resolved.extractImages ?? false,
-            imageOutputDir: resolved.imageOutputDir ?? undefined,
-            extractLinks: resolved.extractLinks ?? true,
-            keepHeadersFooters: resolved.keepHeadersFooters ?? false,
-            extractAnnotations: resolved.extractAnnotations ?? false,
-            extractFormFields: resolved.extractFormFields ?? false,
-            extractStructureTree: resolved.extractStructureTree ?? false,
-            extractBlocks: resolved.extractBlocks ?? false,
-            extractXfaPackets: resolved.extractXfaPackets ?? false,
-            extractDocumentMetadata: resolved.extractDocumentMetadata ?? false,
-            extractContentBounds: resolved.extractContentBounds ?? false,
-            detectScreenshotRects: resolved.detectScreenshotRects ?? false,
-            renderFormFields: resolved.renderFormFields ?? false,
-            preserveVerySmallText: resolved.preserveVerySmallText ?? false,
-            password: resolved.password ?? undefined,
-            quiet: resolved.quiet ?? false,
-            numWorkers: resolved.numWorkers ?? 1,
-            ocrFailureFatal: resolved.ocrFailureFatal ?? true,
-            ocrHedgeDelaysMs: resolved.ocrHedgeDelaysMs ?? [],
-            emitWordBoxes: resolved.emitWordBoxes ?? false,
-            extractTextMetadata: resolved.extractTextMetadata ?? false,
-            cropBox: resolved.cropBox ?? undefined,
-            skipDiagonalText: resolved.skipDiagonalText ?? false,
-            includeComplexity: resolved.includeComplexity ?? false,
-            extractVectorGraphics: resolved.extractVectorGraphics ?? false,
-        };
+// src/native.ts
+import { createRequire } from "module";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var require2 = createRequire(import.meta.url);
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function loadNative() {
+  const triples = {
+    "darwin-x64": "@llamaindex/liteparse-darwin-x64",
+    "darwin-arm64": "@llamaindex/liteparse-darwin-arm64",
+    "linux-x64-gnu": "@llamaindex/liteparse-linux-x64-gnu",
+    "linux-x64-musl": "@llamaindex/liteparse-linux-x64-musl",
+    "linux-arm64-gnu": "@llamaindex/liteparse-linux-arm64-gnu",
+    "linux-arm64-musl": "@llamaindex/liteparse-linux-arm64-musl",
+    "win32-x64-msvc": "@llamaindex/liteparse-win32-x64-msvc",
+    "win32-arm64-msvc": "@llamaindex/liteparse-win32-arm64-msvc"
+  };
+  const platform = process.platform;
+  const arch = process.arch;
+  const candidates = [];
+  if (platform === "linux") {
+    candidates.push(`${platform}-${arch}-gnu`);
+    candidates.push(`${platform}-${arch}-musl`);
+  } else if (platform === "win32") {
+    candidates.push(`${platform}-${arch}-msvc`);
+  } else {
+    candidates.push(`${platform}-${arch}`);
+  }
+  for (const key of candidates) {
+    const pkg = triples[key];
+    if (pkg) {
+      try {
+        return require2(pkg);
+      } catch {
+      }
     }
-    async parse(input) {
-        // Convert Uint8Array to Buffer for the native side
-        const nativeInput = typeof input === "string" ? input : Buffer.from(input);
-        const result = await this._native.parse(nativeInput);
-        return toParseResult(result);
+  }
+  const searchDirs = [__dirname, join(__dirname, ".."), join(__dirname, "..", "..")];
+  const fileNames = [
+    ...candidates.map((c) => `liteparse.${c}.node`),
+    `liteparse.${platform}-${arch}.node`,
+    "liteparse.node"
+  ];
+  for (const dir of searchDirs) {
+    for (const fileName of fileNames) {
+      try {
+        return require2(join(dir, fileName));
+      } catch {
+      }
     }
-    /**
-     * Parse a document in bounded-memory page batches of `batchSize` pages.
-     *
-     * Each yielded result is independent and becomes collectible once the caller
-     * advances the iterator, so a consumer that does not retain batches never
-     * holds more than one batch of pages in memory. A non-PDF source is
-     * converted once when the iterator starts, not once per batch; its temporary
-     * file is released when iteration ends — including an early `break` or
-     * `throw`, which run the generator's cleanup.
-     *
-     * Cross-page passes see only the pages in their own batch, so repeated
-     * header/footer removal and image deduplication are batch-local and the
-     * output can differ from `parse()`. Prefer `parse()` unless the size of the
-     * materialized result is the problem.
-     *
-     * As with any async generator, work starts on the first `next()` call, so
-     * errors (an unreadable file, or a parser configured with `targetPages` —
-     * ambiguous with generated batch ranges) surface on the first iteration
-     * rather than when `parseBatches()` itself is called.
-     */
-    async *parseBatches(input, options = {}) {
-        const nativeInput = typeof input === "string" ? input : Buffer.from(input);
-        const session = await this._native.openBatchSession(nativeInput, options.batchSize);
-        try {
-            const totalPages = session.totalPages;
-            for (;;) {
-                const batch = await session.nextBatch();
-                if (batch == null) {
-                    return;
-                }
-                yield {
-                    startPage: batch.startPage,
-                    endPage: batch.endPage,
-                    totalPages,
-                    result: toParseResult(batch.result),
-                };
-            }
-        }
-        finally {
-            // Frees the session's converted-PDF temp file now instead of at GC —
-            // this runs on normal exhaustion and when the consumer abandons the
-            // loop early.
-            await session.close();
-        }
+  }
+  throw new Error(
+    `Failed to load native module for ${platform}-${arch}. Ensure the correct optional dependency is installed.`
+  );
+}
+var native = loadNative();
+
+// src/pool.ts
+import { fork } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var ParseTimeoutError = class extends Error {
+  source;
+  timeoutMs;
+  constructor(message, source, timeoutMs) {
+    super(message);
+    this.name = "ParseTimeoutError";
+    this.source = source;
+    this.timeoutMs = timeoutMs;
+  }
+};
+var WorkerTimeout = class extends Error {
+};
+var WorkerCrashed = class extends Error {
+};
+var WORKER_PATH = fileURLToPath2(new URL("./pool-worker.js", import.meta.url));
+function reviveBuffers(result) {
+  for (const image of result.images ?? []) {
+    if (image.bytes && !Buffer.isBuffer(image.bytes)) {
+      const b = image.bytes;
+      image.bytes = Buffer.from(b.buffer, b.byteOffset, b.byteLength);
     }
-    /**
-     * Parse from pre-extracted pages, skipping PDFium text extraction. Runs only
-     * grid projection + the configured output formatter, so the caller's own
-     * text-extraction / font-recovery owns the text content. Synchronous: no
-     * PDFium load and no OCR on this path.
-     */
-    parsePages(pages) {
-        const nativePages = pages.map((p) => ({
-            pageNumber: p.pageNumber,
-            pageWidth: p.pageWidth,
-            pageHeight: p.pageHeight,
-            textItems: p.textItems,
-            graphics: p.graphics,
-        }));
-        const result = this._native.parsePages(nativePages);
-        return toParseResult(result);
+  }
+  for (const shot of result.screenshots ?? []) {
+    if (shot.imageBuffer && !Buffer.isBuffer(shot.imageBuffer)) {
+      const b = shot.imageBuffer;
+      shot.imageBuffer = Buffer.from(b.buffer, b.byteOffset, b.byteLength);
     }
-    /**
-     * Determine per-page complexity without running a full parse. Returns one
-     * entry per page with signals and a `needsOcr` verdict — a cheap pre-OCR
-     * check to decide whether a document needs advanced parsing.
-     */
-    async isComplex(input) {
-        const nativeInput = typeof input === "string" ? input : Buffer.from(input);
-        const stats = await this._native.isComplex(nativeInput);
-        return stats.map(toComplexity);
+  }
+  return result;
+}
+var WorkerHandle = class {
+  child;
+  readyPromise;
+  pending = null;
+  dead = false;
+  constructor(config) {
+    this.child = fork(WORKER_PATH, [], {
+      serialization: "advanced",
+      // stdout/stderr inherited: parse logs and crash traces stay visible.
+      stdio: ["ignore", "inherit", "inherit", "ipc"]
+    });
+    let readyResolve;
+    let readyReject;
+    this.readyPromise = new Promise((resolve, reject) => {
+      readyResolve = resolve;
+      readyReject = reject;
+    });
+    this.readyPromise.catch(() => {
+    });
+    this.child.on("message", (msg) => {
+      if (msg.type === "ready") {
+        readyResolve();
+        if (this.pending === null) this.idle();
+      } else if (msg.type === "initError") {
+        readyReject(new Error(msg.message));
+      } else if (this.pending) {
+        const { resolve, reject } = this.pending;
+        this.pending = null;
+        this.idle();
+        if (msg.type === "ok") resolve(reviveBuffers(msg.result));
+        else reject(new WorkerCrashed(msg.message));
+      }
+    });
+    const onGone = (cause) => {
+      this.dead = true;
+      readyReject(new WorkerCrashed(cause));
+      if (this.pending) {
+        const { reject } = this.pending;
+        this.pending = null;
+        reject(new WorkerCrashed(cause));
+      }
+    };
+    this.child.on("error", (e) => onGone(e.message));
+    this.child.on(
+      "exit",
+      (code, signal) => onGone(`worker exited (code=${code}, signal=${signal})`)
+    );
+    this.child.send({ type: "init", config });
+  }
+  /** Resolves when the worker's native parser is constructed. Init time
+   * never counts toward the parse deadline — the deadline is a promise about
+   * parsing, not about process startup. */
+  ready() {
+    return this.readyPromise;
+  }
+  /** An idle pool must not hold the parent's event loop open. */
+  idle() {
+    this.child.unref();
+    this.child.channel?.unref();
+  }
+  request(payload, timeoutMs) {
+    if (this.dead) {
+      return Promise.reject(new WorkerCrashed("worker already exited"));
     }
-    async screenshot(input, pageNumbers) {
-        const nativeInput = typeof input === "string" ? input : Buffer.from(input);
-        const results = await this._native.screenshot(nativeInput, pageNumbers ?? null);
-        return results.map((r) => ({
-            pageNum: r.pageNum,
-            width: r.width,
-            height: r.height,
-            imageBuffer: r.imageBuffer,
-            isSolidFill: r.isSolidFill,
-            rects: r.rects,
-        }));
+    this.child.ref();
+    this.child.channel?.ref();
+    return new Promise((resolve, reject) => {
+      let timer;
+      const settle = (fn) => (value) => {
+        if (timer !== void 0) clearTimeout(timer);
+        fn(value);
+      };
+      this.pending = {
+        resolve: settle(resolve),
+        reject: settle(reject)
+      };
+      if (timeoutMs !== void 0) {
+        timer = setTimeout(() => {
+          if (this.pending) {
+            const { reject: rejectPending } = this.pending;
+            this.pending = null;
+            rejectPending(new WorkerTimeout());
+          }
+        }, timeoutMs);
+      }
+      this.child.send({ type: "parse", payload });
+    });
+  }
+  kill() {
+    this.dead = true;
+    this.child.kill("SIGKILL");
+  }
+  /** Graceful shutdown; escalates to SIGKILL if the worker doesn't exit. */
+  stop() {
+    if (this.dead) return;
+    this.dead = true;
+    try {
+      this.child.send({ type: "stop" });
+    } catch {
     }
-    getConfig() {
-        return { ...this._config };
+    const escalate = setTimeout(() => this.child.kill("SIGKILL"), 5e3);
+    escalate.unref();
+    this.child.once("exit", () => clearTimeout(escalate));
+    this.idle();
+  }
+};
+var WorkerPool = class {
+  config;
+  timeoutMs;
+  workers = /* @__PURE__ */ new Set();
+  idle = [];
+  waiters = [];
+  closed = false;
+  constructor(config, poolSize, parseTimeoutMs) {
+    if (!Number.isInteger(poolSize) || poolSize < 1) {
+      throw new Error("poolSize must be an integer >= 1");
     }
-}
-function toComplexity(s) {
-    return {
-        pageNumber: s.pageNumber,
-        textLength: s.textLength,
-        textCoverage: s.textCoverage,
-        hasSubstantialImages: s.hasSubstantialImages,
-        imageBlockCount: s.imageBlockCount,
-        imageCoverage: s.imageCoverage,
-        largestImageCoverage: s.largestImageCoverage,
-        fullPageImage: s.fullPageImage,
-        uncoveredVectorArea: s.uncoveredVectorArea ?? undefined,
-        isGarbled: s.isGarbled,
-        pageArea: s.pageArea,
-        needsOcr: s.needsOcr,
-        reasons: s.reasons,
-        layout: s.layout
-            ? {
-                columnCount: s.layout.columnCount,
-                ruledTableCount: s.layout.ruledTableCount,
-                ruledTableCoverage: s.layout.ruledTableCoverage,
-                textTableRunCount: s.layout.textTableRunCount,
-                figureCount: s.layout.figureCount,
-                figureCoverage: s.layout.figureCoverage,
-                isComplex: s.layout.isComplex,
-                reasons: s.layout.reasons,
-            }
-            : undefined,
+    if (parseTimeoutMs !== void 0 && !(parseTimeoutMs > 0)) {
+      throw new Error("parseTimeoutMs must be > 0");
+    }
+    this.config = config;
+    this.timeoutMs = parseTimeoutMs;
+    for (let i = 0; i < poolSize; i++) {
+      this.spawnWorker();
+    }
+  }
+  spawnWorker() {
+    const worker = new WorkerHandle(this.config);
+    this.workers.add(worker);
+    this.release(worker);
+  }
+  acquire() {
+    const worker = this.idle.pop();
+    if (worker !== void 0) return Promise.resolve(worker);
+    return new Promise(
+      (resolve, reject) => this.waiters.push({ resolve, reject })
+    );
+  }
+  release(worker) {
+    if (this.closed) {
+      this.workers.delete(worker);
+      worker.stop();
+      return;
+    }
+    const waiter = this.waiters.shift();
+    if (waiter !== void 0) waiter.resolve(worker);
+    else this.idle.push(worker);
+  }
+  retire(worker) {
+    worker.kill();
+    this.workers.delete(worker);
+    if (!this.closed) this.spawnWorker();
+  }
+  /** Run one parse on an idle worker.
+   *
+   * Waits for a free worker first; `parseTimeoutMs` bounds the parse itself,
+   * not the wait. */
+  async parse(payload, source) {
+    if (this.closed) throw new Error("parser pool is closed");
+    const worker = await this.acquire();
+    try {
+      await worker.ready();
+      const result = await worker.request(payload, this.timeoutMs);
+      this.release(worker);
+      return result;
+    } catch (e) {
+      this.retire(worker);
+      if (e instanceof WorkerTimeout) {
+        throw new ParseTimeoutError(
+          `parse of ${source} exceeded ${this.timeoutMs}ms; the worker process was killed`,
+          source,
+          this.timeoutMs
+        );
+      }
+      if (e instanceof WorkerCrashed) {
+        throw new Error(
+          `liteparse worker process died while parsing ${source}: ${e.message}`
+        );
+      }
+      throw e;
+    }
+  }
+  /** Resolves when every worker is initialized. Optional — the first parse
+   * per worker waits for init anyway. */
+  async warmUp() {
+    await Promise.all([...this.workers].map((w) => w.ready()));
+  }
+  /** Shut down all workers. Idempotent. Busy workers are stopped as their
+   * in-flight parses finish. */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const waiter of this.waiters.splice(0)) {
+      waiter.reject(new Error("parser pool is closed"));
+    }
+    for (const worker of this.idle.splice(0)) {
+      this.workers.delete(worker);
+      worker.stop();
+    }
+  }
+};
+
+// src/lib.ts
+var LiteParse = class {
+  _native;
+  _config;
+  _pool = null;
+  constructor(userConfig = {}) {
+    const nativeConfig = {
+      ocrLanguage: userConfig.ocrLanguage,
+      ocrEnabled: userConfig.ocrEnabled,
+      ocrServerUrl: userConfig.ocrServerUrl,
+      ocrServerHeaders: userConfig.ocrServerHeaders,
+      tessdataPath: userConfig.tessdataPath,
+      maxPages: userConfig.maxPages,
+      targetPages: userConfig.targetPages,
+      extractScreenshots: userConfig.extractScreenshots,
+      continueOnPageError: userConfig.continueOnPageError,
+      dpi: userConfig.dpi,
+      outputFormat: userConfig.outputFormat,
+      imageMode: userConfig.imageMode,
+      extractImages: userConfig.extractImages,
+      imageOutputDir: userConfig.imageOutputDir,
+      extractLinks: userConfig.extractLinks,
+      keepHeadersFooters: userConfig.keepHeadersFooters,
+      extractAnnotations: userConfig.extractAnnotations,
+      extractFormFields: userConfig.extractFormFields,
+      extractStructureTree: userConfig.extractStructureTree,
+      extractBlocks: userConfig.extractBlocks,
+      extractXfaPackets: userConfig.extractXfaPackets,
+      extractDocumentMetadata: userConfig.extractDocumentMetadata,
+      extractContentBounds: userConfig.extractContentBounds,
+      detectScreenshotRects: userConfig.detectScreenshotRects,
+      renderFormFields: userConfig.renderFormFields,
+      preserveVerySmallText: userConfig.preserveVerySmallText,
+      password: userConfig.password,
+      quiet: userConfig.quiet,
+      numWorkers: userConfig.numWorkers,
+      ocrFailureFatal: userConfig.ocrFailureFatal,
+      ocrHedgeDelaysMs: userConfig.ocrHedgeDelaysMs,
+      emitWordBoxes: userConfig.emitWordBoxes,
+      extractTextMetadata: userConfig.extractTextMetadata,
+      cropBox: userConfig.cropBox,
+      skipDiagonalText: userConfig.skipDiagonalText,
+      includeComplexity: userConfig.includeComplexity,
+      extractVectorGraphics: userConfig.extractVectorGraphics
+    };
+    this._native = new native.LiteParse(nativeConfig);
+    if (userConfig.parseTimeoutMs !== void 0 && userConfig.poolSize === void 0) {
+      throw new Error(
+        "parseTimeoutMs requires poolSize"
+      );
+    }
+    if (userConfig.poolSize !== void 0) {
+      this._pool = new WorkerPool(
+        nativeConfig,
+        userConfig.poolSize,
+        userConfig.parseTimeoutMs
+      );
+    }
+    const resolved = this._native.config;
+    this._config = {
+      ocrLanguage: resolved.ocrLanguage ?? "eng",
+      ocrEnabled: resolved.ocrEnabled ?? true,
+      ocrServerUrl: resolved.ocrServerUrl ?? void 0,
+      ocrServerHeaders: resolved.ocrServerHeaders ?? void 0,
+      tessdataPath: resolved.tessdataPath ?? void 0,
+      maxPages: resolved.maxPages ?? 1e3,
+      targetPages: resolved.targetPages ?? void 0,
+      extractScreenshots: resolved.extractScreenshots ?? false,
+      continueOnPageError: resolved.continueOnPageError ?? false,
+      dpi: resolved.dpi ?? 150,
+      outputFormat: resolved.outputFormat ?? "json",
+      imageMode: resolved.imageMode ?? "placeholder",
+      extractImages: resolved.extractImages ?? false,
+      imageOutputDir: resolved.imageOutputDir ?? void 0,
+      extractLinks: resolved.extractLinks ?? true,
+      keepHeadersFooters: resolved.keepHeadersFooters ?? false,
+      extractAnnotations: resolved.extractAnnotations ?? false,
+      extractFormFields: resolved.extractFormFields ?? false,
+      extractStructureTree: resolved.extractStructureTree ?? false,
+      extractBlocks: resolved.extractBlocks ?? false,
+      extractXfaPackets: resolved.extractXfaPackets ?? false,
+      extractDocumentMetadata: resolved.extractDocumentMetadata ?? false,
+      extractContentBounds: resolved.extractContentBounds ?? false,
+      detectScreenshotRects: resolved.detectScreenshotRects ?? false,
+      renderFormFields: resolved.renderFormFields ?? false,
+      preserveVerySmallText: resolved.preserveVerySmallText ?? false,
+      password: resolved.password ?? void 0,
+      quiet: resolved.quiet ?? false,
+      numWorkers: resolved.numWorkers ?? 1,
+      ocrFailureFatal: resolved.ocrFailureFatal ?? true,
+      ocrHedgeDelaysMs: resolved.ocrHedgeDelaysMs ?? [],
+      emitWordBoxes: resolved.emitWordBoxes ?? false,
+      extractTextMetadata: resolved.extractTextMetadata ?? false,
+      cropBox: resolved.cropBox ?? void 0,
+      skipDiagonalText: resolved.skipDiagonalText ?? false,
+      includeComplexity: resolved.includeComplexity ?? false,
+      extractVectorGraphics: resolved.extractVectorGraphics ?? false
     };
+  }
+  async parse(input) {
+    const nativeInput = typeof input === "string" ? input : Buffer.from(input);
+    if (this._pool !== null) {
+      const source = typeof nativeInput === "string" ? nativeInput : `<${nativeInput.byteLength} bytes>`;
+      return this._pool.parse(nativeInput, source);
+    }
+    const result = await this._native.parse(nativeInput);
+    return toParseResult(result);
+  }
+  /**
+   * Resolves once every pool worker is initialized. No-op without `poolSize`.
+   *
+   * Optional: the first parse on each worker waits for its init anyway. Call
+   * this before latency-sensitive traffic to avoid paying worker startup on
+   * the first request.
+   */
+  async warmUp() {
+    if (this._pool !== null) await this._pool.warmUp();
+  }
+  /**
+   * Shut down pool workers, if pool mode is enabled. Idempotent.
+   *
+   * Without `poolSize` this is a no-op. An idle pool never keeps the event
+   * loop alive and workers exit when the parent does, so forgetting to call
+   * this leaks nothing past process exit.
+   */
+  close() {
+    if (this._pool !== null) this._pool.close();
+  }
+  /**
+   * Parse a document in bounded-memory page batches of `batchSize` pages.
+   *
+   * Each yielded result is independent and becomes collectible once the caller
+   * advances the iterator, so a consumer that does not retain batches never
+   * holds more than one batch of pages in memory. A non-PDF source is
+   * converted once when the iterator starts, not once per batch; its temporary
+   * file is released when iteration ends — including an early `break` or
+   * `throw`, which run the generator's cleanup.
+   *
+   * Cross-page passes see only the pages in their own batch, so repeated
+   * header/footer removal and image deduplication are batch-local and the
+   * output can differ from `parse()`. Prefer `parse()` unless the size of the
+   * materialized result is the problem.
+   *
+   * As with any async generator, work starts on the first `next()` call, so
+   * errors (an unreadable file, or a parser configured with `targetPages` —
+   * ambiguous with generated batch ranges) surface on the first iteration
+   * rather than when `parseBatches()` itself is called.
+   */
+  async *parseBatches(input, options = {}) {
+    const nativeInput = typeof input === "string" ? input : Buffer.from(input);
+    const session = await this._native.openBatchSession(
+      nativeInput,
+      options.batchSize
+    );
+    try {
+      const totalPages = session.totalPages;
+      for (; ; ) {
+        const batch = await session.nextBatch();
+        if (batch == null) {
+          return;
+        }
+        yield {
+          startPage: batch.startPage,
+          endPage: batch.endPage,
+          totalPages,
+          result: toParseResult(batch.result)
+        };
+      }
+    } finally {
+      await session.close();
+    }
+  }
+  /**
+   * Parse from pre-extracted pages, skipping PDFium text extraction. Runs only
+   * grid projection + the configured output formatter, so the caller's own
+   * text-extraction / font-recovery owns the text content. Synchronous: no
+   * PDFium load and no OCR on this path.
+   */
+  parsePages(pages) {
+    const nativePages = pages.map((p) => ({
+      pageNumber: p.pageNumber,
+      pageWidth: p.pageWidth,
+      pageHeight: p.pageHeight,
+      textItems: p.textItems,
+      graphics: p.graphics
+    }));
+    const result = this._native.parsePages(nativePages);
+    return toParseResult(result);
+  }
+  /**
+   * Determine per-page complexity without running a full parse. Returns one
+   * entry per page with signals and a `needsOcr` verdict — a cheap pre-OCR
+   * check to decide whether a document needs advanced parsing.
+   */
+  async isComplex(input) {
+    const nativeInput = typeof input === "string" ? input : Buffer.from(input);
+    const stats = await this._native.isComplex(nativeInput);
+    return stats.map(toComplexity);
+  }
+  async screenshot(input, pageNumbers) {
+    const nativeInput = typeof input === "string" ? input : Buffer.from(input);
+    const results = await this._native.screenshot(
+      nativeInput,
+      pageNumbers ?? null
+    );
+    return results.map((r) => ({
+      pageNum: r.pageNum,
+      width: r.width,
+      height: r.height,
+      imageBuffer: r.imageBuffer,
+      isSolidFill: r.isSolidFill,
+      rects: r.rects
+    }));
+  }
+  getConfig() {
+    return { ...this._config };
+  }
+};
+function toComplexity(s) {
+  return {
+    pageNumber: s.pageNumber,
+    textLength: s.textLength,
+    textCoverage: s.textCoverage,
+    hasSubstantialImages: s.hasSubstantialImages,
+    imageBlockCount: s.imageBlockCount,
+    imageCoverage: s.imageCoverage,
+    largestImageCoverage: s.largestImageCoverage,
+    fullPageImage: s.fullPageImage,
+    uncoveredVectorArea: s.uncoveredVectorArea ?? void 0,
+    isGarbled: s.isGarbled,
+    pageArea: s.pageArea,
+    needsOcr: s.needsOcr,
+    reasons: s.reasons,
+    layout: s.layout ? {
+      columnCount: s.layout.columnCount,
+      ruledTableCount: s.layout.ruledTableCount,
+      ruledTableCoverage: s.layout.ruledTableCoverage,
+      textTableRunCount: s.layout.textTableRunCount,
+      figureCount: s.layout.figureCount,
+      figureCoverage: s.layout.figureCoverage,
+      isComplex: s.layout.isComplex,
+      reasons: s.layout.reasons
+    } : void 0
+  };
 }
 function toParseResult(result) {
-    return {
-        totalPages: result.totalPages,
-        pages: result.pages.map(toPage),
-        pageErrors: result.pageErrors ?? [],
-        text: result.text,
-        images: (result.images ?? []).map(toImage),
-        screenshots: (result.screenshots ?? []).map(toScreenshot),
-        imageErrorCount: result.imageErrorCount ?? 0,
-        formType: result.formType,
-        creator: result.creator,
-        producer: result.producer,
-        docMeta: result.docMeta,
-        xfaPackets: result.xfaPackets,
-    };
+  return {
+    totalPages: result.totalPages,
+    pages: result.pages.map(toPage),
+    pageErrors: result.pageErrors ?? [],
+    text: result.text,
+    images: (result.images ?? []).map(toImage),
+    screenshots: (result.screenshots ?? []).map(toScreenshot),
+    imageErrorCount: result.imageErrorCount ?? 0,
+    formType: result.formType,
+    creator: result.creator,
+    producer: result.producer,
+    docMeta: result.docMeta,
+    xfaPackets: result.xfaPackets
+  };
 }
 function toPage(p) {
-    return {
-        pageNum: p.pageNum,
-        width: p.width,
-        height: p.height,
-        contentBounds: p.contentBounds,
-        text: p.text,
-        markdown: p.markdown,
-        textItems: p.textItems.map(toTextItem),
-        complexity: p.complexity ? toComplexity(p.complexity) : undefined,
-        vectorGraphics: p.vectorGraphics ?? undefined,
-        annotations: p.annotations,
-        formFields: p.formFields?.map((field) => ({
-            id: field.id,
-            type: field.fieldType,
-            page: field.page,
-            annotationIndex: field.annotationIndex,
-            widgetIndex: field.widgetIndex,
-            objectNumber: field.objectNumber,
-            name: field.name,
-            alternateName: field.alternateName,
-            value: field.value,
-            exportValue: field.exportValue,
-            fieldFlags: field.fieldFlags,
-            controlCount: field.controlCount,
-            controlIndex: field.controlIndex,
-            checked: field.checked,
-            rect: field.rect,
-            options: field.options,
-            selectedOptions: field.selectedOptions,
-        })),
-        structureTree: p.structureTree
-            ? { roots: p.structureTree.roots.map(toStructureTreeElement) }
-            : undefined,
-        blocks: p.blocks,
-    };
+  return {
+    pageNum: p.pageNum,
+    width: p.width,
+    height: p.height,
+    contentBounds: p.contentBounds,
+    text: p.text,
+    markdown: p.markdown,
+    textItems: p.textItems.map(toTextItem),
+    complexity: p.complexity ? toComplexity(p.complexity) : void 0,
+    vectorGraphics: p.vectorGraphics ?? void 0,
+    annotations: p.annotations,
+    formFields: p.formFields?.map((field) => ({
+      id: field.id,
+      type: field.fieldType,
+      page: field.page,
+      annotationIndex: field.annotationIndex,
+      widgetIndex: field.widgetIndex,
+      objectNumber: field.objectNumber,
+      name: field.name,
+      alternateName: field.alternateName,
+      value: field.value,
+      exportValue: field.exportValue,
+      fieldFlags: field.fieldFlags,
+      controlCount: field.controlCount,
+      controlIndex: field.controlIndex,
+      checked: field.checked,
+      rect: field.rect,
+      options: field.options,
+      selectedOptions: field.selectedOptions
+    })),
+    structureTree: p.structureTree ? { roots: p.structureTree.roots.map(toStructureTreeElement) } : void 0,
+    blocks: p.blocks
+  };
 }
 function toStructureTreeElement(element) {
-    const attributes = {};
-    for (const attribute of element.attributes) {
-        if (attribute.booleanValue !== undefined) {
-            attributes[attribute.name] = attribute.booleanValue;
-        }
-        else if (attribute.numberValue !== undefined) {
-            attributes[attribute.name] = attribute.numberValue;
-        }
-        else if (attribute.stringValue !== undefined) {
-            attributes[attribute.name] = attribute.stringValue;
-        }
+  const attributes = {};
+  for (const attribute of element.attributes) {
+    if (attribute.booleanValue !== void 0) {
+      attributes[attribute.name] = attribute.booleanValue;
+    } else if (attribute.numberValue !== void 0) {
+      attributes[attribute.name] = attribute.numberValue;
+    } else if (attribute.stringValue !== void 0) {
+      attributes[attribute.name] = attribute.stringValue;
     }
-    return {
-        type: element.elementType,
-        id: element.id,
-        actualText: element.actualText,
-        altText: element.altText,
-        title: element.title,
-        attributes,
-        markedContentIds: element.markedContentIds,
-        children: element.children.map(toStructureTreeElement),
-        annotations: element.annotations,
-    };
+  }
+  return {
+    type: element.elementType,
+    id: element.id,
+    actualText: element.actualText,
+    altText: element.altText,
+    title: element.title,
+    attributes,
+    markedContentIds: element.markedContentIds,
+    children: element.children.map(toStructureTreeElement),
+    annotations: element.annotations
+  };
 }
 function toImage(img) {
-    return {
-        id: img.id,
-        name: img.name,
-        path: img.path,
-        page: img.page,
-        bbox: img.bbox,
-        width: img.width,
-        height: img.height,
-        rotation: img.rotation,
-        format: img.format,
-        duplicateOf: img.duplicateOf,
-        bytes: img.bytes,
-    };
+  return {
+    id: img.id,
+    name: img.name,
+    path: img.path,
+    page: img.page,
+    bbox: img.bbox,
+    width: img.width,
+    height: img.height,
+    rotation: img.rotation,
+    format: img.format,
+    duplicateOf: img.duplicateOf,
+    bytes: img.bytes
+  };
 }
 function toScreenshot(result) {
-    return {
-        pageNum: result.pageNum,
-        width: result.width,
-        height: result.height,
-        imageBuffer: result.imageBuffer,
-        isSolidFill: result.isSolidFill,
-        rects: result.rects,
-    };
+  return {
+    pageNum: result.pageNum,
+    width: result.width,
+    height: result.height,
+    imageBuffer: result.imageBuffer,
+    isSolidFill: result.isSolidFill,
+    rects: result.rects
+  };
 }
 function toTextItem(item) {
-    return {
-        text: item.text,
-        x: item.x,
-        y: item.y,
-        width: item.width,
-        height: item.height,
-        fontName: item.fontName,
-        fontSize: item.fontSize,
-        fontHeight: item.fontHeight,
-        fontAscent: item.fontAscent,
-        fontDescent: item.fontDescent,
-        fontWeight: item.fontWeight,
-        textWidth: item.textWidth,
-        fontIsBuggy: item.fontIsBuggy,
-        mcid: item.mcid,
-        fillColor: item.fillColor,
-        strokeColor: item.strokeColor,
-        charCodes: item.charCodes,
-        trailingSpaceGenerated: item.trailingSpaceGenerated,
-        confidence: item.confidence,
-        rotation: item.rotation,
-        words: item.words,
-    };
+  return {
+    text: item.text,
+    x: item.x,
+    y: item.y,
+    width: item.width,
+    height: item.height,
+    fontName: item.fontName,
+    fontSize: item.fontSize,
+    fontHeight: item.fontHeight,
+    fontAscent: item.fontAscent,
+    fontDescent: item.fontDescent,
+    fontWeight: item.fontWeight,
+    textWidth: item.textWidth,
+    fontIsBuggy: item.fontIsBuggy,
+    mcid: item.mcid,
+    fillColor: item.fillColor,
+    strokeColor: item.strokeColor,
+    charCodes: item.charCodes,
+    trailingSpaceGenerated: item.trailingSpaceGenerated,
+    confidence: item.confidence,
+    rotation: item.rotation,
+    words: item.words
+  };
 }
-export function searchItems(items, options) {
-    const nativeResults = native.searchItems(items, options.phrase, options.caseSensitive ?? false);
-    return nativeResults.map(toTextItem);
+function searchItems(items, options) {
+  const nativeResults = native.searchItems(
+    items,
+    options.phrase,
+    options.caseSensitive ?? false
+  );
+  return nativeResults.map(toTextItem);
 }
-export default LiteParse;
+var lib_default = LiteParse;
+export {
+  LiteParse,
+  ParseTimeoutError,
+  lib_default as default,
+  searchItems,
+  toParseResult
+};
 //# sourceMappingURL=lib.js.map