@syncfusion/ej2-calculate 35.1.37

package/src/common/address.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Sheet bounds used when expanding whole-row / whole-column references.
+ *
+ * @hidden
+ */
+export interface SheetBounds {
+    rowCount?: number;
+    colCount?: number;
+}
+/**
+ * Returns the 0-based column index for Excel column letters (for example `"A"` → `0`).
+ *
+ * @hidden
+ * @param {string} text - Specifies the text.
+ * @returns {number} - Column index (0-based).
+ */
+export declare function getColIndex(text: string): number;
+/**
+ * Returns Excel column letters for a 1-based column index (for example `1` → `"A"`).
+ *
+ * @hidden
+ * @param {number} colIndex - 1-based column index.
+ * @returns {string} - Column header text.
+ */
+export declare function getColumnHeaderText(colIndex: number): string;
+/**
+ * Parses a cell address into 0-based `[rowIndex, colIndex]`.
+ *
+ * @hidden
+ * @param {string} address - Specifies the address.
+ * @returns {number[]} - [rowIndex, colIndex] (0-based).
+ */
+export declare function getCellIndexes(address: string): number[];
+/**
+ * Builds an `A1`-style cell address from 0-based row and column indexes.
+ *
+ * @hidden
+ * @param {number} sRow - Row index (0-based).
+ * @param {number} sCol - Column index (0-based).
+ * @returns {string} - Cell address.
+ */
+export declare function getCellAddress(sRow: number, sCol: number): string;
+/**
+ * Builds an `A1:B2`-style range address from range indexes.
+ *
+ * @hidden
+ * @param {number[]} range - Range indexes.
+ * @returns {string} - Range address.
+ */
+export declare function getRangeAddress(range: number[]): string;
+/**
+ * Parses a range string into `[startRow, startCol, endRow, endCol]` (0-based).
+ *
+ * @hidden
+ * @param {string} range - Range string (optional sheet prefix allowed).
+ * @param {SheetBounds} [sheetBounds] - Optional sheet bounds for whole-row/column expansion.
+ * @returns {number[]} - Range indexes [startRow, startCol, endRow, endCol].
+ */
+export declare function getRangeIndexes(range: string, sheetBounds?: SheetBounds): number[];

package/src/common/address.js

@@ -0,0 +1,96 @@
+import { isNullOrUndefined } from '@syncfusion/ej2-base';
+/**
+ * Returns the 0-based column index for Excel column letters (for example `"A"` → `0`).
+ *
+ * @hidden
+ * @param {string} text - Specifies the text.
+ * @returns {number} - Column index (0-based).
+ */
+export function getColIndex(text) {
+    var colIdx = 0;
+    text = text.split('').reverse().join('');
+    for (var i = text.length - 1; i >= 0; i--) {
+        colIdx += (text[i].charCodeAt(0) - 64) * (Math.pow(26, i));
+    }
+    return colIdx - 1;
+}
+/**
+ * Returns Excel column letters for a 1-based column index (for example `1` → `"A"`).
+ *
+ * @hidden
+ * @param {number} colIndex - 1-based column index.
+ * @returns {string} - Column header text.
+ */
+export function getColumnHeaderText(colIndex) {
+    var alphabet = 'Z';
+    if (colIndex / 26 > 1) {
+        return getColumnHeaderText((colIndex % 26 === 0) ? (colIndex / 26 - 1) : Math.floor(colIndex / 26))
+            + String.fromCharCode((colIndex % 26) === 0 ? alphabet.charCodeAt(0) : 64 + (colIndex % 26));
+    }
+    else {
+        return String.fromCharCode(64 + (colIndex));
+    }
+}
+/**
+ * Parses a cell address into 0-based `[rowIndex, colIndex]`.
+ *
+ * @hidden
+ * @param {string} address - Specifies the address.
+ * @returns {number[]} - [rowIndex, colIndex] (0-based).
+ */
+export function getCellIndexes(address) {
+    return [parseInt(address.match(/\d+/)[0], 10) - 1, getColIndex(address.match(/[A-Z]+/i)[0].toUpperCase())];
+}
+/**
+ * Builds an `A1`-style cell address from 0-based row and column indexes.
+ *
+ * @hidden
+ * @param {number} sRow - Row index (0-based).
+ * @param {number} sCol - Column index (0-based).
+ * @returns {string} - Cell address.
+ */
+export function getCellAddress(sRow, sCol) {
+    return getColumnHeaderText(sCol + 1) + (sRow + 1);
+}
+/**
+ * Builds an `A1:B2`-style range address from range indexes.
+ *
+ * @hidden
+ * @param {number[]} range - Range indexes.
+ * @returns {string} - Range address.
+ */
+export function getRangeAddress(range) {
+    return getCellAddress(range[0], range[1]) + ':' + (!isNullOrUndefined(range[2]) ?
+        getCellAddress(range[2], range[3]) : getCellAddress(range[0], range[1]));
+}
+/**
+ * Parses a range string into `[startRow, startCol, endRow, endCol]` (0-based).
+ *
+ * @hidden
+ * @param {string} range - Range string (optional sheet prefix allowed).
+ * @param {SheetBounds} [sheetBounds] - Optional sheet bounds for whole-row/column expansion.
+ * @returns {number[]} - Range indexes [startRow, startCol, endRow, endCol].
+ */
+export function getRangeIndexes(range, sheetBounds) {
+    var cellindexes;
+    var indexes = [];
+    if (range) {
+        range = range.lastIndexOf('!') > -1 ? range.substring(range.lastIndexOf('!') + 1) : range;
+        range = range.indexOf(':') === -1 ? range + ':' + range : range;
+        var containsAlphabetsAndDigits = new RegExp(/^(?=.*[a-zA-Z])(?=.*\d)/g);
+        if (!containsAlphabetsAndDigits.test(range)) {
+            var refArr = range.split(':');
+            var rowCount = sheetBounds && sheetBounds.rowCount ? sheetBounds.rowCount - 1 : 1;
+            var colHeader = sheetBounds && sheetBounds.colCount ?
+                getColumnHeaderText(sheetBounds.colCount) : 'A';
+            range = isNullOrUndefined(range.match(/[0-9]/)) ? (refArr[0] + '1:' + refArr[1] + rowCount) :
+                ('A' + refArr[0] + ':' + colHeader + refArr[1]);
+        }
+        range.split(':').forEach(function (address) {
+            cellindexes = getCellIndexes(address);
+            indexes.push(cellindexes[0]);
+            indexes.push(cellindexes[1]);
+        });
+    }
+    return indexes;
+}

package/src/common/cell-ref.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Check whether the value is character or not.
+ *
+ * @hidden
+ * @param {string} value - Specify the value to check.
+ * @returns {boolean} - Returns boolean value.
+ */
+export declare function isChar(value: string): boolean;
+/**
+ * Resolve column index from cell text (1-based Excel style).
+ *
+ * @hidden
+ * @param {string} cell - Cell text.
+ * @returns {number} - Column index.
+ */
+export declare function columnIndex(cell: string): number;
+/**
+ * Check whether the value is a valid single cell reference.
+ *
+ * @hidden
+ * @param {string} value - Specify the value to check.
+ * @returns {boolean} - Returns boolean value.
+ */
+export declare function isValidCellReference(value: string): boolean;
+/**
+ * Check whether the value is cell reference or not.
+ *
+ * @hidden
+ * @param {string} value - Specify the value to check.
+ * @returns {boolean} - Returns boolean value.
+ */
+export declare function isCellReference(value: string): boolean;

package/src/common/cell-ref.js

@@ -0,0 +1,112 @@
+/**
+ * Check whether the value is character or not.
+ *
+ * @hidden
+ * @param {string} value - Specify the value to check.
+ * @returns {boolean} - Returns boolean value.
+ */
+export function isChar(value) {
+    if ((value.charCodeAt(0) >= 65 && value.charCodeAt(0) <= 90) || (value.charCodeAt(0) >= 97 && value.charCodeAt(0) <= 122)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Resolve column index from cell text (1-based Excel style).
+ *
+ * @hidden
+ * @param {string} cell - Cell text.
+ * @returns {number} - Column index.
+ */
+export function columnIndex(cell) {
+    var j = 0;
+    var k = 0;
+    cell = cell.toUpperCase();
+    if (j < cell.length && cell[j] === '!') {
+        j++;
+        while (j < cell.length && cell[j] !== '!') {
+            j++;
+        }
+        j++;
+    }
+    while (j < cell.length && isChar(cell[j])) {
+        var charCode = cell[j].charCodeAt(0);
+        k = k * 26 + charCode - 64;
+        j++;
+    }
+    if (k === 0) {
+        return -1;
+    }
+    return k;
+}
+/**
+ * Check whether the value is a valid single cell reference.
+ *
+ * @hidden
+ * @param {string} value - Specify the value to check.
+ * @returns {boolean} - Returns boolean value.
+ */
+export function isValidCellReference(value) {
+    var text = value;
+    var endNum = 0;
+    var textLength = text.length;
+    for (var i = 0; i < textLength; i++) {
+        if (isChar(text[i])) {
+            endNum++;
+        }
+    }
+    var cellText = text.substring(0, endNum);
+    var cellTextLength = cellText.length;
+    if (cellTextLength !== textLength) {
+        if (cellTextLength < 4) {
+            if (textLength !== 1 && (isNaN(parseInt(text, 10)))) {
+                var cellColIndex = columnIndex(cellText);
+                // XFD is the last column, 16384 - Maximum number of columns in excel.
+                if (cellColIndex < 1 || cellColIndex > 16384) {
+                    return false;
+                }
+                var rowText = text.substring(endNum, textLength);
+                if (rowText.length > 0) {
+                    var isNumeric = true;
+                    for (var j = 0; j < rowText.length; j++) {
+                        var charCode = rowText.charCodeAt(j);
+                        if (charCode < 48 || charCode > 57) {
+                            isNumeric = false;
+                            break;
+                        }
+                    }
+                    if (isNumeric) {
+                        var cellNumber = parseFloat(rowText);
+                        if (cellNumber > 0 && cellNumber < 1048577) { // 1048576 - Maximum number of rows in excel.
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Check whether the value is cell reference or not.
+ *
+ * @hidden
+ * @param {string} value - Specify the value to check.
+ * @returns {boolean} - Returns boolean value.
+ */
+export function isCellReference(value) {
+    var range = value;
+    range = range.split('$').join('');
+    if (range.indexOf(':') > -1) {
+        var rangeSplit = range.split(':');
+        if (isValidCellReference(rangeSplit[0]) && isValidCellReference(rangeSplit[1])) {
+            return true;
+        }
+    }
+    else if (range.indexOf(':') < 0) {
+        if (isValidCellReference(range)) {
+            return true;
+        }
+    }
+    return false;
+}

package/src/common/common.d.ts

@@ -0,0 +1,44 @@
+import { Calculate } from '../base';
+/**
+ * Shared Calculate helper module used by spreadsheet integrations.
+ *
+ * @hidden
+ */
+export declare class CalculateCommon {
+    private parent;
+    /**
+     * @param {Object} parent - Owning Calculate engine.
+     */
+    constructor(parent: Calculate);
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} - Get the module name.
+     */
+    protected getModuleName(): string;
+}
+/**
+ * To check whether the object is undefined.
+ *
+ * @hidden
+ * @param {Object} value - To check the object is undefined
+ * @returns {boolean} - Returns boolean value.
+ * @private
+ */
+export declare function isUndefined(value: Object): boolean;
+/**
+ * @hidden
+ * @param {string} value - specify the value
+ * @returns {string} - get Skeleton Value.
+ */
+export declare function getSkeletonVal(value: string): string;
+/**
+ * To check whether the formula contains external file link.
+ *
+ * @hidden
+ * @param {string} formula - To check the string contains external file link.
+ * @returns {boolean} - Returns boolean value.
+ * @private
+ */
+export declare function isExternalFileLink(formula: string): boolean;

package/src/common/common.js

@@ -0,0 +1,134 @@
+import { ExcelFileFormats } from './enum';
+/**
+ * Shared Calculate helper module used by spreadsheet integrations.
+ *
+ * @hidden
+ */
+var CalculateCommon = /** @class */ (function () {
+    /**
+     * @param {Object} parent - Owning Calculate engine.
+     */
+    function CalculateCommon(parent) {
+        this.parent = parent;
+    }
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} - Get the module name.
+     */
+    CalculateCommon.prototype.getModuleName = function () {
+        return 'calc-common';
+    };
+    return CalculateCommon;
+}());
+export { CalculateCommon };
+/**
+ * To check whether the object is undefined.
+ *
+ * @hidden
+ * @param {Object} value - To check the object is undefined
+ * @returns {boolean} - Returns boolean value.
+ * @private
+ */
+export function isUndefined(value) {
+    return ('undefined' === typeof value);
+}
+/**
+ * @hidden
+ * @param {string} value - specify the value
+ * @returns {string} - get Skeleton Value.
+ */
+export function getSkeletonVal(value) {
+    switch (value) {
+        case 'dd-MMM-yyyy':
+        case 'dd MMM yyyy':
+            value = 'medium';
+            break;
+        case 'MMM yyyy':
+            value = 'yMMM';
+            break;
+        case 'MM/dd/yyyy':
+        case 'dd/MM/yyyy':
+        case 'dd/MM/yy':
+            value = 'short';
+            break;
+        case 'dddd MMMM dd yyyy': //long
+        case 'dd MMMM yyyy':
+            value = 'long';
+            break;
+        case 'd MMMM yyyy':
+            value = 'yMMMd';
+            break;
+        case 'yyyy':
+            value = 'y';
+            break;
+        case 'h:mm':
+            value = 'Hm';
+            break;
+        case 'h:mm tt':
+            value = 'hm';
+            break;
+        case 'h':
+            value = 'H';
+            break;
+        case 'h tt':
+            value = 'h';
+            break;
+        case 'h:mm:ss tt':
+            value = 'hms';
+            break;
+        case 'h:mm:ss':
+            value = 'Hms';
+            break;
+        case 'd':
+            value = 'd';
+            break;
+        case 'd dddd':
+            value = 'Ed';
+            break;
+        case 'M':
+            value = 'M';
+            break;
+        case 'Md':
+            value = 'Md';
+            break;
+        case 'MMM':
+            value = 'MMM';
+            break;
+        case 'ddd MMM d':
+            value = 'MMMEd';
+            break;
+        case 'MMM d':
+            value = 'MMMd';
+            break;
+        case 'M/yyyy':
+            value = 'yM';
+            break;
+        case 'ddd':
+            value = 'E';
+            break;
+        default:
+            value = '';
+            break;
+    }
+    return value;
+}
+/**
+ * To check whether the formula contains external file link.
+ *
+ * @hidden
+ * @param {string} formula - To check the string contains external file link.
+ * @returns {boolean} - Returns boolean value.
+ * @private
+ */
+export function isExternalFileLink(formula) {
+    var isExternalFile = false;
+    for (var format in ExcelFileFormats) {
+        if (formula.indexOf('.' + format + ']') > -1) {
+            isExternalFile = true;
+            break;
+        }
+    }
+    return isExternalFile;
+}

package/src/common/enum.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Indexes into {@link Calculate.getErrorStrings} for Excel-compatible error tokens.
+ *
+ * @hidden
+ *
+ * @example
+ * ```ts
+ * const na = engine.getErrorStrings()[CommonErrors.NA]; // '#N/A'
+ * ```
+ */
+export declare enum CommonErrors {
+    /** `#N/A` */
+    NA = 0,
+    /** `#VALUE!` */
+    Value = 1,
+    /** `#REF!` */
+    Ref = 2,
+    /** `#DIV/0!` */
+    DivZero = 3,
+    /** `#NUM!` */
+    Num = 4,
+    /** `#NAME?` */
+    Name = 5,
+    /** `#NULL!` */
+    Null = 6,
+    /** `#CALC!` */
+    Calc = 7
+}
+/**
+ * Indexes into {@link Calculate.formulaErrorStrings} for parser/engine failure messages.
+ *
+ * @hidden
+ */
+export declare enum FormulasErrorsStrings {
+    OperatorsCannotStartWithExpression = 0,
+    ReservedWordAND = 1,
+    ReservedWordXOR = 2,
+    ReservedWordIf = 3,
+    NumberContains2DecimalPoints = 4,
+    ReservedWordElse = 5,
+    ReservedWordNOT = 6,
+    InvalidCharInNumber = 7,
+    InvalidCharactersFollowingWithOperator = 6,
+    MismatchedParentheses = 8,
+    UnknownFormulaName = 9,
+    RequiresASingleArgument = 10,
+    Requires3Args = 11,
+    InvalidMathArgument = 12,
+    Requires2Args = 13,
+    BadIndex = 14,
+    TooComplex = 15,
+    CircularReference = 16,
+    MissingFormula = 17,
+    ImproperFormula = 18,
+    InvalidExpression = 19,
+    CellEmpty = 20,
+    BadFormula = 21,
+    EmptyExpression = 22,
+    VirtualModeRequired = 23,
+    MismatchedTics = 24,
+    WrongNumberArguments = 25,
+    InvalidArguments = 26,
+    IterationsDoNotConverge = 27,
+    CalculationOverflow = 29,
+    AlreadyRegistered = 28,
+    MissingSheet = 30,
+    CannotParse = 31,
+    ExpressionCannotEndWithAnOperator = 32,
+    Spill = 33,
+    Div = 34
+}
+/**
+ * Excel file format extensions recognized by Calculate helpers.
+ *
+ * @hidden
+ */
+export declare enum ExcelFileFormats {
+    xlsx = "xlsx",
+    xlsm = "xlsm",
+    xlsb = "xlsb",
+    xltx = "xltx",
+    xltm = "xltm",
+    xls = "xls",
+    xml = "xml",
+    xlam = "xlam",
+    xla = "xla",
+    xlw = "xlw",
+    xlr = "xlr",
+    prn = "prn",
+    txt = "txt",
+    csv = "csv",
+    dif = "dif",
+    slk = "slk"
+}

package/src/common/enum.js

@@ -0,0 +1,97 @@
+/**
+ * Indexes into {@link Calculate.getErrorStrings} for Excel-compatible error tokens.
+ *
+ * @hidden
+ *
+ * @example
+ * ```ts
+ * const na = engine.getErrorStrings()[CommonErrors.NA]; // '#N/A'
+ * ```
+ */
+export var CommonErrors;
+(function (CommonErrors) {
+    /** `#N/A` */
+    CommonErrors[CommonErrors["NA"] = 0] = "NA";
+    /** `#VALUE!` */
+    CommonErrors[CommonErrors["Value"] = 1] = "Value";
+    /** `#REF!` */
+    CommonErrors[CommonErrors["Ref"] = 2] = "Ref";
+    /** `#DIV/0!` */
+    CommonErrors[CommonErrors["DivZero"] = 3] = "DivZero";
+    /** `#NUM!` */
+    CommonErrors[CommonErrors["Num"] = 4] = "Num";
+    /** `#NAME?` */
+    CommonErrors[CommonErrors["Name"] = 5] = "Name";
+    /** `#NULL!` */
+    CommonErrors[CommonErrors["Null"] = 6] = "Null";
+    /** `#CALC!` */
+    CommonErrors[CommonErrors["Calc"] = 7] = "Calc";
+})(CommonErrors || (CommonErrors = {}));
+/**
+ * Indexes into {@link Calculate.formulaErrorStrings} for parser/engine failure messages.
+ *
+ * @hidden
+ */
+export var FormulasErrorsStrings;
+(function (FormulasErrorsStrings) {
+    FormulasErrorsStrings[FormulasErrorsStrings["OperatorsCannotStartWithExpression"] = 0] = "OperatorsCannotStartWithExpression";
+    FormulasErrorsStrings[FormulasErrorsStrings["ReservedWordAND"] = 1] = "ReservedWordAND";
+    FormulasErrorsStrings[FormulasErrorsStrings["ReservedWordXOR"] = 2] = "ReservedWordXOR";
+    FormulasErrorsStrings[FormulasErrorsStrings["ReservedWordIf"] = 3] = "ReservedWordIf";
+    FormulasErrorsStrings[FormulasErrorsStrings["NumberContains2DecimalPoints"] = 4] = "NumberContains2DecimalPoints";
+    FormulasErrorsStrings[FormulasErrorsStrings["ReservedWordElse"] = 5] = "ReservedWordElse";
+    FormulasErrorsStrings[FormulasErrorsStrings["ReservedWordNOT"] = 6] = "ReservedWordNOT";
+    FormulasErrorsStrings[FormulasErrorsStrings["InvalidCharInNumber"] = 7] = "InvalidCharInNumber";
+    FormulasErrorsStrings[FormulasErrorsStrings["InvalidCharactersFollowingWithOperator"] = 6] = "InvalidCharactersFollowingWithOperator";
+    FormulasErrorsStrings[FormulasErrorsStrings["MismatchedParentheses"] = 8] = "MismatchedParentheses";
+    FormulasErrorsStrings[FormulasErrorsStrings["UnknownFormulaName"] = 9] = "UnknownFormulaName";
+    FormulasErrorsStrings[FormulasErrorsStrings["RequiresASingleArgument"] = 10] = "RequiresASingleArgument";
+    FormulasErrorsStrings[FormulasErrorsStrings["Requires3Args"] = 11] = "Requires3Args";
+    FormulasErrorsStrings[FormulasErrorsStrings["InvalidMathArgument"] = 12] = "InvalidMathArgument";
+    FormulasErrorsStrings[FormulasErrorsStrings["Requires2Args"] = 13] = "Requires2Args";
+    FormulasErrorsStrings[FormulasErrorsStrings["BadIndex"] = 14] = "BadIndex";
+    FormulasErrorsStrings[FormulasErrorsStrings["TooComplex"] = 15] = "TooComplex";
+    FormulasErrorsStrings[FormulasErrorsStrings["CircularReference"] = 16] = "CircularReference";
+    FormulasErrorsStrings[FormulasErrorsStrings["MissingFormula"] = 17] = "MissingFormula";
+    FormulasErrorsStrings[FormulasErrorsStrings["ImproperFormula"] = 18] = "ImproperFormula";
+    FormulasErrorsStrings[FormulasErrorsStrings["InvalidExpression"] = 19] = "InvalidExpression";
+    FormulasErrorsStrings[FormulasErrorsStrings["CellEmpty"] = 20] = "CellEmpty";
+    FormulasErrorsStrings[FormulasErrorsStrings["BadFormula"] = 21] = "BadFormula";
+    FormulasErrorsStrings[FormulasErrorsStrings["EmptyExpression"] = 22] = "EmptyExpression";
+    FormulasErrorsStrings[FormulasErrorsStrings["VirtualModeRequired"] = 23] = "VirtualModeRequired";
+    FormulasErrorsStrings[FormulasErrorsStrings["MismatchedTics"] = 24] = "MismatchedTics";
+    FormulasErrorsStrings[FormulasErrorsStrings["WrongNumberArguments"] = 25] = "WrongNumberArguments";
+    FormulasErrorsStrings[FormulasErrorsStrings["InvalidArguments"] = 26] = "InvalidArguments";
+    FormulasErrorsStrings[FormulasErrorsStrings["IterationsDoNotConverge"] = 27] = "IterationsDoNotConverge";
+    FormulasErrorsStrings[FormulasErrorsStrings["CalculationOverflow"] = 29] = "CalculationOverflow";
+    FormulasErrorsStrings[FormulasErrorsStrings["AlreadyRegistered"] = 28] = "AlreadyRegistered";
+    FormulasErrorsStrings[FormulasErrorsStrings["MissingSheet"] = 30] = "MissingSheet";
+    FormulasErrorsStrings[FormulasErrorsStrings["CannotParse"] = 31] = "CannotParse";
+    FormulasErrorsStrings[FormulasErrorsStrings["ExpressionCannotEndWithAnOperator"] = 32] = "ExpressionCannotEndWithAnOperator";
+    FormulasErrorsStrings[FormulasErrorsStrings["Spill"] = 33] = "Spill";
+    FormulasErrorsStrings[FormulasErrorsStrings["Div"] = 34] = "Div";
+})(FormulasErrorsStrings || (FormulasErrorsStrings = {}));
+/**
+ * Excel file format extensions recognized by Calculate helpers.
+ *
+ * @hidden
+ */
+export var ExcelFileFormats;
+(function (ExcelFileFormats) {
+    ExcelFileFormats["xlsx"] = "xlsx";
+    ExcelFileFormats["xlsm"] = "xlsm";
+    ExcelFileFormats["xlsb"] = "xlsb";
+    ExcelFileFormats["xltx"] = "xltx";
+    ExcelFileFormats["xltm"] = "xltm";
+    ExcelFileFormats["xls"] = "xls";
+    ExcelFileFormats["xml"] = "xml";
+    ExcelFileFormats["xlam"] = "xlam";
+    ExcelFileFormats["xla"] = "xla";
+    ExcelFileFormats["xlw"] = "xlw";
+    ExcelFileFormats["xlr"] = "xlr";
+    ExcelFileFormats["prn"] = "prn";
+    ExcelFileFormats["txt"] = "txt";
+    ExcelFileFormats["csv"] = "csv";
+    ExcelFileFormats["dif"] = "dif";
+    ExcelFileFormats["slk"] = "slk";
+})(ExcelFileFormats || (ExcelFileFormats = {}));

package/src/common/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared Calculate types, error enumerations, cell addressing, and host helpers.
+ *
+ * @packageDocumentation
+ */
+export * from './common';
+export * from './enum';
+export * from './interface';
+export * from './l10n';

package/src/common/index.js

@@ -0,0 +1,8 @@
+/**
+ * Shared Calculate types, error enumerations, cell addressing, and host helpers.
+ *
+ * @packageDocumentation
+ */
+export * from './common';
+export * from './enum';
+export * from './l10n';