sec-edgar-api 0.0.5 → 0.0.7

package/README.md

@@ -1,8 +1,15 @@
-# sec-edgar-api
+# SEC Edgar API
 
 Fetch and parse earnings reports and other documents filed with the SEC using the EDGAR API.
 This package is focused on the earnings reports for stock analysis.
 
+Some main data points available include:
+
+-   Earnings Reports
+-   Insider Transactions
+-   Institutional Holders
+-   Filing History
+
 ## Installation
 
 ```SH
@@ -93,7 +100,7 @@ interface ReportTranslated {
 import package contents
 
 ```TS
-import { factFileReader, reportParser, secEdgarApi } from 'sec-edgar-api'
+import { secEdgarApi } from 'sec-edgar-api'
 ```
 
 You can fetch reports individually directly from the SEC website, (throttled to 10 requests per second)
@@ -103,38 +110,6 @@ You can fetch reports individually directly from the SEC website, (throttled to
 const reports = await secEdgarApi.getReports({ symbol: 'AAPL' })
 ```
 
-or download all data from the SEC website and read directly from the files so you don't have to worry about rate limiting.
-
-```TS
-import { factsDownloader } from 'sec-edgar-api/downloader'
-
-const downloadDirectory = './downloads/companyfacts'
-
-// Download companyfacts directory from sec.gov (over 15GB)
-await factsDownloader.downloadCompanyFactsDirectory({
-    outputDirname: downloadDirectory,
-    onDownloadComplete: () => process.stdout.write('\n'),
-    onChunk: ({ percentComplete, stage }) => {
-        // Write progress bar to console
-        const countBarsComplete = Math.ceil(percentComplete * 30)
-        const barStr = `${'='.repeat(countBarsComplete)}${' '.repeat(30 - countBarsComplete)}`
-        const percentStr = `${(Math.round(percentComplete * 10000) / 100).toFixed(2)}%`
-        const statusStr = stage === 'download' ? 'Downloading...' : 'Unzipping...'
-
-        process.stdout.write(`\r<${barStr}> ${percentStr} ${statusStr}`)
-    },
-})
-
-// read companyfacts directory
-const companyFacts = factFileReader.readFactFile({
-    companyFactsDirname: downloadDirectory,
-    symbol: 'AAPL',
-})
-
-// parse reports (same return value as secEdgarApi.getReports())
-const reports = reportParser.parseReports(companyFacts)
-```
-
 ## Resolvers
 
 **WARNING** Still in testing. Values may not be accurate for all companies since the properties provided in the reports differ.
@@ -170,17 +145,6 @@ Files for mapping & resolving properties:
 -   Mapping properties: `src/util/key-translations.ts`
 -   Resolving properties: `src/services/ReportParser.ts` (add resolvers to the `resolvers/` directory, import to `/resolver/index.ts`, and add to ReportParser.resolveAll)
 
-These are the scripts I used to get keys commonly used across reports, which you can use to add to `key-translations.ts`
-
-```TS
-import { readAllCompanyFactFiles, getPropertyUsageCounts } from './scripts/script-helpers'
-
-const companyFactsList = readAllCompanyFactFiles(path.resolve('./downloads/companyfacts'), 10)
-const propertyUsageCounts = getPropertyUsageCounts(companyFactsList)
-
-fs.writeFileSync('./downloads/property-usage-counts.json', JSON.stringify(propertyUsageCounts, null, 2))
-```
-
 ### Resources
 
 -   Validate resolved values: https://finance.yahoo.com/

package/build/index.d.ts

@@ -1,4 +1,3 @@
-import FactFileReader from './services/FactFileReader';
 import ReportParser from './services/ReportParser';
 import SecEdgarApi from './services/SecEdgarApi';
 /**
@@ -6,11 +5,6 @@ import SecEdgarApi from './services/SecEdgarApi';
  * reports as json objects.
  */
 declare const reportParser: ReportParser;
-/**
- * Reads files from the companyfacts directory (which can be downloaded
- * using secEdgarApi.downloadCompanyFacts()).
- */
-declare const factFileReader: FactFileReader;
 /**
  * Gets company reports and filings from the SEC EDGAR API. Requests are
  * throttled with 120ms delay between requests to avoid rate limiting.
@@ -18,4 +12,5 @@ declare const factFileReader: FactFileReader;
  * @see https://www.sec.gov/edgar/sec-api-documentation
  */
 declare const secEdgarApi: SecEdgarApi;
-export { reportParser, factFileReader, secEdgarApi };
+export { reportParser, secEdgarApi };
+export * from './types';

package/build/index.js

@@ -1,7 +1,20 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.secEdgarApi = exports.factFileReader = exports.reportParser = void 0;
-var FactFileReader_1 = require("./services/FactFileReader");
+exports.secEdgarApi = exports.reportParser = void 0;
 var ReportParser_1 = require("./services/ReportParser");
 var SecEdgarApi_1 = require("./services/SecEdgarApi");
 /**
@@ -10,12 +23,6 @@ var SecEdgarApi_1 = require("./services/SecEdgarApi");
  */
 var reportParser = new ReportParser_1.default();
 exports.reportParser = reportParser;
-/**
- * Reads files from the companyfacts directory (which can be downloaded
- * using secEdgarApi.downloadCompanyFacts()).
- */
-var factFileReader = new FactFileReader_1.default();
-exports.factFileReader = factFileReader;
 /**
  * Gets company reports and filings from the SEC EDGAR API. Requests are
  * throttled with 120ms delay between requests to avoid rate limiting.
@@ -24,3 +31,4 @@ exports.factFileReader = factFileReader;
  */
 var secEdgarApi = new SecEdgarApi_1.default();
 exports.secEdgarApi = secEdgarApi;
+__exportStar(require("./types"), exports);

package/build/services/DocumentParser/DocumentParser.d.ts

@@ -0,0 +1,16 @@
+import { InsiderTransaction, XMLParams } from '../../types';
+import XMLParser from './XMLParser';
+import parsers from './parsers';
+interface DocumentParserArgs {
+    parser?: XMLParser;
+    parsersByName?: typeof parsers;
+}
+export default class DocumentParser {
+    private readonly parser;
+    private readonly parsersByName;
+    constructor(args?: DocumentParserArgs);
+    parseInsiderTransactions(params: XMLParams): InsiderTransaction[];
+    parseHolders(params: XMLParams): import("../../types").Holder[];
+    parseEarningsTables(params: XMLParams): import("../../types").TableData[];
+}
+export {};

package/build/services/DocumentParser/DocumentParser.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var XMLParser_1 = require("./XMLParser");
+var parsers_1 = require("./parsers");
+var DocumentParser = /** @class */ (function () {
+    function DocumentParser(args) {
+        var _a = args !== null && args !== void 0 ? args : {}, _b = _a.parser, parser = _b === void 0 ? new XMLParser_1.default() : _b, _c = _a.parsersByName, parsersByName = _c === void 0 ? parsers_1.default : _c;
+        this.parser = parser;
+        this.parsersByName = parsersByName;
+    }
+    DocumentParser.prototype.parseInsiderTransactions = function (params) {
+        return this.parsersByName.parseForm4(params, this.parser);
+    };
+    DocumentParser.prototype.parseHolders = function (params) {
+        return this.parsersByName.parseForm13g(params, this.parser);
+    };
+    DocumentParser.prototype.parseEarningsTables = function (params) {
+        return this.parsersByName.parseForm10k(params, this.parser);
+    };
+    return DocumentParser;
+}());
+exports.default = DocumentParser;

package/build/services/DocumentParser/XMLNode/ColNode.d.ts

@@ -0,0 +1,18 @@
+import { RowNode } from './RowNode';
+import { XMLNode } from './XMLNode';
+export declare class ColNode extends XMLNode {
+    private colSpan;
+    private index;
+    private topSiblings;
+    private bottomSiblings;
+    setIndex(index: number): void;
+    getIndex(): number;
+    getParent(): RowNode;
+    addTopSibling(node: ColNode): void;
+    addBottomSibling(node: ColNode): void;
+    getTopSiblings(): ColNode[];
+    getBottomSiblings(): ColNode[];
+    getNextSibling(): ColNode | null;
+    getPreviousSibling(): ColNode | null;
+    getColSpan(): number;
+}

package/build/services/DocumentParser/XMLNode/ColNode.js

@@ -0,0 +1,74 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColNode = void 0;
+var XMLNode_1 = require("./XMLNode");
+var ColNode = /** @class */ (function (_super) {
+    __extends(ColNode, _super);
+    function ColNode() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.colSpan = null;
+        _this.index = null;
+        _this.topSiblings = [];
+        _this.bottomSiblings = [];
+        return _this;
+    }
+    ColNode.prototype.setIndex = function (index) {
+        this.index = index;
+    };
+    ColNode.prototype.getIndex = function () {
+        var _a;
+        return (_a = this.index) !== null && _a !== void 0 ? _a : -1;
+    };
+    ColNode.prototype.getParent = function () {
+        return _super.prototype.getParent.call(this);
+    };
+    ColNode.prototype.addTopSibling = function (node) {
+        this.topSiblings.push(node);
+        if (!node.getBottomSiblings().includes(this)) {
+            node.addBottomSibling(this);
+        }
+    };
+    ColNode.prototype.addBottomSibling = function (node) {
+        this.bottomSiblings.push(node);
+        if (!node.getTopSiblings().includes(this)) {
+            node.addTopSibling(this);
+        }
+    };
+    ColNode.prototype.getTopSiblings = function () {
+        return this.topSiblings;
+    };
+    ColNode.prototype.getBottomSiblings = function () {
+        return this.bottomSiblings;
+    };
+    ColNode.prototype.getNextSibling = function () {
+        return _super.prototype.getNextSibling.call(this);
+    };
+    ColNode.prototype.getPreviousSibling = function () {
+        return _super.prototype.getPreviousSibling.call(this);
+    };
+    ColNode.prototype.getColSpan = function () {
+        var _a;
+        if (this.colSpan)
+            return this.colSpan;
+        var colSpan = Number((_a = this.getAttributes().colspan) !== null && _a !== void 0 ? _a : 1);
+        this.colSpan = colSpan;
+        return colSpan;
+    };
+    return ColNode;
+}(XMLNode_1.XMLNode));
+exports.ColNode = ColNode;

package/build/services/DocumentParser/XMLNode/DocumentNode.d.ts

@@ -0,0 +1,3 @@
+import { XMLNode } from './XMLNode';
+export declare class DocumentNode extends XMLNode {
+}

package/build/services/DocumentParser/XMLNode/DocumentNode.js

@@ -0,0 +1,27 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentNode = void 0;
+var XMLNode_1 = require("./XMLNode");
+var DocumentNode = /** @class */ (function (_super) {
+    __extends(DocumentNode, _super);
+    function DocumentNode() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return DocumentNode;
+}(XMLNode_1.XMLNode));
+exports.DocumentNode = DocumentNode;

package/build/services/DocumentParser/XMLNode/HRNode.d.ts

@@ -0,0 +1,3 @@
+import { XMLNode } from './XMLNode';
+export declare class HRNode extends XMLNode {
+}

package/build/services/DocumentParser/XMLNode/HRNode.js

@@ -0,0 +1,27 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HRNode = void 0;
+var XMLNode_1 = require("./XMLNode");
+var HRNode = /** @class */ (function (_super) {
+    __extends(HRNode, _super);
+    function HRNode() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return HRNode;
+}(XMLNode_1.XMLNode));
+exports.HRNode = HRNode;

package/build/services/DocumentParser/XMLNode/NonTableNode.d.ts

@@ -0,0 +1,3 @@
+import { XMLNode } from './XMLNode';
+export declare class NonTableNode extends XMLNode {
+}

package/build/services/DocumentParser/XMLNode/NonTableNode.js

@@ -0,0 +1,27 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonTableNode = void 0;
+var XMLNode_1 = require("./XMLNode");
+var NonTableNode = /** @class */ (function (_super) {
+    __extends(NonTableNode, _super);
+    function NonTableNode() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return NonTableNode;
+}(XMLNode_1.XMLNode));
+exports.NonTableNode = NonTableNode;

package/build/services/DocumentParser/XMLNode/RowNode.d.ts

@@ -0,0 +1,30 @@
+import { ColNode } from './ColNode';
+import { TableNode } from './TableNode';
+import { XMLNode } from './XMLNode';
+export declare class RowNode extends XMLNode {
+    private isHeader;
+    private isEmpty;
+    getIsEmpty(): boolean;
+    clone(): RowNode;
+    setIsHeader(isHeader: boolean): void;
+    getIsHeader(): boolean;
+    getChildren(): ColNode[];
+    getParent(): TableNode;
+    getNextSibling(): RowNode | null;
+    getPreviousSibling(): RowNode | null;
+    /**
+     * Uses the columns in this row to build a table. Each column is also an array since cols can touch
+     * multiple other cells on the top and bottom due to colspan.
+     *
+     * ```ts
+     * const returnExample = [
+     *     [ [ColNode, ColNode], [ColNode], [ColNode, ColNode, ColNode] ]
+     *     [ [ColNode], [ColNode], [ColNode] ], // this row
+     *     [ [ColNode], [ColNode], [ColNode, ColNode] ],
+     * ]
+     * ```
+     */
+    getTableFromCols(): ColNode[][][];
+    toTable(parseValues?: boolean): (string | number | null)[][];
+    toArray(parseValues?: boolean): (string | number | null)[];
+}

package/build/services/DocumentParser/XMLNode/RowNode.js

@@ -0,0 +1,177 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowNode = void 0;
+var ColNode_1 = require("./ColNode");
+var XMLNode_1 = require("./XMLNode");
+var RowNode = /** @class */ (function (_super) {
+    __extends(RowNode, _super);
+    function RowNode() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.isHeader = false;
+        _this.isEmpty = null;
+        return _this;
+    }
+    RowNode.prototype.getIsEmpty = function () {
+        if (this.isEmpty !== null)
+            return this.isEmpty;
+        this.isEmpty = this.toArray().filter(Boolean).length === 0;
+        return Boolean(this.isEmpty);
+    };
+    RowNode.prototype.clone = function () {
+        var clone = new RowNode({ attributesStr: this.getAttributesStr(), path: this.getPath() });
+        clone.setText(this.getText());
+        this.getChildren().forEach(function (child) {
+            var childNew = new ColNode_1.ColNode({ attributesStr: child.getAttributesStr(), path: child.getPath() });
+            var prevChild = clone.getChildren()[clone.getChildren().length - 1];
+            childNew.setText(child.getText());
+            childNew.setIndex(child.getIndex());
+            prevChild === null || prevChild === void 0 ? void 0 : prevChild.setNextSibling(childNew);
+            clone.addChild(childNew);
+        });
+        return clone;
+    };
+    RowNode.prototype.setIsHeader = function (isHeader) {
+        this.isHeader = isHeader;
+    };
+    RowNode.prototype.getIsHeader = function () {
+        return this.isHeader;
+    };
+    RowNode.prototype.getChildren = function () {
+        return _super.prototype.getChildren.call(this);
+    };
+    RowNode.prototype.getParent = function () {
+        return _super.prototype.getParent.call(this);
+    };
+    RowNode.prototype.getNextSibling = function () {
+        return _super.prototype.getNextSibling.call(this);
+    };
+    RowNode.prototype.getPreviousSibling = function () {
+        return _super.prototype.getPreviousSibling.call(this);
+    };
+    /**
+     * Uses the columns in this row to build a table. Each column is also an array since cols can touch
+     * multiple other cells on the top and bottom due to colspan.
+     *
+     * ```ts
+     * const returnExample = [
+     *     [ [ColNode, ColNode], [ColNode], [ColNode, ColNode, ColNode] ]
+     *     [ [ColNode], [ColNode], [ColNode] ], // this row
+     *     [ [ColNode], [ColNode], [ColNode, ColNode] ],
+     * ]
+     * ```
+     */
+    RowNode.prototype.getTableFromCols = function () {
+        var tableRowCols = [];
+        var colIndexRanges = this.getChildren().map(function (col) { return [col.getIndex(), col.getIndex() + col.getColSpan()]; });
+        for (var _i = 0, _a = this.getParent().getChildren(); _i < _a.length; _i++) {
+            var row = _a[_i];
+            var rowCols = colIndexRanges.map(function () { return []; });
+            for (var _b = 0, _c = row.getChildren(); _b < _c.length; _b++) {
+                var col = _c[_b];
+                var _d = [col.getIndex(), col.getIndex() + col.getColSpan()], indexStart = _d[0], indexEnd = _d[1];
+                for (var i = 0; i < colIndexRanges.length; i++) {
+                    var _e = colIndexRanges[i], boundaryStart = _e[0], boundaryEnd = _e[1];
+                    if (indexEnd <= boundaryStart || indexStart >= boundaryEnd)
+                        continue;
+                    rowCols[i].push(col);
+                }
+            }
+            tableRowCols.push(rowCols);
+        }
+        return tableRowCols;
+    };
+    RowNode.prototype.toTable = function (parseValues) {
+        var _a, _b, _c;
+        if (parseValues === void 0) { parseValues = true; }
+        var table = this.getTableFromCols();
+        var tableTextArr = [];
+        var headerRowIndex = (_a = this.getParent().getHeaderRowIndex()) !== null && _a !== void 0 ? _a : -1;
+        for (var rowIndex = 0; rowIndex < table.length; rowIndex++) {
+            var row = table[rowIndex];
+            var colTextArr = [];
+            for (var _i = 0, row_1 = row; _i < row_1.length; _i++) {
+                var colArr = row_1[_i];
+                var colText = colArr.reduce(function (acc, col) { return "".concat(acc, " ").concat(col.getText()); }, '');
+                // skip rows that are titles within the table body
+                var isTitleRow = colArr.length === 1 &&
+                    colArr[0].getColSpan() >= this.getChildren().length &&
+                    rowIndex > headerRowIndex;
+                if (isTitleRow)
+                    continue;
+                if (!parseValues) {
+                    colTextArr.push(colText.trim());
+                    continue;
+                }
+                // sometimes there is a rogue percent sign that is not in a column, so we need to check the next column
+                var nextCol = (_b = colArr[colArr.length - 1]) === null || _b === void 0 ? void 0 : _b.getNextSibling();
+                var isMissingPercentSign = (nextCol === null || nextCol === void 0 ? void 0 : nextCol.getText().includes('%')) && nextCol.parseValue() === null;
+                var isMissingParenthesis = (nextCol === null || nextCol === void 0 ? void 0 : nextCol.getText().includes(')')) && colText.includes('(') && !colText.includes(')');
+                var colTextTrimmed = isMissingParenthesis ? "".concat(colText.trim(), ")") : colText.trim();
+                colTextTrimmed = isMissingPercentSign ? "".concat(colText.trim(), "%") : colText.trim();
+                colTextTrimmed = this.parseValue(colTextTrimmed);
+                colTextTrimmed =
+                    typeof colTextTrimmed === 'string' ? colTextTrimmed.replace(/\s+/g, ' ') : colTextTrimmed;
+                colTextArr.push(colTextTrimmed);
+            }
+            tableTextArr.push(colTextArr);
+        }
+        if (!parseValues)
+            return tableTextArr;
+        var emptyColIndexes = new Set();
+        cols: for (var colIndex = 0; colIndex < tableTextArr[0].length; colIndex++) {
+            for (var rowIndex = 1; rowIndex < tableTextArr.length; rowIndex++) {
+                if (Boolean(tableTextArr[rowIndex][colIndex]) && tableTextArr[rowIndex][colIndex] !== '%') {
+                    continue cols;
+                }
+            }
+            emptyColIndexes.add(colIndex);
+        }
+        tableTextArr.forEach(function (row, i) {
+            tableTextArr[i] = row.filter(function (_, i) { return !emptyColIndexes.has(i); });
+        });
+        var tableTextArrFiltered = [];
+        for (var rowIndex = 0; rowIndex < tableTextArr.length; rowIndex++) {
+            var row = tableTextArr[rowIndex];
+            var isEmpty = !row.some(Boolean);
+            // if is empty before the header or empty next to another empty row, continue
+            if (isEmpty && (rowIndex < headerRowIndex || !((_c = tableTextArr[rowIndex - 1]) === null || _c === void 0 ? void 0 : _c.some(Boolean)))) {
+                continue;
+            }
+            tableTextArrFiltered.push(row);
+        }
+        return tableTextArr.filter(function (row, i) {
+            var rowPrev = tableTextArr[i - 1];
+            var isEmpty = !row.some(Boolean);
+            var isLast = i === tableTextArr.length - 1;
+            // empty rows cannot be before header, last in array, or next to another empty row
+            return !(isEmpty && (i < headerRowIndex || !(rowPrev === null || rowPrev === void 0 ? void 0 : rowPrev.some(Boolean)) || isLast));
+        });
+    };
+    RowNode.prototype.toArray = function (parseValues) {
+        var _this = this;
+        if (parseValues === void 0) { parseValues = true; }
+        var cols = [];
+        this.getChildren().forEach(function (col) {
+            cols.push(parseValues ? _this.parseValue(col.getText()) : col.getText());
+            Array.from({ length: col.getColSpan() - 1 }).forEach(function () { return cols.push(null); });
+        });
+        return cols;
+    };
+    return RowNode;
+}(XMLNode_1.XMLNode));
+exports.RowNode = RowNode;

package/build/services/DocumentParser/XMLNode/TableNode.d.ts

@@ -0,0 +1,20 @@
+import { RowNode } from './RowNode';
+import { XMLNode } from './XMLNode';
+export declare class TableNode extends XMLNode {
+    private title;
+    private headerRow;
+    getTitle(): string;
+    setTitle(title: string): void;
+    getChildren(): RowNode[];
+    removeTopChild(): void;
+    removeEmptyTopRows(): void;
+    prependChild(node: RowNode): void;
+    toArray(parseValues?: boolean): (string | number | null)[][];
+    setHeaderRow(row: RowNode): void;
+    getHeaderRowIndex(): number | null;
+    mergeHeader(removeMergedChildren?: boolean): RowNode | undefined;
+    /**
+     * If header row is not set, this will try to find it.
+     */
+    getHeaderRow(): RowNode;
+}