mindee 1.3.0 → 1.3.3

package/CHANGELOG.md

@@ -1,102 +1,117 @@
 # CHANGELOG
 
+## v1.3.3
+
+### Fixes
+* 🐛 reject errors instead of printing them only to the console
+
+## v1.3.2
+
+### Fixes
+* 🐛 use PDF length instead of cut PDF size limit
+
+## v1.3.1
+
+### Fixes
+* 🐛 forward api error to stderr instead of stdout
+
 ## v1.3.0
 
 ### Changes
 
-- :sparkles: allow sending the filename for streams and base64
-- fixes :bug: not able to specify MIME type
-- :page_facing_up: change license to MIT
-- :white_check_mark: add node18 to tests
-- various package updates
+* :sparkles: allow sending the filename for streams and base64
+* fixes :bug: not able to specify MIME type
+* :page_facing_up: change license to MIT
+* :white_check_mark: add node18 to tests
+* various package updates
 
 ## v1.2.0
 
 ### Fixes
 
-- fix: 🐛 Get `words` values when `includeWords` parameter is `true`
+* fix: 🐛 Get `words` values when `includeWords` parameter is `true`
 
 ## v1.1.2
 
 ### Fixes
 
-- fix: 🐛 Fix returned probability value
-- fix: 🐛 Fix returned bbox value
+* fix: 🐛 Fix returned probability value
+* fix: 🐛 Fix returned bbox value
 
 ### new
 
-- new: ✨ New Mindee Invoice API V3 support
-- new: ✨ Add new supplier and customer fields
+* new: ✨ New Mindee Invoice API V3 support
+* new: ✨ Add new supplier and customer fields
 
 ## v1.1.0 (2022-01-03)
 
 ### new
 
-- chg: :sparkles: New Mindee API V2 support
-- chg: :zap: Server side invoice reconstruction from multi-page pdfs
-- new: :sparkles: Added OS in User-Agent headers
+* chg: :sparkles: New Mindee API V2 support
+* chg: :zap: Server side invoice reconstruction from multi-page pdfs
+* new: :sparkles: Added OS in User-Agent headers
 
 
 ## v1.0.9 (2021-12-09)
 
 ### Fixes
 
-- fix: 🐛 handle attribute of type array when merging pages
+* fix: 🐛 handle attribute of type array when merging pages
 
 ## v1.0.8 (2021-11-29)
 
 ### Fixes
 
-- 🐛 fix cutPDF for ReadableStream + add it for base64 file string
-- 🐛 Updated api Input initialization to specifically declare parameters
-- 🐛 prevent error when the mime type isn't detectable
-- 🐛 raise proper error when the APi doesn't return a valid JSON
+* 🐛 fix cutPDF for ReadableStream + add it for base64 file string
+* 🐛 Updated api Input initialization to specifically declare parameters
+* 🐛 prevent error when the mime type isn't detectable
+* 🐛 raise proper error when the APi doesn't return a valid JSON
 
 ### new
 
-- :see_no_evil: add .DS_Store to ignore file
+* :see_no_evil: add .DS_Store to ignore file
 
 ## v1.0.7 (2021-11-25)
 
 ### New
 
-- ✨ Added pdf page number parameter for multi-pages pdfs with file
+* ✨ Added pdf page number parameter for multi-pages pdfs with file
 
 ### Changes
 
-- :arrow_up: upgrade path-parse dependency
-- :arrow_up: upgrade browserslist dependency
-- :arrow_up: upgrade lodash dependency
-- :arrow_up: upgrade y18n dependency
+* :arrow_up: upgrade path-parse dependency
+* :arrow_up: upgrade browserslist dependency
+* :arrow_up: upgrade lodash dependency
+* :arrow_up: upgrade y18n dependency
 
 ## v1.0.4 (2021-02-18)
 
 ### New
 
-- :sparkles: :zap: Add a parameter `filename` and a default filename for streams
+* :sparkles: :zap: Add a parameter `filename` and a default filename for streams
 
 ### Changes
 
-- :zap: Change parse function to use an object instead of multiples parameters
+* :zap: Change parse function to use an object instead of multiples parameters
 
 ## v1.0.3 (2021-02-01)
 
 ### Fixes
 
-- :bug: \_request parameters
-- :bug: `pageNumber` default value
-- :bug: reconstruction method set fields to probability
+* :bug: \_request parameters
+* :bug: `pageNumber` default value
+* :bug: reconstruction method set fields to probability
 
 ## v1.0.2 (2021-02-01)
 
 ### Changes
 
-- :zap: Better coverage for total tax
+* :zap: Better coverage for total tax
 
 ### Fixes
 
-- :bug: `includeWords` is now working
+* :bug: `includeWords` is now working
 
 ## v1.0.1 (2021-01-11)
 
-- 🎉 First release
+* 🎉 First release

package/dist/api/financialDocument.js

@@ -0,0 +1,51 @@
+"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.APIFinancialDocument = void 0;
+const object_1 = require("@api/object");
+const inputs_1 = require("@mindee/inputs");
+class APIFinancialDocument extends object_1.APIObject {
+    constructor(invoiceToken, receiptToken) {
+        super(undefined, "financialDocument");
+        this.invoiceToken = invoiceToken;
+        this.receiptToken = receiptToken;
+        this.invoiceToken = invoiceToken;
+        this.receiptToken = receiptToken;
+    }
+    /**
+     * @param {String} file: Receipt filepath (allowed jpg, png, tiff, pdf)
+     * @param {String} inputType: String in {'path', 'stream', 'base64'}
+     * @param {Boolean} includeWords: extract all words into http_response
+     * @param {String} version: expense_receipt api version
+     * @param {Boolean} cutPdf: Automatically reconstruct pdf with more than 4 pages
+     * @returns {Response} Wrapped response with Receipts objects parsed
+     */
+    parse({ input, inputType = "path", filename = undefined, version = "3", cutPdf = true, includeWords = false, }) {
+        const _super = Object.create(null, {
+            parse: { get: () => super.parse },
+            _request: { get: () => super._request }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const inputFile = new inputs_1.Input(input, inputType, cutPdf, filename);
+            yield inputFile.init();
+            this.apiToken =
+                inputFile.fileExtension === "application/pdf"
+                    ? this.invoiceToken
+                    : this.receiptToken;
+            const url = inputFile.fileExtension === "application/pdf"
+                ? `/invoices/v${version}/predict`
+                : `/expense_receipts/v${version}/predict`;
+            _super.parse.call(this);
+            return _super._request.call(this, url, inputFile, includeWords);
+        });
+    }
+}
+exports.APIFinancialDocument = APIFinancialDocument;

package/dist/api/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIInvoice = exports.request = exports.Response = exports.APIReceipt = exports.APIObject = void 0;
+var object_1 = require("@api/object");
+Object.defineProperty(exports, "APIObject", { enumerable: true, get: function () { return object_1.APIObject; } });
+var receipt_1 = require("@api/receipt");
+Object.defineProperty(exports, "APIReceipt", { enumerable: true, get: function () { return receipt_1.APIReceipt; } });
+var response_1 = require("@api/response");
+Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return response_1.Response; } });
+var request_1 = require("@api/request");
+Object.defineProperty(exports, "request", { enumerable: true, get: function () { return request_1.request; } });
+var invoice_1 = require("@api/invoice");
+Object.defineProperty(exports, "APIInvoice", { enumerable: true, get: function () { return invoice_1.APIInvoice; } });

package/dist/api/invoice.js

@@ -0,0 +1,59 @@
+"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.APIInvoice = void 0;
+const object_1 = require("@api/object");
+const inputs_1 = require("@mindee/inputs");
+class APIInvoice extends object_1.APIObject {
+    constructor(apiToken = undefined) {
+        super(apiToken, "invoice");
+        this.apiToken = apiToken;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore TO DO : FIX
+        this.baseUrl = `${this.baseUrl}/invoices/`;
+    }
+    /**
+     * @param {Boolean} includeWords: , extract all words into http_response
+     * @param {Boolean} cutPdf: Automatically reconstruct pdf with more than 4 pages
+     * @param {String} inputType: String in {'path', 'stream', 'base64'}
+     * @param {String} file: Receipt filepath (allowed jpg, png, tiff, pdf)
+     * @param {String} version: expense_receipt api version
+     * @returns {Response} Wrapped response with Receipts objects parsed
+     */
+    parse({ input, inputType = "path", filename = undefined, version = "3", cutPdf = true, includeWords = false, }) {
+        const _super = Object.create(null, {
+            parse: { get: () => super.parse },
+            _request: { get: () => super._request }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.parse.call(this);
+            const inputFile = new inputs_1.Input(input, inputType, cutPdf, filename);
+            yield inputFile.init();
+            const url = `v${version}/predict`;
+            return yield _super._request.call(this, url, inputFile, includeWords);
+        });
+    }
+    /**
+      @param {String} inputFile - Input object
+      @param {} response - HTTP response
+      @param {Document} documentType - Document class in {"Receipt", "Invoice", "Financial_document"}
+      @returns {Response}
+    */
+    wrapResponse(inputFile, response, documentType) {
+        var _a, _b, _c, _d, _e;
+        const result = super.wrapResponse(inputFile, response, documentType);
+        result.documentType =
+            ((_e = (_d = (_c = (_b = (_a = result.httpResponse.data) === null || _a === void 0 ? void 0 : _a.predictions) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.document_type) === null || _d === void 0 ? void 0 : _d.value) === null || _e === void 0 ? void 0 : _e.toLowerCase()) ||
+                result.documentType;
+        return result;
+    }
+}
+exports.APIInvoice = APIInvoice;

package/dist/api/object.js

@@ -0,0 +1,80 @@
+"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.APIObject = void 0;
+const response_1 = require("@api/response");
+const handler_1 = require("@errors/handler");
+const request_1 = require("@api/request");
+/**
+ * Base class for APIs (APIReceipt & APIInvoice)
+ *  @param {String} apiToken - Token of the API used for parsing document
+ *  @param {String} apiName - Name of the API used for parsing document
+ */
+class APIObject {
+    constructor(apiToken = undefined, apiName = "") {
+        this.apiToken = apiToken;
+        this.apiName = apiName;
+        this.apiToken = apiToken;
+        this.baseUrl = "https://api.mindee.net/v1/products/mindee";
+        this.apiName = apiName;
+    }
+    /**
+     */
+    parse() {
+        if (!this.apiToken) {
+            handler_1.errorHandler.throw({
+                error: new Error(`Missing API token for ${this.apiName}. \
+          Have you create a mindee Client with a ${this.apiName}Token in parameters ?`),
+            });
+        }
+    }
+    /**
+      @param {String} url - API url for request
+      @param {Input} inputFile - input file for API
+      @param {Boolean} includeWords - Include Mindee vision words in Response
+      @returns {Response}
+    */
+    _request(url, inputFile, includeWords = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = {
+                "X-Inferuser-Token": this.apiToken,
+            };
+            const response = yield (0, request_1.request)(`${this.baseUrl}${url}`, "POST", headers, inputFile, includeWords);
+            return this.wrapResponse(inputFile, response, this.apiName);
+        });
+    }
+    /**
+      @param {String} inputFile - Input object
+      @param {} response - HTTP response
+      @param {Document} documentType - Document class in {"Receipt", "Invoice", "Financial_document"}
+      @returns {Response}
+    */
+    wrapResponse(inputFile, response, documentType) {
+        if (response.statusCode > 201) {
+            const errorMessage = JSON.stringify(response.data, null, 4);
+            handler_1.errorHandler.throw(new Error(`${this.apiName} API ${response.statusCode} HTTP error: ${errorMessage}`));
+            return new response_1.Response({
+                httpResponse: response,
+                documentType: documentType,
+                document: undefined,
+                input: inputFile,
+                error: true,
+            });
+        }
+        return new response_1.Response({
+            httpResponse: response,
+            documentType: documentType,
+            document: inputFile,
+            input: inputFile,
+        });
+    }
+}
+exports.APIObject = APIObject;

package/dist/api/receipt.js

@@ -0,0 +1,45 @@
+"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.APIReceipt = void 0;
+const object_1 = require("@api/object");
+const inputs_1 = require("@mindee/inputs");
+class APIReceipt extends object_1.APIObject {
+    constructor(apiToken = undefined) {
+        super(apiToken, "receipt");
+        this.apiToken = apiToken;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore TO DO : FIX
+        this.baseUrl = `${this.baseUrl}/expense_receipts/`;
+    }
+    /**
+     * @param {String} file: Receipt filepath (allowed jpg, png, tiff, pdf)
+     * @param {String} inputType: String in {'path', 'stream', 'base64'}
+     * @param {Boolean} includeWords: extract all words into http_response
+     * @param {String} version: expense_receipt api version
+     * @param {Boolean} cutPdf: Automatically reconstruct pdf with more than 4 pages
+     * @returns {Response} Wrapped response with Receipts objects parsed
+     */
+    parse({ input, inputType = "path", filename = undefined, version = "3", cutPdf = true, includeWords = false, }) {
+        const _super = Object.create(null, {
+            parse: { get: () => super.parse },
+            _request: { get: () => super._request }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.parse.call(this);
+            const inputFile = new inputs_1.Input(input, inputType, cutPdf, filename);
+            yield inputFile.init();
+            const url = `v${version}/predict`;
+            return yield _super._request.call(this, url, inputFile, includeWords);
+        });
+    }
+}
+exports.APIReceipt = APIReceipt;

package/dist/api/request.js

@@ -0,0 +1,90 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.request = void 0;
+const https = __importStar(require("https"));
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const package_json_1 = require("../../package.json");
+const url_1 = require("url");
+const form_data_1 = __importDefault(require("form-data"));
+const os = __importStar(require("os"));
+const request = (url, method, headers, input, includeWords = false) => {
+    return new Promise(function (resolve, reject) {
+        const form = new form_data_1.default();
+        let body;
+        headers["User-Agent"] = `mindee-api-nodejs@v${package_json_1.version} nodejs-${process.version} ${os.type().toLowerCase()}`;
+        if (["path", "stream"].includes(input.inputType)) {
+            const fileParams = { filename: input.filename };
+            form.append("document", input.fileObject, fileParams);
+            if (includeWords)
+                form.append("include_mvision", "true");
+            headers = Object.assign(Object.assign({}, headers), form.getHeaders());
+        }
+        else if (input.inputType === "base64") {
+            const body_obj = { document: input.fileObject };
+            if (includeWords)
+                body_obj["include_mvision"] = "true";
+            body = JSON.stringify(body_obj);
+            headers["Content-Type"] = "application/json";
+            headers["Content-Length"] = body.length;
+        }
+        const uri = new url_1.URL(url);
+        const options = {
+            method: method,
+            headers: headers,
+            hostname: uri.hostname,
+            path: `${uri.pathname}${uri.search}`,
+        };
+        const req = https.request(options, function (res) {
+            let responseBody = [];
+            res.on("data", function (chunk) {
+                responseBody += chunk;
+            });
+            res.on("end", function () {
+                try {
+                    resolve(Object.assign(Object.assign({}, res), { data: JSON.parse(responseBody) }));
+                }
+                catch (error) {
+                    console.log(responseBody, error);
+                }
+            });
+        });
+        req.on("error", (err) => {
+            reject(err);
+        });
+        if (["path", "stream"].includes(input.inputType)) {
+            form.pipe(req);
+        }
+        if (input.inputType === "base64") {
+            req.write(body);
+            req.end();
+        }
+    });
+};
+exports.request = request;

package/dist/api/response.js

@@ -0,0 +1,91 @@
+"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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = void 0;
+const receipt_1 = require("@documents/receipt");
+const invoice_1 = require("@documents/invoice");
+const financialDocument_1 = require("@documents/financialDocument");
+const promises_1 = __importDefault(require("fs/promises"));
+class Response {
+    constructor(_a) {
+        var { httpResponse, documentType, input, error, reconsctruted = false } = _a, args = __rest(_a, ["httpResponse", "documentType", "input", "error", "reconsctruted"]);
+        this.httpResponse = httpResponse;
+        this.documentType = documentType;
+        this.input = input;
+        if (!error && !reconsctruted)
+            this.formatResponse();
+        if (reconsctruted === true) {
+            Object.assign(this, args);
+        }
+    }
+    dump(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield promises_1.default.writeFile(path, JSON.stringify(Object.entries(this)));
+        });
+    }
+    static load(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = promises_1.default.readFile(path);
+            const args = JSON.parse(file);
+            return new Response(Object.assign({ reconsctruted: true }, args));
+        });
+    }
+    formatResponse() {
+        const http_data_document = this.httpResponse.data.document;
+        const constructors = {
+            receipt: (params) => new receipt_1.Receipt(params),
+            invoice: (params) => new invoice_1.Invoice(params),
+            financialDocument: (params) => new financialDocument_1.FinancialDocument(params),
+        };
+        const predictions = http_data_document.inference.pages.entries();
+        this[`${this.documentType}s`] = [];
+        const document_words_content = [];
+        // Create a list of Document (Receipt, Invoice...) for each page of the input document
+        for (const [pageNumber, prediction] of predictions) {
+            let page_words_content = [];
+            if ("ocr" in http_data_document &&
+                Object.keys(http_data_document.ocr).length > 0) {
+                page_words_content =
+                    http_data_document.ocr["mvision-v1"].pages[pageNumber].all_words;
+                document_words_content.push(...http_data_document.ocr["mvision-v1"].pages[pageNumber].all_words);
+            }
+            this[`${this.documentType}s`].push(constructors[this.documentType]({
+                apiPrediction: prediction.prediction,
+                inputFile: this.input,
+                pageNumber: pageNumber,
+                words: page_words_content,
+            }));
+        }
+        // Merge the list of Document into a unique Document
+        this[this.documentType] = constructors[this.documentType]({
+            apiPrediction: http_data_document.inference.prediction,
+            inputFile: this.input,
+            pageNumber: http_data_document.n_pages,
+            level: "document",
+            words: document_words_content,
+        });
+    }
+}
+exports.Response = Response;

package/dist/documents/document.js

@@ -0,0 +1,80 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Document = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+class Document {
+    /**
+     * 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
+     */
+    constructor(inputFile = undefined) {
+        this.filepath = undefined;
+        this.filename = undefined;
+        this.fileExtension = undefined;
+        if (inputFile != undefined) {
+            this.filepath = inputFile.filepath;
+            this.filename = inputFile.filename;
+            this.fileExtension = inputFile.fileExtension;
+        }
+        this.checklist = {};
+    }
+    clone() {
+        return JSON.parse(JSON.stringify(this));
+    }
+    /** return true if all checklist of the document if true */
+    checkAll() {
+        return this.checklist.every((item) => item == true);
+    }
+    /** Export document into a JSON file */
+    dump(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield promises_1.default.writeFile(path, JSON.stringify(Object.entries(this)));
+        });
+    }
+    /** Create a Document from a JSON file */
+    static load(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = promises_1.default.readFile(path);
+            const args = JSON.parse(file);
+            return new Document(Object.assign({ reconsctruted: true }, args));
+        });
+    }
+    /**
+     * 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) {
+        var _a, _b;
+        const finalDocument = documents[0].clone();
+        const attributes = Object.getOwnPropertyNames(finalDocument);
+        for (const document of documents) {
+            for (const attribute of attributes) {
+                if (Array.isArray(document === null || document === void 0 ? void 0 : document[attribute])) {
+                    finalDocument[attribute] = ((_a = finalDocument[attribute]) === null || _a === void 0 ? void 0 : _a.length)
+                        ? finalDocument[attribute]
+                        : document === null || document === void 0 ? void 0 : document[attribute];
+                }
+                else if (((_b = document === null || document === void 0 ? void 0 : document[attribute]) === null || _b === void 0 ? void 0 : _b.probability) >
+                    finalDocument[attribute].probability) {
+                    finalDocument[attribute] = document === null || document === void 0 ? void 0 : document[attribute];
+                }
+            }
+        }
+        return finalDocument;
+    }
+}
+exports.Document = Document;