@gridsheet/react-core 1.0.0-alpha.0 → 1.0.0-alpha.2

package/dist/{src/formula → formula}/evaluator.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stripSheetName = exports.absolutizeFormula = exports.Parser = exports.Lexer = exports.Token = exports.Function = exports.IdRange = exports.Id = exports.Range = exports.Ref = exports.InvalidRef = exports.Unreferenced = exports.Value = exports.SheetId = exports.SheetName = exports.FormulaError = void 0;
+exports.stripSheetName = exports.absolutizeFormula = exports.Parser = exports.Lexer = exports.Token = exports.FunctionEntity = exports.IdRangeEntity = exports.IdEntity = exports.RangeEntity = exports.RefEntity = exports.InvalidRefEntity = exports.UnreferencedEntity = exports.ValueEntity = exports.FormulaError = void 0;
 const structs_1 = require("../lib/structs");
 const converters_1 = require("../lib/converters");
 // strip sharp and dollars
 const getId = (idString, stripAbsolute = true) => {
     let id = idString.slice(1);
-    if (stripAbsolute && id.startsWith("$")) {
+    if (stripAbsolute && id.startsWith('$')) {
         id = id.slice(1);
     }
-    if (stripAbsolute && id.endsWith("$")) {
+    if (stripAbsolute && id.endsWith('$')) {
         id = id.slice(0, -1);
     }
     return id;
@@ -27,58 +27,48 @@ class Entity {
         this.value = value;
     }
 }
-class SheetName extends Entity {
-    evaluate({ table }) {
-        return table;
-    }
-    id(table) {
-        return `#${table.sheets[this.value]}!`;
-    }
-}
-exports.SheetName = SheetName;
-class SheetId extends Entity {
-    evaluate({ table }) {
-        return table.tables[this.value];
-    }
-    name(table) {
-        return table.tables[this.value].sheetName + "!";
-    }
-}
-exports.SheetId = SheetId;
-class Value extends Entity {
-    evaluate({}) {
+class ValueEntity extends Entity {
+    evaluate() {
         return this.value;
     }
 }
-exports.Value = Value;
-class Unreferenced extends Entity {
-    evaluate({}) {
-        throw new FormulaError("#REF!", `Reference does not exist.`);
+exports.ValueEntity = ValueEntity;
+class UnreferencedEntity extends Entity {
+    evaluate() {
+        throw new FormulaError('#REF!', `Reference does not exist.`);
     }
 }
-exports.Unreferenced = Unreferenced;
-class InvalidRef extends Entity {
-    evaluate({}) {
-        throw new FormulaError("#NAME?", `Invalid ref: ${this.value}`);
+exports.UnreferencedEntity = UnreferencedEntity;
+class InvalidRefEntity extends Entity {
+    evaluate() {
+        throw new FormulaError('#NAME?', `Invalid ref: ${this.value}`);
     }
 }
-exports.InvalidRef = InvalidRef;
-class Ref extends Entity {
+exports.InvalidRefEntity = InvalidRefEntity;
+class RefEntity extends Entity {
     constructor(value) {
         super(value);
     }
     parse(table) {
-        if (this.value.indexOf("!") !== -1) {
-            const [rawSheetName, ref] = this.value.split("!");
+        if (this.value.indexOf('!') !== -1) {
+            const [rawSheetName, ref] = this.value.split('!');
             const sheetName = (0, exports.stripSheetName)(rawSheetName);
-            return { table: table.getTableBySheetName(sheetName), ref: ref.toUpperCase(), sheetName };
+            return {
+                table: table.getTableBySheetName(sheetName),
+                ref: ref.toUpperCase(),
+                sheetName,
+            };
         }
-        return { table, ref: this.value.toUpperCase(), sheetName: (0, exports.stripSheetName)(table.sheetName) };
+        return {
+            table,
+            ref: this.value.toUpperCase(),
+            sheetName: (0, exports.stripSheetName)(table.sheetName),
+        };
     }
     evaluate({ table }) {
         const parsed = this.parse(table);
         if (parsed.table == null) {
-            throw new FormulaError("#REF!", `Unknown sheet: ${parsed.sheetName}`);
+            throw new FormulaError('#REF!', `Unknown sheet: ${parsed.sheetName}`);
         }
         const { y, x } = (0, converters_1.a2p)(parsed.ref);
         return parsed.table.trim({ top: y, left: x, bottom: y, right: x });
@@ -98,16 +88,16 @@ class Ref extends Entity {
         return this.value;
     }
 }
-exports.Ref = Ref;
-class Range extends Entity {
+exports.RefEntity = RefEntity;
+class RangeEntity extends Entity {
     parse(table) {
-        const rawRefs = this.value.split(":");
+        const rawRefs = this.value.split(':');
         const refs = [];
-        let sheetName = "";
+        let sheetName = '';
         for (let i = 0; i < rawRefs.length; i++) {
             const ref = rawRefs[i];
-            if (ref.indexOf("!") !== -1) {
-                const [rawSheetName, rawRef] = ref.split("!");
+            if (ref.indexOf('!') !== -1) {
+                const [rawSheetName, rawRef] = ref.split('!');
                 refs.push(rawRef.toUpperCase());
                 if (i === 0) {
                     sheetName = (0, exports.stripSheetName)(rawSheetName);
@@ -126,7 +116,7 @@ class Range extends Entity {
     evaluate({ table }) {
         const parsed = this.parse(table);
         if (parsed.table == null) {
-            throw new FormulaError("#REF!", `Unknown sheet: ${parsed.sheetName}`);
+            throw new FormulaError('#REF!', `Unknown sheet: ${parsed.sheetName}`);
         }
         const area = (0, structs_1.rangeToArea)(this.complementRange(parsed.table, parsed.refs));
         return parsed.table.trim(area);
@@ -136,21 +126,19 @@ class Range extends Entity {
         if (parsed.table == null) {
             return this.value;
         }
-        const range = parsed.refs
-            .map((ref) => parsed.table.getIdByAddress(ref))
-            .join(":");
+        const range = parsed.refs.map((ref) => parsed.table.getIdByAddress(ref)).join(':');
         if (parsed.table === table) {
             return range;
         }
         return `#${parsed.table.sheetId}!${range}`;
     }
     complementRange(table, refs) {
-        let [start = "", end = ""] = refs;
+        let [start = '', end = ''] = refs;
         if (!start.match(/[1-9]\d*/)) {
-            start += "1";
+            start += '1';
         }
         if (!start.match(/[a-zA-Z]/)) {
-            start = "A" + start;
+            start = 'A' + start;
         }
         if (!end.match(/[1-9]\d*/)) {
             end += table.getNumRows();
@@ -161,11 +149,11 @@ class Range extends Entity {
         return `${start}:${end}`;
     }
 }
-exports.Range = Range;
-class Id extends Entity {
+exports.RangeEntity = RangeEntity;
+class IdEntity extends Entity {
     parse(table) {
-        if (this.value.indexOf("!") !== -1) {
-            const [tableId, id] = this.value.split("!");
+        if (this.value.indexOf('!') !== -1) {
+            const [tableId, id] = this.value.split('!');
             return { table: table.tables[tableId.slice(1)], id: getId(id, false) };
         }
         return { table, id: getId(this.value, false) };
@@ -174,7 +162,12 @@ class Id extends Entity {
         const parsed = this.parse(table);
         const { y, x } = parsed.table.getPointById(parsed.id);
         const [absY, absX] = [Math.abs(y), Math.abs(x)];
-        return parsed.table.trim({ top: absY, left: absX, bottom: absY, right: absX });
+        return parsed.table.trim({
+            top: absY,
+            left: absX,
+            bottom: absY,
+            right: absX,
+        });
     }
     ref(table, slideY = 0, slideX = 0) {
         const parsed = this.parse(table);
@@ -188,35 +181,38 @@ class Id extends Entity {
     slide(table, slideY = 0, slideX = 0) {
         const address = this.ref(table, slideY, slideX);
         if (address == null || address.length < 2) {
-            return "#REF!";
+            return '#REF!';
         }
         return table.getIdByAddress(address);
     }
 }
-exports.Id = Id;
-class IdRange extends Entity {
+exports.IdEntity = IdEntity;
+class IdRangeEntity extends Entity {
     parse(table) {
         const range = this.value;
-        if (range.indexOf("!") !== -1) {
-            const [sheetId, idRange] = range.split("!");
+        if (range.indexOf('!') !== -1) {
+            const [sheetId, idRange] = range.split('!');
             table = table.tables[sheetId.slice(1)];
-            return { table, ids: idRange.split(":") };
+            return { table, ids: idRange.split(':') };
         }
-        return { table, ids: range.split(":") };
+        return { table, ids: range.split(':') };
     }
     evaluate({ table }) {
         const parsed = this.parse(table);
-        const [p1, p2] = parsed.ids
-            .map((id) => getId(id))
-            .map((id) => parsed.table.getPointById(id));
-        return parsed.table.trim({ top: p1.y, left: p1.x, bottom: p2.y, right: p2.x });
+        const [p1, p2] = parsed.ids.map((id) => getId(id)).map((id) => parsed.table.getPointById(id));
+        return parsed.table.trim({
+            top: p1.y,
+            left: p1.x,
+            bottom: p2.y,
+            right: p2.x,
+        });
     }
     range(table, slideY = 0, slideX = 0) {
         const parsed = this.parse(table);
         const range = parsed.ids
             .map((id) => getId(id, false))
             .map((id) => parsed.table.getAddressById(id, slideY, slideX))
-            .join(":");
+            .join(':');
         if (parsed.table.sheetId === table.sheetId) {
             return range;
         }
@@ -225,11 +221,11 @@ class IdRange extends Entity {
     }
     slide(table, slideY = 0, slideX = 0) {
         const range = this.range(table, slideY, slideX);
-        return new Range(range).idRange(table);
+        return new RangeEntity(range).idRange(table);
     }
 }
-exports.IdRange = IdRange;
-class Function {
+exports.IdRangeEntity = IdRangeEntity;
+class FunctionEntity {
     constructor(name, precedence = 0, args = []) {
         this.name = name;
         this.precedence = precedence;
@@ -239,30 +235,30 @@ class Function {
         const name = this.name.toLowerCase();
         const Func = table.getFunction(name);
         if (Func == null) {
-            throw new FormulaError("#NAME?", `Unknown function: ${name}`);
+            throw new FormulaError('#NAME?', `Unknown function: ${name}`);
         }
         const func = new Func({ args: this.args, table });
         return func.call();
     }
 }
-exports.Function = Function;
-const ZERO = new Value(0);
+exports.FunctionEntity = FunctionEntity;
+const ZERO = new ValueEntity(0);
 const INFIX_FUNCTION_NAME_MAP = {
-    "+": "add",
-    "-": "minus",
-    "/": "divide",
-    "*": "multiply",
-    "^": "power",
-    "&": "concat",
-    "=": "eq",
-    "<>": "ne",
-    ">": "gt",
-    ">=": "gte",
-    "<": "lt",
-    "<=": "lte",
+    '+': 'add',
+    '-': 'minus',
+    '/': 'divide',
+    '*': 'multiply',
+    '^': 'power',
+    '&': 'concat',
+    '=': 'eq',
+    '<>': 'ne',
+    '>': 'gt',
+    '>=': 'gte',
+    '<': 'lt',
+    '<=': 'lte',
 };
 const PREFIX_FUNCTION_NAME_MAP = {
-    "-": "uminus",
+    '-': 'uminus',
 };
 class Token {
     constructor(type, entity, precedence = 0) {
@@ -272,43 +268,49 @@ class Token {
     }
     convert() {
         switch (this.type) {
-            case "VALUE":
-                return new Value(this.entity);
-            case "ID":
-                return new Id(this.entity);
-            case "ID_RANGE":
-                return new IdRange(this.entity);
-            case "REF":
-                return new Ref(this.entity);
-            case "RANGE":
-                return new Range(this.entity);
-            case "INFIX_OPERATOR": {
+            case 'VALUE':
+                return new ValueEntity(this.entity);
+            // eslint-disable-next-line no-fallthrough
+            case 'ID':
+                return new IdEntity(this.entity);
+            // eslint-disable-next-line no-fallthrough
+            case 'ID_RANGE':
+                return new IdRangeEntity(this.entity);
+            // eslint-disable-next-line no-fallthrough
+            case 'REF':
+                return new RefEntity(this.entity);
+            // eslint-disable-next-line no-fallthrough
+            case 'RANGE':
+                return new RangeEntity(this.entity);
+            // eslint-disable-next-line no-fallthrough
+            case 'INFIX_OPERATOR': {
                 const name = INFIX_FUNCTION_NAME_MAP[this.entity];
-                return new Function(name, this.precedence);
+                return new FunctionEntity(name, this.precedence);
+                // eslint-disable-next-line no-fallthrough
             }
-            case "PREFIX_OPERATOR": {
+            case 'PREFIX_OPERATOR': {
                 const name = PREFIX_FUNCTION_NAME_MAP[this.entity];
-                return new Function(name, this.precedence);
+                return new FunctionEntity(name, this.precedence);
+                // eslint-disable-next-line no-fallthrough
             }
-            case "FUNCTION":
-                return new Function(this.entity);
-            case "SHEET_NAME":
-                return new SheetName(this.entity);
-            case "SHEET_ID":
-                return new SheetId(this.entity);
-            case "UNREFERENCED":
-                return new Unreferenced(this.entity);
-            case "INVALID_REF":
-                return new InvalidRef(this.entity);
+            case 'FUNCTION':
+                return new FunctionEntity(this.entity);
+            // eslint-disable-next-line no-fallthrough
+            case 'UNREFERENCED':
+                return new UnreferencedEntity(this.entity);
+            // eslint-disable-next-line no-fallthrough
+            case 'INVALID_REF':
+                return new InvalidRefEntity(this.entity);
+            // eslint-disable-next-line no-fallthrough
         }
     }
 }
 exports.Token = Token;
 const isWhiteSpace = (char) => {
-    return char === " " || char === "\n" || char === "\t";
+    return char === ' ' || char === '\n' || char === '\t';
 };
-const TOKEN_OPEN = new Token("OPEN", "("), TOKEN_CLOSE = new Token("CLOSE", ")"), TOKEN_COMMA = new Token("COMMA", ","), TOKEN_ADD = new Token("INFIX_OPERATOR", "+", 3), TOKEN_MINUS = new Token("INFIX_OPERATOR", "-", 3), TOKEN_UMINUS = new Token("PREFIX_OPERATOR", "-", 6), TOKEN_DIVIDE = new Token("INFIX_OPERATOR", "/", 4), TOKEN_MULTIPLY = new Token("INFIX_OPERATOR", "*", 4), TOKEN_POWER = new Token("INFIX_OPERATOR", "^", 5), TOKEN_CONCAT = new Token("INFIX_OPERATOR", "&", 4), TOKEN_GTE = new Token("INFIX_OPERATOR", ">=", 2), TOKEN_GT = new Token("INFIX_OPERATOR", ">", 2), TOKEN_LTE = new Token("INFIX_OPERATOR", "<=", 2), TOKEN_LT = new Token("INFIX_OPERATOR", "<", 2), TOKEN_NE = new Token("INFIX_OPERATOR", "<>", 1), TOKEN_EQ = new Token("INFIX_OPERATOR", "=", 1);
-const BOOLS = { ["true"]: true, ["false"]: false };
+const TOKEN_OPEN = new Token('OPEN', '('), TOKEN_CLOSE = new Token('CLOSE', ')'), TOKEN_COMMA = new Token('COMMA', ','), TOKEN_ADD = new Token('INFIX_OPERATOR', '+', 3), TOKEN_MINUS = new Token('INFIX_OPERATOR', '-', 3), TOKEN_UMINUS = new Token('PREFIX_OPERATOR', '-', 6), TOKEN_DIVIDE = new Token('INFIX_OPERATOR', '/', 4), TOKEN_MULTIPLY = new Token('INFIX_OPERATOR', '*', 4), TOKEN_POWER = new Token('INFIX_OPERATOR', '^', 5), TOKEN_CONCAT = new Token('INFIX_OPERATOR', '&', 4), TOKEN_GTE = new Token('INFIX_OPERATOR', '>=', 2), TOKEN_GT = new Token('INFIX_OPERATOR', '>', 2), TOKEN_LTE = new Token('INFIX_OPERATOR', '<=', 2), TOKEN_LT = new Token('INFIX_OPERATOR', '<', 2), TOKEN_NE = new Token('INFIX_OPERATOR', '<>', 1), TOKEN_EQ = new Token('INFIX_OPERATOR', '=', 1);
+const BOOLS = { ['true']: true, ['false']: false };
 class Lexer {
     constructor(formula) {
         this.tokens = [];
@@ -334,41 +336,46 @@ class Lexer {
         return this.tokens
             .map((t) => {
             switch (t.type) {
-                case "VALUE":
-                    if (typeof t.entity === "number" || typeof t.entity === "boolean") {
+                case 'VALUE':
+                    if (typeof t.entity === 'number' || typeof t.entity === 'boolean') {
                         return t.entity;
                     }
                     return `"${t.entity}"`;
-                case "ID":
-                    return new Id(t.entity).slide(table, slideY, slideX);
-                case "ID_RANGE":
-                    return new IdRange(t.entity).slide(table, slideY, slideX);
-                case "REF":
-                    return new Ref(t.entity).id(table);
-                case "RANGE":
-                    return new Range(t.entity).idRange(table);
+                // eslint-disable-next-line no-fallthrough
+                case 'ID':
+                    return new IdEntity(t.entity).slide(table, slideY, slideX);
+                // eslint-disable-next-line no-fallthrough
+                case 'ID_RANGE':
+                    return new IdRangeEntity(t.entity).slide(table, slideY, slideX);
+                // eslint-disable-next-line no-fallthrough
+                case 'REF':
+                    return new RefEntity(t.entity).id(table);
+                // eslint-disable-next-line no-fallthrough
+                case 'RANGE':
+                    return new RangeEntity(t.entity).idRange(table);
+                // eslint-disable-next-line no-fallthrough
             }
             return t.entity;
         })
-            .join("");
+            .join('');
     }
     stringifyToRef(table) {
         return this.tokens
             .map((t) => {
             switch (t.type) {
-                case "VALUE":
-                    if (typeof t.entity === "number" || typeof t.entity === "boolean") {
+                case 'VALUE':
+                    if (typeof t.entity === 'number' || typeof t.entity === 'boolean') {
                         return t.entity;
                     }
                     return `"${t.entity}"`;
-                case "ID":
-                    return new Id(t.entity).ref(table);
-                case "ID_RANGE":
-                    return new IdRange(t.entity).range(table);
+                case 'ID':
+                    return new IdEntity(t.entity).ref(table);
+                case 'ID_RANGE':
+                    return new IdRangeEntity(t.entity).range(table);
             }
             return t.entity;
         })
-            .join("");
+            .join('');
     }
     tokenize() {
         var _a, _b;
@@ -379,23 +386,22 @@ class Lexer {
             switch (char) {
                 case undefined:
                     return;
-                case "(":
+                case '(':
                     this.tokens.push(TOKEN_OPEN);
                     continue;
-                case ")":
+                case ')':
                     this.tokens.push(TOKEN_CLOSE);
                     continue;
-                case ",":
+                case ',':
                     this.tokens.push(TOKEN_COMMA);
                     continue;
-                case "+":
+                case '+':
                     this.tokens.push(TOKEN_ADD);
                     continue;
-                case "-": {
+                case '-': {
                     const prev1 = (_a = this.getToken(-1)) === null || _a === void 0 ? void 0 : _a.type;
                     const prev2 = (_b = this.getToken(-2)) === null || _b === void 0 ? void 0 : _b.type;
-                    if (prev1 === "INFIX_OPERATOR" ||
-                        (prev1 === "SPACE" && prev2 === "INFIX_OPERATOR")) {
+                    if (prev1 === 'INFIX_OPERATOR' || (prev1 === 'SPACE' && prev2 === 'INFIX_OPERATOR')) {
                         this.tokens.push(TOKEN_UMINUS);
                     }
                     else {
@@ -403,36 +409,36 @@ class Lexer {
                     }
                     continue;
                 }
-                case "/":
+                case '/':
                     this.tokens.push(TOKEN_DIVIDE);
                     continue;
-                case "*":
+                case '*':
                     this.tokens.push(TOKEN_MULTIPLY);
                     continue;
-                case "^":
+                case '^':
                     this.tokens.push(TOKEN_POWER);
                     continue;
-                case "&":
+                case '&':
                     this.tokens.push(TOKEN_CONCAT);
                     continue;
-                case "=":
+                case '=':
                     this.tokens.push(TOKEN_EQ);
                     continue;
-                case ">":
-                    if (this.get() === "=") {
+                case '>':
+                    if (this.get() === '=') {
                         this.next();
                         this.tokens.push(TOKEN_GTE);
                         continue;
                     }
                     this.tokens.push(TOKEN_GT);
                     continue;
-                case "<":
-                    if (this.get() === "=") {
+                case '<':
+                    if (this.get() === '=') {
                         this.next();
                         this.tokens.push(TOKEN_LTE);
                         continue;
                     }
-                    if (this.get() === ">") {
+                    if (this.get() === '>') {
                         this.next();
                         this.tokens.push(TOKEN_NE);
                         continue;
@@ -441,23 +447,26 @@ class Lexer {
                     continue;
                 case '"': {
                     const buf = this.getString('"');
-                    this.tokens.push(new Token("VALUE", buf));
+                    this.tokens.push(new Token('VALUE', buf));
                     continue;
                 }
                 case "'": {
                     const buf = this.getString("'");
                     char = `'${buf}'`;
+                    break;
                 }
-                case "!": {
+                case '!': {
                     this.foreign = true;
+                    break;
                     // not continue
                 }
             } // switch end
             let buf = char;
+            // eslint-disable-next-line no-constant-condition
             while (true) {
                 const c = this.get();
-                if (c === "(") {
-                    this.tokens.push(new Token("FUNCTION", buf), TOKEN_OPEN);
+                if (c === '(') {
+                    this.tokens.push(new Token('FUNCTION', buf), TOKEN_OPEN);
                     this.next();
                     break;
                 }
@@ -466,35 +475,33 @@ class Lexer {
                         break;
                     }
                     if (buf.match(/^[+-]?(\d*[.])?\d+$/)) {
-                        this.tokens.push(new Token("VALUE", parseFloat(buf)));
+                        this.tokens.push(new Token('VALUE', parseFloat(buf)));
                     }
                     else {
-                        // @ts-ignore
                         const bool = BOOLS[buf.toLowerCase()];
                         if (bool != null) {
-                            this.tokens.push(new Token("VALUE", bool));
+                            this.tokens.push(new Token('VALUE', bool));
                         }
-                        else if (buf.startsWith("#")) {
-                            if (buf === "#REF!") {
-                                this.tokens.push(new Token("UNREFERENCED", buf));
+                        else if (buf.startsWith('#')) {
+                            if (buf === '#REF!') {
+                                this.tokens.push(new Token('UNREFERENCED', buf));
                             }
-                            else if (buf.indexOf(":") !== -1) {
-                                this.tokens.push(new Token("ID_RANGE", buf));
+                            else if (buf.indexOf(':') !== -1) {
+                                this.tokens.push(new Token('ID_RANGE', buf));
                             }
                             else {
-                                this.tokens.push(new Token("ID", buf));
+                                this.tokens.push(new Token('ID', buf));
                             }
                         }
-                        else if (buf.indexOf(":") !== -1) {
-                            this.tokens.push(new Token("RANGE", buf));
+                        else if (buf.indexOf(':') !== -1) {
+                            this.tokens.push(new Token('RANGE', buf));
                         }
                         else {
-                            // @ts-ignore
                             if (isNaN(buf[buf.length - 1])) {
-                                this.tokens.push(new Token("INVALID_REF", buf));
+                                this.tokens.push(new Token('INVALID_REF', buf));
                             }
                             else {
-                                this.tokens.push(new Token("REF", buf));
+                                this.tokens.push(new Token('REF', buf));
                             }
                         }
                     }
@@ -506,16 +513,17 @@ class Lexer {
         }
     }
     skipSpaces() {
-        let space = "";
+        let space = '';
         while (this.isWhiteSpace()) {
             space += this.formula[this.index++];
         }
-        if (space !== "") {
-            this.tokens.push(new Token("SPACE", space));
+        if (space !== '') {
+            this.tokens.push(new Token('SPACE', space));
         }
     }
     getString(quote = '"') {
-        let buf = "";
+        let buf = '';
+        // eslint-disable-next-line no-constant-condition
         while (true) {
             const c = this.get();
             this.next();
@@ -563,30 +571,31 @@ class Parser {
         };
         while (this.tokens.length > this.index) {
             const token = this.tokens[this.index++];
-            if (token.type === "SPACE") {
+            if (token.type === 'SPACE') {
                 continue;
             }
-            if (token.type === "COMMA") {
+            if (token.type === 'COMMA') {
                 if (!underFunction) {
-                    throw new FormulaError("#ERROR!", "Invalid comma");
+                    throw new FormulaError('#ERROR!', 'Invalid comma');
                 }
                 return complement(true);
             }
-            else if (token.type === "VALUE" ||
-                token.type === "ID" ||
-                token.type === "ID_RANGE" ||
-                token.type === "REF" ||
-                token.type === "RANGE" ||
-                token.type === "UNREFERENCED" ||
-                token.type === "INVALID_REF") {
+            else if (token.type === 'VALUE' ||
+                token.type === 'ID' ||
+                token.type === 'ID_RANGE' ||
+                token.type === 'REF' ||
+                token.type === 'RANGE' ||
+                token.type === 'UNREFERENCED' ||
+                token.type === 'INVALID_REF') {
                 const expr = token.convert();
                 stack.push(expr);
             }
-            else if (token.type === "FUNCTION") {
+            else if (token.type === 'FUNCTION') {
                 this.index++;
                 this.depth++;
                 const func = token.convert();
                 stack.push(func);
+                // eslint-disable-next-line no-constant-condition
                 while (true) {
                     const { expr, hasNext } = this.parse(true);
                     if (expr) {
@@ -597,26 +606,26 @@ class Parser {
                     }
                 }
             }
-            else if (token.type === "OPEN") {
+            else if (token.type === 'OPEN') {
                 this.depth++;
                 const { expr } = this.parse(false);
                 stack.push(expr);
             }
-            else if (token.type === "CLOSE") {
+            else if (token.type === 'CLOSE') {
                 if (this.depth-- === 0) {
-                    throw new FormulaError("#ERROR!", "Unexpected end paren");
+                    throw new FormulaError('#ERROR!', 'Unexpected end paren');
                 }
                 return complement();
             }
-            else if (token.type === "INFIX_OPERATOR") {
+            else if (token.type === 'INFIX_OPERATOR') {
                 const operator = token.convert();
                 let left = stack.pop();
                 if (left == null) {
-                    if (operator.name === "minus" || operator.name === "add") {
+                    if (operator.name === 'minus' || operator.name === 'add') {
                         left = ZERO;
                     }
                     else {
-                        throw new FormulaError("#ERROR!", "Missing left expression");
+                        throw new FormulaError('#ERROR!', 'Missing left expression');
                     }
                 }
                 if (lastOperator == null) {
@@ -636,7 +645,7 @@ class Parser {
                 }
                 lastOperator = operator;
             }
-            else if (token.type === "PREFIX_OPERATOR") {
+            else if (token.type === 'PREFIX_OPERATOR') {
                 const operator = token.convert();
                 if (lastOperator) {
                     lastOperator.args.push(operator);
@@ -652,11 +661,11 @@ class Parser {
 }
 exports.Parser = Parser;
 const absolutizeFormula = ({ value, table, slideY = 0, slideX = 0, }) => {
-    if (typeof value === "string" || value instanceof String) {
-        if (value.charAt(0) === "=") {
+    if (typeof value === 'string' || value instanceof String) {
+        if (value.charAt(0) === '=') {
             const lexer = new Lexer(value.substring(1));
             lexer.tokenize();
-            return "=" + lexer.stringifyToId(table, slideY, slideX);
+            return '=' + lexer.stringifyToId(table, slideY, slideX);
         }
     }
     return value;
@@ -673,7 +682,7 @@ const stripSheetName = (sheetName) => {
 };
 exports.stripSheetName = stripSheetName;
 const wrapSheetName = (sheetName) => {
-    if (sheetName.indexOf(" ") !== -1) {
+    if (sheetName.indexOf(' ') !== -1) {
         return `'${sheetName}'`;
     }
     return sheetName;