mindee 5.1.1 → 5.2.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Mindee Node.js API Library Changelog
 
+## v5.2.0 - 2026-04-14
+### Changes
+* :sparkles: add support for crop operation for V2
+* :sparkles: add support for split operation for V2
+* :arrow_up: bump dependencies
+### Fixes
+* :bug: fix quality defaulting to 4.17 (300/72) instead of 1 when extracting cropped zones
+* :bug: fix split extraction not allowing for image files
+* :bug: fix naming in extracted PDFs
+
+
 ## v5.1.1 - 2026-03-11
 ### Changes
 * :heavy_minus_sign: tslib is never imported, remove from dependencies

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mindee",
-    "version": "5.1.1",
+    "version": "5.2.0",
     "description": "Mindee Client Library for Node.js",
     "author": {
         "name": "Mindee",
@@ -48,9 +48,9 @@
     },
     "dependencies": {
         "commander": "^14.0.3",
-        "file-type": "^21.3.1",
+        "file-type": "^21.3.3",
         "tmp": "^0.2.5",
-        "undici": ">=6.23.0 <8.0.0"
+        "undici": ">=6.24.0 <7.0.0 || >=7.24.0 <8.0.0"
     },
     "optionalDependencies": {
         "@cantoo/pdf-lib": "^2.5.3",
@@ -65,7 +65,7 @@
         "@types/node": "^20.19.37",
         "@types/tmp": "^0.2.6",
         "@typescript-eslint/eslint-plugin": "^8.57.0",
-        "@typescript-eslint/parser": "^8.57.0",
+        "@typescript-eslint/parser": "^8.58.1",
         "eslint": "^10.0.3",
         "eslint-plugin-jsdoc": "^62.7.1",
         "globals": "^17.4.0",
@@ -73,7 +73,7 @@
         "tsc-alias": "^1.8.16",
         "tslib": "^2.8.1",
         "tsx": "^4.21.0",
-        "typedoc": "^0.28.17",
+        "typedoc": "^0.28.18",
         "typescript": "^5.9.3"
     },
     "keywords": [

package/src/image/extractedImage.d.ts

@@ -5,8 +5,10 @@ import { BufferInput } from "../input/index.js";
  */
 export declare class ExtractedImage {
     buffer: Buffer;
-    protected internalFileName: string;
-    protected constructor(buffer: Uint8Array, fileName: string);
+    filename: string;
+    pageId?: number;
+    elementId?: number;
+    constructor(buffer: Uint8Array, fileName: string, pageId?: number, elementId?: number);
     /**
      * Saves the document to a file.
      *

package/src/image/extractedImage.js

@@ -10,9 +10,11 @@ import { loadOptionalDependency } from "../dependency/index.js";
  * Generic class for image extraction
  */
 export class ExtractedImage {
-    constructor(buffer, fileName) {
+    constructor(buffer, fileName, pageId, elementId) {
         this.buffer = Buffer.from(buffer);
-        this.internalFileName = fileName;
+        this.filename = fileName;
+        this.pageId = pageId;
+        this.elementId = elementId;
     }
     /**
      * Saves the document to a file.
@@ -93,7 +95,7 @@ export class ExtractedImage {
     asSource() {
         return new BufferInput({
             buffer: this.buffer,
-            filename: this.internalFileName,
+            filename: this.filename,
         });
     }
 }

package/src/image/imageExtractor.d.ts

@@ -1,9 +1,20 @@
-import type * as pdfLibTypes from "@cantoo/pdf-lib";
 import { Polygon } from "../geometry/index.js";
+import { ExtractedImage } from "../image/extractedImage.js";
+import { LocalInputSource } from "../input/index.js";
+import type * as pdfLibTypes from "@cantoo/pdf-lib";
+/**
+ * Extracts elements from a PDF document based on a list of bounding boxes.
+ * @param inputSource The input source to extract from.
+ * @param polygonsPerPage List of polygons to extract from per page.
+ * @param quality JPEG quality of extracted images.
+ */
+export declare function extractImagesFromPolygon(inputSource: LocalInputSource, polygonsPerPage: Map<number, Polygon[]>, quality?: number): Promise<ExtractedImage[]>;
 /**
  * Extracts elements from a page based off of a list of bounding boxes.
  *
  * @param pdfPage PDF Page to extract from.
  * @param polygons List of coordinates to pull the elements from.
+ * @param asImage Whether to return the extracted elements as images.
+ * @param quality JPEG quality of extracted images, given as number between 0 and 1.
  */
-export declare function extractFromPage(pdfPage: pdfLibTypes.PDFPage, polygons: Polygon[]): Promise<Uint8Array<ArrayBufferLike>[]>;
+export declare function extractFromPage(pdfPage: pdfLibTypes.PDFPage, polygons: Polygon[], asImage?: boolean, quality?: number): Promise<Uint8Array<ArrayBufferLike>[]>;

package/src/image/imageExtractor.js

@@ -1,44 +1,76 @@
+import { loadOptionalDependency } from "../dependency/index.js";
+import { MindeeImageError } from "../errors/index.js";
 import { getMinMaxX, getMinMaxY } from "../geometry/index.js";
 import { adjustForRotation } from "../geometry/polygonUtils.js";
-import { loadOptionalDependency } from "../dependency/index.js";
+import { ExtractedImage } from "../image/extractedImage.js";
+import { logger } from "../logger.js";
+import { createPdfFromInputSource } from "../pdf/pdfOperation.js";
+import { rasterizePage } from "../pdf/pdfUtils.js";
 let pdfLib = null;
 async function getPdfLib() {
     if (!pdfLib) {
-        const pdfLibImport = await loadOptionalDependency("@cantoo/pdf-lib", "Text Embedding");
+        const pdfLibImport = await loadOptionalDependency("@cantoo/pdf-lib", "Image Extraction");
         pdfLib = pdfLibImport.default || pdfLibImport;
     }
     return pdfLib;
 }
+/**
+ * Extracts elements from a PDF document based on a list of bounding boxes.
+ * @param inputSource The input source to extract from.
+ * @param polygonsPerPage List of polygons to extract from per page.
+ * @param quality JPEG quality of extracted images.
+ */
+export async function extractImagesFromPolygon(inputSource, polygonsPerPage, quality) {
+    const allExtractedImages = [];
+    const pdfDoc = await createPdfFromInputSource(inputSource);
+    for (const [pageId, polygons] of polygonsPerPage) {
+        logger.debug(`Extracting images from page ${pageId}`);
+        const pdfPage = pdfDoc.getPage(pageId);
+        const extractions = (await extractFromPage(pdfPage, polygons, true, quality));
+        const extractedImages = extractions.map((v, i) => new ExtractedImage(v, inputSource.filename + `_page${pageId}-${i}.jpg`, pageId, i));
+        allExtractedImages.push(...extractedImages);
+    }
+    return allExtractedImages;
+}
 /**
  * Extracts elements from a page based off of a list of bounding boxes.
  *
  * @param pdfPage PDF Page to extract from.
  * @param polygons List of coordinates to pull the elements from.
+ * @param asImage Whether to return the extracted elements as images.
+ * @param quality JPEG quality of extracted images, given as number between 0 and 1.
  */
-export async function extractFromPage(pdfPage, polygons) {
+export async function extractFromPage(pdfPage, polygons, asImage = false, quality) {
     const pdfLib = await getPdfLib();
     const { width, height } = pdfPage.getSize();
     const extractedElements = [];
-    // Manual upscale.
-    // Fixes issues with the OCR.
-    const qualityScale = 300 / 72;
+    if (quality && (quality < 0)) {
+        throw new MindeeImageError("Quality must be a number between 0 and 1");
+    }
+    if (quality && quality > 1) {
+        logger.warn("Quality is greater than 1, this operation will apply a manual upscale on the output." +
+            " Use only if you know what you are doing.");
+    }
+    const qualityScale = quality ?? 1;
     const orientation = pdfPage.getRotation().angle;
+    const sourceDoc = pdfPage.doc;
+    const pageIndex = sourceDoc.getPages().indexOf(pdfPage);
     for (const origPolygon of polygons) {
-        const polygon = adjustForRotation(origPolygon, orientation);
+        logger.debug(`Extracting image with polygon: ${origPolygon.toString()}`);
         const tempPdf = await pdfLib.PDFDocument.create();
+        const [copiedPage] = await tempPdf.copyPages(sourceDoc, [pageIndex]);
+        const polygon = adjustForRotation(origPolygon, orientation);
         const newWidth = width * (getMinMaxX(polygon).max - getMinMaxX(polygon).min);
         const newHeight = height * (getMinMaxY(polygon).max - getMinMaxY(polygon).min);
-        const cropped = await tempPdf.embedPage(pdfPage, {
+        const cropped = await tempPdf.embedPage(copiedPage, {
             left: getMinMaxX(polygon).min * width,
             right: getMinMaxX(polygon).max * width,
             top: height - (getMinMaxY(polygon).min * height),
             bottom: height - (getMinMaxY(polygon).max * height),
         });
-        // Determine the final page dimensions based on orientation
         let finalWidth;
         let finalHeight;
         if (orientation === 90 || orientation === 270) {
-            // For 90/270 rotations, swap width and height
             finalWidth = newHeight * qualityScale;
             finalHeight = newWidth * qualityScale;
         }
@@ -52,8 +84,8 @@ export async function extractFromPage(pdfPage, polygons) {
             y: 0,
             width: finalWidth,
             height: finalHeight,
+            color: pdfLib.rgb(1, 1, 1),
         });
-        // Draw the cropped page with rotation applied
         if (orientation === 0) {
             samplePage.drawPage(cropped, {
                 width: newWidth * qualityScale,
@@ -87,7 +119,13 @@ export async function extractFromPage(pdfPage, polygons) {
                 rotate: pdfLib.degrees(90),
             });
         }
-        extractedElements.push(await tempPdf.save());
+        const pdfBuffer = Buffer.from(await tempPdf.save());
+        if (asImage) {
+            extractedElements.push(await rasterizePage(pdfBuffer, 0, 100));
+        }
+        else {
+            extractedElements.push(pdfBuffer);
+        }
     }
     return extractedElements;
 }

package/src/pdf/extractedPdf.d.ts

@@ -0,0 +1,25 @@
+import { BufferInput } from "../input/index.js";
+import { Buffer } from "node:buffer";
+export declare class ExtractedPdf {
+    readonly buffer: Buffer;
+    readonly filename: string;
+    readonly pageCount: number;
+    constructor(pdfData: Buffer<ArrayBufferLike>, filename: string, pageCount: number);
+    /**
+     * Saves the document to a file.
+     *
+     * @param outputPath Path to save the file to.
+     */
+    saveToFileAsync(outputPath: string): Promise<void>;
+    /**
+     * Saves the document to a file synchronously.
+     * @param outputPath
+     */
+    saveToFile(outputPath: string): void;
+    /**
+     * Return the file as a Mindee-compatible BufferInput source.
+     *
+     * @returns A BufferInput source.
+     */
+    asSource(): BufferInput;
+}

package/src/pdf/extractedPdf.js

@@ -0,0 +1,65 @@
+import path from "node:path";
+import { BufferInput, MIMETYPES } from "../input/index.js";
+import { MindeeError } from "../errors/index.js";
+import { writeFile } from "fs/promises";
+import { logger } from "../logger.js";
+import { writeFileSync } from "node:fs";
+export class ExtractedPdf {
+    constructor(pdfData, filename, pageCount) {
+        this.buffer = pdfData;
+        this.filename = filename;
+        this.pageCount = pageCount;
+    }
+    /**
+     * Saves the document to a file.
+     *
+     * @param outputPath Path to save the file to.
+     */
+    async saveToFileAsync(outputPath) {
+        const fileExt = path.extname(outputPath).toLowerCase();
+        if (fileExt !== ".pdf" && !MIMETYPES.has(fileExt)) {
+            outputPath += ".pdf";
+        }
+        try {
+            await writeFile(path.resolve(outputPath), this.buffer);
+            logger.info(`File saved successfully to ${path.resolve(outputPath)}.`);
+        }
+        catch (e) {
+            if (e instanceof TypeError) {
+                throw new MindeeError("Invalid path/filename provided.");
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    /**
+     * Saves the document to a file synchronously.
+     * @param outputPath
+     */
+    saveToFile(outputPath) {
+        try {
+            writeFileSync(path.resolve(outputPath), this.buffer);
+            logger.info(`File saved successfully to ${path.resolve(outputPath)}.`);
+        }
+        catch (e) {
+            if (e instanceof TypeError) {
+                throw new MindeeError("Invalid path/filename provided.");
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    /**
+     * Return the file as a Mindee-compatible BufferInput source.
+     *
+     * @returns A BufferInput source.
+     */
+    asSource() {
+        return new BufferInput({
+            buffer: this.buffer,
+            filename: this.filename,
+        });
+    }
+}

package/src/pdf/pdfCompressor.js

@@ -1,9 +1,7 @@
 import { logger } from "../logger.js";
-import tmp from "tmp";
-import * as fs from "node:fs";
 import { compressImage } from "../image/index.js";
 import { loadOptionalDependency } from "../dependency/index.js";
-import { extractTextFromPdf, hasSourceText } from "./pdfUtils.js";
+import { extractTextFromPdf, hasSourceText, rasterizePage } from "./pdfUtils.js";
 let pdfLib = null;
 async function getPdfLib() {
     if (!pdfLib) {
@@ -105,7 +103,7 @@ async function compressPagesWithQuality(pdfData, extractedPdfInfo, imageQuality,
     for (let i = 0; i < extractedPdfInfo.pages.length; i++) {
         const page = pdfDoc.getPages()[i];
         const rasterizedPage = await rasterizePage(pdfData, i + 1, imageQuality);
-        const compressedImage = await compressImage(Buffer.from(rasterizedPage, "binary"), imageQuality);
+        const compressedImage = await compressImage(rasterizedPage, imageQuality);
         if (!disableSourceText) {
             await addTextToPdfPage(page, extractedText);
         }
@@ -187,42 +185,6 @@ async function getFontFromName(fontName) {
     }
     return font;
 }
-/**
- * Rasterizes a PDF page.
- *
- * @param pdfData Buffer representation of the entire PDF file.
- * @param index Index of the page to rasterize.
- * @param quality Quality to apply during rasterization.
- */
-async function rasterizePage(pdfData, index, quality = 85) {
-    const popplerImport = await loadOptionalDependency("node-poppler", "Image Processing");
-    const poppler = popplerImport.default || popplerImport;
-    const popplerInstance = new poppler.Poppler();
-    const tmpPdf = tmp.fileSync();
-    const tempPdfPath = tmpPdf.name;
-    const antialiasOption = "best";
-    try {
-        await fs.promises.writeFile(tempPdfPath, pdfData);
-        const options = {
-            antialias: antialiasOption,
-            firstPageToConvert: index,
-            lastPageToConvert: index,
-            jpegFile: true,
-            jpegOptions: `quality=${quality}`,
-            singleFile: true
-        };
-        const jpegBuffer = await popplerInstance.pdfToCairo(tempPdfPath, undefined, options);
-        await fs.promises.unlink(tempPdfPath);
-        return jpegBuffer;
-    }
-    catch (error) {
-        logger.error("Error rasterizing PDF:", error);
-        throw error;
-    }
-    finally {
-        tmpPdf.removeCallback();
-    }
-}
 /**
  * Performs linear interpolation between two numbers.
  * @param start The starting value.

package/src/pdf/pdfExtractor.d.ts

@@ -0,0 +1,46 @@
+import { LocalInputSource } from "../input/index.js";
+import { ExtractedPdf } from "../pdf/extractedPdf.js";
+export declare class PdfExtractor {
+    /**
+     * Buffer containing the PDF data.
+     * @private
+     */
+    private sourcePdf;
+    /**
+     * Filename of the PDF.
+     * @private
+     */
+    private filename;
+    /**
+     * Input document.
+     * @private
+     */
+    private readonly inputDocument;
+    /**
+     * Whether the extractor has been initialized.
+     * @private
+     */
+    private initialized;
+    /**
+     * PDF library instance.
+     * @private
+     */
+    private pdfLib;
+    /**
+     * List of extracted PDFs.
+     * @private
+     */
+    private extractedPdfs;
+    constructor(inputDocument: string | LocalInputSource);
+    init(): Promise<void>;
+    /**
+     * Gets the number of pages in the PDF.
+     * @returns The number of pages in the PDF.
+     */
+    getPageCount(): Promise<number>;
+    /**
+     * Extracts pages from the PDF.
+     * @param pageIndexes
+     */
+    extractSubDocuments(pageIndexes: number[][]): Promise<ExtractedPdf[]>;
+}

package/src/pdf/pdfExtractor.js

@@ -0,0 +1,128 @@
+import { PageOptionsOperation, PathInput } from "../input/index.js";
+import { logger } from "../logger.js";
+import path from "path";
+import { loadOptionalDependency } from "../dependency/index.js";
+import { MindeeInputSourceError, MindeePdfError } from "../errors/index.js";
+import { ExtractedPdf } from "../pdf/extractedPdf.js";
+import { createPdfFromInputSource, extractPages } from "../pdf/pdfOperation.js";
+let pdfLib = null;
+async function getPdfLib() {
+    if (!pdfLib) {
+        const pdfLibImport = await loadOptionalDependency("@cantoo/pdf-lib", "Text Embedding");
+        pdfLib = pdfLibImport.default || pdfLibImport;
+    }
+    return pdfLib;
+}
+export class PdfExtractor {
+    constructor(inputDocument) {
+        /**
+         * Buffer containing the PDF data.
+         * @private
+         */
+        this.sourcePdf = null;
+        /**
+         * Filename of the PDF.
+         * @private
+         */
+        this.filename = null;
+        /**
+         * Whether the extractor has been initialized.
+         * @private
+         */
+        this.initialized = false;
+        /**
+         * PDF library instance.
+         * @private
+         */
+        this.pdfLib = null;
+        /**
+         * List of extracted PDFs.
+         * @private
+         */
+        this.extractedPdfs = null;
+        this.inputDocument = inputDocument;
+    }
+    async init() {
+        this.pdfLib = await getPdfLib();
+        if (typeof this.inputDocument === "string") {
+            logger.debug(`Loading from path: ${this.inputDocument}`);
+            try {
+                const tempPathInput = new PathInput({ inputPath: this.inputDocument });
+                await tempPathInput.init();
+                if (tempPathInput.isPdf()) {
+                    this.sourcePdf = tempPathInput.fileObject;
+                }
+                else {
+                    const pdfObject = await createPdfFromInputSource(tempPathInput);
+                    this.sourcePdf = Buffer.from(await pdfObject.save());
+                }
+            }
+            catch {
+                throw new MindeeInputSourceError("Couldn't generate PDF from input.");
+            }
+            this.filename = path.basename(this.inputDocument);
+        }
+        else {
+            logger.debug(`Loading document: ${this.inputDocument.filename}`);
+            await this.inputDocument.init();
+            if (this.inputDocument.isPdf()) {
+                this.sourcePdf = this.inputDocument.fileObject;
+            }
+            else {
+                const pdfObject = await createPdfFromInputSource(this.inputDocument);
+                const arrayBuffer = await pdfObject.save();
+                this.sourcePdf = Buffer.from(arrayBuffer);
+            }
+            this.filename = this.inputDocument.filename;
+        }
+        this.initialized = true;
+        if (!this.sourcePdf) {
+            throw new MindeePdfError("Could not load PDF source.");
+        }
+    }
+    /**
+     * Gets the number of pages in the PDF.
+     * @returns The number of pages in the PDF.
+     */
+    async getPageCount() {
+        if (!this.initialized) {
+            await this.init();
+        }
+        const currentPdf = await this.pdfLib.PDFDocument.load(this.sourcePdf, {
+            ignoreEncryption: true,
+            password: ""
+        });
+        return currentPdf.getPageCount();
+    }
+    /**
+     * Extracts pages from the PDF.
+     * @param pageIndexes
+     */
+    async extractSubDocuments(pageIndexes) {
+        if (this.extractedPdfs && this.extractedPdfs.length > 0) {
+            return this.extractedPdfs;
+        }
+        if (!this.initialized) {
+            await this.init();
+        }
+        this.extractedPdfs = [];
+        for (const pageRange of pageIndexes) {
+            logger.debug(`Extracting pages ${pageRange.join(", ")}`);
+            if (pageRange.length === 0) {
+                throw new MindeeInputSourceError("Empty indexes not allowed for extraction.");
+            }
+            const pageOptions = {
+                pageIndexes: pageRange,
+                operation: PageOptionsOperation.KeepOnly,
+                onMinPages: 1,
+            };
+            const splitName = path.basename(this.filename, path.extname(this.filename));
+            const startPage = String(pageRange[0] + 1).padStart(3, "0");
+            const endPage = String(pageRange[pageRange.length - 1] + 1).padStart(3, "0");
+            const fieldFilename = `${splitName}_page_${startPage}-${endPage}.pdf`;
+            const page = await extractPages(this.sourcePdf, pageOptions);
+            this.extractedPdfs.push(new ExtractedPdf(page.file, fieldFilename, pageRange.length));
+        }
+        return this.extractedPdfs;
+    }
+}

package/src/pdf/pdfOperation.d.ts

@@ -1,4 +1,6 @@
+import type * as pdfLibTypes from "@cantoo/pdf-lib";
 import { PageOptions } from "../input/pageOptions.js";
+import { LocalInputSource } from "../input/index.js";
 export interface SplitPdf {
     file: Buffer;
     totalPagesRemoved: number;
@@ -16,3 +18,8 @@ export declare function extractPages(file: Buffer, pageOptions: PageOptions): Pr
  * @returns the number of pages in the file.
  */
 export declare function countPages(file: Buffer): Promise<number>;
+/**
+ * Creates a PDF from a local file. Converts images to PDFs if needed.
+ * @param inputSource The input source to create a PDF from.
+ */
+export declare function createPdfFromInputSource(inputSource: LocalInputSource): Promise<pdfLibTypes.PDFDocument>;

package/src/pdf/pdfOperation.js

@@ -1,6 +1,6 @@
 import { errorHandler } from "../errors/handler.js";
 import { PageOptionsOperation } from "../input/pageOptions.js";
-import { MindeeError } from "../errors/index.js";
+import { MindeeError, MindeeInputSourceError } from "../errors/index.js";
 import { logger } from "../logger.js";
 import { loadOptionalDependency } from "../dependency/index.js";
 let pdfLib = null;
@@ -84,3 +84,36 @@ export async function countPages(file) {
     });
     return currentPdf.getPageCount();
 }
+/**
+ * Creates a PDF from a local file. Converts images to PDFs if needed.
+ * @param inputSource The input source to create a PDF from.
+ */
+export async function createPdfFromInputSource(inputSource) {
+    const pdfLib = await getPdfLib();
+    let pdfDoc;
+    if (!["image/jpeg", "image/jpg", "image/png", "application/pdf"].includes(inputSource.mimeType)) {
+        throw new MindeeInputSourceError('Unsupported file type "' +
+            inputSource.mimeType +
+            '" Currently supported types are .png, .jpg and .pdf');
+    }
+    else if (inputSource.isPdf()) {
+        pdfDoc = await pdfLib.PDFDocument.load(inputSource.fileObject, {
+            ignoreEncryption: true,
+            password: ""
+        });
+    }
+    else {
+        pdfDoc = await pdfLib.PDFDocument.create();
+        let image;
+        if (inputSource.mimeType === "image/png") {
+            image = await pdfDoc.embedPng(inputSource.fileObject);
+        }
+        else {
+            image = await pdfDoc.embedJpg(inputSource.fileObject);
+        }
+        const imageDims = image.scale(1);
+        const pageImage = pdfDoc.addPage([imageDims.width, imageDims.height]);
+        pageImage.drawImage(image);
+    }
+    return pdfDoc;
+}

package/src/pdf/pdfUtils.d.ts

@@ -28,3 +28,12 @@ export declare function extractTextFromPdf(pdfBuffer: Buffer): Promise<Extracted
  * @returns A Promise containing a boolean indicating if the PDF has source text.
  */
 export declare function hasSourceText(pdfData: Buffer): Promise<boolean>;
+/**
+ * Rasterizes a PDF page.
+ *
+ * @param pdfData Buffer representation of the entire PDF file.
+ * @param index Index of the page to rasterize.
+ * @param quality Quality to apply during rasterization.
+ * @return Buffer containing the rasterized image data.
+ */
+export declare function rasterizePage(pdfData: Buffer, index: number, quality?: number): Promise<Buffer>;

package/src/pdf/pdfUtils.js

@@ -1,5 +1,8 @@
+import tmp from "tmp";
+import * as fs from "node:fs";
 import { MindeePdfError } from "../errors/index.js";
 import { loadOptionalDependency } from "../dependency/index.js";
+import { logger } from "../logger.js";
 function getConcatenatedText(pages) {
     return pages.flatMap(page => page.content.map(item => item.str)).join(" ");
 }
@@ -51,3 +54,40 @@ export async function hasSourceText(pdfData) {
     const text = await extractTextFromPdf(pdfData);
     return text.getConcatenatedText().trim().length > 0;
 }
+/**
+ * Rasterizes a PDF page.
+ *
+ * @param pdfData Buffer representation of the entire PDF file.
+ * @param index Index of the page to rasterize.
+ * @param quality Quality to apply during rasterization.
+ * @return Buffer containing the rasterized image data.
+ */
+export async function rasterizePage(pdfData, index, quality = 85) {
+    const popplerImport = await loadOptionalDependency("node-poppler", "Image Processing");
+    const poppler = popplerImport.default || popplerImport;
+    const popplerInstance = new poppler.Poppler();
+    const tmpPdf = tmp.fileSync();
+    const tempPdfPath = tmpPdf.name;
+    const antialiasOption = "best";
+    try {
+        await fs.promises.writeFile(tempPdfPath, pdfData);
+        const options = {
+            antialias: antialiasOption,
+            firstPageToConvert: index,
+            lastPageToConvert: index,
+            jpegFile: true,
+            jpegOptions: `quality=${quality}`,
+            singleFile: true
+        };
+        const jpegBuffer = await popplerInstance.pdfToCairo(tempPdfPath, undefined, options);
+        await fs.promises.unlink(tempPdfPath);
+        return Buffer.from(jpegBuffer, "binary");
+    }
+    catch (error) {
+        logger.error("Error rasterizing PDF:", error);
+        throw error;
+    }
+    finally {
+        tmpPdf.removeCallback();
+    }
+}

package/src/v1/extraction/multiReceiptsExtractor/multiReceiptsExtractor.js

@@ -1,4 +1,5 @@
-import { MindeeError, MindeeInputSourceError } from "../../../errors/index.js";
+import { MindeeError } from "../../../errors/index.js";
+import { createPdfFromInputSource } from "../../../pdf/pdfOperation.js";
 import { ExtractedMultiReceiptImage } from "../../../v1/extraction/index.js";
 import { extractFromPage } from "../../../image/index.js";
 import { loadOptionalDependency } from "../../../dependency/index.js";
@@ -20,42 +21,14 @@ async function getPdfLib() {
  * pages.
  */
 async function extractReceiptsFromPage(pdfPage, boundingBoxes, pageId) {
-    const extractedReceiptsRaw = await extractFromPage(pdfPage, boundingBoxes);
+    const manualUpscaleFactor = 300 / 72;
+    const extractedReceiptsRaw = await extractFromPage(pdfPage, boundingBoxes, false, manualUpscaleFactor);
     const extractedReceipts = [];
     for (let i = 0; i < extractedReceiptsRaw.length; i++) {
         extractedReceipts.push(new ExtractedMultiReceiptImage(extractedReceiptsRaw[i], pageId, i));
     }
     return extractedReceipts;
 }
-async function loadPdfDoc(inputFile) {
-    const pdfLib = await getPdfLib();
-    let pdfDoc;
-    if (!["image/jpeg", "image/jpg", "image/png", "application/pdf"].includes(inputFile.mimeType)) {
-        throw new MindeeInputSourceError('Unsupported file type "' +
-            inputFile.mimeType +
-            '" Currently supported types are .png, .jpg and .pdf');
-    }
-    else if (inputFile.isPdf()) {
-        pdfDoc = await pdfLib.PDFDocument.load(inputFile.fileObject, {
-            ignoreEncryption: true,
-            password: ""
-        });
-    }
-    else {
-        pdfDoc = await pdfLib.PDFDocument.create();
-        let image;
-        if (inputFile.mimeType === "image/png") {
-            image = await pdfDoc.embedPng(inputFile.fileObject);
-        }
-        else {
-            image = await pdfDoc.embedJpg(inputFile.fileObject);
-        }
-        const imageDims = image.scale(1);
-        const pageImage = pdfDoc.addPage([imageDims.width, imageDims.height]);
-        pageImage.drawImage(image);
-    }
-    return pdfDoc;
-}
 /**
  * Extracts individual receipts from multi-receipts documents.
  *
@@ -69,9 +42,9 @@ export async function extractReceipts(inputFile, inference) {
     if (!inference.prediction.receipts) {
         throw new MindeeError("No possible receipts candidates found for MultiReceipts extraction.");
     }
-    const pdfDoc = await loadPdfDoc(inputFile);
+    const pdfDoc = await createPdfFromInputSource(inputFile);
     for (let pageId = 0; pageId < pdfDoc.getPageCount(); pageId++) {
-        const [page] = await pdfDoc.copyPages(pdfDoc, [pageId]);
+        const page = pdfDoc.getPage(pageId);
         page.setRotation(pdfLib.degrees(inference.pages[pageId].orientation?.value ?? 0));
         const receiptPositions = inference.pages[pageId].prediction.receipts.map((receipt) => receipt.boundingBox);
         const extractedReceipts = await extractReceiptsFromPage(page, receiptPositions, pageId);

package/src/v2/fileOperations/crop.d.ts

@@ -0,0 +1,18 @@
+import { LocalInputSource } from "../../input/index.js";
+import { CropItem } from "../../v2/product/crop/index.js";
+import { CropFiles } from "../../v2/fileOperations/cropFiles.js";
+import { ExtractedImage } from "../../image/index.js";
+/**
+ * Extracts a single specified crop from a given input source.
+ * @param inputSource Local input source.
+ * @param crop Crop to extract.
+ */
+export declare function extractSingleCrop(inputSource: LocalInputSource, crop: CropItem): Promise<ExtractedImage>;
+/**
+ * Extracts a list of crops from a document.
+ * @param inputSource Local input source.
+ * @param crops List of crops to extract.
+ * @param quality JPEG quality of extracted images.
+ * @return a list of extracted files, as a CropFiles object.
+ */
+export declare function extractCrops(inputSource: LocalInputSource, crops: CropItem[], quality?: number): Promise<CropFiles>;

package/src/v2/fileOperations/crop.js

@@ -0,0 +1,35 @@
+import { MindeeError } from "../../errors/index.js";
+import { extractImagesFromPolygon } from "../../image/imageExtractor.js";
+import { CropFiles } from "../../v2/fileOperations/cropFiles.js";
+import { logger } from "../../logger.js";
+/**
+ * Extracts a single specified crop from a given input source.
+ * @param inputSource Local input source.
+ * @param crop Crop to extract.
+ */
+export async function extractSingleCrop(inputSource, crop) {
+    return (await extractCrops(inputSource, [crop]))[0];
+}
+/**
+ * Extracts a list of crops from a document.
+ * @param inputSource Local input source.
+ * @param crops List of crops to extract.
+ * @param quality JPEG quality of extracted images.
+ * @return a list of extracted files, as a CropFiles object.
+ */
+export async function extractCrops(inputSource, crops, quality) {
+    if (crops.length === 0) {
+        throw new MindeeError("No crop indexes provided.");
+    }
+    logger.debug("Extracting crops: " + crops.join(", "));
+    const polygonsByPage = new Map();
+    for (const crop of crops) {
+        const pageId = crop.location.page;
+        if (!polygonsByPage.has(pageId)) {
+            polygonsByPage.set(pageId, []);
+        }
+        polygonsByPage.get(pageId).push(crop.location.polygon);
+    }
+    const extractedCrops = await extractImagesFromPolygon(inputSource, polygonsByPage, quality);
+    return new CropFiles(...extractedCrops);
+}

package/src/v2/fileOperations/cropFiles.d.ts

@@ -0,0 +1,4 @@
+import { ExtractedImage } from "../../image/index.js";
+export declare class CropFiles extends Array<ExtractedImage> {
+    constructor(...items: ExtractedImage[]);
+}

package/src/v2/fileOperations/cropFiles.js

@@ -0,0 +1,5 @@
+export class CropFiles extends Array {
+    constructor(...items) {
+        super(...items);
+    }
+}

package/src/v2/fileOperations/index.d.ts

@@ -0,0 +1 @@
+export {};

package/src/v2/fileOperations/index.js

@@ -0,0 +1 @@
+export {};

package/src/v2/fileOperations/split.d.ts

@@ -0,0 +1,21 @@
+import { LocalInputSource } from "../../input/index.js";
+import { SplitFiles } from "../../v2/fileOperations/splitFiles.js";
+/**
+ * Extracts a single specified split from a
+ * @param inputSource
+ * @param split
+ */
+export declare function extractSingleSplit(inputSource: LocalInputSource, split: number[]): Promise<SplitFiles>;
+/**
+ * Extracts splits as complete PDFs from the document.
+ * @param inputSource Local input source.
+ * @param splits List of sub-lists of pages to keep.
+ * @return a list of extracted files.
+ * @throws MindeeError if no indexes are provided.
+ */
+export declare function extractSplits(inputSource: LocalInputSource, splits: number[][]): Promise<SplitFiles>;
+/**
+ * Expands a range of pages into a list of page indexes.
+ * @param range start and end of the page range
+ */
+export declare function expandRange(range: [number, number]): number[];

package/src/v2/fileOperations/split.js

@@ -0,0 +1,48 @@
+import { MindeeError } from "../../errors/index.js";
+import { PdfExtractor } from "../../pdf/pdfExtractor.js";
+import { SplitFiles } from "../../v2/fileOperations/splitFiles.js";
+import { logger } from "../../logger.js";
+import { ExtractedPdf } from "../../pdf/extractedPdf.js";
+/**
+ * Extracts a single specified split from a
+ * @param inputSource
+ * @param split
+ */
+export async function extractSingleSplit(inputSource, split) {
+    return await extractSplits(inputSource, [split]);
+}
+/**
+ * Extracts splits as complete PDFs from the document.
+ * @param inputSource Local input source.
+ * @param splits List of sub-lists of pages to keep.
+ * @return a list of extracted files.
+ * @throws MindeeError if no indexes are provided.
+ */
+export async function extractSplits(inputSource, splits) {
+    const pageGroups = splits.filter(e => e.length > 0);
+    if (pageGroups.length === 0) {
+        throw new MindeeError("No valid split indexes provided.");
+    }
+    logger.debug("Extracting splits: " + splits.join(", "));
+    const pdfExtractor = new PdfExtractor(inputSource);
+    await pdfExtractor.init();
+    if (splits.length === 0) {
+        return new SplitFiles();
+    }
+    const pageCount = await pdfExtractor.getPageCount();
+    if (splits.length === 1 && splits[0].at(-1) === pageCount - 1) {
+        return new SplitFiles(new ExtractedPdf(inputSource.fileObject, inputSource.filename, pageCount));
+    }
+    const subDocuments = await pdfExtractor.extractSubDocuments(pageGroups);
+    return new SplitFiles(...subDocuments);
+}
+/**
+ * Expands a range of pages into a list of page indexes.
+ * @param range start and end of the page range
+ */
+export function expandRange(range) {
+    if (range[0] > range[1]) {
+        throw new MindeeError("Invalid page range provided.");
+    }
+    return Array.from({ length: range[1] - range[0] + 1 }, (_, i) => range[0] + i);
+}

package/src/v2/fileOperations/splitFiles.d.ts

@@ -0,0 +1,4 @@
+import { ExtractedPdf } from "../../pdf/extractedPdf.js";
+export declare class SplitFiles extends Array<ExtractedPdf> {
+    constructor(...args: ExtractedPdf[]);
+}

package/src/v2/fileOperations/splitFiles.js

@@ -0,0 +1,5 @@
+export class SplitFiles extends Array {
+    constructor(...args) {
+        super(...args);
+    }
+}

package/src/v2/product/crop/cropItem.d.ts

@@ -1,8 +1,16 @@
 import { FieldLocation } from "../../../v2/parsing/inference/field/index.js";
 import { StringDict } from "../../../parsing/index.js";
+import { LocalInputSource } from "../../../input/index.js";
+import { ExtractedImage } from "../../../image/index.js";
 export declare class CropItem {
     objectType: string;
     location: FieldLocation;
     constructor(serverResponse: StringDict);
     toString(): string;
+    /**
+     * Extracts a single crop from an input.
+     * @param inputSource The input file to extract from.
+     * @param quality Optional quality parameter for image extraction, default is undefined (full quality).
+     */
+    extractFromFile(inputSource: LocalInputSource, quality?: number): Promise<ExtractedImage>;
 }

package/src/v2/product/crop/cropItem.js

@@ -1,4 +1,5 @@
 import { FieldLocation } from "../../../v2/parsing/inference/field/index.js";
+import { extractCrops } from "../../../v2/fileOperations/crop.js";
 export class CropItem {
     constructor(serverResponse) {
         this.objectType = serverResponse["object_type"];
@@ -7,4 +8,12 @@ export class CropItem {
     toString() {
         return `* :Location: ${this.location}\n  :Object Type: ${this.objectType}`;
     }
+    /**
+     * Extracts a single crop from an input.
+     * @param inputSource The input file to extract from.
+     * @param quality Optional quality parameter for image extraction, default is undefined (full quality).
+     */
+    async extractFromFile(inputSource, quality = 1) {
+        return (await extractCrops(inputSource, [this], quality))[0];
+    }
 }

package/src/v2/product/crop/cropResponse.d.ts

@@ -1,6 +1,8 @@
+import { LocalInputSource } from "../../../input/index.js";
 import { StringDict } from "../../../parsing/stringDict.js";
-import { CropInference } from "./cropInference.js";
+import { CropFiles } from "../../../v2/fileOperations/cropFiles.js";
 import { BaseResponse } from "../../../v2/parsing/index.js";
+import { CropInference } from "./cropInference.js";
 export declare class CropResponse extends BaseResponse {
     /**
      * Response for a crop utility inference.
@@ -10,4 +12,10 @@ export declare class CropResponse extends BaseResponse {
      * @param serverResponse JSON response from the server.
      */
     constructor(serverResponse: StringDict);
+    /**
+     * Extracts all crops from an input.
+     * @param inputSource The input file to extract from.
+     * @param quality Optional quality parameter for image extraction, default is undefined (full quality).
+     */
+    extractFromFile(inputSource: LocalInputSource, quality?: number): Promise<CropFiles>;
 }

package/src/v2/product/crop/cropResponse.js

@@ -1,5 +1,6 @@
-import { CropInference } from "./cropInference.js";
+import { extractCrops } from "../../../v2/fileOperations/crop.js";
 import { BaseResponse } from "../../../v2/parsing/index.js";
+import { CropInference } from "./cropInference.js";
 export class CropResponse extends BaseResponse {
     /**
      * @param serverResponse JSON response from the server.
@@ -8,4 +9,12 @@ export class CropResponse extends BaseResponse {
         super(serverResponse);
         this.inference = new CropInference(serverResponse["inference"]);
     }
+    /**
+     * Extracts all crops from an input.
+     * @param inputSource The input file to extract from.
+     * @param quality Optional quality parameter for image extraction, default is undefined (full quality).
+     */
+    async extractFromFile(inputSource, quality = 1) {
+        return await extractCrops(inputSource, this.inference.result.crops, quality);
+    }
 }

package/src/v2/product/split/splitRange.d.ts

@@ -1,4 +1,5 @@
 import { StringDict } from "../../../parsing/index.js";
+import { LocalInputSource } from "../../../input/index.js";
 /**
  * Split inference result.
  */
@@ -14,4 +15,9 @@ export declare class SplitRange {
     documentType: string;
     constructor(serverResponse: StringDict);
     toString(): string;
+    /**
+     * Extracts a single split from the input file.
+     * @param inputSource The input file to extract from.
+     */
+    extractFromFile(inputSource: LocalInputSource): Promise<import("../../../pdf/extractedPdf.js").ExtractedPdf>;
 }

package/src/v2/product/split/splitRange.js

@@ -1,3 +1,4 @@
+import { expandRange, extractSplits } from "../../../v2/fileOperations/split.js";
 /**
  * Split inference result.
  */
@@ -10,4 +11,12 @@ export class SplitRange {
         const pageRange = this.pageRange.join(",");
         return `* :Page Range: ${pageRange}\n  :Document Type: ${this.documentType}`;
     }
+    /**
+     * Extracts a single split from the input file.
+     * @param inputSource The input file to extract from.
+     */
+    async extractFromFile(inputSource) {
+        const pageRange = [expandRange(this.pageRange)];
+        return (await extractSplits(inputSource, pageRange))[0];
+    }
 }

package/src/v2/product/split/splitResponse.d.ts

@@ -1,6 +1,8 @@
 import { StringDict } from "../../../parsing/stringDict.js";
 import { SplitInference } from "./splitInference.js";
 import { BaseResponse } from "../../../v2/parsing/index.js";
+import { LocalInputSource } from "../../../input/index.js";
+import { SplitFiles } from "../../../v2/fileOperations/splitFiles.js";
 export declare class SplitResponse extends BaseResponse {
     /**
      * Response for an OCR utility inference.
@@ -10,4 +12,9 @@ export declare class SplitResponse extends BaseResponse {
      * @param serverResponse JSON response from the server.
      */
     constructor(serverResponse: StringDict);
+    /**
+     * Extracts all splits from an input PDF.
+     * @param inputSource The input file to extract from.
+     */
+    extractFromFile(inputSource: LocalInputSource): Promise<SplitFiles>;
 }

package/src/v2/product/split/splitResponse.js

@@ -1,5 +1,6 @@
 import { SplitInference } from "./splitInference.js";
 import { BaseResponse } from "../../../v2/parsing/index.js";
+import { expandRange, extractSplits } from "../../../v2/fileOperations/split.js";
 export class SplitResponse extends BaseResponse {
     /**
      * @param serverResponse JSON response from the server.
@@ -8,4 +9,15 @@ export class SplitResponse extends BaseResponse {
         super(serverResponse);
         this.inference = new SplitInference(serverResponse["inference"]);
     }
+    /**
+     * Extracts all splits from an input PDF.
+     * @param inputSource The input file to extract from.
+     */
+    async extractFromFile(inputSource) {
+        const splits = [];
+        for (const split of this.inference.result.splits) {
+            splits.push(expandRange(split.pageRange));
+        }
+        return await extractSplits(inputSource, splits);
+    }
 }