@lofcz/tinysheet-formula-parser 0.2.13 → 1.0.2

package/dist/index.js

@@ -0,0 +1,934 @@
+import Emitter from "tiny-emitter";
+import * as formulajsNs from "@formulajs/formulajs";
+import { EmbeddedActionsParser, Lexer, createToken } from "chevrotain";
+//#region packages/formula-parser/src/helper/number.js
+/**
+* Convert value into number.
+*
+* @param {String|Number} number
+* @returns {*}
+*/
+function toNumber(number) {
+	let result;
+	if (typeof number === "number") result = number;
+	else if (typeof number === "string") result = number.indexOf(".") > -1 ? parseFloat(number) : parseInt(number, 10);
+	return result;
+}
+/**
+* Invert provided number.
+*
+* @param {Number} number
+* @returns {Number} Returns inverted number.
+*/
+function invertNumber(number) {
+	return -1 * toNumber(number);
+}
+//#endregion
+//#region packages/formula-parser/src/error.js
+const ERROR = "ERROR";
+const ERROR_DIV_ZERO = "DIV/0";
+const ERROR_NAME = "NAME";
+const ERROR_NOT_AVAILABLE = "N/A";
+const ERROR_NULL = "NULL";
+const ERROR_NUM = "NUM";
+const ERROR_REF = "REF";
+const ERROR_VALUE = "VALUE";
+const errors = {
+	[ERROR]: "#ERROR!",
+	[ERROR_DIV_ZERO]: "#DIV/0!",
+	[ERROR_NAME]: "#NAME?",
+	["N/A"]: "#N/A",
+	[ERROR_NULL]: "#NULL!",
+	["NUM"]: "#NUM!",
+	["REF"]: "#REF!",
+	[ERROR_VALUE]: "#VALUE!"
+};
+/**
+* Return error type based on provided error id.
+*
+* @param {String} type Error type.
+* @returns {String|null} Returns error id.
+*/
+function error(type) {
+	let result;
+	type = (type + "").replace(/#|!|\?/g, "");
+	if (errors[type]) result = errors[type];
+	return result ? result : null;
+}
+/**
+* Check if error type is strict valid with knows errors.
+*
+* @param {String} Error type.
+* @return {Boolean}
+*/
+function isValidStrict(type) {
+	let valid = false;
+	for (const i in errors) if (Object.prototype.hasOwnProperty.call(errors, i) && errors[i] === type) {
+		valid = true;
+		break;
+	}
+	return valid;
+}
+function func$12(first, ...rest) {
+	const result = rest.reduce((acc, value) => acc + toNumber(value || 0), toNumber(first || 0));
+	if (isNaN(result)) throw Error(ERROR_VALUE);
+	return result;
+}
+func$12.SYMBOL = "+";
+function func$11(...params) {
+	return params.reduce((acc, value) => acc + value.toString(), "");
+}
+func$11.SYMBOL = "&";
+function func$10(first, ...rest) {
+	const result = rest.reduce((acc, value) => acc / toNumber(value), toNumber(first));
+	if (result === Infinity) throw Error(ERROR_DIV_ZERO);
+	if (isNaN(result)) throw Error(ERROR_VALUE);
+	return result;
+}
+func$10.SYMBOL = "/";
+function func$9(exp1, exp2) {
+	return exp1 === exp2;
+}
+func$9.SYMBOL = "=";
+//#endregion
+//#region packages/formula-parser/src/formulajs.js
+function functionKeyCount(obj) {
+	if (!obj || typeof obj !== "object") return 0;
+	return Object.keys(obj).filter((key) => typeof obj[key] === "function").length;
+}
+/**
+* Vitest/Vite CJS interop puts formulas on `.default` (enumerable).
+* Bun flattens them onto the namespace; `.default` is a smaller legacy map.
+* Prefer whichever object exposes more formula functions.
+*/
+const formulajs = functionKeyCount(formulajsNs.default) > functionKeyCount(formulajsNs) ? formulajsNs.default : formulajsNs;
+//#endregion
+//#region packages/formula-parser/src/supported-formulas.js
+/**
+* Collect formula call names, including Excel-style dotted paths
+* (RANK.EQ, BINOM.DIST.RANGE, T.DIST.2T, …).
+*
+* Uses a path stack (not a global visited set) so the same formulajs
+* function object can contribute aliases under multiple Excel names
+* (e.g. CHIDIST.RT and CHISQ.DIST.RT).
+*/
+function collectSupportedFormulas(lib, prefix = "", names = /* @__PURE__ */ new Set(), stack = /* @__PURE__ */ new Set()) {
+	if (!lib || typeof lib !== "object" && typeof lib !== "function") return names;
+	if (stack.has(lib)) return names;
+	stack.add(lib);
+	for (const key of Object.keys(lib)) {
+		const value = lib[key];
+		const name = prefix ? `${prefix}.${key}` : key;
+		if (typeof value === "function") {
+			names.add(name);
+			collectSupportedFormulas(value, name, names, stack);
+		} else if (value && typeof value === "object") collectSupportedFormulas(value, name, names, stack);
+	}
+	stack.delete(lib);
+	return names;
+}
+const SUPPORTED_FORMULAS = [...collectSupportedFormulas(formulajs)];
+//#endregion
+//#region packages/formula-parser/src/evaluate-by-operator/operator/formula-function.js
+const SYMBOL$8 = SUPPORTED_FORMULAS;
+function func$8(symbol) {
+	return function __formulaFunction(...params) {
+		symbol = symbol.toUpperCase();
+		const symbolParts = symbol.split(".");
+		let foundFormula = false;
+		let result;
+		if (symbolParts.length === 1) {
+			if (formulajs[symbolParts[0]]) {
+				foundFormula = true;
+				result = formulajs[symbolParts[0]](...params);
+			}
+		} else {
+			const length = symbolParts.length;
+			let index = 0;
+			let nestedFormula = formulajs;
+			while (index < length) {
+				nestedFormula = nestedFormula[symbolParts[index]];
+				index++;
+				if (!nestedFormula) {
+					nestedFormula = null;
+					break;
+				}
+			}
+			if (nestedFormula) {
+				foundFormula = true;
+				result = nestedFormula(...params);
+			}
+		}
+		if (!foundFormula) throw Error(ERROR_NAME);
+		if (result instanceof Error) throw result;
+		return result;
+	};
+}
+func$8.isFactory = true;
+func$8.SYMBOL = SYMBOL$8;
+function func$7(exp1, exp2) {
+	return exp1 > exp2;
+}
+func$7.SYMBOL = ">";
+function func$6(exp1, exp2) {
+	return exp1 >= exp2;
+}
+func$6.SYMBOL = ">=";
+function func$5(exp1, exp2) {
+	return exp1 < exp2;
+}
+func$5.SYMBOL = "<";
+function func$4(exp1, exp2) {
+	return exp1 <= exp2;
+}
+func$4.SYMBOL = "<=";
+function func$3(first, ...rest) {
+	const result = rest.reduce((acc, value) => acc - toNumber(value), toNumber(first));
+	if (isNaN(result)) throw Error(ERROR_VALUE);
+	return result;
+}
+func$3.SYMBOL = "-";
+function func$2(first, ...rest) {
+	const result = rest.reduce((acc, value) => acc * toNumber(value), toNumber(first));
+	if (isNaN(result)) throw Error(ERROR_VALUE);
+	return result;
+}
+func$2.SYMBOL = "*";
+function func$1(exp1, exp2) {
+	return exp1 !== exp2;
+}
+func$1.SYMBOL = "<>";
+function func(exp1, exp2) {
+	const result = Math.pow(toNumber(exp1), toNumber(exp2));
+	if (isNaN(result)) throw Error(ERROR_VALUE);
+	return result;
+}
+func.SYMBOL = "^";
+//#endregion
+//#region packages/formula-parser/src/evaluate-by-operator/evaluate-by-operator.js
+const availableOperators = Object.create(null);
+/**
+* Evaluate values by operator id.git
+*
+* @param {String} operator Operator id.
+* @param {Array} [params=[]] Arguments to evaluate.
+* @returns {*}
+*/
+function evaluateByOperator(operator, params = []) {
+	operator = operator.toUpperCase();
+	if (!availableOperators[operator]) throw Error(ERROR_NAME);
+	return availableOperators[operator](...params);
+}
+/**
+* Register operator.
+*
+* @param {String|Array} symbol Symbol to register.
+* @param {Function} func Logic to register for this symbol.
+*/
+function registerOperation(symbol, func) {
+	if (!Array.isArray(symbol)) symbol = [symbol.toUpperCase()];
+	symbol.forEach((s) => {
+		if (func.isFactory) availableOperators[s] = func(s);
+		else availableOperators[s] = func;
+	});
+}
+registerOperation(func$12.SYMBOL, func$12);
+registerOperation(func$11.SYMBOL, func$11);
+registerOperation(func$10.SYMBOL, func$10);
+registerOperation(func$9.SYMBOL, func$9);
+registerOperation(func.SYMBOL, func);
+registerOperation(func$8.SYMBOL, func$8);
+registerOperation(func$7.SYMBOL, func$7);
+registerOperation(func$6.SYMBOL, func$6);
+registerOperation(func$5.SYMBOL, func$5);
+registerOperation(func$4.SYMBOL, func$4);
+registerOperation(func$2.SYMBOL, func$2);
+registerOperation(func$1.SYMBOL, func$1);
+registerOperation(func$3.SYMBOL, func$3);
+//#endregion
+//#region packages/formula-parser/src/grammar-parser/grammar-parser.js
+const sheetNameRegexp = `(?:[A-Za-z0-9_À-ʯ]+|'(?:(?!').|'')*')!`;
+const WhiteSpace = createToken({
+	name: "WhiteSpace",
+	pattern: /\s+/,
+	group: Lexer.SKIPPED
+});
+const StringLiteral = createToken({
+	name: "StringLiteral",
+	pattern: /"(?:\\["]|[^"])*"|'(?:\\[']|[^'])*'/
+});
+const ErrorLiteral = createToken({
+	name: "ErrorLiteral",
+	pattern: /#[A-Z0-9/]+[!?]?/
+});
+const FunctionName = createToken({
+	name: "FunctionName",
+	pattern: /[A-Za-z][A-Za-z0-9_.]*(?=\()/
+});
+const AbsoluteCell = createToken({
+	name: "AbsoluteCell",
+	pattern: new RegExp(`(?:${sheetNameRegexp})?\\$[A-Za-z]+\\$[0-9]+`)
+});
+const MixedCell = createToken({
+	name: "MixedCell",
+	pattern: new RegExp(`(?:${sheetNameRegexp})?(?:\\$[A-Za-z]+[0-9]+|[A-Za-z]+\\$[0-9]+)`)
+});
+const RelativeCell = createToken({
+	name: "RelativeCell",
+	pattern: new RegExp(`(?:${sheetNameRegexp})?[A-Za-z]+[0-9]+`)
+});
+const ArrayLiteral = createToken({
+	name: "ArrayLiteral",
+	pattern: /\[[^\]]*]/
+});
+const NumberLiteral = createToken({
+	name: "NumberLiteral",
+	pattern: /(?:\d+\.?\d*|\.\d+)/
+});
+const Variable = createToken({
+	name: "Variable",
+	pattern: /[A-Za-z_][A-Za-z0-9_.]*/
+});
+const NotOp = createToken({
+	name: "NotOp",
+	pattern: /NOT/,
+	longer_alt: Variable
+});
+const OpNe = createToken({
+	name: "OpNe",
+	pattern: /<>/
+});
+const OpLe = createToken({
+	name: "OpLe",
+	pattern: /<=/
+});
+const OpGe = createToken({
+	name: "OpGe",
+	pattern: />=/
+});
+const OpEq = createToken({
+	name: "OpEq",
+	pattern: /=/
+});
+const OpLt = createToken({
+	name: "OpLt",
+	pattern: /</
+});
+const OpGt = createToken({
+	name: "OpGt",
+	pattern: />/
+});
+const OpPlus = createToken({
+	name: "OpPlus",
+	pattern: /\+/
+});
+const OpMinus = createToken({
+	name: "OpMinus",
+	pattern: /-/
+});
+const OpMul = createToken({
+	name: "OpMul",
+	pattern: /\*/
+});
+const OpDiv = createToken({
+	name: "OpDiv",
+	pattern: /\//
+});
+const OpPow = createToken({
+	name: "OpPow",
+	pattern: /\^/
+});
+const OpConcat = createToken({
+	name: "OpConcat",
+	pattern: /&/
+});
+const OpPercent = createToken({
+	name: "OpPercent",
+	pattern: /%/
+});
+const LParen = createToken({
+	name: "LParen",
+	pattern: /\(/
+});
+const RParen = createToken({
+	name: "RParen",
+	pattern: /\)/
+});
+const Colon = createToken({
+	name: "Colon",
+	pattern: /:/
+});
+const Semicolon = createToken({
+	name: "Semicolon",
+	pattern: /;/
+});
+const Comma = createToken({
+	name: "Comma",
+	pattern: /,/
+});
+const Dot = createToken({
+	name: "Dot",
+	pattern: /\./
+});
+const allTokens = [
+	WhiteSpace,
+	StringLiteral,
+	ErrorLiteral,
+	FunctionName,
+	AbsoluteCell,
+	MixedCell,
+	RelativeCell,
+	ArrayLiteral,
+	NumberLiteral,
+	OpNe,
+	OpLe,
+	OpGe,
+	NotOp,
+	OpEq,
+	OpLt,
+	OpGt,
+	OpPlus,
+	OpMinus,
+	OpMul,
+	OpDiv,
+	OpPow,
+	OpConcat,
+	OpPercent,
+	LParen,
+	RParen,
+	Colon,
+	Semicolon,
+	Comma,
+	Dot,
+	Variable
+];
+const FormulaLexer = new Lexer(allTokens);
+var FormulaParser = class extends EmbeddedActionsParser {
+	constructor() {
+		super(allTokens);
+		const $ = this;
+		$.RULE("expression", () => $.SUBRULE($.equality));
+		$.RULE("equality", () => {
+			let left = $.SUBRULE($.relational);
+			$.MANY(() => {
+				$.CONSUME(OpEq);
+				const right = $.SUBRULE2($.relational);
+				left = $.yy.evaluateByOperator("=", [left, right]);
+			});
+			return left;
+		});
+		$.RULE("relational", () => {
+			let left = $.SUBRULE($.additive);
+			$.MANY(() => {
+				const op = $.OR([
+					{ ALT: () => {
+						$.CONSUME(OpLe);
+						return "<=";
+					} },
+					{ ALT: () => {
+						$.CONSUME(OpGe);
+						return ">=";
+					} },
+					{ ALT: () => {
+						$.CONSUME(OpNe);
+						return "<>";
+					} },
+					{ ALT: () => {
+						$.CONSUME(NotOp);
+						return "NOT";
+					} },
+					{ ALT: () => {
+						$.CONSUME(OpLt);
+						return "<";
+					} },
+					{ ALT: () => {
+						$.CONSUME(OpGt);
+						return ">";
+					} }
+				]);
+				const right = $.SUBRULE2($.additive);
+				left = $.yy.evaluateByOperator(op, [left, right]);
+			});
+			return left;
+		});
+		$.RULE("additive", () => {
+			let left = $.SUBRULE($.multiplicative);
+			$.MANY(() => {
+				const op = $.OR([{ ALT: () => {
+					$.CONSUME(OpPlus);
+					return "+";
+				} }, { ALT: () => {
+					$.CONSUME(OpMinus);
+					return "-";
+				} }]);
+				const right = $.SUBRULE2($.multiplicative);
+				left = $.yy.evaluateByOperator(op, [left, right]);
+			});
+			return left;
+		});
+		$.RULE("multiplicative", () => {
+			let left = $.SUBRULE($.power);
+			$.MANY(() => {
+				const op = $.OR([{ ALT: () => {
+					$.CONSUME(OpMul);
+					return "*";
+				} }, { ALT: () => {
+					$.CONSUME(OpDiv);
+					return "/";
+				} }]);
+				const right = $.SUBRULE2($.power);
+				left = $.yy.evaluateByOperator(op, [left, right]);
+			});
+			return left;
+		});
+		$.RULE("power", () => {
+			let left = $.SUBRULE($.concat);
+			$.MANY(() => {
+				$.CONSUME(OpPow);
+				const right = $.SUBRULE2($.concat);
+				left = $.yy.evaluateByOperator("^", [left, right]);
+			});
+			return left;
+		});
+		$.RULE("concat", () => {
+			let left = $.SUBRULE($.unary);
+			$.MANY(() => {
+				$.CONSUME(OpConcat);
+				const right = $.SUBRULE2($.unary);
+				left = $.yy.evaluateByOperator("&", [left, right]);
+			});
+			return left;
+		});
+		$.RULE("unary", () => $.OR([
+			{ ALT: () => {
+				$.CONSUME(OpMinus);
+				const value = $.SUBRULE($.unary);
+				let n1 = $.yy.invertNumber(value);
+				if (isNaN(n1)) n1 = 0;
+				return n1;
+			} },
+			{ ALT: () => {
+				$.CONSUME(OpPlus);
+				let n1 = $.yy.toNumber($.SUBRULE2($.unary));
+				if (isNaN(n1)) n1 = 0;
+				return n1;
+			} },
+			{ ALT: () => $.SUBRULE($.primary) }
+		]));
+		$.RULE("primary", () => $.OR([
+			{ ALT: () => $.SUBRULE($.number) },
+			{ ALT: () => {
+				const tok = $.CONSUME(StringLiteral);
+				return $.yy.trimEdges(tok.image);
+			} },
+			{ ALT: () => $.SUBRULE($.cell) },
+			{ ALT: () => $.SUBRULE($.functionCall) },
+			{ ALT: () => $.SUBRULE($.variableSequence) },
+			{ ALT: () => {
+				$.CONSUME(LParen);
+				const value = $.SUBRULE($.expression);
+				$.CONSUME(RParen);
+				return value;
+			} },
+			{ ALT: () => $.SUBRULE($.error) }
+		]));
+		$.RULE("number", () => {
+			let value = $.yy.toNumber($.CONSUME(NumberLiteral).image);
+			$.OPTION(() => {
+				$.CONSUME(OpPercent);
+				value *= .01;
+			});
+			return value;
+		});
+		$.RULE("cell", () => {
+			const start = $.OR([
+				{ ALT: () => $.CONSUME(AbsoluteCell).image },
+				{ ALT: () => $.CONSUME(MixedCell).image },
+				{ ALT: () => $.CONSUME(RelativeCell).image }
+			]);
+			const end = $.OPTION(() => {
+				$.CONSUME(Colon);
+				return $.OR2([
+					{ ALT: () => $.CONSUME2(AbsoluteCell).image },
+					{ ALT: () => $.CONSUME2(MixedCell).image },
+					{ ALT: () => $.CONSUME2(RelativeCell).image }
+				]);
+			});
+			if (end) return $.yy.rangeValue(start, end);
+			return $.yy.cellValue(start);
+		});
+		$.RULE("functionCall", () => {
+			const name = $.CONSUME(FunctionName).image;
+			$.CONSUME(LParen);
+			const args = $.OPTION(() => $.SUBRULE($.expseq));
+			$.CONSUME(RParen);
+			return args ? $.yy.callFunction(name, args) : $.yy.callFunction(name);
+		});
+		$.RULE("expseq", () => $.OR([{ ALT: () => {
+			const tok = $.CONSUME(ArrayLiteral);
+			return $.yy.trimEdges(tok.image).split(",");
+		} }, { ALT: () => {
+			const args = [$.SUBRULE($.expression)];
+			$.MANY(() => {
+				$.OR2([{ ALT: () => $.CONSUME(Comma) }, { ALT: () => $.CONSUME(Semicolon) }]);
+				args.push($.SUBRULE2($.expression));
+			});
+			return args;
+		} }]));
+		$.RULE("variableSequence", () => {
+			const parts = [$.CONSUME(Variable).image];
+			$.MANY(() => {
+				$.CONSUME(Dot);
+				parts.push($.CONSUME2(Variable).image);
+			});
+			return $.yy.callVariable(parts[0]);
+		});
+		$.RULE("error", () => {
+			const tok = $.CONSUME(ErrorLiteral);
+			$.OPTION(() => $.CONSUME2(ErrorLiteral));
+			return $.yy.throwError(tok.image);
+		});
+		this.yy = {
+			evaluateByOperator: () => null,
+			toNumber: (v) => v,
+			invertNumber: (v) => v,
+			trimEdges: (v) => v,
+			throwError: () => null,
+			callVariable: () => null,
+			callFunction: () => null,
+			cellValue: () => null,
+			rangeValue: () => null
+		};
+		this.performSelfAnalysis();
+	}
+};
+/**
+* Drop-in replacement for the old jison GrammarParser.
+* Exposes `.yy` hooks and `.parse(input)`.
+*/
+function Parser$1() {
+	this.yy = {};
+	this._parser = new FormulaParser();
+}
+Parser$1.prototype.parse = function parse(input) {
+	if (typeof input !== "string") throw new Error("Parser error");
+	const lexResult = FormulaLexer.tokenize(input);
+	if (lexResult.errors.length > 0) throw new Error(lexResult.errors[0].message || "Lexer error");
+	this._parser.yy = this.yy;
+	this._parser.input = lexResult.tokens;
+	const result = this._parser.expression();
+	if (this._parser.errors.length > 0) {
+		const err = this._parser.errors[0];
+		throw new Error(err.message || "Parser error");
+	}
+	return result;
+};
+Parser$1.prototype.Parser = Parser$1;
+//#endregion
+//#region packages/formula-parser/src/helper/string.js
+/**
+* Trim value by cutting character starting from the beginning and ending at the same time.
+*
+* @param {String} string String to trimming.
+* @param {Number} [margin=1] Number of character to cut.
+* @returns {String}
+*/
+function trimEdges(string, margin = 1) {
+	string = string.substring(margin, string.length - margin);
+	return string;
+}
+//#endregion
+//#region packages/formula-parser/src/helper/cell.js
+/**
+* Convert row label to index.
+*
+* @param {String} label Row label (eq. '1', '5')
+* @returns {Number} Returns -1 if label is not recognized otherwise proper row index.
+*/
+function rowLabelToIndex(label) {
+	let result = parseInt(label, 10);
+	if (isNaN(result)) result = -1;
+	else result = Math.max(result - 1, -1);
+	return result;
+}
+/**
+* Convert row index to label.
+*
+* @param {Number} row Row index.
+* @returns {String} Returns row label (eq. '1', '7').
+*/
+function rowIndexToLabel(row) {
+	let result = "";
+	if (row >= 0) result = `${row + 1}`;
+	return result;
+}
+const COLUMN_LABEL_BASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const COLUMN_LABEL_BASE_LENGTH = 26;
+/**
+* Convert column label to index.
+*
+* @param {String} label Column label (eq. 'ABB', 'CNQ')
+* @returns {Number} Returns -1 if label is not recognized otherwise proper column index.
+*/
+function columnLabelToIndex(label) {
+	let result = 0;
+	if (typeof label === "string") {
+		label = label.toUpperCase();
+		for (let i = 0, j = label.length - 1; i < label.length; i += 1, j -= 1) result += Math.pow(COLUMN_LABEL_BASE_LENGTH, j) * (COLUMN_LABEL_BASE.indexOf(label[i]) + 1);
+	}
+	--result;
+	return result;
+}
+/**
+* Convert column index to label.
+*
+* @param {Number} column Column index.
+* @returns {String} Returns column label (eq. 'ABB', 'CNQ').
+*/
+function columnIndexToLabel(column) {
+	let result = "";
+	while (column >= 0) {
+		result = String.fromCharCode(column % COLUMN_LABEL_BASE_LENGTH + 97) + result;
+		column = Math.floor(column / COLUMN_LABEL_BASE_LENGTH) - 1;
+	}
+	return result.toUpperCase();
+}
+const LABEL_EXTRACT_REGEXP = new RegExp(`^(?:([A-Za-z0-9_À-ʯ]+|'(?:(?!').|'')*')!)?([$])?([A-Za-z]*)([$])?([0-9]*)$`);
+/**
+* Extract cell coordinates.
+*
+* @param {String} label Cell coordinates (eq. 'A1', '$B6', '$N$98').
+* @returns {Array} Returns an array of objects.
+*/
+function extractLabel(label) {
+	if (typeof label !== "string" || !LABEL_EXTRACT_REGEXP.test(label)) return [];
+	const [, sheetNameStr, columnAbs, column, rowAbs, row] = label.toUpperCase().match(LABEL_EXTRACT_REGEXP);
+	if (column == null && row == null) return [];
+	const sheetName = sheetNameStr == null ? null : label.slice(0, sheetNameStr.length).replace(/^'|'$/g, "").replace(/''/g, "'");
+	return [
+		{
+			index: rowLabelToIndex(row),
+			label: row,
+			isAbsolute: rowAbs === "$"
+		},
+		{
+			index: columnLabelToIndex(column),
+			label: column,
+			isAbsolute: columnAbs === "$"
+		},
+		sheetName
+	];
+}
+/**
+* Convert row and column indexes into cell label.
+*
+* @param {Object} row Object with `index` and `isAbsolute` properties.
+* @param {Object} column Object with `index` and `isAbsolute` properties.
+* @returns {String} Returns cell label.
+*/
+function toLabel(row, column) {
+	const rowLabel = (row.isAbsolute ? "$" : "") + rowIndexToLabel(row.index);
+	return (column.isAbsolute ? "$" : "") + columnIndexToLabel(column.index) + rowLabel;
+}
+//#endregion
+//#region packages/formula-parser/src/parser.js
+/**
+* @class Parser
+*/
+var Parser = class extends Emitter {
+	constructor() {
+		super();
+		this.parser = new Parser$1();
+		this.parser.yy = {
+			toNumber,
+			trimEdges,
+			invertNumber,
+			throwError: (errorName) => this._throwError(errorName),
+			callVariable: (variable) => this._callVariable(variable),
+			evaluateByOperator,
+			callFunction: (name, params) => this._callFunction(name, params),
+			cellValue: (value) => this._callCellValue(value),
+			rangeValue: (start, end) => this._callRangeValue(start, end)
+		};
+		this.variables = Object.create(null);
+		this.functions = Object.create(null);
+		this.options = Object.create(null);
+		this.setVariable("TRUE", true).setVariable("FALSE", false).setVariable("NULL", null);
+	}
+	/**
+	* Parse formula expression.
+	*
+	* @param {string} expression to parse.
+	* @param {object} options additional params.
+	* @param {string} options.sheetId id of sheet which the formula expression belongs to.
+	* @return {*} Returns an object with tow properties `error` and `result`.
+	*/
+	parse(expression, options) {
+		let result = null;
+		let error$1 = null;
+		this.options = options;
+		try {
+			if (expression === "") result = "";
+			else result = this.parser.parse(expression);
+		} catch (ex) {
+			const message = error(ex.message);
+			if (message) error$1 = message;
+			else error$1 = error(ERROR);
+		}
+		if (result instanceof Error) {
+			error$1 = error(result.message) || error("ERROR");
+			result = null;
+		}
+		return {
+			error: error$1,
+			result
+		};
+	}
+	/**
+	* Set predefined variable name which can be visible while parsing formula expression.
+	*
+	* @param {String} name Variable name.
+	* @param {*} value Variable value.
+	* @returns {Parser}
+	*/
+	setVariable(name, value) {
+		this.variables[name] = value;
+		return this;
+	}
+	/**
+	* Get variable name.
+	*
+	* @param {String} name Variable name.
+	* @returns {*}
+	*/
+	getVariable(name) {
+		return this.variables[name];
+	}
+	/**
+	* Retrieve variable value by its name.
+	*
+	* @param name Variable name.
+	* @returns {*}
+	* @private
+	*/
+	_callVariable(name) {
+		let value = this.getVariable(name);
+		this.emit("callVariable", name, (newValue) => {
+			if (newValue !== void 0) value = newValue;
+		});
+		if (value === void 0) throw Error(ERROR_NAME);
+		return value;
+	}
+	/**
+	* Set custom function which can be visible while parsing formula expression.
+	*
+	* @param {String} name Custom function name.
+	* @param {Function} fn Custom function.
+	* @returns {Parser}
+	*/
+	setFunction(name, fn) {
+		this.functions[name] = fn;
+		return this;
+	}
+	/**
+	* Get custom function.
+	*
+	* @param {String} name Custom function name.
+	* @returns {*}
+	*/
+	getFunction(name) {
+		return this.functions[name];
+	}
+	/**
+	* Call function with provided params.
+	*
+	* @param name Function name.
+	* @param params Function params.
+	* @returns {*}
+	* @private
+	*/
+	_callFunction(name, params = []) {
+		const fn = this.getFunction(name);
+		let value;
+		if (fn) value = fn(params);
+		this.emit("callFunction", name, params, (newValue) => {
+			if (newValue !== void 0) value = newValue;
+		});
+		return value === void 0 ? evaluateByOperator(name, params) : value;
+	}
+	/**
+	* Retrieve value by its label (`B3`, `B$3`, `B$3`, `$B$3`).
+	*
+	* @param {String} label Coordinates.
+	* @returns {*}
+	* @private
+	*/
+	_callCellValue(label) {
+		const [row, column, sheetName] = extractLabel(label);
+		if (column?.index === -1) {
+			if (row.isAbsolute || column.isAbsolute) throw Error(ERROR_NAME);
+			return row.index + 1;
+		} else if (row?.index === -1) throw Error(ERROR_NAME);
+		let value = void 0;
+		const normalizedLabel = toLabel(row, column);
+		this.emit("callCellValue", {
+			label: normalizedLabel,
+			row,
+			column,
+			sheetName
+		}, this.options, (_value) => {
+			value = _value;
+		});
+		return value;
+	}
+	/**
+	* Retrieve value by its label (`B3:A1`, `B$3:A1`, `B$3:$A1`, `$B$3:A$1`).
+	*
+	* @param {String} startLabel Coordinates of the first cell.
+	* @param {String} endLabel Coordinates of the last cell.
+	* @returns {Array} Returns an array of mixed values.
+	* @private
+	*/
+	_callRangeValue(startLabel, endLabel) {
+		const [startRow, startColumn, startSheetName] = extractLabel(startLabel);
+		const [endRow, endColumn, endSheetName] = extractLabel(endLabel);
+		if (endSheetName != null && startSheetName != endSheetName) throw Error(ERROR_VALUE);
+		let startCell = {};
+		let endCell = {};
+		startCell.sheetName = startSheetName;
+		if (startRow.index <= endRow.index) {
+			startCell.row = startRow;
+			endCell.row = endRow;
+		} else {
+			startCell.row = endRow;
+			endCell.row = startRow;
+		}
+		if (startColumn.index <= endColumn.index) {
+			startCell.column = startColumn;
+			endCell.column = endColumn;
+		} else {
+			startCell.column = endColumn;
+			endCell.column = startColumn;
+		}
+		startCell.label = toLabel(startCell.row, startCell.column);
+		endCell.label = toLabel(endCell.row, endCell.column);
+		let value = [];
+		this.emit("callRangeValue", startCell, endCell, this.options, (_value = []) => {
+			value = _value;
+		});
+		return value;
+	}
+	/**
+	* Try to throw error by its name.
+	*
+	* @param {String} errorName Error name.
+	* @returns {String}
+	* @private
+	*/
+	_throwError(errorName) {
+		if (isValidStrict(errorName)) throw Error(errorName);
+		throw Error(ERROR);
+	}
+};
+//#endregion
+export { ERROR, ERROR_DIV_ZERO, ERROR_NAME, ERROR_NOT_AVAILABLE, ERROR_NULL, ERROR_NUM, ERROR_REF, ERROR_VALUE, Parser, SUPPORTED_FORMULAS, columnIndexToLabel, columnLabelToIndex, error, extractLabel, rowIndexToLabel, rowLabelToIndex, toLabel };