sec-edgar-api 0.2.1 → 0.2.3

package/build/services/ReportBuilder/FactSplitAdjuster.js

@@ -0,0 +1,203 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Adjust share-based property values for splits. Checks where the split was applied,
+ * and adjusts all previously filed share facts accordingly.
+ */
+var FactSplitAdjuster = /** @class */ (function () {
+    function FactSplitAdjuster() {
+        this.splitKey = 'StockholdersEquityNoteStockSplitConversionRatio1';
+        this.splitByFiscalYearAmount = new Map();
+        this.factsByYearQuarterByPropertyName = new Map();
+        this.factsAnnaulByYearByPropertyName = new Map();
+        this.resolvedProperties = new Set();
+        this.sortedSplits = null;
+    }
+    FactSplitAdjuster.prototype.getMap = function (map, propertyName) {
+        var _a;
+        return (_a = map.get(propertyName)) !== null && _a !== void 0 ? _a : map.set(propertyName, new Map()).get(propertyName);
+    };
+    FactSplitAdjuster.prototype.add = function (fact) {
+        var propertyName = fact.name, year = fact.year, fiscalPeriod = fact.fiscalPeriod, unit = fact.unit, filed = fact.filed, value = fact.value, end = fact.end;
+        if (this.isSplitProperty(propertyName)) {
+            this.addSplitData({ end: end, filed: filed, fiscalYear: year, value: Number(value) });
+            return;
+        }
+        if (!this.isSplitAdjustableUnit(unit))
+            return;
+        if (this.resolvedProperties.has(propertyName)) {
+            throw new Error("Property ".concat(propertyName, " has already been resolved"));
+        }
+        var isAnnual = fiscalPeriod === 'FY';
+        var map = isAnnual
+            ? this.getMap(this.factsAnnaulByYearByPropertyName, propertyName)
+            : this.getMap(this.factsByYearQuarterByPropertyName, propertyName);
+        var key = "".concat(year, "_").concat(fiscalPeriod);
+        map.set(key, fact);
+    };
+    FactSplitAdjuster.prototype.getSplitsAsc = function () {
+        if (this.sortedSplits)
+            return this.sortedSplits;
+        var sortedSplits = Array.from(this.splitByFiscalYearAmount.values()).sort(function (a, b) {
+            return a.filed < b.filed ? -1 : 1;
+        });
+        this.sortedSplits = sortedSplits;
+        return sortedSplits;
+    };
+    FactSplitAdjuster.prototype.isSplitProperty = function (propertyName) {
+        return propertyName === this.splitKey;
+    };
+    FactSplitAdjuster.prototype.addSplitData = function (data) {
+        var end = data.end, filed = data.filed, fiscalYear = data.fiscalYear, value = data.value;
+        var split = value;
+        var key = "".concat(fiscalYear, "-").concat(split);
+        var prevSplit = this.splitByFiscalYearAmount.get(key);
+        if (!prevSplit) {
+            this.splitByFiscalYearAmount.set(key, __assign(__assign({}, data), { firstFiled: filed }));
+            this.sortedSplits = null;
+            return;
+        }
+        var curEnd = end;
+        var curFiled = filed;
+        var prevEnd = prevSplit.end;
+        var prevFiled = prevSplit.filed;
+        var shouldUpdateFactItem = !prevSplit || prevEnd < curEnd || (prevEnd === curEnd && prevFiled > curFiled);
+        var shouldUpdateFirstFiled = prevFiled > curFiled;
+        if (shouldUpdateFactItem) {
+            var curData = this.splitByFiscalYearAmount.get(key);
+            curData.end = end;
+            curData.filed = filed;
+            curData.value = value;
+            curData.fiscalYear = fiscalYear;
+            this.sortedSplits = null;
+        }
+        if (shouldUpdateFirstFiled) {
+            var curData = this.splitByFiscalYearAmount.get(key);
+            curData.firstFiled = curFiled;
+            this.sortedSplits = null;
+        }
+    };
+    /**
+     * TODO: Find a more reliable way of checking if the split has already been applied.
+     */
+    FactSplitAdjuster.prototype.didApplySplit = function (params) {
+        var nextValue = params.nextValue, prevValue = params.prevValue, split = params.split, isShareRatio = params.isShareRatio, value = params.value, filed = params.filed;
+        if (filed > split.filed) {
+            return true;
+        }
+        var dateFiled = new Date(filed);
+        // TODO: adust by adding a year because sometimes the already adjusted facts are filed within the
+        // year before the split. this might be because the split is listed under a different property? Look into this...
+        if (dateFiled.setFullYear(dateFiled.getFullYear() + 1) < new Date(split.firstFiled).getTime()) {
+            return false;
+        }
+        var valWithSplit = isShareRatio ? value / split.value : value * split.value;
+        // if we still don't know, see if applying the split puts us closer or further from the prev/next quarter value.
+        if (prevValue !== null) {
+            var difference = Math.abs(prevValue - value);
+            var differenceSplit = Math.abs(prevValue - valWithSplit);
+            return difference < differenceSplit;
+        }
+        if (nextValue !== null) {
+            var difference = Math.abs(nextValue - value);
+            var differenceSplit = Math.abs(nextValue - valWithSplit);
+            return difference < differenceSplit;
+        }
+        return true;
+    };
+    FactSplitAdjuster.prototype.isSplitAdjustableUnit = function (unit) {
+        return unit.toLowerCase().includes('share');
+    };
+    FactSplitAdjuster.prototype.isShareRatioUnit = function (unit) {
+        var unitLower = unit.toLowerCase();
+        return unitLower !== 'shares' && unitLower.includes('share'); // ex: USD/shares or USD-per-share
+    };
+    FactSplitAdjuster.prototype.getSortedFacts = function (propertyName, isAnnual) {
+        var _a, _b, _c;
+        var bucket = isAnnual ? this.factsAnnaulByYearByPropertyName : this.factsByYearQuarterByPropertyName;
+        var facts = Array.from((_b = (_a = bucket.get(propertyName)) === null || _a === void 0 ? void 0 : _a.values()) !== null && _b !== void 0 ? _b : []);
+        return (_c = facts.sort(function (a, b) { return (a.filed < b.filed ? -1 : 1); })) !== null && _c !== void 0 ? _c : [];
+    };
+    FactSplitAdjuster.prototype.resolveProperty = function (propertyName) {
+        if (this.resolvedProperties.has(propertyName))
+            return;
+        var factsAscQuarter = this.getSortedFacts(propertyName, false);
+        var factsAscAnnual = this.getSortedFacts(propertyName, true);
+        this.adjustValuesForSplits({ facts: factsAscQuarter });
+        this.adjustValuesForSplits({ facts: factsAscAnnual });
+        this.resolvedProperties.add(propertyName);
+    };
+    FactSplitAdjuster.prototype.get = function (propertyName, year, fiscalPeriod) {
+        var _a;
+        this.resolveProperty(propertyName);
+        var key = "".concat(year, "_").concat(fiscalPeriod);
+        var isAnnual = fiscalPeriod === 'FY';
+        var bucket = isAnnual ? this.factsAnnaulByYearByPropertyName : this.factsByYearQuarterByPropertyName;
+        var fact = (_a = bucket.get(propertyName)) === null || _a === void 0 ? void 0 : _a.get(key);
+        return fact === null || fact === void 0 ? void 0 : fact.value;
+    };
+    FactSplitAdjuster.prototype.forEach = function (callback) {
+        var _this = this;
+        this.factsByYearQuarterByPropertyName.forEach(function (factsByYearQuarter, propertyName) {
+            _this.resolveProperty(propertyName);
+            factsByYearQuarter.forEach(function (fact, key) {
+                var _a = key.split('_'), year = _a[0], fiscalPeriod = _a[1];
+                callback({ propertyName: propertyName, year: Number(year), fiscalPeriod: fiscalPeriod, value: Number(fact.value) });
+            });
+        });
+        this.factsAnnaulByYearByPropertyName.forEach(function (factsByYear, propertyName) {
+            _this.resolveProperty(propertyName);
+            factsByYear.forEach(function (fact, key) {
+                var _a = key.split('_'), year = _a[0], fiscalPeriod = _a[1];
+                callback({ propertyName: propertyName, year: Number(year), fiscalPeriod: fiscalPeriod, value: Number(fact.value) });
+            });
+        });
+    };
+    FactSplitAdjuster.prototype.adjustValuesForSplits = function (params) {
+        var _a, _b, _c, _d;
+        var facts = params.facts;
+        var splits = this.getSplitsAsc();
+        if (facts.length === 0 || splits.length === 0)
+            return;
+        var isShareRatio = this.isShareRatioUnit(facts[0].unit);
+        for (var splitIndex = splits.length - 1; splitIndex >= 0; splitIndex--) {
+            var split = splits[splitIndex];
+            for (var factIndex = facts.length - 1; factIndex >= 0; factIndex--) {
+                var fact = facts[factIndex];
+                var value = fact.value, filed = fact.filed;
+                var nextValue = (_b = (_a = facts[factIndex + 1]) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : null;
+                var prevValue = (_d = (_c = facts[factIndex - 1]) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : null;
+                var didApplySplit = this.didApplySplit({
+                    filed: filed,
+                    isShareRatio: isShareRatio,
+                    nextValue: nextValue,
+                    prevValue: prevValue,
+                    split: split,
+                    value: value,
+                });
+                if (didApplySplit || !split.value) {
+                    continue;
+                }
+                if (isShareRatio) {
+                    fact.value /= split.value;
+                }
+                else {
+                    fact.value *= split.value;
+                }
+            }
+        }
+    };
+    return FactSplitAdjuster;
+}());
+exports.default = FactSplitAdjuster;

package/build/services/ReportBuilder/ReportBuilder.d.ts

@@ -0,0 +1,40 @@
+import { CompanyFactListData, FiscalPeriod, ReportRaw } from '../../types';
+import { SetReportDatesParams } from './FactFiscalCalculator';
+export interface FactItem {
+    cik: number | string;
+    end: string;
+    filed: string;
+    name: string;
+    unit: string;
+    value: number | string;
+    start?: string;
+    hasSegments?: boolean;
+    accn?: string;
+    form?: string;
+    fp?: string;
+    frame?: string;
+    fy?: number;
+    /** For XBRL reports only */
+    segments?: {
+        value: string;
+        dimension: string;
+    }[];
+    uuid?: string;
+}
+export interface FactItemWithFiscals extends FactItem {
+    fiscalPeriod: FiscalPeriod;
+    year: number;
+}
+/**
+ * Builds ReportRaw objects from facts. also applies splits and adjusts for fiscal periods.
+ */
+export default class ReportBuilder {
+    private readonly factRecordBuilder;
+    createFacts(companyFacts: CompanyFactListData): {
+        facts: FactItem[];
+    };
+    buildReports(params: {
+        facts: FactItem[];
+        reportDates?: SetReportDatesParams[];
+    }): ReportRaw[];
+}

package/build/services/ReportBuilder/ReportBuilder.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var FactFiscalCalculator_1 = require("./FactFiscalCalculator");
+var FactPeriodResolver_1 = require("./FactPeriodResolver");
+var FactRecordBuilder_1 = require("./FactRecordBuilder");
+var FactSplitAdjuster_1 = require("./FactSplitAdjuster");
+/**
+ * Builds ReportRaw objects from facts. also applies splits and adjusts for fiscal periods.
+ */
+var ReportBuilder = /** @class */ (function () {
+    function ReportBuilder() {
+        this.factRecordBuilder = new FactRecordBuilder_1.default();
+    }
+    ReportBuilder.prototype.createFacts = function (companyFacts) {
+        return this.factRecordBuilder.createFacts(companyFacts);
+    };
+    ReportBuilder.prototype.buildReports = function (params) {
+        var _a, _b, _c, _d, _e;
+        var facts = params.facts, reportDates = params.reportDates;
+        if (facts.length === 0) {
+            return [];
+        }
+        var accessionByYearQuarter = new Map();
+        reportDates === null || reportDates === void 0 ? void 0 : reportDates.forEach(function (params) {
+            var year = params.year, quarter = params.quarter, accn = params.accn;
+            if (accn)
+                accessionByYearQuarter.set("".concat(year, "_").concat(quarter), accn);
+        });
+        var reportsCik = Number(facts[0].cik);
+        var factFiscalCalculator = new FactFiscalCalculator_1.default();
+        var factPeriodResolver = new FactPeriodResolver_1.default({ cik: reportsCik });
+        var factSplitAdjuster = new FactSplitAdjuster_1.default();
+        facts.forEach(function (fact) { return factFiscalCalculator.add(fact); });
+        reportDates === null || reportDates === void 0 ? void 0 : reportDates.forEach(function (params) { return factFiscalCalculator.setReportDates(params); });
+        var unitByPropertyName = new Map();
+        var splitDateDataByKey = new Map();
+        var minYear = Infinity;
+        var maxYear = -Infinity;
+        var countByAccnByYearQuarter = new Map();
+        var filedByPropertyYearQuarterValue = new Map();
+        for (var _i = 0, facts_1 = facts; _i < facts_1.length; _i++) {
+            var fact = facts_1[_i];
+            var end = fact.end, name_1 = fact.name, unit = fact.unit, segments = fact.segments, start = fact.start, value = fact.value, cik = fact.cik, form = fact.form, filed = fact.filed, accn = fact.accn;
+            if (Number(fact.cik) !== Number(reportsCik)) {
+                throw new Error("All facts must have the same cik ".concat(reportsCik, " !== ").concat(Number(cik)));
+            }
+            var segmentValue = segments === null || segments === void 0 ? void 0 : segments.map(function (seg) { return "".concat(seg.dimension, "_").concat(seg.value); }).join('&');
+            var propertyName = (_a = name_1.split(':').pop()) !== null && _a !== void 0 ? _a : '';
+            var propertyNameWithSegment = propertyName + (segmentValue ? "_".concat(segmentValue) : '');
+            var _f = factFiscalCalculator.getFiscalYearQuarter({ dateStr: end }), quarter = _f.quarter, year = _f.year;
+            if (year < minYear)
+                minYear = year;
+            if (year > maxYear)
+                maxYear = year;
+            var splitKey = "".concat(year, "_").concat(value);
+            var factFiledKey = "".concat(year, "_").concat(quarter, "_").concat(propertyNameWithSegment, "_").concat(value);
+            var isSplit = factSplitAdjuster.isSplitProperty(propertyName);
+            unitByPropertyName.set(propertyNameWithSegment, unit);
+            filedByPropertyYearQuarterValue.set(factFiledKey, filed);
+            if (isSplit && new Date(end) > new Date((_c = (_b = splitDateDataByKey.get(splitKey)) === null || _b === void 0 ? void 0 : _b.end) !== null && _c !== void 0 ? _c : 0)) {
+                splitDateDataByKey.set(splitKey, { end: end, quarter: quarter });
+            }
+            var accnKey = "".concat(year, "_").concat(quarter);
+            var accnGiven = accessionByYearQuarter.get(accnKey);
+            var filedDistance = Math.abs(new Date(filed).getTime() - new Date(end !== null && end !== void 0 ? end : 0).getTime()) / 86400000;
+            var isFiledRecent = filedDistance < 60;
+            if (!accnGiven && isFiledRecent && accn && (!form || form === '10-K' || form === '10-Q')) {
+                var countByAccn = (_d = countByAccnByYearQuarter.get(accnKey)) !== null && _d !== void 0 ? _d : new Map();
+                countByAccn.set(accn, ((_e = countByAccn.get(accn)) !== null && _e !== void 0 ? _e : 0) + 1);
+                countByAccnByYearQuarter.set(accnKey, countByAccn);
+            }
+            factPeriodResolver.add({
+                year: year,
+                start: start,
+                end: end,
+                name: propertyNameWithSegment,
+                quarter: quarter,
+                value: value,
+                filed: filed,
+            });
+        }
+        countByAccnByYearQuarter.forEach(function (countByAccn, yearQuarter) {
+            if (accessionByYearQuarter.has(yearQuarter))
+                return;
+            var maxCount = 0;
+            var accessionNumber = '';
+            countByAccn.forEach(function (count, accn) {
+                if (count > maxCount) {
+                    maxCount = count;
+                    accessionNumber = accn;
+                }
+            });
+            accessionByYearQuarter.set(yearQuarter, accessionNumber);
+        });
+        minYear = Number.isFinite(minYear) ? minYear : new Date().getFullYear();
+        maxYear = Number.isFinite(maxYear) ? maxYear : new Date().getFullYear();
+        var reportsByKey = new Map();
+        // resolves quarterly and annual properties and creates reports
+        factPeriodResolver.forEach(function (data) {
+            var _a, _b;
+            var fiscalPeriod = data.fiscalPeriod, propertyName = data.propertyName, value = data.value, year = data.year;
+            var key = "".concat(year, "_").concat(fiscalPeriod);
+            var quarter = fiscalPeriod === 'FY' ? 4 : Number(fiscalPeriod[1]);
+            var dates = factFiscalCalculator.getDatesByYearQuarter({ quarter: quarter, year: year });
+            var _c = dates !== null && dates !== void 0 ? dates : { filed: '', end: '' }, filed = _c.filed, end = _c.end;
+            var accessionNumber = accessionByYearQuarter.get("".concat(year, "_").concat(quarter));
+            var accessionNoHyphen = accessionNumber === null || accessionNumber === void 0 ? void 0 : accessionNumber.replace(/-/g, '');
+            var url = accessionNumber
+                ? "https://www.sec.gov/Archives/edgar/data/".concat(reportsCik, "/").concat(accessionNoHyphen, "/").concat(accessionNumber, ".txt")
+                : null;
+            if (!reportsByKey.has(key)) {
+                reportsByKey.set(key, {
+                    cik: reportsCik,
+                    url: url,
+                    dateFiled: filed,
+                    dateReport: end,
+                    fiscalPeriod: fiscalPeriod,
+                    fiscalYear: year,
+                    splitDate: null,
+                    splitRatio: null,
+                });
+            }
+            var filedKey = "".concat(year, "_").concat(quarter, "_").concat(propertyName, "_").concat(value);
+            // add facts to adjust for splits
+            factSplitAdjuster.add({
+                end: end,
+                // use the original fact filed date instead of the report filed date to know if the fact has been split.
+                filed: (_a = filedByPropertyYearQuarterValue.get(filedKey)) !== null && _a !== void 0 ? _a : filed,
+                fiscalPeriod: fiscalPeriod,
+                name: propertyName,
+                unit: (_b = unitByPropertyName.get(propertyName)) !== null && _b !== void 0 ? _b : '',
+                year: year,
+                value: Number(value),
+                accn: accessionNumber !== null && accessionNumber !== void 0 ? accessionNumber : '',
+            });
+            var report = reportsByKey.get(key);
+            report[propertyName] = value;
+        });
+        // iterate through facts adjustable for splits and assign values to reports
+        factSplitAdjuster.forEach(function (data) {
+            var year = data.year, fiscalPeriod = data.fiscalPeriod, propertyName = data.propertyName, value = data.value;
+            var key = "".concat(year, "_").concat(fiscalPeriod);
+            var report = reportsByKey.get(key);
+            if (!report)
+                return;
+            report[propertyName] = Math.round(value * 10000) / 10000;
+        });
+        // add split dates and values to reports
+        factSplitAdjuster.getSplitsAsc().forEach(function (split) {
+            var _a, _b, _c, _d;
+            var _e = factFiscalCalculator.getFiscalYearQuarter({ dateStr: split.end }), quarter = _e.quarter, year = _e.year;
+            var keySplit = "".concat(year, "_").concat(split.value);
+            var splitDateData = (_a = splitDateDataByKey.get(keySplit)) !== null && _a !== void 0 ? _a : { end: null, quarter: null };
+            var splitDate = (_b = splitDateData.end) !== null && _b !== void 0 ? _b : split.filed;
+            var splitQuarter = (_c = splitDateData.quarter) !== null && _c !== void 0 ? _c : quarter;
+            var fiscalPeriod = "Q".concat(splitQuarter);
+            var keyReport = "".concat(year, "_").concat(fiscalPeriod);
+            var report = reportsByKey.get(keyReport);
+            var reportAnnual = splitQuarter === 4 ? (_d = reportsByKey.get("".concat(year, "_FY"))) !== null && _d !== void 0 ? _d : null : null;
+            if (report) {
+                report.splitRatio = split.value;
+                report.splitDate = splitDate;
+            }
+            // also assign to annual for Q4
+            if (reportAnnual) {
+                reportAnnual.splitRatio = split.value;
+                reportAnnual.splitDate = splitDate;
+            }
+        });
+        // sort reports ASC by year and quarter
+        var reportsSorted = [];
+        for (var year = minYear; year <= maxYear; year++) {
+            for (var i = 0; i < 5; i++) {
+                var fiscalPeriod = i === 4 ? 'FY' : "Q".concat(i + 1);
+                var key = "".concat(year, "_").concat(fiscalPeriod);
+                var report = reportsByKey.get(key);
+                if (report && report.dateReport) {
+                    reportsSorted.push(report);
+                }
+            }
+        }
+        return reportsSorted;
+    };
+    return ReportBuilder;
+}());
+exports.default = ReportBuilder;

package/build/services/ReportBuilder/ReportRawResolvable.d.ts

@@ -0,0 +1,17 @@
+import { ReportRaw } from '../../types';
+export type TemplateCode = 'I' | 'T' | 'B' | 'M' | 'N' | 'U';
+export default class ReportRawResolvable {
+    readonly report: ReportRaw;
+    private readonly emptyKeys;
+    private readonly addedProps;
+    private readonly calcMap;
+    private readonly templateCode;
+    private readonly keyStack;
+    constructor(report: ReportRaw, templateCode?: TemplateCode | null, calcMap?: Record<string, Record<string, string[]>>);
+    get(key: string): string | number | boolean | undefined;
+    getNumber(key: string): number;
+    isAdded(key: string): boolean;
+    private getChildKeysArr;
+    private calculateNumericKey;
+    toJSON(): ReportRaw;
+}

package/build/services/ReportBuilder/ReportRawResolvable.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var calculation_map_by_ns_1 = require("../../util/calculation-map-by-ns");
+var ReportRawResolvable = /** @class */ (function () {
+    function ReportRawResolvable(report, templateCode, calcMap) {
+        if (templateCode === void 0) { templateCode = null; }
+        if (calcMap === void 0) { calcMap = calculation_map_by_ns_1.calculationMapByNs; }
+        this.emptyKeys = new Set();
+        this.addedProps = new Set();
+        this.keyStack = new Set();
+        this.templateCode = templateCode !== null && templateCode !== void 0 ? templateCode : 'N';
+        this.report = report;
+        this.calcMap = calcMap;
+    }
+    ReportRawResolvable.prototype.get = function (key) {
+        var _a;
+        return (_a = this.report[key]) !== null && _a !== void 0 ? _a : this.calculateNumericKey(key, key);
+    };
+    ReportRawResolvable.prototype.getNumber = function (key) {
+        return Number(this.get(key)) || 0;
+    };
+    ReportRawResolvable.prototype.isAdded = function (key) {
+        return this.addedProps.has(key);
+    };
+    ReportRawResolvable.prototype.getChildKeysArr = function (key) {
+        var calcsByRole = this.calcMap[key];
+        if (calcsByRole === undefined) {
+            return [];
+        }
+        if (calcsByRole._) {
+            return [calcsByRole._];
+        }
+        var preferredKeys = [];
+        switch (this.templateCode) {
+            case 'I':
+                preferredKeys = [
+                    'StatementOfCashFlowsIndirectInvestmentBasedOperations',
+                    'StatementOfFinancialPositionUnclassified-InvestmentBasedOperations',
+                    'StatementOfCashFlowsIndirectDepositBasedOperations',
+                    'StatementOfFinancialPositionUnclassified-DepositBasedOperationsFirstAlternate',
+                    'StatementOfFinancialPositionUnclassified-DepositBasedOperations',
+                ];
+                break;
+            case 'B':
+                preferredKeys = [
+                    'StatementOfFinancialPositionUnclassified-DepositBasedOperationsFirstAlternate',
+                    'StatementOfFinancialPositionUnclassified-DepositBasedOperations',
+                ];
+                break;
+        }
+        var k = preferredKeys.find(function (k) { return calcsByRole[k]; });
+        if (!k) {
+            k = Object.keys(calcsByRole)[0];
+        }
+        return Object.keys(calcsByRole)
+            .sort(function (a, b) {
+            var indexA = preferredKeys.indexOf(a);
+            var indexB = preferredKeys.indexOf(b);
+            if (indexB === -1)
+                return -1;
+            if (indexA === -1)
+                return 1;
+            return indexA - indexB;
+        })
+            .map(function (k) { return calcsByRole[k]; });
+    };
+    ReportRawResolvable.prototype.calculateNumericKey = function (key, topLevelKey) {
+        var _a;
+        if (this.keyStack.has(key)) {
+            return undefined;
+        }
+        this.keyStack.add(key);
+        if (this.emptyKeys.has(key)) {
+            return undefined;
+        }
+        var childKeysArr = this.getChildKeysArr(key);
+        if (childKeysArr.length === 0) {
+            return undefined;
+        }
+        var didAdd = false;
+        var finalSum = 0;
+        for (var _i = 0, childKeysArr_1 = childKeysArr; _i < childKeysArr_1.length; _i++) {
+            var childKeys = childKeysArr_1[_i];
+            var sum = 0;
+            for (var _b = 0, childKeys_1 = childKeys; _b < childKeys_1.length; _b++) {
+                var k = childKeys_1[_b];
+                var _c = k.split('|'), childKey = _c[0], weightStr = _c[1];
+                var value = (_a = this.report[childKey]) !== null && _a !== void 0 ? _a : this.calculateNumericKey(childKey, topLevelKey);
+                if (typeof value !== 'number') {
+                    continue;
+                }
+                didAdd = true;
+                sum += value * Number(weightStr);
+            }
+            if (sum === 0) {
+                continue;
+            }
+            finalSum = sum;
+            break;
+        }
+        if (!didAdd) {
+            this.emptyKeys.add(key);
+            return undefined;
+        }
+        this.report[key] = finalSum;
+        this.addedProps.add(key);
+        return finalSum;
+    };
+    ReportRawResolvable.prototype.toJSON = function () {
+        return this.report;
+    };
+    return ReportRawResolvable;
+}());
+exports.default = ReportRawResolvable;

package/build/services/ReportBuilder/index.d.ts

@@ -0,0 +1,2 @@
+import ReportBuilder from './ReportBuilder';
+export default ReportBuilder;

package/build/services/ReportBuilder/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ReportBuilder_1 = require("./ReportBuilder");
+exports.default = ReportBuilder_1.default;

package/build/services/ReportParser/PropertyResolver.d.ts

@@ -18,6 +18,7 @@ export default class PropertyResolver {
             resolveLiabilityCurrent: typeof import("./resolvers/resolve-liability-current").resolveLiabilityCurrent;
             resolveQ4FiscalYearMatchingProperties: typeof import("./resolvers/resolve-q4-fiscal-year-matching-properties").resolveQ4FiscalYearMatchingProperties;
             resolveCashFlowWorkingCapitalNonCash: typeof import("./resolvers/resolve-cash-flow-working-capital-non-cash").resolveCashFlowWorkingCapitalNonCash;
+            resolveSplitRatio: typeof import("./resolvers/resolve-split-ratio").resolveSplitRatio;
         };
     });
     getDefaultResolvers(): typeof resolvers;

package/build/services/ReportParser/PropertyResolver.js

@@ -37,6 +37,7 @@ var PropertyResolver = /** @class */ (function () {
             _this.resolvers.resolveCashFlowOperating(report);
             _this.resolvers.resolveCashFlowCapex(report);
             _this.resolvers.resolveCashFlowFree(report);
+            _this.resolvers.resolveSplitRatio(report);
         });
     };
     return PropertyResolver;

package/build/services/ReportParser/ReportParser.d.ts

@@ -1,7 +1,6 @@
 import { CompanyFactListData, ReportRaw, ReportTranslated } from '../../types';
-import { IterateFactsCallbackData } from './FactIterator';
 import PropertyResolver from './PropertyResolver';
-import ReportRawParser, { ParseReportsOptions } from './ReportRawParser';
+import ReportRawParser from './ReportRawParser';
 import ReportWrapper from './ReportWrapper';
 interface ReportParserArgs {
     reportRawParser?: ReportRawParser;
@@ -24,7 +23,7 @@ export default class ReportParser {
      *
      * @param companyFactListData This is the json file contents of CIK[number].json file from the SEC website. You can find these using their API or by downloading the companyfacts.zip file: https://www.sec.gov/edgar/sec-api-documentation
      */
-    parseReports(companyFactListData: Pick<CompanyFactListData, 'facts'>, usePropertyResolver?: boolean): ReportWrapper[];
+    parseReports(companyFactListData: CompanyFactListData, usePropertyResolver?: boolean): ReportWrapper[];
     /**
      * Same as parseReports but accepts ReportRaw[] instead of CompanyFactListData
      */
@@ -34,17 +33,11 @@ export default class ReportParser {
      *
      * @see https://www.sec.gov/edgar/sec-api-documentation
      */
-    parseReportsRaw(companyFactListData: Pick<CompanyFactListData, 'facts'>, options?: ParseReportsOptions): ReportRaw[];
+    parseReportsRaw(companyFactListData: CompanyFactListData): ReportRaw[];
     /**
      * parseReportsRaw but removes meta data from the report
      */
-    parseReportsRawNoMeta(companyFactListData: Pick<CompanyFactListData, 'facts'>, options?: ParseReportsOptions): Record<string, number>[];
-    /**
-     * Avoids deep nesting logic while iteratating through company facts
-     *
-     * @param callback called on each company fact.
-     */
-    iterateCompanyFacts(companyFactListData: Pick<CompanyFactListData, 'facts'>, callback: (data: IterateFactsCallbackData) => void): void;
+    parseReportsRawNoMeta(companyFactListData: CompanyFactListData): Record<string, number>[];
     /**
      * Translate ReportRaw to ReportTranslated by default, but can be used to translate to any object using both the callback and keyTranslator
      *