@leankylin-sheet/formula-parser 3.1.29 → 3.1.31

package/{es/grammar-parser/grammar-parser.js → dist/index.js}

@@ -1,3 +1,481 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Emitter = require('tiny-emitter');
+var formulajs = require('@formulajs/formulajs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () {
+            return e[k];
+          }
+        });
+      }
+    });
+  }
+  n['default'] = e;
+  return Object.freeze(n);
+}
+
+var Emitter__default = /*#__PURE__*/_interopDefaultLegacy(Emitter);
+var formulajs__namespace = /*#__PURE__*/_interopNamespace(formulajs);
+
+function _callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _possibleConstructorReturn(self, call) {
+  if (call && (typeof call === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized(self);
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+/**
+ * Convert value into number.
+ *
+ * @param {String|Number} number
+ * @returns {*}
+ */
+function toNumber(number) {
+  var 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);
+}
+
+var ERROR = 'ERROR';
+var ERROR_DIV_ZERO = 'DIV/0';
+var ERROR_NAME = 'NAME';
+var ERROR_NOT_AVAILABLE = 'N/A';
+var ERROR_NULL = 'NULL';
+var ERROR_NUM = 'NUM';
+var ERROR_REF = 'REF';
+var ERROR_VALUE = 'VALUE';
+var errors = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, ERROR, '#ERROR!'), ERROR_DIV_ZERO, '#DIV/0!'), ERROR_NAME, '#NAME?'), ERROR_NOT_AVAILABLE, '#N/A'), ERROR_NULL, '#NULL!'), ERROR_NUM, '#NUM!'), ERROR_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) {
+  var 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) {
+  var valid = false;
+  for (var i in errors) {
+    if (Object.prototype.hasOwnProperty.call(errors, i) && errors[i] === type) {
+      valid = true;
+      break;
+    }
+  }
+  return valid;
+}
+
+var SYMBOL = '+';
+function func(first) {
+  for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    rest[_key - 1] = arguments[_key];
+  }
+  var result = rest.reduce(function (acc, value) {
+    return acc + toNumber(value || 0);
+  }, toNumber(first || 0));
+  if (isNaN(result)) {
+    throw Error(ERROR_VALUE);
+  }
+  return result;
+}
+func.SYMBOL = SYMBOL;
+
+var SYMBOL$1 = '&';
+function func$1() {
+  for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
+    params[_key] = arguments[_key];
+  }
+  return params.reduce(function (acc, value) {
+    return acc + value.toString();
+  }, '');
+}
+func$1.SYMBOL = SYMBOL$1;
+
+var SYMBOL$2 = '/';
+function func$2(first) {
+  for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    rest[_key - 1] = arguments[_key];
+  }
+  var result = rest.reduce(function (acc, value) {
+    return acc / toNumber(value);
+  }, toNumber(first));
+  if (result === Infinity) {
+    return ERROR_DIV_ZERO;
+    // throw Error(ERROR_DIV_ZERO);
+  }
+  if (isNaN(result)) {
+    return ERROR_VALUE;
+    // throw Error(ERROR_VALUE);
+  }
+  return result;
+}
+func$2.SYMBOL = SYMBOL$2;
+
+var SYMBOL$3 = '=';
+function func$3(exp1, exp2) {
+  return exp1 === exp2;
+}
+func$3.SYMBOL = SYMBOL$3;
+
+var SUPPORTED_FORMULAS = Object.keys(formulajs__namespace);
+
+var SYMBOL$4 = SUPPORTED_FORMULAS;
+function func$4(symbol) {
+  return function __formulaFunction() {
+    symbol = symbol.toUpperCase();
+    var symbolParts = symbol.split('.');
+    var foundFormula = false;
+    var result;
+    if (symbolParts.length === 1) {
+      if (formulajs__namespace[symbolParts[0]]) {
+        foundFormula = true;
+        result = formulajs__namespace[symbolParts[0]].apply(formulajs__namespace, arguments);
+      }
+    } else {
+      var length = symbolParts.length;
+      var index = 0;
+      var nestedFormula = formulajs__namespace;
+      while (index < length) {
+        nestedFormula = nestedFormula[symbolParts[index]];
+        index++;
+        if (!nestedFormula) {
+          nestedFormula = null;
+          break;
+        }
+      }
+      if (nestedFormula) {
+        foundFormula = true;
+        result = nestedFormula.apply(void 0, arguments);
+      }
+    }
+    if (!foundFormula) {
+      throw Error(ERROR_NAME);
+    }
+    return result;
+  };
+}
+func$4.isFactory = true;
+func$4.SYMBOL = SYMBOL$4;
+
+var SYMBOL$5 = '>';
+function func$5(exp1, exp2) {
+  return exp1 > exp2;
+}
+func$5.SYMBOL = SYMBOL$5;
+
+var SYMBOL$6 = '>=';
+function func$6(exp1, exp2) {
+  return exp1 >= exp2;
+}
+func$6.SYMBOL = SYMBOL$6;
+
+var SYMBOL$7 = '<';
+function func$7(exp1, exp2) {
+  return exp1 < exp2;
+}
+func$7.SYMBOL = SYMBOL$7;
+
+var SYMBOL$8 = '<=';
+function func$8(exp1, exp2) {
+  return exp1 <= exp2;
+}
+func$8.SYMBOL = SYMBOL$8;
+
+var SYMBOL$9 = '-';
+function func$9(first) {
+  for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    rest[_key - 1] = arguments[_key];
+  }
+  var result = rest.reduce(function (acc, value) {
+    return acc - toNumber(value);
+  }, toNumber(first));
+  if (isNaN(result)) {
+    throw Error(ERROR_VALUE);
+  }
+  return result;
+}
+func$9.SYMBOL = SYMBOL$9;
+
+var SYMBOL$a = '*';
+function func$a(first) {
+  for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    rest[_key - 1] = arguments[_key];
+  }
+  var result = rest.reduce(function (acc, value) {
+    return acc * toNumber(value);
+  }, toNumber(first));
+  if (isNaN(result)) {
+    throw Error(ERROR_VALUE);
+  }
+  return result;
+}
+func$a.SYMBOL = SYMBOL$a;
+
+var SYMBOL$b = '<>';
+function func$b(exp1, exp2) {
+  return exp1 !== exp2;
+}
+func$b.SYMBOL = SYMBOL$b;
+
+var SYMBOL$c = '^';
+function func$c(exp1, exp2) {
+  var result = Math.pow(toNumber(exp1), toNumber(exp2));
+  if (isNaN(result)) {
+    throw Error(ERROR_VALUE);
+  }
+  return result;
+}
+func$c.SYMBOL = SYMBOL$c;
+
+var 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) {
+  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  operator = operator.toUpperCase();
+  if (!availableOperators[operator]) {
+    throw Error(ERROR_NAME);
+  }
+  return availableOperators[operator].apply(availableOperators, _toConsumableArray(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(function (s) {
+    if (func.isFactory) {
+      availableOperators[s] = func(s);
+    } else {
+      availableOperators[s] = func;
+    }
+  });
+}
+registerOperation(func.SYMBOL, func);
+registerOperation(func$1.SYMBOL, func$1);
+registerOperation(func$2.SYMBOL, func$2);
+registerOperation(func$3.SYMBOL, func$3);
+registerOperation(func$c.SYMBOL, func$c);
+registerOperation(func$4.SYMBOL, func$4);
+registerOperation(func$5.SYMBOL, func$5);
+registerOperation(func$6.SYMBOL, func$6);
+registerOperation(func$7.SYMBOL, func$7);
+registerOperation(func$8.SYMBOL, func$8);
+registerOperation(func$a.SYMBOL, func$a);
+registerOperation(func$b.SYMBOL, func$b);
+registerOperation(func$9.SYMBOL, func$9);
+
 /* parser generated by jison 0.4.18 */
 /*
   Returns a Parser object of the following structure:
@@ -192,7 +670,6 @@ var parser = {
     switch (yystate) {
       case 1:
         return $$[$0 - 1];
-        break;
       case 2:
         this.$ = yy.callVariable($$[$0][0]);
         break;
@@ -854,7 +1331,6 @@ var parser = {
     var _this = this;
     var self = this,
       stack = [0],
-      tstack = [],
       // token stack
       vstack = [null],
       // semantic value stack
@@ -913,7 +1389,6 @@ var parser = {
       preErrorSymbol,
       state,
       action,
-      a,
       r,
       yyval = {},
       p,
@@ -1390,119 +1865,82 @@ var lexer = function () {
     },
     options: {},
     performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
-      var YYSTATE = YY_START;
       switch ($avoiding_name_collisions) {
         case 0:
           /* skip whitespace */
           break;
         case 1:
           return 8;
-          break;
         case 2:
           return 8;
-          break;
         case 3:
           return 21;
-          break;
         case 4:
           return 35;
-          break;
         case 5:
           return 24;
-          break;
         case 6:
           return 26;
-          break;
         case 7:
           return 26;
-          break;
         case 8:
           return 25;
-          break;
         case 9:
           return 21;
-          break;
         case 10:
           return 31;
-          break;
         case 11:
           return 31;
-          break;
         case 12:
           return 33;
-          break;
         case 13:
           return 28;
-          break;
         case 14:
           return 9;
-          break;
         case 15:
           return ' ';
-          break;
         case 16:
           return 32;
-          break;
         case 17:
           return 27;
-          break;
         case 18:
           return 29;
-          break;
         case 19:
           return 30;
-          break;
         case 20:
           return 18;
-          break;
         case 21:
           return 19;
-          break;
         case 22:
           return 17;
-          break;
         case 23:
           return 11;
-          break;
         case 24:
           return 20;
-          break;
         case 25:
           return 12;
-          break;
         case 26:
           return 13;
-          break;
         case 27:
           return 15;
-          break;
         case 28:
           return 14;
-          break;
         case 29:
           return 16;
-          break;
         case 30:
           return '"';
-          break;
         case 31:
           return "'";
-          break;
         case 32:
           return "!";
-          break;
         case 33:
           return 10;
-          break;
         case 34:
           return 34;
-          break;
         case 35:
           return '#';
-          break;
         case 36:
           return 5;
-          break;
       }
     },
     rules: [/^(?:\s+)/, /^(?:"(\\["]|[^"])*")/, /^(?:'(\\[']|[^'])*'[^'!])/, /^(?:[A-Za-z]{1,}[A-Za-z_0-9\.]+(?=[(]))/, /^(?:#[A-Z0-9\/]+(!|\?)?)/, ABSOLUTE_CELL, MIXED_CELL_COL, MIXED_CELL_ROW, RELATIVE_CELL, /^(?:[A-Za-z\.]+(?=[(]))/, /^(?:[A-Za-z]{1,}[A-Za-z_0-9]+)/, /^(?:[A-Za-z_]+)/, /^(?:[0-9]+)/, /^(?:\[(.*)?\])/, /^(?:&)/, /^(?: )/, /^(?:[.])/, /^(?::)/, /^(?:;)/, /^(?:,)/, /^(?:\*)/, /^(?:\/)/, /^(?:-)/, /^(?:\+)/, /^(?:\^)/, /^(?:\()/, /^(?:\))/, /^(?:>)/, /^(?:<)/, /^(?:NOT\b)/, /^(?:")/, /^(?:')/, /^(?:!)/, /^(?:=)/, /^(?:%)/, /^(?:[#])/, /^(?:$)/],
@@ -1516,8 +1954,431 @@ var lexer = function () {
   return lexer;
 }();
 parser.lexer = lexer;
-export function Parser() {
+function Parser() {
   this.yy = {};
 }
 Parser.prototype = parser;
-parser.Parser = Parser;
+parser.Parser = Parser;
+
+/* eslint-disable import/prefer-default-export */
+/**
+ * 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) {
+  var margin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  string = string.substring(margin, string.length - margin);
+  return string;
+}
+
+/**
+ * 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) {
+  var 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) {
+  var result = '';
+  if (row >= 0) {
+    result = "".concat(row + 1);
+  }
+  return result;
+}
+var COLUMN_LABEL_BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+var COLUMN_LABEL_BASE_LENGTH = COLUMN_LABEL_BASE.length;
+
+/**
+ * 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) {
+  var result = 0;
+  if (typeof label === 'string') {
+    label = label.toUpperCase();
+    for (var 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) {
+  var 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();
+}
+var simpleSheetName$1 = "[A-Za-z0-9_\xC0-\u02AF]+";
+var quotedSheetName$1 = "'(?:(?!').|'')*'";
+var sheetNameRegexp$1 = "(".concat(simpleSheetName$1, "|").concat(quotedSheetName$1, ")!");
+var LABEL_EXTRACT_REGEXP = new RegExp("^(?:".concat(sheetNameRegexp$1, ")?([$])?([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 [];
+  }
+  var _label$toUpperCase$ma = label.toUpperCase().match(LABEL_EXTRACT_REGEXP),
+    _label$toUpperCase$ma2 = _slicedToArray(_label$toUpperCase$ma, 6),
+    sheetNameStr = _label$toUpperCase$ma2[1],
+    columnAbs = _label$toUpperCase$ma2[2],
+    column = _label$toUpperCase$ma2[3],
+    rowAbs = _label$toUpperCase$ma2[4],
+    row = _label$toUpperCase$ma2[5];
+  if (column == null && row == null) return [];
+  var 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) {
+  var rowLabel = (row.isAbsolute ? '$' : '') + rowIndexToLabel(row.index);
+  var columnLabel = (column.isAbsolute ? '$' : '') + columnIndexToLabel(column.index);
+  return columnLabel + rowLabel;
+}
+
+/**
+ * @class Parser
+ */
+var Parser$1 = /*#__PURE__*/function (_Emitter) {
+  function Parser$1() {
+    var _this;
+    _classCallCheck(this, Parser$1);
+    _this = _callSuper(this, Parser$1);
+    _this.parser = new Parser();
+    _this.parser.yy = {
+      toNumber: toNumber,
+      trimEdges: trimEdges,
+      invertNumber: invertNumber,
+      throwError: function throwError(errorName) {
+        return _this._throwError(errorName);
+      },
+      callVariable: function callVariable(variable) {
+        return _this._callVariable(variable);
+      },
+      evaluateByOperator: evaluateByOperator,
+      callFunction: function callFunction(name, params) {
+        return _this._callFunction(name, params);
+      },
+      cellValue: function cellValue(value) {
+        return _this._callCellValue(value);
+      },
+      rangeValue: function rangeValue(start, end) {
+        return _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);
+    return _this;
+  }
+
+  /**
+   * 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`.
+   */
+  _inherits(Parser$1, _Emitter);
+  return _createClass(Parser$1, [{
+    key: "parse",
+    value: function parse(expression, options) {
+      var result = null;
+      var error$1 = null;
+      this.options = options;
+      try {
+        if (expression === '') {
+          result = '';
+        } else {
+          result = this.parser.parse(expression);
+        }
+      } catch (ex) {
+        var 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: result
+      };
+    }
+
+    /**
+     * Set predefined variable name which can be visible while parsing formula expression.
+     *
+     * @param {String} name Variable name.
+     * @param {*} value Variable value.
+     * @returns {Parser}
+     */
+  }, {
+    key: "setVariable",
+    value: function setVariable(name, value) {
+      this.variables[name] = value;
+      return this;
+    }
+
+    /**
+     * Get variable name.
+     *
+     * @param {String} name Variable name.
+     * @returns {*}
+     */
+  }, {
+    key: "getVariable",
+    value: function getVariable(name) {
+      return this.variables[name];
+    }
+
+    /**
+     * Retrieve variable value by its name.
+     *
+     * @param name Variable name.
+     * @returns {*}
+     * @private
+     */
+  }, {
+    key: "_callVariable",
+    value: function _callVariable(name) {
+      var value = this.getVariable(name);
+      this.emit('callVariable', name, function (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}
+     */
+  }, {
+    key: "setFunction",
+    value: function setFunction(name, fn) {
+      this.functions[name] = fn;
+      return this;
+    }
+
+    /**
+     * Get custom function.
+     *
+     * @param {String} name Custom function name.
+     * @returns {*}
+     */
+  }, {
+    key: "getFunction",
+    value: function getFunction(name) {
+      return this.functions[name];
+    }
+
+    /**
+     * Call function with provided params.
+     *
+     * @param name Function name.
+     * @param params Function params.
+     * @returns {*}
+     * @private
+     */
+  }, {
+    key: "_callFunction",
+    value: function _callFunction(name) {
+      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+      var fn = this.getFunction(name);
+      var value;
+      if (fn) {
+        value = fn(params);
+      }
+      this.emit('callFunction', name, params, function (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
+     */
+  }, {
+    key: "_callCellValue",
+    value: function _callCellValue(label) {
+      var _extractLabel = extractLabel(label),
+        _extractLabel2 = _slicedToArray(_extractLabel, 3),
+        row = _extractLabel2[0],
+        column = _extractLabel2[1],
+        sheetName = _extractLabel2[2];
+      if ((column === null || column === void 0 ? void 0 : column.index) === -1) {
+        if (row.isAbsolute || column.isAbsolute) {
+          throw Error(ERROR_NAME);
+        }
+        return row.index + 1;
+      } else if ((row === null || row === void 0 ? void 0 : row.index) === -1) {
+        throw Error(ERROR_NAME);
+      }
+      var value = void 0;
+      this.emit('callCellValue', {
+        label: label,
+        row: row,
+        column: column,
+        sheetName: sheetName
+      }, this.options, function (_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
+     */
+  }, {
+    key: "_callRangeValue",
+    value: function _callRangeValue(startLabel, endLabel) {
+      var _extractLabel3 = extractLabel(startLabel),
+        _extractLabel4 = _slicedToArray(_extractLabel3, 3),
+        startRow = _extractLabel4[0],
+        startColumn = _extractLabel4[1],
+        startSheetName = _extractLabel4[2];
+      var _extractLabel5 = extractLabel(endLabel),
+        _extractLabel6 = _slicedToArray(_extractLabel5, 3),
+        endRow = _extractLabel6[0],
+        endColumn = _extractLabel6[1],
+        endSheetName = _extractLabel6[2];
+      if (endSheetName != null && startSheetName != endSheetName) {
+        throw Error(ERROR_VALUE);
+      }
+      var startCell = {};
+      var 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);
+      var value = [];
+      this.emit('callRangeValue', startCell, endCell, this.options, function () {
+        var _value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+        value = _value;
+      });
+      return value;
+    }
+
+    /**
+     * Try to throw error by its name.
+     *
+     * @param {String} errorName Error name.
+     * @returns {String}
+     * @private
+     */
+  }, {
+    key: "_throwError",
+    value: function _throwError(errorName) {
+      if (isValidStrict(errorName)) {
+        throw Error(errorName);
+      }
+      throw Error(ERROR);
+    }
+  }]);
+}(Emitter__default['default']);
+
+exports.ERROR = ERROR;
+exports.ERROR_DIV_ZERO = ERROR_DIV_ZERO;
+exports.ERROR_NAME = ERROR_NAME;
+exports.ERROR_NOT_AVAILABLE = ERROR_NOT_AVAILABLE;
+exports.ERROR_NULL = ERROR_NULL;
+exports.ERROR_NUM = ERROR_NUM;
+exports.ERROR_REF = ERROR_REF;
+exports.ERROR_VALUE = ERROR_VALUE;
+exports.Parser = Parser$1;
+exports.SUPPORTED_FORMULAS = SUPPORTED_FORMULAS;
+exports.columnIndexToLabel = columnIndexToLabel;
+exports.columnLabelToIndex = columnLabelToIndex;
+exports.error = error;
+exports.extractLabel = extractLabel;
+exports.rowIndexToLabel = rowIndexToLabel;
+exports.rowLabelToIndex = rowLabelToIndex;
+exports.toLabel = toLabel;