sec-edgar-api 0.0.6 → 0.1.0

package/README.md

@@ -9,6 +9,8 @@ Some main data points available include:
 -   Insider Transactions
 -   Institutional Holders
 -   Filing History
+-   Directors & Executives
+-   Executive Compensation
 
 ## Installation
 

package/build/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];

package/build/services/Client/Client.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { ClientRequest, IncomingMessage, RequestOptions } from 'http';
-declare type Primitive = string | number | boolean | null | undefined;
+type Primitive = string | number | boolean | null | undefined;
 interface HttpClient {
     request: (options: string | URL | RequestOptions, callback?: (res: IncomingMessage) => void) => ClientRequest;
 }

package/build/services/Client/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];

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

@@ -11,5 +11,6 @@ export default class DocumentParser {
     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

@@ -14,6 +14,9 @@ var DocumentParser = /** @class */ (function () {
     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;
+}

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

@@ -0,0 +1,132 @@
+"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.TableNode = void 0;
+var XMLNode_1 = require("./XMLNode");
+var TableNode = /** @class */ (function (_super) {
+    __extends(TableNode, _super);
+    function TableNode() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.title = null;
+        _this.headerRow = null;
+        return _this;
+    }
+    TableNode.prototype.getTitle = function () {
+        var _a;
+        return (_a = this.title) !== null && _a !== void 0 ? _a : '';
+    };
+    TableNode.prototype.setTitle = function (title) {
+        this.title = title;
+    };
+    TableNode.prototype.getChildren = function () {
+        return _super.prototype.getChildren.call(this);
+    };
+    TableNode.prototype.removeTopChild = function () {
+        this.removeChild(this.getChildren()[0]);
+    };
+    TableNode.prototype.removeEmptyTopRows = function () {
+        var _a;
+        while ((_a = this.getChildren()[0]) === null || _a === void 0 ? void 0 : _a.getIsEmpty()) {
+            this.removeChild(this.getChildren()[0]);
+        }
+    };
+    TableNode.prototype.prependChild = function (node) {
+        var prevTopChild = this.getChildren()[0];
+        this.getChildren().unshift(node);
+        if (node.getParent() !== this)
+            node.setParent(this);
+        prevTopChild === null || prevTopChild === void 0 ? void 0 : prevTopChild.setPreviousSibling(node);
+        var colArrTop = [];
+        var colArrBottom = [];
+        node.getChildren().forEach(function (col) {
+            colArrTop.push(col);
+            Array.from({ length: col.getColSpan() - 1 }).forEach(function () { return colArrTop.push(col); });
+        });
+        prevTopChild === null || prevTopChild === void 0 ? void 0 : prevTopChild.getChildren().forEach(function (col, i) {
+            colArrBottom.push(col);
+            Array.from({ length: col.getColSpan() - 1 }).forEach(function () { return colArrBottom.push(col); });
+            if (!col.getTopSiblings().includes(colArrTop[i])) {
+                col.addTopSibling(colArrTop[i]);
+            }
+        });
+    };
+    TableNode.prototype.toArray = function (parseValues) {
+        if (parseValues === void 0) { parseValues = true; }
+        return this.getChildren().map(function (row) { return row.toArray(parseValues); });
+    };
+    TableNode.prototype.setHeaderRow = function (row) {
+        this.headerRow = row;
+    };
+    TableNode.prototype.getHeaderRowIndex = function () {
+        var rows = this.getChildren();
+        // assume body index starts with row that has a non-bold number in it.
+        var bodyIndex = rows.findIndex(function (row) {
+            return row.getChildren().some(function (col) { return typeof col.parseValue() === 'number' && !col.getText().includes('}}'); });
+        });
+        var getRowData = function (row) { return row.getChildren().map(function (col) { return col.parseValue(); }); };
+        // if the header row is only one value, or empty, it's likely a label in the table body, so keep moving up.
+        var headerIndex = bodyIndex - 1;
+        while (rows[headerIndex] && getRowData(rows[headerIndex]).filter(Boolean).length <= 1 && headerIndex >= 0) {
+            headerIndex--;
+        }
+        return headerIndex >= 0 ? headerIndex : null;
+    };
+    TableNode.prototype.mergeHeader = function (removeMergedChildren) {
+        var _a, _b, _c;
+        if (removeMergedChildren === void 0) { removeMergedChildren = true; }
+        var headerRowIndex = (_a = this.getHeaderRowIndex()) !== null && _a !== void 0 ? _a : -1;
+        var headerRow = (_b = this.getChildren()[headerRowIndex]) !== null && _b !== void 0 ? _b : null;
+        if (!headerRow)
+            return;
+        var table = headerRow.toTable(false);
+        var headerRowCols = headerRow.getChildren();
+        // start from the row above the header row to merge.
+        for (var rowIndex = headerRowIndex - 1; rowIndex >= 0; rowIndex--) {
+            var curRow = table[rowIndex];
+            // go through each header column to merge with the one above.
+            for (var colIndex = 0; colIndex < curRow.length; colIndex++) {
+                if (table[headerRowIndex][colIndex] === null)
+                    continue;
+                // if prev header col is empty, get nearest to the left.
+                var colIndexCur = colIndex;
+                while (!curRow[colIndexCur] && colIndexCur >= 0) {
+                    colIndexCur--;
+                }
+                // if the value is empty, continue.
+                var colValue = (_c = curRow[colIndexCur]) !== null && _c !== void 0 ? _c : null;
+                if (!colValue || !this.parseValue("".concat(colValue)))
+                    continue;
+                headerRowCols[colIndex].setText("".concat(colValue, " ").concat(headerRowCols[colIndex].getText()).trim());
+            }
+        }
+        if (removeMergedChildren) {
+            while (this.getChildren()[0] !== headerRow && this.getChildren().length > 0) {
+                this.removeTopChild();
+            }
+        }
+        return headerRow;
+    };
+    /**
+     * If header row is not set, this will try to find it.
+     */
+    TableNode.prototype.getHeaderRow = function () {
+        var _a, _b, _c;
+        return (_c = (_a = this.headerRow) !== null && _a !== void 0 ? _a : this.getChildren()[(_b = this.getHeaderRowIndex()) !== null && _b !== void 0 ? _b : -1]) !== null && _c !== void 0 ? _c : null;
+    };
+    return TableNode;
+}(XMLNode_1.XMLNode));
+exports.TableNode = TableNode;

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

@@ -0,0 +1,37 @@
+interface XMLNodeArgs {
+    path?: string;
+    attributesStr?: string;
+}
+interface GetSiblingsParams {
+    dir: 'previous' | 'next';
+    stopAtType?: new () => XMLNode;
+    includeStopAtType?: boolean;
+}
+export declare class XMLNode {
+    private parent;
+    private previousSibling;
+    private nextSibling;
+    private children;
+    private text;
+    private attributesStr;
+    private path;
+    constructor(args?: XMLNodeArgs);
+    getSiblings(params: GetSiblingsParams): XMLNode[];
+    extractBold(str?: string): string;
+    parseValue(str?: string | null): string | number | null;
+    setPreviousSibling(node: XMLNode | null): void;
+    setNextSibling(node: XMLNode | null): void;
+    removeChild(node: XMLNode): void;
+    setParent(node: XMLNode | null): void;
+    getNextSibling(): XMLNode | null;
+    getPreviousSibling(): XMLNode | null;
+    getParent(): XMLNode | null;
+    getAttributes(): Record<string, string>;
+    getAttributesStr(): string;
+    getChildren(): XMLNode[];
+    addChild(node: XMLNode): void;
+    getText(): string;
+    setText(text: string): void;
+    getPath(): string;
+}
+export {};