sec-edgar-api 0.4.1 → 0.5.0

package/README.md

@@ -56,7 +56,6 @@ interface ReportTranslated {
 
 	equityTotal: number | null
 	equityRetainedEarnings: number | null
-	equityStockPreferred: number | null
 
 	sharesOutstanding: number | null
 	sharesOutstandingDiluted: number | null
@@ -83,16 +82,21 @@ interface ReportTranslated {
 	expenseDepreciationAccumulated: number | null
 	expenseStockCompensation: number | null
 	expenseNonCashOther: number | null
+	expenseSellingGeneralAdministrative: number | null
 
 	incomeOperating: number | null
 	incomeNet: number | null
+	incomePretax: number | null
 
 	cashFlowFree: number | null
 	cashFlowDividendsPaid: number | null
 	cashFlowDividendsPaidPreferred: number | null
 
-	cashFlowCapex: number | null
 	cashFlowOperating: number | null
+	cashFlowInvesting: number | null
+	cashFlowFinancing: number | null
+
+	cashFlowCapex: number | null
 	cashFlowDeferredTax: number | null
 
 	cashFlowWorkingCapitalNonCash: number | null

package/build/index.d.ts

@@ -1,5 +1,7 @@
 import ReportParser from './services/ReportParser';
 import SecEdgarApi from './services/SecEdgarApi';
+import ReportResolvable from './services/ReportParser/ReportResolvable';
+import { utilMap } from './util/util-map';
 /**
  * Takes company facts data from the SEC and translates them to
  * reports as json objects.
@@ -12,5 +14,5 @@ declare const reportParser: ReportParser;
  * @see https://www.sec.gov/edgar/sec-api-documentation
  */
 declare const secEdgarApi: SecEdgarApi;
-export { reportParser, secEdgarApi };
-export * from './types';
+export { reportParser, secEdgarApi, ReportResolvable, utilMap };
+export type * from './types';

package/build/index.js

@@ -1,22 +1,12 @@
 "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.reportParser = void 0;
+exports.utilMap = exports.ReportResolvable = exports.secEdgarApi = exports.reportParser = void 0;
 var ReportParser_1 = require("./services/ReportParser");
 var SecEdgarApi_1 = require("./services/SecEdgarApi");
+var ReportResolvable_1 = require("./services/ReportParser/ReportResolvable");
+exports.ReportResolvable = ReportResolvable_1.default;
+var util_map_1 = require("./util/util-map");
+Object.defineProperty(exports, "utilMap", { enumerable: true, get: function () { return util_map_1.utilMap; } });
 /**
  * Takes company facts data from the SEC and translates them to
  * reports as json objects.
@@ -31,4 +21,3 @@ exports.reportParser = reportParser;
  */
 var secEdgarApi = new SecEdgarApi_1.default();
 exports.secEdgarApi = secEdgarApi;
-__exportStar(require("./types"), exports);

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

@@ -38,7 +38,7 @@ export default class DocumentParser {
     parseCurrentFilingsXbrl(params: XMLParams): import("../../types").CurrentFilingsXBRL;
     parseXbrl(params: XMLParams & GetDocumentXbrlParams): import("./XBRLParser/XBRLParser").XbrlParseResult & {
         report: import("../../types").ReportRaw | null;
-        facts: import("../../types").FactItem[];
+        facts: import("../../types").FactItemExtended[];
         xml: string;
     };
 }

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

@@ -1,4 +1,4 @@
-import { XbrlInstance } from '../../../types/xbrl.type';
+import type { XbrlInstance } from '../../../types/xbrl.type';
 export default class InstanceParser {
     private readonly xmlParser;
     private parseContext;

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

@@ -1,4 +1,4 @@
-import { XbrlLinkbase } from '../../../types/xbrl.type';
+import type { XbrlLinkbase } from '../../../types';
 import XMLParser from '../XMLParser';
 export default class LinkbaseParser {
     private readonly xmlParser;

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

@@ -1,4 +1,4 @@
-import { XbrlSchema } from '../../../types/xbrl.type';
+import type { XbrlSchema } from '../../../types/xbrl.type';
 export default class SchemaParser {
     private readonly xmlParser;
     private parseAppInfo;

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

@@ -1,4 +1,4 @@
-import { XbrlInstance, XbrlLinkbase, XbrlSchema } from '../../../types/xbrl.type';
+import type { XbrlInstance, XbrlLinkbase, XbrlSchema } from '../../../types';
 import { XbrlFormHeader } from './HeaderParser';
 export interface XbrlParseResult {
     header: XbrlFormHeader;

package/build/services/DocumentParser/parsers/parse-companies.d.ts

@@ -1,5 +1,4 @@
-import { XMLParams } from '../../../types';
-import { CompanySearchResult } from '../../../types/company-search.type';
+import type { CompanySearchResult, XMLParams } from '../../../types';
 export declare function parseCompanies(params: XMLParams): {
     items: CompanySearchResult[];
 };

package/build/services/DocumentParser/parsers/parse-insider-transaction.d.ts

@@ -1,5 +1,4 @@
-import { XMLParams } from '../../../types';
-import { InsiderTransaction, Issuer, Owner } from '../../../types/insider-transaction.type';
+import type { InsiderTransaction, Issuer, Owner, XMLParams } from '../../../types';
 export declare function parseInsiderTransactions(params: XMLParams): {
     transactions: InsiderTransaction[];
     owners: Owner[];

package/build/services/DocumentParser/parsers/parse-xbrl.d.ts

@@ -1,8 +1,8 @@
-import { FactItem, ReportRaw, XMLParams } from '../../../types';
+import type { FactItemExtended, ReportRaw, XMLParams } from '../../../types';
 import { GetDocumentXbrlParams } from '../../SecEdgarApi';
 import { XbrlParseResult } from '../XBRLParser/XBRLParser';
 export declare function parseXbrl(params: XMLParams & GetDocumentXbrlParams): XbrlParseResult & {
     report: ReportRaw | null;
-    facts: FactItem[];
+    facts: FactItemExtended[];
     xml: string;
 };

package/build/services/DocumentParser/parsers/parse-xbrl.js

@@ -43,12 +43,7 @@ function buildReportsFromFacts(params) {
         fiscalYear: fiscalYear,
     };
     // if there is a split fact, make sure it's from the current fiscal year
-    var allowedMonthsPriorForSplit = fiscalPeriod === 'FY' ? 12 : 3;
-    var splitFact = facts.find(function (f) {
-        var _a;
-        return f.name.endsWith(constants_1.KEY_SPLIT) &&
-            isWithinDays({ dateA: f.filed, dateB: (_a = filing === null || filing === void 0 ? void 0 : filing.reportDate) !== null && _a !== void 0 ? _a : '', days: allowedMonthsPriorForSplit * 30 });
-    });
+    var splitFact = facts.find(function (f) { var _a; return f.name.endsWith(constants_1.KEY_SPLIT) && isWithinDays({ dateA: f.filed, dateB: (_a = filing === null || filing === void 0 ? void 0 : filing.reportDate) !== null && _a !== void 0 ? _a : '', days: 90 }); });
     var reportFocus = {
         cik: Number(cik !== null && cik !== void 0 ? cik : reportFactValues.cik),
         dateFiled: (_d = filing === null || filing === void 0 ? void 0 : filing.filingDate) !== null && _d !== void 0 ? _d : '',
@@ -71,8 +66,11 @@ function buildReportsFromFacts(params) {
             startDate: (_j = fact.start) !== null && _j !== void 0 ? _j : '',
             endDate: fact.end,
         });
-        var isFocusFact = (_k = isFocusFactByDateKey.get(dateKey)) !== null && _k !== void 0 ? _k : isWithinDays({ dateA: fact.end, dateB: reportFocus.dateReport, days: 45 });
-        isFocusFactByDateKey.set(dateKey, isFocusFact);
+        var isSplitFact = fact === splitFact;
+        var isFocusFact = (_k = isFocusFactByDateKey.get(dateKey)) !== null && _k !== void 0 ? _k : (isWithinDays({ dateA: fact.end, dateB: reportFocus.dateReport, days: 45 }) || isSplitFact);
+        if (!isSplitFact) {
+            isFocusFactByDateKey.set(dateKey, isFocusFact);
+        }
         var el = fact;
         var scale = Number((_l = el.scale) !== null && _l !== void 0 ? _l : 0) || 0;
         var decimals = Number((_m = el.decimals) !== null && _m !== void 0 ? _m : 0) || 0;
@@ -106,8 +104,14 @@ function buildReportsFromFacts(params) {
         factByName.set(prevFactKey, fact);
         reportByDateRange[dateKey][nameKey] = fact.value;
         if (isFocusFact) {
+            if (prevFact)
+                prevFact.isUsedInReport = false;
+            fact.isUsedInReport = true;
             reportFocus[nameKey] = fact.value;
         }
+        else {
+            fact.isUsedInReport = false;
+        }
     }
     return { reportFocus: reportFocus, reportByDateRange: reportByDateRange, factsFiltered: Array.from(factByName.values()) };
 }

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

@@ -1,12 +1,13 @@
-import { CompanyFactListData, ReportRaw, ReportTranslated } from '../../types';
+import type { CalculationMap, CompanyFactListData, ReportRaw, ReportTranslated } from '../../types';
 import ReportRawBuilder from '../ReportRawBuilder';
-import { GetReportsRawParams } from '../SecEdgarApi';
+import { BuildReportsParams } from '../ReportRawBuilder/ReportRawBuilder';
 import PropertyResolver from './PropertyResolver';
 import ReportWrapper from './ReportWrapper';
 interface ReportParserArgs {
     reportBuilder?: ReportRawBuilder;
     propertyResolver?: PropertyResolver;
     keyTranslator?: Record<string, string[]>;
+    defaultCalculationMap?: CalculationMap<ReportTranslated>;
 }
 type TranslateRawReportsCallback<T> = (report: T extends undefined ? ReportTranslated : Record<keyof T, string | number>, reportRaw: ReportRaw, keyTranslator: T) => ReportTranslated | ReportRaw | Record<string, string | number | null>;
 /**
@@ -16,24 +17,36 @@ export default class ReportParser {
     private readonly keyTranslator;
     private readonly propertyResolver;
     private readonly reportBuilder;
+    private defaultCalculationMap;
     constructor(args?: ReportParserArgs);
     /**
      * Same as parseReports but accepts ReportRaw[] instead of CompanyFactListData
+     *
+     * @deprecated Formerly parseReportsFromRaw. Will be removed in future version.
      */
-    parseReportsFromRaw(params: {
+    parseReportsFromRawLegacy(params: {
         reportsRaw: ReportRaw[];
         usePropertyResolver?: boolean;
     }): ReportWrapper[];
+    /**
+     * Same as parseReports but accepts ReportRaw[] instead of CompanyFactListData
+     */
+    parseReportsFromRaw<T = ReportTranslated>(params: {
+        reportsRaw: ReportRaw[];
+        calculationMap?: CalculationMap<T>;
+    }): (ReportRaw & T)[];
     /**
      * Parse raw reports
      *
      * @see https://www.sec.gov/edgar/sec-api-documentation
      */
-    parseReportsRaw(companyFactListData: CompanyFactListData, options?: Omit<GetReportsRawParams, 'symbol'>): ReportRaw[];
+    parseReportsRaw(companyFactListData: CompanyFactListData, options: Omit<BuildReportsParams, 'facts'> & {
+        includeNamePrefix?: boolean;
+    }): ReportRaw[];
     /**
-     * parseReportsRaw but removes meta data from the report
+     * Builds ReportRaw[] from facts
      */
-    parseReportsRawNoMeta(companyFactListData: CompanyFactListData): Record<string, number>[];
+    buildReports(params: BuildReportsParams): ReportRaw[];
     /**
      * Translate ReportRaw to ReportTranslated by default, but can be used to translate to any object using both the callback and keyTranslator
      *

package/build/services/ReportParser/ReportParser.js

@@ -1,23 +1,40 @@
 "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 });
+var calculation_map_1 = require("../../util/calculation-map");
 var key_translations_1 = require("../../util/key-translations");
+var util_map_1 = require("../../util/util-map");
 var ReportRawBuilder_1 = require("../ReportRawBuilder");
 var PropertyResolver_1 = require("./PropertyResolver");
+var ReportResolvable_1 = require("./ReportResolvable");
 var ReportWrapper_1 = require("./ReportWrapper");
 /**
  * Takes company facts data from the SEC and translates them to reports as json objects.
  */
 var ReportParser = /** @class */ (function () {
     function ReportParser(args) {
-        var _a = args !== null && args !== void 0 ? args : {}, _b = _a.propertyResolver, propertyResolver = _b === void 0 ? new PropertyResolver_1.default() : _b, _c = _a.reportBuilder, reportBuilder = _c === void 0 ? new ReportRawBuilder_1.default() : _c, _d = _a.keyTranslator, keyTranslator = _d === void 0 ? key_translations_1.default : _d;
+        var _a = args !== null && args !== void 0 ? args : {}, _b = _a.propertyResolver, propertyResolver = _b === void 0 ? new PropertyResolver_1.default() : _b, _c = _a.reportBuilder, reportBuilder = _c === void 0 ? new ReportRawBuilder_1.default() : _c, _d = _a.keyTranslator, keyTranslator = _d === void 0 ? key_translations_1.default : _d, _e = _a.defaultCalculationMap, defaultCalculationMap = _e === void 0 ? util_map_1.utilMap.expandMap(calculation_map_1.calculationMapCondensed) : _e;
         this.keyTranslator = keyTranslator;
         this.propertyResolver = propertyResolver;
         this.reportBuilder = reportBuilder;
+        this.defaultCalculationMap = defaultCalculationMap;
     }
     /**
      * Same as parseReports but accepts ReportRaw[] instead of CompanyFactListData
+     *
+     * @deprecated Formerly parseReportsFromRaw. Will be removed in future version.
      */
-    ReportParser.prototype.parseReportsFromRaw = function (params) {
+    ReportParser.prototype.parseReportsFromRawLegacy = function (params) {
         var reportsRaw = params.reportsRaw, _a = params.usePropertyResolver, usePropertyResolver = _a === void 0 ? true : _a;
         var reportByYearQuarter = new Map();
         var reportsRawFiltered = reportsRaw;
@@ -33,36 +50,50 @@ var ReportParser = /** @class */ (function () {
         }
         return reportWrappers;
     };
+    /**
+     * Same as parseReports but accepts ReportRaw[] instead of CompanyFactListData
+     */
+    ReportParser.prototype.parseReportsFromRaw = function (params) {
+        var reportsRaw = params.reportsRaw, calculationMap = params.calculationMap;
+        var calcMap = calculationMap !== null && calculationMap !== void 0 ? calculationMap : this.defaultCalculationMap;
+        return reportsRaw.map(function (report) {
+            var _a;
+            var reportNew = {
+                cik: report.cik,
+                dateFiled: report.dateFiled,
+                dateReport: report.dateReport,
+                fiscalPeriod: report.fiscalPeriod,
+                url: report.url,
+                fiscalYear: report.fiscalYear,
+                splitDate: report.splitDate,
+                splitRatio: report.splitRatio,
+            };
+            var reportResolvable = new ReportResolvable_1.default({
+                report: report,
+                calculationMap: calcMap,
+            });
+            for (var key in calcMap) {
+                var value = (_a = reportResolvable.get(key)) !== null && _a !== void 0 ? _a : null;
+                reportNew[key] = value;
+            }
+            return reportNew;
+        });
+    };
     /**
      * Parse raw reports
      *
      * @see https://www.sec.gov/edgar/sec-api-documentation
      */
     ReportParser.prototype.parseReportsRaw = function (companyFactListData, options) {
-        if (options === void 0) { options = {}; }
-        var adjustForSplits = options.adjustForSplits, resolvePeriodValues = options.resolvePeriodValues, includeNamePrefix = options.includeNamePrefix;
+        var includeNamePrefix = options.includeNamePrefix;
         var facts = this.reportBuilder.createFacts(companyFactListData, includeNamePrefix).facts;
-        return this.reportBuilder.buildReports({
-            facts: facts,
-            adjustForSplits: adjustForSplits,
-            resolvePeriodValues: resolvePeriodValues,
-        });
+        return this.reportBuilder.buildReports(__assign({ facts: facts }, options));
     };
     /**
-     * parseReportsRaw but removes meta data from the report
+     * Builds ReportRaw[] from facts
      */
-    ReportParser.prototype.parseReportsRawNoMeta = function (companyFactListData) {
-        var reportsRaw = this.parseReportsRaw(companyFactListData);
-        reportsRaw.forEach(function (reportRaw) {
-            var report = reportRaw;
-            delete report.dateFiled;
-            delete report.dateReport;
-            delete report.fiscalPeriod;
-            delete report.fiscalYear;
-            delete report.splitRatio;
-            delete report.splitDate;
-        });
-        return reportsRaw;
+    ReportParser.prototype.buildReports = function (params) {
+        return this.reportBuilder.buildReports(params);
     };
     /**
      * Translate ReportRaw to ReportTranslated by default, but can be used to translate to any object using both the callback and keyTranslator

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

@@ -0,0 +1,52 @@
+import type { CalculationMapCalculation, CalculationMap } from '../../types/calculation-map.type';
+interface GetCalculatedFromGroupResult {
+    missingKeys: string[] | null;
+    isMissingRequiredKey: boolean;
+    hasAtLeastOneKey: boolean;
+    value: number | null;
+}
+interface GetCalculatedFromGroupParams {
+    group: CalculationMapCalculation;
+    breakIfMissingRequiredKey?: boolean;
+}
+export default class ReportResolvable {
+    readonly report: Record<string, string | number | null | boolean>;
+    private readonly calculationMap;
+    private readonly keyStack;
+    private readonly calculatedValues;
+    private readonly usedGroupIndexesByKey;
+    private depth;
+    constructor(args: {
+        report: Record<string, string | number | null | boolean>;
+        calculationMap?: CalculationMap;
+        /** Used for member facts */
+        pathSeparator?: string;
+    });
+    getMap(): CalculationMap;
+    clearCache(): void;
+    /**
+     * Used when testing to remove groups that are not being used.
+     */
+    getUsedGroupIndexesByKey(): Record<string, number[]>;
+    /**
+     * Gets value from report, or calculates it using calculationMap.
+     */
+    get(key: string): string | number | null | boolean | undefined;
+    /**
+     * Returns 0 for non-numeric values
+     */
+    getNumber(key: string): number;
+    getCalculatedFromGroup(params: GetCalculatedFromGroupParams): GetCalculatedFromGroupResult;
+    private _get;
+    private _getCalculatedFromGroup;
+    /**
+     * @param skipSingleMatch When true, skips groups that match only one key. Used for testing groups.
+     */
+    getCalculated(key: string, skipSingleMatch?: boolean): {
+        value: string | number | boolean | null;
+        groupIndex: number;
+    };
+    private _getCalculated;
+    toJSON(): Record<string, string | number | boolean | null>;
+}
+export {};

package/build/services/ReportParser/ReportResolvable.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ReportResolvable = /** @class */ (function () {
+    function ReportResolvable(args) {
+        this.calculationMap = {};
+        this.keyStack = new Set();
+        this.calculatedValues = new Map();
+        this.usedGroupIndexesByKey = new Map();
+        this.depth = 0;
+        var report = args.report, calculationMap = args.calculationMap;
+        this.calculationMap = calculationMap !== null && calculationMap !== void 0 ? calculationMap : {};
+        this.report = report;
+        this.usedGroupIndexesByKey = new Map();
+    }
+    ReportResolvable.prototype.getMap = function () {
+        return this.calculationMap;
+    };
+    ReportResolvable.prototype.clearCache = function () {
+        this.calculatedValues.clear();
+    };
+    /**
+     * Used when testing to remove groups that are not being used.
+     */
+    ReportResolvable.prototype.getUsedGroupIndexesByKey = function () {
+        var obj = {};
+        this.usedGroupIndexesByKey.forEach(function (indexes, key) { return (obj[key] = Array.from(indexes)); });
+        return obj;
+    };
+    /**
+     * Gets value from report, or calculates it using calculationMap.
+     */
+    ReportResolvable.prototype.get = function (key) {
+        this.depth = 0;
+        return this._get(key);
+    };
+    /**
+     * Returns 0 for non-numeric values
+     */
+    ReportResolvable.prototype.getNumber = function (key) {
+        return Number(this.get(key)) || 0;
+    };
+    ReportResolvable.prototype.getCalculatedFromGroup = function (params) {
+        this.depth = 0;
+        return this._getCalculatedFromGroup(params);
+    };
+    ReportResolvable.prototype._get = function (key, parentKey) {
+        var _a, _b;
+        return (_a = this.report[key]) !== null && _a !== void 0 ? _a : ((_b = this._getCalculated(key, parentKey)) !== null && _b !== void 0 ? _b : {}).value;
+    };
+    ReportResolvable.prototype._getCalculatedFromGroup = function (params, parentKey, skipSingleMatch) {
+        var _a;
+        if (skipSingleMatch === void 0) { skipSingleMatch = false; }
+        var group = params.group, _b = params.breakIfMissingRequiredKey, breakIfMissingRequiredKey = _b === void 0 ? true : _b;
+        var calculation = group.calculation;
+        var hasAtLeastOneKey = false;
+        var isMissingRequiredKey = false;
+        var missingKeys = [];
+        var finalSum = 0;
+        for (var _i = 0, calculation_1 = calculation; _i < calculation_1.length; _i++) {
+            var item = calculation_1[_i];
+            if (skipSingleMatch && calculation.length < 2)
+                continue;
+            var childKey = item.key, weight = item.weight, isRequired = item.isRequired;
+            var value = (_a = this._get(childKey, parentKey)) !== null && _a !== void 0 ? _a : null;
+            var hasKey = typeof value === 'number';
+            hasAtLeastOneKey = hasAtLeastOneKey || hasKey;
+            isMissingRequiredKey = isMissingRequiredKey || (isRequired && !hasKey);
+            if (!hasKey) {
+                missingKeys.push(childKey);
+            }
+            if (isMissingRequiredKey && breakIfMissingRequiredKey) {
+                break;
+            }
+            var valueAdjusted = (Number(value) || 0) * weight;
+            finalSum += valueAdjusted;
+        }
+        return { hasAtLeastOneKey: hasAtLeastOneKey, isMissingRequiredKey: isMissingRequiredKey, missingKeys: missingKeys, value: hasAtLeastOneKey ? finalSum : null };
+    };
+    /**
+     * @param skipSingleMatch When true, skips groups that match only one key. Used for testing groups.
+     */
+    ReportResolvable.prototype.getCalculated = function (key, skipSingleMatch) {
+        var _a;
+        if (skipSingleMatch === void 0) { skipSingleMatch = false; }
+        this.depth = 0;
+        return (_a = this._getCalculated(key, undefined, skipSingleMatch)) !== null && _a !== void 0 ? _a : { value: null, groupIndex: -1 };
+    };
+    ReportResolvable.prototype._getCalculated = function (key, parentKey, skipSingleMatch) {
+        var _a, _b, _c, _d, _e;
+        if (skipSingleMatch === void 0) { skipSingleMatch = false; }
+        this.depth++;
+        if (this.report[key] !== undefined && !skipSingleMatch) {
+            return { value: this.report[key], groupIndex: -1 };
+        }
+        if (this.calculatedValues.has(key)) {
+            var calculatedValue = this.calculatedValues.get(key);
+            var calculatedLength = (_b = (_a = this.calculationMap[key]) === null || _a === void 0 ? void 0 : _a.groups[calculatedValue === null || calculatedValue === void 0 ? void 0 : calculatedValue.groupIndex]) === null || _b === void 0 ? void 0 : _b.calculation.length;
+            if (!skipSingleMatch || calculatedLength > 1)
+                return calculatedValue;
+        }
+        if (this.keyStack.has(key) || this.depth >= 50) {
+            return null;
+        }
+        this.keyStack.add(key);
+        var calculationOptions = (_c = this.calculationMap[key]) !== null && _c !== void 0 ? _c : { isTranslation: true, groups: [] };
+        var result = null;
+        var calculationGroups = (_d = calculationOptions.groups) !== null && _d !== void 0 ? _d : [];
+        for (var i = 0; i < calculationGroups.length; i++) {
+            var group = calculationGroups[i];
+            var _f = this._getCalculatedFromGroup({
+                group: group,
+                breakIfMissingRequiredKey: true,
+            }, key, skipSingleMatch), hasAtLeastOneKey = _f.hasAtLeastOneKey, isMissingRequiredKey = _f.isMissingRequiredKey, value = _f.value;
+            if (!hasAtLeastOneKey || isMissingRequiredKey || typeof value !== 'number') {
+                continue;
+            }
+            var groupResult = { value: value, groupIndex: i };
+            // used for dev purposes to see which groups are being used.
+            var indexBucket = ((_e = this.usedGroupIndexesByKey.get(key)) !== null && _e !== void 0 ? _e : this.usedGroupIndexesByKey.set(key, new Set()).get(key));
+            indexBucket.add(i);
+            result = groupResult;
+            break;
+        }
+        if (parentKey === undefined && !skipSingleMatch) {
+            this.calculatedValues.set(key, result);
+        }
+        this.keyStack.delete(key);
+        return result;
+    };
+    ReportResolvable.prototype.toJSON = function () {
+        return this.report;
+    };
+    return ReportResolvable;
+}());
+exports.default = ReportResolvable;

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

@@ -1,4 +1,4 @@
-import { ReportTranslated } from '../../types';
+import type { ReportTranslated } from '../../types';
 type ExtendableReportProxy = {
     new (report: ReportTranslated): ReportTranslated;
 };

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

@@ -1,4 +1,4 @@
-import { FiscalPeriod, ReportRaw, ReportTranslated } from '../../types';
+import type { FiscalPeriod, ReportRaw, ReportTranslated } from '../../types';
 import ReportTranslatedProxy from './ReportTranslatedProxy';
 /**
  * Contains translated report and raw report with methods to access other reports

package/build/services/ReportParser/resolvers/resolve-ebit.js

@@ -7,6 +7,12 @@ function resolveEbit(report) {
         report.ebit = report.incomeOperating;
         return;
     }
+    if (!report.ebit && report.incomeNet && report.expenseTax) {
+        report.ebit = report.incomeNet + report.expenseTax;
+    }
+    if (!report.ebitda && report.ebit && report.expenseDepreciation) {
+        report.ebitda = report.ebit + report.expenseDepreciation;
+    }
     var _a = report, ebit = _a.ebit, expenseDepreciation = _a.expenseDepreciation, ebitda = _a.ebitda;
     var nullKey = (0, helpers_1.getSingleNullKey)({ ebit: ebit, expenseDepreciation: expenseDepreciation, ebitda: ebitda });
     switch (nullKey) {

package/build/services/ReportParser/resolvers/resolve-q4-fiscal-year-matching-properties.js

@@ -28,7 +28,6 @@ function resolveQ4FiscalYearMatchingProperties(reportWrapper) {
         'liabilityNonCurrentDebt',
         'liabilityTotal',
         'equityRetainedEarnings',
-        'equityStockPreferred',
         'equityTotal',
         'dateFiled',
         'dateReport',

package/build/services/ReportRawBuilder/FactFiscalCalculator.d.ts

@@ -1,3 +1,4 @@
+import type { FactItem, FilingListItemTranslated } from '../../types';
 export interface SetReportDatesParams {
     year: number;
     quarter: number;
@@ -17,6 +18,13 @@ export default class FactFiscalCalculator {
     private readonly endDateCountMap;
     private readonly filedDateCountByEndDate;
     private didResolve;
+    constructor(params?: {
+        facts?: Pick<FactItem, 'end' | 'filed'>[];
+        filings?: Pick<FilingListItemTranslated, 'form' | 'reportDate' | 'filingDate' | 'accessionNumber'>[];
+    });
+    useFilingsForDates(params: {
+        filings: Pick<FilingListItemTranslated, 'form' | 'reportDate' | 'filingDate' | 'accessionNumber'>[];
+    }): void;
     add(fact: {
         end: string;
         filed: string;