mindee 1.4.0 → 2.0.0

package/dist/src/api/response.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PassportResponse = exports.FinancialDocResponse = exports.ReceiptResponse = exports.InvoiceResponse = exports.StandardProductResponse = exports.CustomResponse = exports.Response = void 0;
+const documents_1 = require("../documents");
+const fields_1 = require("../fields");
+/**
+ * Base class for all responses.
+ */
+class Response {
+    constructor(params) {
+        this.pages = [];
+        this.httpResponse = params.httpResponse;
+        this.documentType = params.documentType;
+        this.inputFile = params.input;
+    }
+    getPageText(httpDataDocument, pageId) {
+        const pageText = new fields_1.FullText();
+        if ("ocr" in httpDataDocument &&
+            Object.keys(httpDataDocument.ocr).length > 0) {
+            pageText.words =
+                httpDataDocument.ocr["mvision-v1"].pages[pageId].all_words;
+        }
+        return pageText;
+    }
+}
+exports.Response = Response;
+/**
+ * Class for all constructed (API Builder) endpoint responses.
+ */
+class CustomResponse extends Response {
+    constructor(params) {
+        super(params);
+        if (!params.error) {
+            this.formatResponse();
+        }
+    }
+    formatResponse() {
+        const httpDataDocument = this.httpResponse.data.document;
+        httpDataDocument.inference.pages.forEach((apiPage) => {
+            this.pages.push(new documents_1.CustomDocument({
+                apiPrediction: apiPage.prediction,
+                inputFile: this.inputFile,
+                pageId: apiPage.id,
+                documentType: this.documentType,
+            }));
+        });
+        this.document = new documents_1.CustomDocument({
+            apiPrediction: httpDataDocument.inference.prediction,
+            inputFile: this.inputFile,
+            documentType: this.documentType,
+        });
+    }
+}
+exports.CustomResponse = CustomResponse;
+/**
+ * Generic class for all standard (Off-the-Shelf) endpoint responses.
+ */
+class StandardProductResponse extends Response {
+    constructor(documentClass, params) {
+        super(params);
+        this.documentClass = documentClass;
+        if (!params.error) {
+            this.formatResponse();
+        }
+    }
+    formatResponse() {
+        const httpDataDocument = this.httpResponse.data.document;
+        httpDataDocument.inference.pages.forEach((apiPage) => {
+            const pageText = this.getPageText(httpDataDocument, apiPage.id);
+            this.pages.push(new this.documentClass({
+                apiPrediction: apiPage.prediction,
+                inputFile: this.inputFile,
+                pageId: apiPage.id,
+                fullText: pageText,
+            }));
+        });
+        this.document = new this.documentClass({
+            apiPrediction: httpDataDocument.inference.prediction,
+            inputFile: this.inputFile,
+        });
+    }
+}
+exports.StandardProductResponse = StandardProductResponse;
+class InvoiceResponse extends StandardProductResponse {
+    constructor(params) {
+        super(documents_1.Invoice, params);
+    }
+}
+exports.InvoiceResponse = InvoiceResponse;
+class ReceiptResponse extends StandardProductResponse {
+    constructor(params) {
+        super(documents_1.Receipt, params);
+    }
+}
+exports.ReceiptResponse = ReceiptResponse;
+class FinancialDocResponse extends StandardProductResponse {
+    constructor(params) {
+        super(documents_1.FinancialDocument, params);
+    }
+}
+exports.FinancialDocResponse = FinancialDocResponse;
+class PassportResponse extends StandardProductResponse {
+    constructor(params) {
+        super(documents_1.Passport, params);
+    }
+}
+exports.PassportResponse = PassportResponse;

package/dist/src/cli.d.ts

@@ -0,0 +1 @@
+export declare function cli(): void;

package/dist/src/cli.js

@@ -0,0 +1,117 @@
+"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/client.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+import { Input } from "./inputs";
+import { Response } from "./api";
+import { Document } from "./documents";
+import { DocumentConfig, responseSig } from "./documents/documentConfig";
+import { ReadStream } from "fs";
+declare type DocConfigs = Map<string[], DocumentConfig>;
+interface PredictOptions {
+    docType?: string;
+    username?: string;
+    cutPages?: boolean;
+    fullText?: boolean;
+}
+declare class DocumentClient {
+    inputDoc: Input;
+    docConfigs: DocConfigs;
+    constructor(inputDoc: Input, docConfigs: DocConfigs);
+    parse<RespType extends Response<Document>>(responseClass: responseSig<RespType>, params?: PredictOptions): Promise<RespType>;
+    protected getDocType(responseClass: string): string;
+}
+interface customConfigParams {
+    accountName: string;
+    documentType: string;
+    version?: string;
+}
+interface ClientOptions {
+    apiKey?: string;
+    throwOnError?: boolean;
+    debug?: boolean;
+}
+/**
+ * Mindee Client
+ */
+export declare class Client {
+    readonly docConfigs: DocConfigs;
+    protected apiKey: string;
+    /**
+     * @param options
+     */
+    constructor(options?: ClientOptions);
+    protected addStandardEndpoints(): void;
+    addEndpoint({ accountName, documentType, version, }: customConfigParams): this;
+    docFromPath(inputPath: string): DocumentClient;
+    docFromBase64(inputString: string, filename: string): DocumentClient;
+    docFromStream(inputStream: ReadStream, filename: string): DocumentClient;
+    docFromBytes(inputBytes: string, filename: string): DocumentClient;
+}
+export {};

package/dist/src/client.js

@@ -0,0 +1,134 @@
+"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.Client = void 0;
+const inputs_1 = require("./inputs");
+const api_1 = require("./api");
+const documents_1 = require("./documents");
+const documentConfig_1 = require("./documents/documentConfig");
+const handler_1 = require("./errors/handler");
+const logger_1 = require("./logger");
+const constants_1 = require("./constants");
+class DocumentClient {
+    constructor(inputDoc, docConfigs) {
+        this.inputDoc = inputDoc;
+        this.docConfigs = docConfigs;
+    }
+    parse(responseClass, params = {
+        docType: "",
+        username: "",
+        cutPages: true,
+        fullText: false,
+    }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // seems like there should be a better way of doing this
+            const fullText = (params === null || params === void 0 ? void 0 : params.fullText) !== undefined ? params.fullText : false;
+            const cutPages = (params === null || params === void 0 ? void 0 : params.cutPages) !== undefined ? params.cutPages : true;
+            const docType = params.docType === undefined || params.docType === ""
+                ? this.getDocType(responseClass.name)
+                : params.docType;
+            const found = [];
+            this.docConfigs.forEach((config, configKey) => {
+                if (configKey[1] === docType) {
+                    found.push(configKey);
+                }
+            });
+            if (found.length === 0) {
+                throw `Document type not configured: '${docType}'`;
+            }
+            let configKey = [];
+            if (found.length === 1) {
+                configKey = found[0];
+            }
+            else if (params.username) {
+                configKey = [params.username, docType];
+            }
+            const docConfig = this.docConfigs.get(configKey);
+            if (docConfig === undefined) {
+                // TODO: raise error printing all usernames
+                throw `Couldn't find the config '${configKey}'`;
+            }
+            return yield docConfig.predict(responseClass, {
+                inputDoc: this.inputDoc,
+                includeWords: fullText,
+                cutPages: cutPages,
+            });
+        });
+    }
+    getDocType(responseClass) {
+        return constants_1.ProductConfigs.getByResponseClassName(responseClass).docType;
+    }
+}
+/**
+ * Mindee Client
+ */
+class Client {
+    /**
+     * @param options
+     */
+    constructor(options) {
+        const throwOnError = (options === null || options === void 0 ? void 0 : options.throwOnError) === undefined ? true : options.throwOnError;
+        const debug = (options === null || options === void 0 ? void 0 : options.debug) === undefined ? false : options.debug;
+        this.apiKey = (options === null || options === void 0 ? void 0 : options.apiKey) === undefined ? "" : options.apiKey;
+        this.docConfigs = new Map();
+        handler_1.errorHandler.throwOnError = throwOnError;
+        logger_1.logger.level =
+            (debug !== null && debug !== void 0 ? debug : process.env.MINDEE_DEBUG)
+                ? logger_1.LOG_LEVELS["debug"]
+                : logger_1.LOG_LEVELS["warn"];
+        logger_1.logger.debug("Client initialized");
+        this.addStandardEndpoints();
+    }
+    // TODO: init only those endpoints we actually need.
+    addStandardEndpoints() {
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.DOC_TYPE_INVOICE], new documentConfig_1.InvoiceConfig(this.apiKey));
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.DOC_TYPE_RECEIPT], new documentConfig_1.ReceiptConfig(this.apiKey));
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.DOC_TYPE_FINANCIAL], new documentConfig_1.FinancialDocConfig(this.apiKey));
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.DOC_TYPE_PASSPORT], new documentConfig_1.PassportConfig(this.apiKey));
+    }
+    addEndpoint({ accountName, documentType, version = "1", }) {
+        this.docConfigs.set([accountName, documentType], new documentConfig_1.CustomDocConfig({
+            accountName: accountName,
+            documentType: documentType,
+            version: version,
+            apiKey: this.apiKey,
+        }));
+        return this;
+    }
+    docFromPath(inputPath) {
+        const doc = new inputs_1.PathInput({
+            inputPath: inputPath,
+        });
+        return new DocumentClient(doc, this.docConfigs);
+    }
+    docFromBase64(inputString, filename) {
+        const doc = new inputs_1.Base64Input({
+            inputString: inputString,
+            filename: filename,
+        });
+        return new DocumentClient(doc, this.docConfigs);
+    }
+    docFromStream(inputStream, filename) {
+        const doc = new inputs_1.StreamInput({
+            inputStream: inputStream,
+            filename: filename,
+        });
+        return new DocumentClient(doc, this.docConfigs);
+    }
+    docFromBytes(inputBytes, filename) {
+        const doc = new inputs_1.BytesInput({
+            inputBytes: inputBytes,
+            filename: filename,
+        });
+        return new DocumentClient(doc, this.docConfigs);
+    }
+}
+exports.Client = Client;

package/dist/src/constants.d.ts

@@ -0,0 +1,13 @@
+import { Response } from "./api";
+import { Document } from "./documents";
+export interface ProductConfig {
+    description: string;
+    docType: string;
+    responseClass: typeof Response<Document>;
+    fullText: boolean;
+}
+export declare class ProductConfigs {
+    private static configs;
+    static getByResponseClassName(responseClass: string): ProductConfig;
+    static getByDocType(docType: string): ProductConfig;
+}

package/dist/src/constants.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductConfigs = void 0;
+const api_1 = require("./api");
+const documents_1 = require("./documents");
+class ProductConfigs {
+    static getByResponseClassName(responseClass) {
+        const config = this.configs.find((element) => element.responseClass.name === responseClass);
+        if (config === undefined) {
+            throw `Unknown response class: ${responseClass}`;
+        }
+        return config;
+    }
+    static getByDocType(docType) {
+        const config = this.configs.find((element) => element.docType === docType);
+        if (config === undefined) {
+            throw `Unknown document type: ${docType}`;
+        }
+        return config;
+    }
+}
+exports.ProductConfigs = ProductConfigs;
+ProductConfigs.configs = [
+    {
+        description: "Invoice",
+        docType: documents_1.DOC_TYPE_INVOICE,
+        responseClass: api_1.InvoiceResponse,
+        fullText: true,
+    },
+    {
+        description: "Expense Receipt",
+        docType: documents_1.DOC_TYPE_RECEIPT,
+        responseClass: api_1.ReceiptResponse,
+        fullText: true,
+    },
+    {
+        description: "Passport",
+        docType: documents_1.DOC_TYPE_PASSPORT,
+        responseClass: api_1.PassportResponse,
+        fullText: false,
+    },
+    {
+        description: "Financial Document (receipt or invoice)",
+        docType: documents_1.DOC_TYPE_FINANCIAL,
+        responseClass: api_1.FinancialDocResponse,
+        fullText: true,
+    },
+    {
+        description: "A custom document",
+        docType: documents_1.DOC_TYPE_CUSTOM,
+        responseClass: api_1.CustomResponse,
+        fullText: false,
+    },
+];

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

@@ -0,0 +1,14 @@
+import { Document, DocumentConstructorProps } from "./document";
+import { ClassificationField, ListField } from "../fields";
+import { stringDict } from "../fields/field";
+export interface CustomDocConstructorProps extends DocumentConstructorProps {
+    documentType: string;
+}
+export declare class CustomDocument extends Document {
+    fields: Map<string, ListField>;
+    classifications: Map<string, ClassificationField>;
+    readonly documentType: string;
+    constructor({ inputFile, apiPrediction, pageId, documentType, }: CustomDocConstructorProps);
+    protected setField(fieldName: string, apiPrediction: stringDict, pageId: number | undefined): void;
+    toString(): string;
+}

package/dist/src/documents/custom.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomDocument = void 0;
+const document_1 = require("./document");
+const fields_1 = require("../fields");
+class CustomDocument extends document_1.Document {
+    constructor({ inputFile, apiPrediction, pageId, documentType, }) {
+        super(inputFile, pageId);
+        this.fields = new Map();
+        this.classifications = new Map();
+        this.documentType = documentType;
+        Object.keys(apiPrediction).forEach((fieldName) => {
+            this.setField(fieldName, apiPrediction, pageId);
+        });
+    }
+    setField(fieldName, apiPrediction, pageId) {
+        // Currently, two types of fields possible in a custom API response:
+        // fields having a list of values, and classification fields.
+        const fieldPrediction = apiPrediction[fieldName];
+        if (fieldPrediction["values"] !== undefined) {
+            // Only value lists have the 'values' attribute.
+            this.fields.set(fieldName, new fields_1.ListField({
+                prediction: fieldPrediction,
+                pageId: pageId,
+            }));
+        }
+        else if (fieldPrediction["value"] !== undefined) {
+            // Only classifications have the 'value' attribute.
+            this.classifications.set(fieldName, new fields_1.ClassificationField({ prediction: fieldPrediction }));
+        }
+        else {
+            throw "Unknown API field type";
+        }
+    }
+    toString() {
+        let outStr = `----- ${this.documentType} -----`;
+        outStr += `\nFilename: ${this.filename}`.trimEnd();
+        this.classifications.forEach((fieldData, name) => {
+            outStr += `\n${name}: ${fieldData}`.trimEnd();
+        });
+        this.fields.forEach((fieldData, name) => {
+            outStr += `\n${name}: ${fieldData}`.trimEnd();
+        });
+        outStr += "\n----------------------\n";
+        return outStr;
+    }
+}
+exports.CustomDocument = CustomDocument;

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

@@ -0,0 +1,38 @@
+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/document.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Document = void 0;
+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
+     * @param {number} pageId - Page ID for multi-page document
+     * @param {FullText} fullText - full OCR extracted text
+     */
+    constructor(inputFile, pageId, fullText) {
+        this.filename = "";
+        this.filepath = undefined;
+        this.pageId = pageId;
+        if (inputFile !== undefined) {
+            this.filepath = inputFile.filepath;
+            this.filename = inputFile.filename;
+            this.mimeType = inputFile.mimeType;
+        }
+        this.fullText = fullText;
+        this.checklist = {};
+    }
+    clone() {
+        return JSON.parse(JSON.stringify(this));
+    }
+    /** return true if all checklist of the document if true */
+    checkAll() {
+        return Object.values(this.checklist).every((item) => item);
+    }
+    /**
+     * 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.confidence) >
+                    finalDocument[attribute].confidence) {
+                    finalDocument[attribute] = document === null || document === void 0 ? void 0 : document[attribute];
+                }
+            }
+        }
+        return finalDocument;
+    }
+    static cleanOutString(outStr) {
+        const lines = / \n/gm;
+        return outStr.replace(lines, "\n");
+    }
+}
+exports.Document = Document;