@llamaindex/liteparse 2.13.0 → 2.14.0

package/dist/lib.cjs

@@ -0,0 +1,712 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib.ts
+var lib_exports = {};
+__export(lib_exports, {
+  LiteParse: () => LiteParse,
+  ParseTimeoutError: () => ParseTimeoutError,
+  default: () => lib_default,
+  searchItems: () => searchItems,
+  toParseResult: () => toParseResult
+});
+module.exports = __toCommonJS(lib_exports);
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/native.ts
+var import_node_module = require("module");
+var import_node_path = require("path");
+var import_node_url = require("url");
+var require2 = (0, import_node_module.createRequire)(importMetaUrl);
+var __dirname = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
+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 {
+      }
+    }
+  }
+  const searchDirs = [__dirname, (0, import_node_path.join)(__dirname, ".."), (0, import_node_path.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((0, import_node_path.join)(dir, fileName));
+      } catch {
+      }
+    }
+  }
+  throw new Error(
+    `Failed to load native module for ${platform}-${arch}. Ensure the correct optional dependency is installed.`
+  );
+}
+var native = loadNative();
+
+// src/pool.ts
+var import_node_child_process = require("child_process");
+var import_node_url2 = require("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 = (0, import_node_url2.fileURLToPath)(new URL("./pool-worker.js", importMetaUrl));
+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);
+    }
+  }
+  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);
+    }
+  }
+  return result;
+}
+var WorkerHandle = class {
+  child;
+  readyPromise;
+  pending = null;
+  dead = false;
+  constructor(config) {
+    this.child = (0, import_node_child_process.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"));
+    }
+    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 {
+    }
+    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");
+    }
+    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
+  };
+}
+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) : 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 !== 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
+  };
+}
+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
+  };
+}
+function toScreenshot(result) {
+  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
+  };
+}
+function searchItems(items, options) {
+  const nativeResults = native.searchItems(
+    items,
+    options.phrase,
+    options.caseSensitive ?? false
+  );
+  return nativeResults.map(toTextItem);
+}
+var lib_default = LiteParse;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LiteParse,
+  ParseTimeoutError,
+  searchItems,
+  toParseResult
+});
+//# sourceMappingURL=lib.cjs.map