mindee 2.0.0 → 2.1.0

package/src/inputs.js

@@ -0,0 +1,196 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BytesInput = exports.StreamInput = exports.Base64Input = exports.PathInput = exports.Input = exports.INPUT_TYPE_PATH = exports.INPUT_TYPE_BYTES = exports.INPUT_TYPE_BASE64 = exports.INPUT_TYPE_STREAM = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const fileType = __importStar(require("file-type"));
+const handler_1 = require("./errors/handler");
+const pdf_lib_1 = require("pdf-lib");
+const node_buffer_1 = require("node:buffer");
+const logger_1 = require("./logger");
+exports.INPUT_TYPE_STREAM = "stream";
+exports.INPUT_TYPE_BASE64 = "base64";
+exports.INPUT_TYPE_BYTES = "bytes";
+exports.INPUT_TYPE_PATH = "path";
+const MIMETYPES = new Map([
+    [".pdf", "application/pdf"],
+    [".heic", "image/heic"],
+    [".jpg", "image/jpeg"],
+    [".jpeg", "image/jpeg"],
+    [".png", "image/png"],
+    [".tif", "image/tiff"],
+    [".tiff", "image/tiff"],
+    [".webp", "image/webp"],
+]);
+const ALLOWED_INPUT_TYPES = [
+    exports.INPUT_TYPE_STREAM,
+    exports.INPUT_TYPE_BASE64,
+    exports.INPUT_TYPE_BYTES,
+    exports.INPUT_TYPE_PATH,
+];
+class Input {
+    /**
+     * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
+     *                             NB: dummy is only used for tests purposes
+     * @param {Boolean} cutPages
+     * NB: Because of async calls, init() should be called after creating the object
+     */
+    constructor({ inputType }) {
+        this.MAX_DOC_PAGES = 3;
+        this.filename = "";
+        this.mimeType = "";
+        this.fileObject = node_buffer_1.Buffer.alloc(0);
+        // Check if inputType is valid
+        if (!ALLOWED_INPUT_TYPES.includes(inputType)) {
+            const allowed = Array.from(MIMETYPES.keys()).join(", ");
+            handler_1.errorHandler.throw(new Error(`Invalid input type, must be one of ${allowed}.`));
+        }
+        this.inputType = inputType;
+        logger_1.logger.debug(`Loading file from: ${inputType}`);
+    }
+    async init() {
+        throw new Error("not Implemented");
+    }
+    isPdf() {
+        return this.mimeType === "application/pdf";
+    }
+    async checkMimetype() {
+        let mimeType;
+        const fileExt = path.extname(this.filename);
+        if (fileExt) {
+            mimeType = MIMETYPES.get(fileExt.toLowerCase()) || "";
+        }
+        else {
+            const guess = await fileType.fromBuffer(this.fileObject);
+            if (guess !== undefined) {
+                mimeType = guess.mime;
+            }
+            else {
+                throw "Could not determine the MIME type of the file";
+            }
+        }
+        if (!mimeType) {
+            const allowed = Array.from(MIMETYPES.keys()).join(", ");
+            const err = new Error(`Invalid file type, must be one of ${allowed}.`);
+            handler_1.errorHandler.throw(err);
+        }
+        logger_1.logger.debug(`File is of type: ${mimeType}`);
+        return mimeType;
+    }
+    async countPages() {
+        const pdfDocument = await pdf_lib_1.PDFDocument.load(this.fileObject, {
+            ignoreEncryption: true,
+        });
+        return pdfDocument.getPageCount();
+    }
+    /** Merge PDF pages */
+    async cutPdf() {
+        const currentPdf = await pdf_lib_1.PDFDocument.load(this.fileObject, {
+            ignoreEncryption: true,
+        });
+        const pdfLength = currentPdf.getPageCount();
+        if (pdfLength <= this.MAX_DOC_PAGES) {
+            return;
+        }
+        const newPdf = await pdf_lib_1.PDFDocument.create();
+        const pagesNumbers = [0, pdfLength - 2, pdfLength - 1].slice(0, this.MAX_DOC_PAGES);
+        logger_1.logger.debug(`Cutting PDF, keeping pages: ${pagesNumbers}`);
+        const pages = await newPdf.copyPages(currentPdf, pagesNumbers);
+        pages.forEach((page) => newPdf.addPage(page));
+        const data = await newPdf.save();
+        this.fileObject = node_buffer_1.Buffer.from(data);
+    }
+}
+exports.Input = Input;
+class PathInput extends Input {
+    constructor({ inputPath }) {
+        super({
+            inputType: exports.INPUT_TYPE_PATH,
+        });
+        this.inputPath = inputPath;
+        this.filename = path.basename(this.inputPath);
+    }
+    async init() {
+        logger_1.logger.debug(`Loading from: ${this.inputPath}`);
+        this.fileObject = node_buffer_1.Buffer.from(await fs_1.promises.readFile(this.inputPath));
+        this.mimeType = await this.checkMimetype();
+    }
+}
+exports.PathInput = PathInput;
+class Base64Input extends Input {
+    constructor({ inputString, filename }) {
+        super({
+            inputType: exports.INPUT_TYPE_BASE64,
+        });
+        this.filename = filename;
+        this.inputString = inputString;
+    }
+    async init() {
+        this.fileObject = node_buffer_1.Buffer.from(this.inputString, "base64");
+        this.mimeType = await this.checkMimetype();
+        // clear out the string
+        this.inputString = "";
+    }
+}
+exports.Base64Input = Base64Input;
+class StreamInput extends Input {
+    constructor({ inputStream, filename }) {
+        super({
+            inputType: exports.INPUT_TYPE_STREAM,
+        });
+        this.filename = filename;
+        this.inputStream = inputStream;
+    }
+    async init() {
+        this.fileObject = await this.stream2buffer(this.inputStream);
+        this.mimeType = await this.checkMimetype();
+    }
+    async stream2buffer(stream) {
+        return new Promise((resolve, reject) => {
+            const _buf = Array();
+            stream.on("data", (chunk) => _buf.push(chunk));
+            stream.on("end", () => resolve(node_buffer_1.Buffer.concat(_buf)));
+            stream.on("error", (err) => reject(`Error converting stream - ${err}`));
+        });
+    }
+}
+exports.StreamInput = StreamInput;
+class BytesInput extends Input {
+    constructor({ inputBytes, filename }) {
+        super({
+            inputType: exports.INPUT_TYPE_BYTES,
+        });
+        this.filename = filename;
+        this.inputBytes = inputBytes;
+    }
+    async init() {
+        this.fileObject = node_buffer_1.Buffer.from(this.inputBytes, "hex");
+        this.mimeType = await this.checkMimetype();
+        // clear out the string
+        this.inputBytes = "";
+    }
+}
+exports.BytesInput = BytesInput;

package/bin/mindee

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-
-require('../dist/src/cli').cli();

package/dist/package.json

@@ -1,70 +0,0 @@
-{
-    "name": "mindee",
-    "version": "2.0.0",
-    "description": "Mindee Client Library for Node.js",
-    "main": "src/index.js",
-    "license": "MIT",
-    "scripts": {
-        "build": "tsc --build",
-        "clean": "rm -rf ./dist",
-        "test": "mocha 'tests/**/*.spec.ts'",
-        "lint-fix": "eslint 'src/**/*.ts' --fix",
-        "lint": "eslint 'src/**/*.ts' --report-unused-disable-directives && echo 'Your .ts files look good.'",
-        "docs": "jsdoc -r src -d docs"
-    },
-    "files": [
-        "dist/",
-        "bin/",
-        "LICENSE",
-        "README.md",
-        "CHANGELOG.md"
-    ],
-    "engines": {
-        "node": ">= 14.0.0"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/mindee/mindee-api-nodejs.git"
-    },
-    "author": {
-        "name": "Mindee",
-        "email": "devrel@mindee.com",
-        "url": "https://mindee.com/"
-    },
-    "bugs": {
-        "url": "https://github.com/mindee/mindee-api-nodejs/issues"
-    },
-    "homepage": "https://mindee.com/",
-    "devDependencies": {
-        "@tsconfig/node16": "^1.0.3",
-        "@types/chai": "^4.3.1",
-        "@types/mocha": "^9.1.1",
-        "@types/node": "^17.0.38",
-        "@typescript-eslint/eslint-plugin": "^5.30.0",
-        "@typescript-eslint/parser": "^5.30.0",
-        "chai": "^4.3.6",
-        "eslint": "^8.18.0",
-        "eslint-config-prettier": "^8.5.0",
-        "eslint-plugin-prettier": "^4.1.0",
-        "jsdoc": "^3.6.10",
-        "mocha": "^10.0.0",
-        "prettier": "^2.7.1",
-        "ts-node": "^10.8.1",
-        "typescript": "^4.7.4"
-    },
-    "dependencies": {
-        "commander": "^9.4.0",
-        "file-type": "^16.5.4",
-        "form-data": "^3.0.1",
-        "mrz": "^3.1.4",
-        "pdf-lib": "^1.17.1"
-    },
-    "keywords": [
-        "typescript",
-        "mindee",
-        "api",
-        "client",
-        "client library",
-        "nodejs"
-    ]
-}

package/dist/src/api/index.d.ts

@@ -1,2 +0,0 @@
-export { Response, InvoiceResponse, ReceiptResponse, FinancialDocResponse, PassportResponse, CustomResponse, } from "./response";
-export { Endpoint, InvoiceEndpoint, ReceiptEndpoint, PassportEndpoint, CustomEndpoint, STANDARD_API_OWNER, API_KEY_ENVVAR_NAME, } from "./endpoint";

package/dist/src/cli.js

@@ -1,117 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cli = void 0;
-const commander_1 = require("commander");
-const documents_1 = require("./documents");
-const api_1 = require("./api");
-const client_1 = require("./client");
-const constants_1 = require("./constants");
-const program = new commander_1.Command();
-const COMMAND_INVOICE = "invoice";
-const COMMAND_RECEIPT = "receipt";
-const COMMAND_PASSPORT = "passport";
-const COMMAND_FINANCIAL = "financial";
-const COMMAND_CUSTOM = "custom";
-const CLI_COMMAND_CONFIG = new Map([
-    [COMMAND_INVOICE, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_INVOICE)],
-    [COMMAND_RECEIPT, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_RECEIPT)],
-    [COMMAND_PASSPORT, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_PASSPORT)],
-    [COMMAND_FINANCIAL, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_FINANCIAL)],
-    [COMMAND_CUSTOM, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_CUSTOM)],
-]);
-function predictCall(command, inputPath, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const conf = CLI_COMMAND_CONFIG.get(command);
-        if (conf === undefined) {
-            throw new Error(`Invalid document type ${command}`);
-        }
-        const mindeeClient = new client_1.Client({
-            apiKey: options.apiKey,
-            debug: options.debug,
-        });
-        if (command === COMMAND_CUSTOM) {
-            mindeeClient.addEndpoint({
-                accountName: options.user,
-                documentType: options.documentType,
-            });
-        }
-        const doc = mindeeClient.docFromPath(inputPath);
-        const params = {
-            docType: command === COMMAND_CUSTOM ? options.documentType : conf.docType,
-            username: command === COMMAND_CUSTOM ? options.user : api_1.STANDARD_API_OWNER,
-            cutPages: options.cutPages,
-            fullText: options.fullText,
-        };
-        // Tried setting the response by using the responseClass property in constants.PRODUCTS_CONFIG
-        // This compiled, but threw an exception:
-        //   TypeError: responseType is not a constructor
-        //
-        // So using a switch to explicitly set the response class parameter. Ugly, but works.
-        // Improvements welcome!
-        let response;
-        switch (command) {
-            case COMMAND_INVOICE:
-                response = yield doc.parse(api_1.InvoiceResponse, params);
-                break;
-            case COMMAND_RECEIPT:
-                response = yield doc.parse(api_1.ReceiptResponse, params);
-                break;
-            case COMMAND_FINANCIAL:
-                response = yield doc.parse(api_1.FinancialDocResponse, params);
-                break;
-            case COMMAND_PASSPORT:
-                response = yield doc.parse(api_1.PassportResponse, params);
-                break;
-            case COMMAND_CUSTOM:
-                response = yield doc.parse(api_1.CustomResponse, params);
-                break;
-            default:
-                throw `Unhandled command: ${command}`;
-        }
-        if (response.document) {
-            console.log(`\n${response.document}`);
-        }
-    });
-}
-function cli() {
-    program.name("mindee");
-    program.option("-d, --debug", "high verbosity mode");
-    CLI_COMMAND_CONFIG.forEach((info, name) => {
-        const prog = program.command(name);
-        prog.description(info.description);
-        prog.option("-k, --api-key <api_key>", "API key for document endpoint");
-        prog.option("-C, --no-cut-pages", "Don't cut document pages");
-        if (info.fullText) {
-            prog.option("-t, --full-text", "Include full document text in response");
-        }
-        if (name === COMMAND_CUSTOM) {
-            prog.requiredOption("-u, --user <username>", "API account name for the endpoint");
-            prog.option("-v, --version <version>", "API account name for the endpoint");
-            prog.argument("<endpoint_name>", "API endpoint name");
-        }
-        prog.argument("<input_path>", "Full path to the file");
-        if (name === COMMAND_CUSTOM) {
-            prog.action((endpointName, inputPath, options, command) => {
-                const allOptions = Object.assign(Object.assign(Object.assign({}, program.opts()), options), { documentType: endpointName });
-                predictCall(command.name(), inputPath, allOptions);
-            });
-        }
-        else {
-            prog.action((inputPath, options, command) => {
-                const allOptions = Object.assign(Object.assign(Object.assign({}, program.opts()), options), { endpointName: undefined });
-                predictCall(command.name(), inputPath, allOptions);
-            });
-        }
-    });
-    program.parse(process.argv);
-}
-exports.cli = cli;

package/dist/src/documents/document.d.ts

@@ -1,38 +0,0 @@
-import { Input } from "../inputs";
-import { FullText } from "../fields";
-export interface DocumentConstructorProps {
-    apiPrediction: {
-        [index: string]: any;
-    };
-    inputFile?: Input;
-    pageId?: number;
-    fullText?: FullText;
-}
-export declare class Document {
-    checklist: {
-        [index: string]: boolean;
-    };
-    mimeType: string | undefined;
-    filename: string;
-    filepath: string | undefined;
-    fullText?: FullText;
-    pageId?: number | undefined;
-    /**
-     * Takes a list of Documents and return one Document where
-     * each field is set with the maximum probability field
-     * @param {Input} inputFile - input file given to parse the document
-     * @param {number} pageId - Page ID for multi-page document
-     * @param {FullText} fullText - full OCR extracted text
-     */
-    constructor(inputFile?: Input, pageId?: number, fullText?: FullText);
-    clone(): any;
-    /** return true if all checklist of the document if true */
-    checkAll(): boolean;
-    /**
-     * Takes a list of Documents and return one Document where
-     * each field is set with the maximum probability field
-     * @param {Array<Document>} documents - A list of Documents
-     */
-    static mergePages(documents: any): any;
-    static cleanOutString(outStr: string): string;
-}

package/dist/src/documents/receipt.d.ts

@@ -1,24 +0,0 @@
-import { Document, DocumentConstructorProps } from "./document";
-import { TaxField, Field, Amount, Locale, Orientation, DateField } from "../fields";
-export declare class Receipt extends Document {
-    #private;
-    locale: Locale;
-    totalIncl: Amount;
-    date: DateField;
-    /** Receipt category as seen on the receipt. */
-    category: Field;
-    merchantName: Field;
-    time: Field;
-    orientation: Orientation | undefined;
-    totalTax: Amount;
-    totalExcl: Amount;
-    taxes: TaxField[];
-    /**
-     * @param {Object} apiPrediction - Json parsed prediction from HTTP response
-     * @param {Input} inputFile - input file given to parse the document
-     * @param {number} pageId - Page ID for multi-page document
-     * @param {FullText} fullText - full OCR extracted text
-     */
-    constructor({ apiPrediction, inputFile, fullText, pageId, }: DocumentConstructorProps);
-    toString(): string;
-}

package/dist/src/inputs.js

@@ -1,223 +0,0 @@
-"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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BytesInput = exports.StreamInput = exports.Base64Input = exports.PathInput = exports.Input = exports.INPUT_TYPE_PATH = exports.INPUT_TYPE_BYTES = exports.INPUT_TYPE_BASE64 = exports.INPUT_TYPE_STREAM = void 0;
-const fs_1 = require("fs");
-const path = __importStar(require("path"));
-const fileType = __importStar(require("file-type"));
-const handler_1 = require("./errors/handler");
-const pdf_lib_1 = require("pdf-lib");
-const node_buffer_1 = require("node:buffer");
-const logger_1 = require("./logger");
-exports.INPUT_TYPE_STREAM = "stream";
-exports.INPUT_TYPE_BASE64 = "base64";
-exports.INPUT_TYPE_BYTES = "bytes";
-exports.INPUT_TYPE_PATH = "path";
-const MIMETYPES = new Map([
-    [".pdf", "application/pdf"],
-    [".heic", "image/heic"],
-    [".jpg", "image/jpeg"],
-    [".jpeg", "image/jpeg"],
-    [".png", "image/png"],
-    [".tif", "image/tiff"],
-    [".tiff", "image/tiff"],
-    [".webp", "image/webp"],
-]);
-const ALLOWED_INPUT_TYPES = [
-    exports.INPUT_TYPE_STREAM,
-    exports.INPUT_TYPE_BASE64,
-    exports.INPUT_TYPE_BYTES,
-    exports.INPUT_TYPE_PATH,
-];
-class Input {
-    /**
-     * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
-     *                             NB: dummy is only used for tests purposes
-     * @param {Boolean} cutPages
-     * NB: Because of async calls, init() should be called after creating the object
-     */
-    constructor({ inputType }) {
-        this.MAX_DOC_PAGES = 3;
-        this.filename = "";
-        this.mimeType = "";
-        this.fileObject = node_buffer_1.Buffer.alloc(0);
-        // Check if inputType is valid
-        if (!ALLOWED_INPUT_TYPES.includes(inputType)) {
-            const allowed = Array.from(MIMETYPES.keys()).join(", ");
-            handler_1.errorHandler.throw(new Error(`Invalid input type, must be one of ${allowed}.`));
-        }
-        this.inputType = inputType;
-        logger_1.logger.debug(`Loading file from: ${inputType}`);
-    }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("not Implemented");
-        });
-    }
-    isPdf() {
-        return this.mimeType === "application/pdf";
-    }
-    checkMimetype() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let mimeType;
-            const fileExt = path.extname(this.filename);
-            if (fileExt) {
-                mimeType = MIMETYPES.get(fileExt.toLowerCase()) || "";
-            }
-            else {
-                const guess = yield fileType.fromBuffer(this.fileObject);
-                if (guess !== undefined) {
-                    mimeType = guess.mime;
-                }
-                else {
-                    throw "Could not determine the MIME type of the file";
-                }
-            }
-            if (!mimeType) {
-                const allowed = Array.from(MIMETYPES.keys()).join(", ");
-                const err = new Error(`Invalid file type, must be one of ${allowed}.`);
-                handler_1.errorHandler.throw(err);
-            }
-            logger_1.logger.debug(`File is of type: ${mimeType}`);
-            return mimeType;
-        });
-    }
-    countPages() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pdfDocument = yield pdf_lib_1.PDFDocument.load(this.fileObject, {
-                ignoreEncryption: true,
-            });
-            return pdfDocument.getPageCount();
-        });
-    }
-    /** Merge PDF pages */
-    cutPdf() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentPdf = yield pdf_lib_1.PDFDocument.load(this.fileObject, {
-                ignoreEncryption: true,
-            });
-            const pdfLength = currentPdf.getPageCount();
-            if (pdfLength <= this.MAX_DOC_PAGES) {
-                return;
-            }
-            const newPdf = yield pdf_lib_1.PDFDocument.create();
-            const pagesNumbers = [0, pdfLength - 2, pdfLength - 1].slice(0, this.MAX_DOC_PAGES);
-            logger_1.logger.debug(`Cutting PDF, keeping pages: ${pagesNumbers}`);
-            const pages = yield newPdf.copyPages(currentPdf, pagesNumbers);
-            pages.forEach((page) => newPdf.addPage(page));
-            const data = yield newPdf.save();
-            this.fileObject = node_buffer_1.Buffer.from(data);
-        });
-    }
-}
-exports.Input = Input;
-class PathInput extends Input {
-    constructor({ inputPath }) {
-        super({
-            inputType: exports.INPUT_TYPE_PATH,
-        });
-        this.inputPath = inputPath;
-        this.filename = path.basename(this.inputPath);
-    }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger_1.logger.debug(`Loading from: ${this.inputPath}`);
-            this.fileObject = node_buffer_1.Buffer.from(yield fs_1.promises.readFile(this.inputPath));
-            this.mimeType = yield this.checkMimetype();
-        });
-    }
-}
-exports.PathInput = PathInput;
-class Base64Input extends Input {
-    constructor({ inputString, filename }) {
-        super({
-            inputType: exports.INPUT_TYPE_BASE64,
-        });
-        this.filename = filename;
-        this.inputString = inputString;
-    }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.fileObject = node_buffer_1.Buffer.from(this.inputString, "base64");
-            this.mimeType = yield this.checkMimetype();
-            // clear out the string
-            this.inputString = "";
-        });
-    }
-}
-exports.Base64Input = Base64Input;
-class StreamInput extends Input {
-    constructor({ inputStream, filename }) {
-        super({
-            inputType: exports.INPUT_TYPE_STREAM,
-        });
-        this.filename = filename;
-        this.inputStream = inputStream;
-    }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.fileObject = yield this.stream2buffer(this.inputStream);
-            this.mimeType = yield this.checkMimetype();
-        });
-    }
-    stream2buffer(stream) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                const _buf = Array();
-                stream.on("data", (chunk) => _buf.push(chunk));
-                stream.on("end", () => resolve(node_buffer_1.Buffer.concat(_buf)));
-                stream.on("error", (err) => reject(`Error converting stream - ${err}`));
-            });
-        });
-    }
-}
-exports.StreamInput = StreamInput;
-class BytesInput extends Input {
-    constructor({ inputBytes, filename }) {
-        super({
-            inputType: exports.INPUT_TYPE_BYTES,
-        });
-        this.filename = filename;
-        this.inputBytes = inputBytes;
-    }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.fileObject = node_buffer_1.Buffer.from(this.inputBytes, "hex");
-            this.mimeType = yield this.checkMimetype();
-            // clear out the string
-            this.inputBytes = "";
-        });
-    }
-}
-exports.BytesInput = BytesInput;