mindee 4.36.3 → 5.0.0-alpha2

package/src/geometry/polygonUtils.js

@@ -1,23 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCentroid = getCentroid;
-exports.isPointInY = isPointInY;
-exports.getMinMaxY = getMinMaxY;
-exports.isPointInPolygonY = isPointInPolygonY;
-exports.relativeY = relativeY;
-exports.isPointInX = isPointInX;
-exports.getMinMaxX = getMinMaxX;
-exports.isPointInPolygonX = isPointInPolygonX;
-exports.relativeX = relativeX;
-exports.getMinYCoordinate = getMinYCoordinate;
-exports.getMinXCoordinate = getMinXCoordinate;
-exports.compareOnY = compareOnY;
-exports.compareOnX = compareOnX;
-exports.adjustForRotation = adjustForRotation;
 /**
  * Get the central point (centroid) given a list of points.
  */
-function getCentroid(vertices) {
+export function getCentroid(vertices) {
     const numbVertices = vertices.length;
     const xSum = vertices
         .map((point) => point[0])
@@ -30,20 +14,20 @@ function getCentroid(vertices) {
 /**
  * Determine if a Point is within two Y coordinates.
  */
-function isPointInY(centroid, yMin, yMax) {
+export function isPointInY(centroid, yMin, yMax) {
     return yMin <= centroid[1] && centroid[1] <= yMax;
 }
 /**
  * Get the maximum and minimum Y coordinates in a given list of Points.
  */
-function getMinMaxY(vertices) {
+export function getMinMaxY(vertices) {
     const points = vertices.map((point) => point[1]);
     return { min: Math.min(...points), max: Math.max(...points) };
 }
 /**
  * Determine if a Point is within a Polygon's Y axis.
  */
-function isPointInPolygonY(centroid, polygon) {
+export function isPointInPolygonY(centroid, polygon) {
     const yCoords = getMinMaxY(polygon);
     return isPointInY(centroid, yCoords.min, yCoords.max);
 }
@@ -52,7 +36,7 @@ function isPointInPolygonY(centroid, polygon) {
  *
  * Can be used to order (sort) words in the same column.
  */
-function relativeY(polygon) {
+export function relativeY(polygon) {
     const sum = polygon
         .map((point) => point[1])
         .reduce((prev, cur) => prev + cur);
@@ -61,20 +45,20 @@ function relativeY(polygon) {
 /**
  * Determine if a Point is within two X coordinates.
  */
-function isPointInX(centroid, xMin, xMax) {
+export function isPointInX(centroid, xMin, xMax) {
     return xMin <= centroid[0] && centroid[0] <= xMax;
 }
 /**
  * Get the maximum and minimum X coordinates in a given list of Points.
  */
-function getMinMaxX(vertices) {
+export function getMinMaxX(vertices) {
     const points = vertices.map((point) => point[0]);
     return { min: Math.min(...points), max: Math.max(...points) };
 }
 /**
  * Determine if a Point is within a Polygon's X axis.
  */
-function isPointInPolygonX(centroid, polygon) {
+export function isPointInPolygonX(centroid, polygon) {
     const xCoords = getMinMaxX(polygon);
     return isPointInX(centroid, xCoords.min, xCoords.max);
 }
@@ -83,13 +67,13 @@ function isPointInPolygonX(centroid, polygon) {
  *
  * Can be used to order (sort) words in the same line.
  */
-function relativeX(polygon) {
+export function relativeX(polygon) {
     const sum = polygon
         .map((point) => point[0])
         .reduce((prev, cur) => prev + cur);
     return polygon.length * sum;
 }
-function getMinYCoordinate(polygon) {
+export function getMinYCoordinate(polygon) {
     return polygon.sort((point1, point2) => {
         if (point1[1] < point2[1]) {
             return -1;
@@ -100,7 +84,7 @@ function getMinYCoordinate(polygon) {
         return 0;
     })[0][1];
 }
-function getMinXCoordinate(polygon) {
+export function getMinXCoordinate(polygon) {
     return polygon.sort((point1, point2) => {
         if (point1[0] < point2[0]) {
             return -1;
@@ -111,21 +95,21 @@ function getMinXCoordinate(polygon) {
         return 0;
     })[0][0];
 }
-function compareOnY(polygon1, polygon2) {
+export function compareOnY(polygon1, polygon2) {
     const sort = getMinYCoordinate(polygon1) - getMinYCoordinate(polygon2);
     if (sort === 0) {
         return 0;
     }
     return sort < 0 ? -1 : 1;
 }
-function compareOnX(polygon1, polygon2) {
+export function compareOnX(polygon1, polygon2) {
     const sort = getMinXCoordinate(polygon1) - getMinXCoordinate(polygon2);
     if (sort === 0) {
         return 0;
     }
     return sort < 0 ? -1 : 1;
 }
-function adjustForRotation(polygon, orientation) {
+export function adjustForRotation(polygon, orientation) {
     if (orientation === 90) {
         return polygon.map(([x, y]) => [y, 1 - x]);
     }

package/src/http/apiCore.d.ts

@@ -0,0 +1,30 @@
+import { Dispatcher } from "undici";
+import { InputSource, PageOptions } from "../input/index.js";
+export declare const TIMEOUT_DEFAULT: number;
+export interface RequestOptions {
+    hostname: string;
+    path: string;
+    method: any;
+    timeout: number;
+    headers: any;
+    body?: any;
+}
+export interface BaseHttpResponse {
+    messageObj: any;
+    data: {
+        [key: string]: any;
+    };
+}
+/**
+ * Cuts a document's pages according to the given options.
+ * @param inputDoc input document.
+ * @param pageOptions page cutting options.
+ */
+export declare function cutDocPages(inputDoc: InputSource, pageOptions: PageOptions): Promise<void>;
+/**
+ * Reads a response from the API and processes it.
+ * @param dispatcher custom dispatcher to use for the request.
+ * @param options options related to the request itself.
+ * @returns the processed request.
+ */
+export declare function sendRequestAndReadResponse(dispatcher: Dispatcher, options: RequestOptions): Promise<BaseHttpResponse>;

package/src/http/apiCore.js

@@ -0,0 +1,53 @@
+import { logger } from "../logger.js";
+import { request } from "undici";
+import { LocalInputSource } from "../input/index.js";
+export const TIMEOUT_DEFAULT = 120;
+/**
+ * Cuts a document's pages according to the given options.
+ * @param inputDoc input document.
+ * @param pageOptions page cutting options.
+ */
+export async function cutDocPages(inputDoc, pageOptions) {
+    if (inputDoc instanceof LocalInputSource && inputDoc.isPdf()) {
+        await inputDoc.applyPageOptions(pageOptions);
+    }
+}
+/**
+ * Reads a response from the API and processes it.
+ * @param dispatcher custom dispatcher to use for the request.
+ * @param options options related to the request itself.
+ * @returns the processed request.
+ */
+export async function sendRequestAndReadResponse(dispatcher, options) {
+    const url = `https://${options.hostname}${options.path}`;
+    logger.debug(`${options.method}: ${url}`);
+    const response = await request(url, {
+        method: options.method,
+        headers: options.headers,
+        bodyTimeout: options.timeout,
+        body: options.body,
+        throwOnError: false,
+        dispatcher: dispatcher
+    });
+    logger.debug("Parsing the response ...");
+    let responseBody = await response.body.text();
+    // handle empty responses from server, for example, in the case of redirects
+    if (!responseBody) {
+        responseBody = "{}";
+    }
+    try {
+        const parsedResponse = JSON.parse(responseBody);
+        logger.debug("JSON parsed successfully, returning plain object.");
+        return {
+            messageObj: response,
+            data: parsedResponse,
+        };
+    }
+    catch {
+        logger.error("Could not parse the return as JSON.");
+        return {
+            messageObj: response,
+            data: { reconstructedResponse: responseBody },
+        };
+    }
+}

package/src/http/baseSettings.d.ts

@@ -1,10 +1,14 @@
+import { Dispatcher } from "undici";
 export interface MindeeApiConstructorProps {
     apiKey?: string;
+    dispatcher?: Dispatcher;
 }
 export declare abstract class BaseSettings {
+    apiKey: string;
     hostname: string;
     timeout: number;
-    protected constructor();
+    dispatcher: Dispatcher;
+    protected constructor(apiKey?: string, dispatcher?: Dispatcher);
     protected getUserAgent(): string;
     protected abstract apiKeyFromEnv(): string;
     protected abstract hostnameFromEnv(): string;

package/src/http/baseSettings.js

@@ -1,46 +1,18 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseSettings = void 0;
-const package_json_1 = require("../../package.json");
-const os = __importStar(require("os"));
-const apiSettings_1 = require("./apiSettings");
-class BaseSettings {
-    constructor() {
+import { getGlobalDispatcher } from "undici";
+import packageJson from "../../package.json" with { type: "json" };
+import * as os from "os";
+import { TIMEOUT_DEFAULT } from "./apiCore.js";
+export class BaseSettings {
+    constructor(apiKey, dispatcher) {
+        if (apiKey === undefined || !apiKey || apiKey.length === 0) {
+            this.apiKey = this.apiKeyFromEnv();
+        }
+        else {
+            this.apiKey = apiKey;
+        }
+        this.dispatcher = dispatcher ?? getGlobalDispatcher();
         this.hostname = this.hostnameFromEnv();
-        this.timeout = process.env.MINDEE_REQUEST_TIMEOUT ? parseInt(process.env.MINDEE_REQUEST_TIMEOUT) : apiSettings_1.TIMEOUT_DEFAULT;
+        this.timeout = process.env.MINDEE_REQUEST_TIMEOUT ? parseInt(process.env.MINDEE_REQUEST_TIMEOUT) : TIMEOUT_DEFAULT;
     }
     getUserAgent() {
         let platform = os.type().toLowerCase();
@@ -53,7 +25,6 @@ class BaseSettings {
         else if (platform.includes("bsd")) {
             platform = "bsd";
         }
-        return `mindee-api-nodejs@v${package_json_1.version} nodejs-${process.version} ${platform}`;
+        return `mindee-api-nodejs@v${packageJson.version} nodejs-${process.version} ${platform}`;
     }
 }
-exports.BaseSettings = BaseSettings;

package/src/http/index.d.ts

@@ -1,6 +1,3 @@
-export { Endpoint } from "./endpoint";
-export { EndpointResponse } from "./baseEndpoint";
-export { STANDARD_API_OWNER, API_KEY_ENVVAR_NAME, ApiSettings, } from "./apiSettings";
-export { MindeeHttpError, MindeeHttp400Error, MindeeHttp401Error, MindeeHttp403Error, MindeeHttp404Error, MindeeHttp413Error, MindeeHttp429Error, MindeeHttp500Error, MindeeHttp504Error, handleError, } from "./error";
-export { isValidSyncResponse, isValidAsyncResponse, cleanRequestData, } from "./responseValidation";
-export { PredictParams, WorkflowParams } from "./httpParams";
+export type { BaseHttpResponse } from "./apiCore.js";
+export { isValidSyncResponse, isValidAsyncResponse, cleanRequestData, } from "../v1/http/responseValidation.js";
+export { BaseSettings } from "./baseSettings.js";

package/src/http/index.js

@@ -1,24 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanRequestData = exports.isValidAsyncResponse = exports.isValidSyncResponse = exports.handleError = exports.MindeeHttp504Error = exports.MindeeHttp500Error = exports.MindeeHttp429Error = exports.MindeeHttp413Error = exports.MindeeHttp404Error = exports.MindeeHttp403Error = exports.MindeeHttp401Error = exports.MindeeHttp400Error = exports.MindeeHttpError = exports.ApiSettings = exports.API_KEY_ENVVAR_NAME = exports.STANDARD_API_OWNER = exports.Endpoint = void 0;
-var endpoint_1 = require("./endpoint");
-Object.defineProperty(exports, "Endpoint", { enumerable: true, get: function () { return endpoint_1.Endpoint; } });
-var apiSettings_1 = require("./apiSettings");
-Object.defineProperty(exports, "STANDARD_API_OWNER", { enumerable: true, get: function () { return apiSettings_1.STANDARD_API_OWNER; } });
-Object.defineProperty(exports, "API_KEY_ENVVAR_NAME", { enumerable: true, get: function () { return apiSettings_1.API_KEY_ENVVAR_NAME; } });
-Object.defineProperty(exports, "ApiSettings", { enumerable: true, get: function () { return apiSettings_1.ApiSettings; } });
-var error_1 = require("./error");
-Object.defineProperty(exports, "MindeeHttpError", { enumerable: true, get: function () { return error_1.MindeeHttpError; } });
-Object.defineProperty(exports, "MindeeHttp400Error", { enumerable: true, get: function () { return error_1.MindeeHttp400Error; } });
-Object.defineProperty(exports, "MindeeHttp401Error", { enumerable: true, get: function () { return error_1.MindeeHttp401Error; } });
-Object.defineProperty(exports, "MindeeHttp403Error", { enumerable: true, get: function () { return error_1.MindeeHttp403Error; } });
-Object.defineProperty(exports, "MindeeHttp404Error", { enumerable: true, get: function () { return error_1.MindeeHttp404Error; } });
-Object.defineProperty(exports, "MindeeHttp413Error", { enumerable: true, get: function () { return error_1.MindeeHttp413Error; } });
-Object.defineProperty(exports, "MindeeHttp429Error", { enumerable: true, get: function () { return error_1.MindeeHttp429Error; } });
-Object.defineProperty(exports, "MindeeHttp500Error", { enumerable: true, get: function () { return error_1.MindeeHttp500Error; } });
-Object.defineProperty(exports, "MindeeHttp504Error", { enumerable: true, get: function () { return error_1.MindeeHttp504Error; } });
-Object.defineProperty(exports, "handleError", { enumerable: true, get: function () { return error_1.handleError; } });
-var responseValidation_1 = require("./responseValidation");
-Object.defineProperty(exports, "isValidSyncResponse", { enumerable: true, get: function () { return responseValidation_1.isValidSyncResponse; } });
-Object.defineProperty(exports, "isValidAsyncResponse", { enumerable: true, get: function () { return responseValidation_1.isValidAsyncResponse; } });
-Object.defineProperty(exports, "cleanRequestData", { enumerable: true, get: function () { return responseValidation_1.cleanRequestData; } });
+export { isValidSyncResponse, isValidAsyncResponse, cleanRequestData, } from "../v1/http/responseValidation.js";
+export { BaseSettings } from "./baseSettings.js";

package/src/image/extractedImage.d.ts

@@ -0,0 +1,29 @@
+import { Buffer } from "node:buffer";
+import { BufferInput } from "../input/index.js";
+/**
+ * Generic class for image extraction
+ */
+export declare class ExtractedImage {
+    buffer: Buffer;
+    protected internalFileName: string;
+    protected constructor(buffer: Uint8Array, fileName: string);
+    /**
+     * Saves the document to a file.
+     *
+     * @param outputPath Path to save the file to.
+     */
+    saveToFileAsync(outputPath: string): Promise<void>;
+    /**
+     * Attempts to saves the document to a file synchronously.
+     * Throws an error if the file extension is not supported or if the file could not be saved to disk for some reason.
+     *
+     * @param outputPath Path to save the file to.
+     */
+    saveToFile(outputPath: string): void;
+    /**
+     * Return the file as a Mindee-compatible BufferInput source.
+     *
+     * @returns A BufferInput source.
+     */
+    asSource(): BufferInput;
+}

package/src/image/extractedImage.js

@@ -0,0 +1,99 @@
+import { Buffer } from "node:buffer";
+import { MindeeError } from "../errors/index.js";
+import { writeFileSync } from "node:fs";
+import { writeFile } from "fs/promises";
+import path from "node:path";
+import { BufferInput, MIMETYPES } from "../input/index.js";
+import { logger } from "../logger.js";
+import { loadOptionalDependency } from "../dependency/index.js";
+/**
+ * Generic class for image extraction
+ */
+export class ExtractedImage {
+    constructor(buffer, fileName) {
+        this.buffer = Buffer.from(buffer);
+        this.internalFileName = fileName;
+    }
+    /**
+     * Saves the document to a file.
+     *
+     * @param outputPath Path to save the file to.
+     */
+    async saveToFileAsync(outputPath) {
+        const fileExt = path.extname(outputPath).toLowerCase();
+        if (!MIMETYPES.has(fileExt)) {
+            throw new MindeeError(`Unsupported file extension: ${fileExt}`);
+        }
+        try {
+            let outputBuffer = this.buffer;
+            if (fileExt !== ".pdf") {
+                const popplerImport = await loadOptionalDependency("node-poppler", "Image Processing");
+                const poppler = popplerImport.default || popplerImport;
+                const popplerInstance = new poppler.Poppler();
+                const options = {
+                    firstPageToConvert: 1,
+                    lastPageToConvert: 1,
+                    singleFile: true,
+                };
+                if (fileExt === ".png") {
+                    options.pngFile = true;
+                }
+                else if (fileExt === ".jpg" || fileExt === ".jpeg") {
+                    options.jpegFile = true;
+                }
+                else if (fileExt === ".tiff" || fileExt === ".tif") {
+                    options.tiffFile = true;
+                }
+                const result = await popplerInstance.pdfToCairo(this.buffer, undefined, options);
+                outputBuffer = Buffer.from(result, "latin1");
+            }
+            await writeFile(path.resolve(outputPath), outputBuffer);
+            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;
+            }
+        }
+    }
+    /**
+     * Attempts to saves the document to a file synchronously.
+     * Throws an error if the file extension is not supported or if the file could not be saved to disk for some reason.
+     *
+     * @param outputPath Path to save the file to.
+     */
+    saveToFile(outputPath) {
+        const fileExt = path.extname(outputPath).toLowerCase();
+        if (fileExt !== ".pdf") {
+            throw new MindeeError(`Unsupported file extension: ${fileExt}. For image formats, use saveToFileAsync() instead.`);
+        }
+        else {
+            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.internalFileName,
+        });
+    }
+}

package/src/image/imageCompressor.js

@@ -0,0 +1,32 @@
+import { loadOptionalDependency } from "../dependency/index.js";
+import { MindeeImageError } from "../errors/index.js";
+/**
+ * Compresses an image with the given parameters.
+ *
+ * @param imageBuffer Buffer representation of an image.
+ * @param quality Quality to apply to the image (JPEG).
+ * @param maxWidth Maximum bound for width.
+ * @param maxHeight Maximum bound for height.
+ */
+export async function compressImage(imageBuffer, quality = 85, maxWidth = null, maxHeight = null) {
+    const sharpLoaded = await loadOptionalDependency("sharp", "Image compression");
+    const sharp = sharpLoaded.default || sharpLoaded;
+    let sharpImage = sharp(imageBuffer);
+    const metadata = await sharpImage.metadata();
+    if (metadata.width === undefined || metadata.height === undefined) {
+        throw new MindeeImageError("Source image has invalid dimensions.");
+    }
+    maxWidth ?? (maxWidth = metadata.width);
+    maxHeight ?? (maxHeight = metadata.height);
+    if (maxWidth || maxHeight) {
+        sharpImage = sharpImage.resize({
+            width: maxWidth,
+            height: maxHeight,
+            fit: "inside",
+            withoutEnlargement: true,
+        });
+    }
+    return await sharpImage
+        .jpeg({ quality: quality })
+        .toBuffer();
+}

package/src/image/imageExtractor.d.ts

@@ -0,0 +1,9 @@
+import type * as pdfLibTypes from "@cantoo/pdf-lib";
+import { Polygon } from "../geometry/index.js";
+/**
+ * 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.
+ */
+export declare function extractFromPage(pdfPage: pdfLibTypes.PDFPage, polygons: Polygon[]): Promise<Uint8Array<ArrayBufferLike>[]>;

package/src/image/imageExtractor.js

@@ -0,0 +1,93 @@
+import { getMinMaxX, getMinMaxY } from "../geometry/index.js";
+import { adjustForRotation } from "../geometry/polygonUtils.js";
+import { loadOptionalDependency } from "../dependency/index.js";
+let pdfLib = null;
+async function getPdfLib() {
+    if (!pdfLib) {
+        const pdfLibImport = await loadOptionalDependency("@cantoo/pdf-lib", "Text Embedding");
+        pdfLib = pdfLibImport.default || pdfLibImport;
+    }
+    return pdfLib;
+}
+/**
+ * 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.
+ */
+export async function extractFromPage(pdfPage, polygons) {
+    const pdfLib = await getPdfLib();
+    const { width, height } = pdfPage.getSize();
+    const extractedElements = [];
+    // Manual upscale.
+    // Fixes issues with the OCR.
+    const qualityScale = 300 / 72;
+    const orientation = pdfPage.getRotation().angle;
+    for (const origPolygon of polygons) {
+        const polygon = adjustForRotation(origPolygon, orientation);
+        const tempPdf = await pdfLib.PDFDocument.create();
+        const newWidth = width * (getMinMaxX(polygon).max - getMinMaxX(polygon).min);
+        const newHeight = height * (getMinMaxY(polygon).max - getMinMaxY(polygon).min);
+        const cropped = await tempPdf.embedPage(pdfPage, {
+            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;
+        }
+        else {
+            finalWidth = newWidth * qualityScale;
+            finalHeight = newHeight * qualityScale;
+        }
+        const samplePage = tempPdf.addPage([finalWidth, finalHeight]);
+        samplePage.drawRectangle({
+            x: 0,
+            y: 0,
+            width: finalWidth,
+            height: finalHeight,
+        });
+        // Draw the cropped page with rotation applied
+        if (orientation === 0) {
+            samplePage.drawPage(cropped, {
+                width: newWidth * qualityScale,
+                height: newHeight * qualityScale,
+            });
+        }
+        else if (orientation === 90) {
+            samplePage.drawPage(cropped, {
+                x: 0,
+                y: finalHeight,
+                width: newWidth * qualityScale,
+                height: newHeight * qualityScale,
+                rotate: pdfLib.degrees(270),
+            });
+        }
+        else if (orientation === 180) {
+            samplePage.drawPage(cropped, {
+                x: finalWidth,
+                y: finalHeight,
+                width: newWidth * qualityScale,
+                height: newHeight * qualityScale,
+                rotate: pdfLib.degrees(180),
+            });
+        }
+        else if (orientation === 270) {
+            samplePage.drawPage(cropped, {
+                x: finalWidth,
+                y: 0,
+                width: newWidth * qualityScale,
+                height: newHeight * qualityScale,
+                rotate: pdfLib.degrees(90),
+            });
+        }
+        extractedElements.push(await tempPdf.save());
+    }
+    return extractedElements;
+}

package/src/image/index.d.ts

@@ -0,0 +1,3 @@
+export { compressImage } from "./imageCompressor.js";
+export { ExtractedImage } from "./extractedImage.js";
+export { extractFromPage } from "./imageExtractor.js";

package/src/image/index.js

@@ -0,0 +1,3 @@
+export { compressImage } from "./imageCompressor.js";
+export { ExtractedImage } from "./extractedImage.js";
+export { extractFromPage } from "./imageExtractor.js";

package/src/index.d.ts

@@ -1,8 +1,10 @@
-export * as product from "./product";
-export { Client, PredictOptions, WorkflowOptions } from "./client";
-export { ClientV2, InferenceParameters, PollingOptions } from "./clientV2";
-export { AsyncPredictResponse, PredictResponse, Inference, Prediction, Document, Page, } from "./parsing/common";
-export { InferenceFile, InferenceResponse, JobResponse, RawText, RagMetadata, } from "./parsing/v2";
-export { InputSource, Base64Input, BufferInput, BytesInput, PathInput, StreamInput, UrlInput, PageOptions, PageOptionsOperation, LocalResponse } from "./input";
-export * as internal from "./internal";
-export * as imageOperations from "./imageOperations";
+export { InputSource, Base64Input, BufferInput, BytesInput, PathInput, StreamInput, UrlInput, PageOptionsOperation, } from "./input/index.js";
+export type { PageOptions } from "./input/index.js";
+export * as image from "./image/index.js";
+export * as pdf from "./pdf/index.js";
+export * as geometry from "./geometry/index.js";
+export * as v1 from "./v1/index.js";
+export * as v2 from "./v2/index.js";
+export * as product from "./v2/product/index.js";
+export { Client, JobResponse, ErrorResponse, } from "./v2/index.js";
+export type { PollingOptions } from "./v2/index.js";