@gridsheet/react-core 0.12.4-rc.1 → 0.12.4

package/dist/formula/evaluator.js

@@ -1,567 +1,557 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../lib/structs", "../lib/converters"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.convertFormulaAbsolute = exports.Parser = exports.Lexer = exports.Token = exports.Function = exports.IdRange = exports.Id = exports.Range = exports.Ref = exports.InvalidRef = exports.Unreferenced = exports.Value = 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("$")) {
-            id = id.slice(1);
-        }
-        if (stripAbsolute && id.endsWith("$")) {
-            id = id.slice(0, -1);
-        }
-        return id;
-    };
-    class FormulaError {
-        constructor(code, message, error) {
-            this.code = code;
-            this.message = message;
-            this.error = error;
-        }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFormulaAbsolute = exports.Parser = exports.Lexer = exports.Token = exports.Function = exports.IdRange = exports.Id = exports.Range = exports.Ref = exports.InvalidRef = exports.Unreferenced = exports.Value = 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("$")) {
+        id = id.slice(1);
     }
-    exports.FormulaError = FormulaError;
-    class Entity {
-        constructor(value) {
-            this.value = value;
-        }
+    if (stripAbsolute && id.endsWith("$")) {
+        id = id.slice(0, -1);
     }
-    class Value extends Entity {
-        evaluate({}) {
-            return this.value;
-        }
+    return id;
+};
+class FormulaError {
+    constructor(code, message, error) {
+        this.code = code;
+        this.message = message;
+        this.error = error;
     }
-    exports.Value = Value;
-    class Unreferenced extends Entity {
-        evaluate({}) {
-            throw new FormulaError("#REF!", `Reference does not exist.`);
-        }
+}
+exports.FormulaError = FormulaError;
+class Entity {
+    constructor(value) {
+        this.value = value;
     }
-    exports.Unreferenced = Unreferenced;
-    class InvalidRef extends Entity {
-        evaluate({}) {
-            throw new FormulaError("#NAME?", `Invalid ref: ${this.value}`);
-        }
+}
+class Value extends Entity {
+    evaluate({}) {
+        return this.value;
     }
-    exports.InvalidRef = InvalidRef;
-    class Ref extends Entity {
-        constructor(value) {
-            super(value.toUpperCase());
-        }
-        evaluate({ table }) {
-            const { y, x } = (0, converters_1.a2p)(this.value);
-            return table.trim({ top: y, left: x, bottom: y, right: x });
-        }
-        id(table) {
-            const id = table.getIdByAddress(this.value);
-            if (id) {
-                return id;
-            }
-            return this.value;
+}
+exports.Value = Value;
+class Unreferenced 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.InvalidRef = InvalidRef;
+class Ref extends Entity {
+    constructor(value) {
+        super(value.toUpperCase());
+    }
+    evaluate({ table }) {
+        const { y, x } = (0, converters_1.a2p)(this.value);
+        return table.trim({ top: y, left: x, bottom: y, right: x });
+    }
+    id(table) {
+        const id = table.getIdByAddress(this.value);
+        if (id) {
+            return id;
         }
+        return this.value;
+    }
+}
+exports.Ref = Ref;
+class Range extends Entity {
+    constructor(value) {
+        super(value.toUpperCase());
     }
-    exports.Ref = Ref;
-    class Range extends Entity {
-        constructor(value) {
-            super(value.toUpperCase());
+    evaluate({ table }) {
+        const area = (0, structs_1.rangeToArea)(this.complementRange(table));
+        return table.trim(area);
+    }
+    idRange(table) {
+        return this.value
+            .split(":")
+            .map((ref) => table.getIdByAddress(ref))
+            .join(":");
+    }
+    complementRange(table) {
+        const cells = this.value.split(":");
+        let [start = "", end = ""] = cells;
+        if (!start.match(/[1-9]\d*/)) {
+            start += "1";
         }
-        evaluate({ table }) {
-            const area = (0, structs_1.rangeToArea)(this.complementRange(table));
-            return table.trim(area);
+        if (!start.match(/[a-zA-Z]/)) {
+            start = "A" + start;
         }
-        idRange(table) {
-            return this.value
-                .split(":")
-                .map((ref) => table.getIdByAddress(ref))
-                .join(":");
+        if (!end.match(/[1-9]\d*/)) {
+            end += table.getNumRows();
         }
-        complementRange(table) {
-            const cells = this.value.split(":");
-            let [start = "", end = ""] = cells;
-            if (!start.match(/[1-9]\d*/)) {
-                start += "1";
-            }
-            if (!start.match(/[a-zA-Z]/)) {
-                start = "A" + start;
-            }
-            if (!end.match(/[1-9]\d*/)) {
-                end += table.getNumRows();
-            }
-            if (!end.match(/[a-zA-Z]/)) {
-                end = (0, converters_1.x2c)(table.getNumCols() + 1) + end;
-            }
-            return `${start}:${end}`;
+        if (!end.match(/[a-zA-Z]/)) {
+            end = (0, converters_1.x2c)(table.getNumCols() + 1) + end;
         }
+        return `${start}:${end}`;
     }
-    exports.Range = Range;
-    class Id extends Entity {
-        evaluate({ table }) {
-            const id = getId(this.value);
-            const { y, x } = table.getPointById(id);
-            return table.trim({ top: y, left: x, bottom: y, right: x });
-        }
-        ref(table, slideY = 0, slideX = 0) {
-            return table.getAddressById(getId(this.value, false), slideY, slideX);
-        }
-        slide(table, slideY = 0, slideX = 0) {
-            const address = this.ref(table, slideY, slideX);
-            if (address == null || address.length < 2) {
-                return "#REF!";
-            }
-            return table.getIdByAddress(address);
-        }
+}
+exports.Range = Range;
+class Id extends Entity {
+    evaluate({ table }) {
+        const id = getId(this.value);
+        const { y, x } = table.getPointById(id);
+        return table.trim({ top: y, left: x, bottom: y, right: x });
     }
-    exports.Id = Id;
-    class IdRange extends Entity {
-        evaluate({ table }) {
-            const ids = this.value.split(":");
-            const [p1, p2] = ids
-                .map((id) => getId(id))
-                .map((id) => table.getPointById(id));
-            return table.trim({ top: p1.y, left: p1.x, bottom: p2.y, right: p2.x });
-        }
-        range(table, slideY = 0, slideX = 0) {
-            return this.value
-                .split(":")
-                .map((id) => getId(id, false))
-                .map((id) => table.getAddressById(id, slideY, slideX))
-                .join(":");
-        }
-        slide(table, slideY = 0, slideX = 0) {
-            const range = this.range(table, slideY, slideX);
-            return new Range(range).idRange(table);
-        }
+    ref(table, slideY = 0, slideX = 0) {
+        return table.getAddressById(getId(this.value, false), slideY, slideX);
     }
-    exports.IdRange = IdRange;
-    class Function {
-        constructor(name, precedence = 0, args = []) {
-            this.name = name;
-            this.precedence = precedence;
-            this.args = args;
+    slide(table, slideY = 0, slideX = 0) {
+        const address = this.ref(table, slideY, slideX);
+        if (address == null || address.length < 2) {
+            return "#REF!";
         }
-        evaluate({ table }) {
-            const name = this.name.toLowerCase();
-            const Func = table.getFunction(name);
-            if (Func == null) {
-                throw new FormulaError("#NAME?", `Unknown function: ${name}`);
+        return table.getIdByAddress(address);
+    }
+}
+exports.Id = Id;
+class IdRange extends Entity {
+    evaluate({ table }) {
+        const ids = this.value.split(":");
+        const [p1, p2] = ids
+            .map((id) => getId(id))
+            .map((id) => table.getPointById(id));
+        return table.trim({ top: p1.y, left: p1.x, bottom: p2.y, right: p2.x });
+    }
+    range(table, slideY = 0, slideX = 0) {
+        return this.value
+            .split(":")
+            .map((id) => getId(id, false))
+            .map((id) => table.getAddressById(id, slideY, slideX))
+            .join(":");
+    }
+    slide(table, slideY = 0, slideX = 0) {
+        const range = this.range(table, slideY, slideX);
+        return new Range(range).idRange(table);
+    }
+}
+exports.IdRange = IdRange;
+class Function {
+    constructor(name, precedence = 0, args = []) {
+        this.name = name;
+        this.precedence = precedence;
+        this.args = args;
+    }
+    evaluate({ table }) {
+        const name = this.name.toLowerCase();
+        const Func = table.getFunction(name);
+        if (Func == null) {
+            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);
+const INFIX_FUNCTION_NAME_MAP = {
+    "+": "add",
+    "-": "minus",
+    "/": "divide",
+    "*": "multiply",
+    "^": "power",
+    "&": "concat",
+    "=": "eq",
+    "<>": "ne",
+    ">": "gt",
+    ">=": "gte",
+    "<": "lt",
+    "<=": "lte",
+};
+const PREFIX_FUNCTION_NAME_MAP = {
+    "-": "uminus",
+};
+class Token {
+    constructor(type, entity, precedence = 0) {
+        this.type = type;
+        this.entity = entity;
+        this.precedence = precedence;
+    }
+    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": {
+                const name = INFIX_FUNCTION_NAME_MAP[this.entity];
+                return new Function(name, this.precedence);
             }
-            const func = new Func({ args: this.args, table });
-            return func.call();
+            case "PREFIX_OPERATOR": {
+                const name = PREFIX_FUNCTION_NAME_MAP[this.entity];
+                return new Function(name, this.precedence);
+            }
+            case "FUNCTION":
+                return new Function(this.entity);
+            case "UNREFERENCED":
+                return new Unreferenced(this.entity);
+            case "INVALID_REF":
+                return new InvalidRef(this.entity);
         }
     }
-    exports.Function = Function;
-    const ZERO = new Value(0);
-    const INFIX_FUNCTION_NAME_MAP = {
-        "+": "add",
-        "-": "minus",
-        "/": "divide",
-        "*": "multiply",
-        "^": "power",
-        "&": "concat",
-        "=": "eq",
-        "<>": "ne",
-        ">": "gt",
-        ">=": "gte",
-        "<": "lt",
-        "<=": "lte",
-    };
-    const PREFIX_FUNCTION_NAME_MAP = {
-        "-": "uminus",
-    };
-    class Token {
-        constructor(type, entity, precedence = 0) {
-            this.type = type;
-            this.entity = entity;
-            this.precedence = precedence;
-        }
-        convert() {
-            switch (this.type) {
+}
+exports.Token = Token;
+const isWhiteSpace = (char) => {
+    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 };
+class Lexer {
+    constructor(formula) {
+        this.tokens = [];
+        this.formula = formula;
+        this.index = 0;
+        this.tokens = [];
+    }
+    isWhiteSpace() {
+        return isWhiteSpace(this.formula[this.index]);
+    }
+    next(base = 1) {
+        this.index += base;
+    }
+    get(base = 0) {
+        const c = this.formula[this.index + base];
+        return c;
+    }
+    getToken(base = 0) {
+        return this.tokens[this.tokens.length + base];
+    }
+    stringifyToId(table, slideY = 0, slideX = 0) {
+        return this.tokens
+            .map((t) => {
+            switch (t.type) {
                 case "VALUE":
-                    return new Value(this.entity);
+                    if (typeof t.entity === "number" || typeof t.entity === "boolean") {
+                        return t.entity;
+                    }
+                    return `"${t.entity}"`;
                 case "ID":
-                    return new Id(this.entity);
+                    return new Id(t.entity).slide(table, slideY, slideX);
                 case "ID_RANGE":
-                    return new IdRange(this.entity);
+                    return new IdRange(t.entity).slide(table, slideY, slideX);
                 case "REF":
-                    return new Ref(this.entity);
+                    return new Ref(t.entity).id(table);
                 case "RANGE":
-                    return new Range(this.entity);
-                case "INFIX_OPERATOR": {
-                    const name = INFIX_FUNCTION_NAME_MAP[this.entity];
-                    return new Function(name, this.precedence);
-                }
-                case "PREFIX_OPERATOR": {
-                    const name = PREFIX_FUNCTION_NAME_MAP[this.entity];
-                    return new Function(name, this.precedence);
-                }
-                case "FUNCTION":
-                    return new Function(this.entity);
-                case "UNREFERENCED":
-                    return new Unreferenced(this.entity);
-                case "INVALID_REF":
-                    return new InvalidRef(this.entity);
+                    return new Range(t.entity).idRange(table);
             }
-        }
+            return t.entity;
+        })
+            .join("");
     }
-    exports.Token = Token;
-    const isWhiteSpace = (char) => {
-        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 };
-    class Lexer {
-        constructor(formula) {
-            this.tokens = [];
-            this.formula = formula;
-            this.index = 0;
-            this.tokens = [];
-        }
-        isWhiteSpace() {
-            return isWhiteSpace(this.formula[this.index]);
-        }
-        next(base = 1) {
-            this.index += base;
-        }
-        get(base = 0) {
-            const c = this.formula[this.index + base];
-            return c;
-        }
-        getToken(base = 0) {
-            return this.tokens[this.tokens.length + base];
-        }
-        stringifyToId(table, slideY = 0, slideX = 0) {
-            return this.tokens
-                .map((t) => {
-                switch (t.type) {
-                    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);
-                }
-                return t.entity;
-            })
-                .join("");
-        }
-        stringifyToRef(table) {
-            return this.tokens
-                .map((t) => {
-                switch (t.type) {
-                    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);
+    stringifyToRef(table) {
+        return this.tokens
+            .map((t) => {
+            switch (t.type) {
+                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);
+            }
+            return t.entity;
+        })
+            .join("");
+    }
+    tokenize() {
+        var _a, _b;
+        while (this.index <= this.formula.length) {
+            this.skipSpaces();
+            const char = this.get();
+            this.next();
+            switch (char) {
+                case undefined:
+                    return;
+                case "(":
+                    this.tokens.push(TOKEN_OPEN);
+                    continue;
+                case ")":
+                    this.tokens.push(TOKEN_CLOSE);
+                    continue;
+                case ",":
+                    this.tokens.push(TOKEN_COMMA);
+                    continue;
+                case "+":
+                    this.tokens.push(TOKEN_ADD);
+                    continue;
+                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")) {
+                        this.tokens.push(TOKEN_UMINUS);
+                    }
+                    else {
+                        this.tokens.push(TOKEN_MINUS);
+                    }
+                    continue;
                 }
-                return t.entity;
-            })
-                .join("");
-        }
-        tokenize() {
-            var _a, _b;
-            while (this.index <= this.formula.length) {
-                this.skipSpaces();
-                const char = this.get();
-                this.next();
-                switch (char) {
-                    case undefined:
-                        return;
-                    case "(":
-                        this.tokens.push(TOKEN_OPEN);
-                        continue;
-                    case ")":
-                        this.tokens.push(TOKEN_CLOSE);
-                        continue;
-                    case ",":
-                        this.tokens.push(TOKEN_COMMA);
-                        continue;
-                    case "+":
-                        this.tokens.push(TOKEN_ADD);
-                        continue;
-                    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")) {
-                            this.tokens.push(TOKEN_UMINUS);
-                        }
-                        else {
-                            this.tokens.push(TOKEN_MINUS);
-                        }
+                case "/":
+                    this.tokens.push(TOKEN_DIVIDE);
+                    continue;
+                case "*":
+                    this.tokens.push(TOKEN_MULTIPLY);
+                    continue;
+                case "^":
+                    this.tokens.push(TOKEN_POWER);
+                    continue;
+                case "&":
+                    this.tokens.push(TOKEN_CONCAT);
+                    continue;
+                case "=":
+                    this.tokens.push(TOKEN_EQ);
+                    continue;
+                case ">":
+                    if (this.get() === "=") {
+                        this.next();
+                        this.tokens.push(TOKEN_GTE);
                         continue;
                     }
-                    case "/":
-                        this.tokens.push(TOKEN_DIVIDE);
-                        continue;
-                    case "*":
-                        this.tokens.push(TOKEN_MULTIPLY);
-                        continue;
-                    case "^":
-                        this.tokens.push(TOKEN_POWER);
-                        continue;
-                    case "&":
-                        this.tokens.push(TOKEN_CONCAT);
-                        continue;
-                    case "=":
-                        this.tokens.push(TOKEN_EQ);
-                        continue;
-                    case ">":
-                        if (this.get() === "=") {
-                            this.next();
-                            this.tokens.push(TOKEN_GTE);
-                            continue;
-                        }
-                        this.tokens.push(TOKEN_GT);
-                        continue;
-                    case "<":
-                        if (this.get() === "=") {
-                            this.next();
-                            this.tokens.push(TOKEN_LTE);
-                            continue;
-                        }
-                        if (this.get() === ">") {
-                            this.next();
-                            this.tokens.push(TOKEN_NE);
-                            continue;
-                        }
-                        this.tokens.push(TOKEN_LT);
-                        continue;
-                    case '"': {
-                        const buf = this.getString();
-                        this.tokens.push(new Token("VALUE", buf));
+                    this.tokens.push(TOKEN_GT);
+                    continue;
+                case "<":
+                    if (this.get() === "=") {
+                        this.next();
+                        this.tokens.push(TOKEN_LTE);
                         continue;
                     }
-                } // switch end
-                let buf = char;
-                while (true) {
-                    const c = this.get();
-                    if (c === "(") {
-                        this.tokens.push(new Token("FUNCTION", buf), TOKEN_OPEN);
+                    if (this.get() === ">") {
                         this.next();
+                        this.tokens.push(TOKEN_NE);
+                        continue;
+                    }
+                    this.tokens.push(TOKEN_LT);
+                    continue;
+                case '"': {
+                    const buf = this.getString();
+                    this.tokens.push(new Token("VALUE", buf));
+                    continue;
+                }
+            } // switch end
+            let buf = char;
+            while (true) {
+                const c = this.get();
+                if (c === "(") {
+                    this.tokens.push(new Token("FUNCTION", buf), TOKEN_OPEN);
+                    this.next();
+                    break;
+                }
+                if (c == null || c.match(/[ +\-/*^&=<>),]/)) {
+                    if (buf.length === 0) {
                         break;
                     }
-                    if (c == null || c.match(/[ +\-/*^&=<>),]/)) {
-                        if (buf.length === 0) {
-                            break;
+                    if (buf.match(/^[+-]?(\d*[.])?\d+$/)) {
+                        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));
+                        }
+                        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 {
+                                this.tokens.push(new Token("ID", buf));
+                            }
                         }
-                        if (buf.match(/^[+-]?(\d*[.])?\d+$/)) {
-                            this.tokens.push(new Token("VALUE", parseFloat(buf)));
+                        else if (buf.indexOf(":") !== -1) {
+                            this.tokens.push(new Token("RANGE", buf));
                         }
                         else {
                             // @ts-ignore
-                            const bool = BOOLS[buf.toLowerCase()];
-                            if (bool != null) {
-                                this.tokens.push(new Token("VALUE", bool));
-                            }
-                            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 {
-                                    this.tokens.push(new Token("ID", buf));
-                                }
-                            }
-                            else if (buf.indexOf(":") !== -1) {
-                                this.tokens.push(new Token("RANGE", buf));
+                            if (isNaN(buf[buf.length - 1])) {
+                                this.tokens.push(new Token("INVALID_REF", buf));
                             }
                             else {
-                                // @ts-ignore
-                                if (isNaN(buf[buf.length - 1])) {
-                                    this.tokens.push(new Token("INVALID_REF", buf));
-                                }
-                                else {
-                                    this.tokens.push(new Token("REF", buf));
-                                }
+                                this.tokens.push(new Token("REF", buf));
                             }
                         }
-                        break;
                     }
-                    buf += c;
-                    this.next();
+                    break;
                 }
+                buf += c;
+                this.next();
             }
         }
-        skipSpaces() {
-            let space = "";
-            while (this.isWhiteSpace()) {
-                space += this.formula[this.index++];
-            }
-            if (space !== "") {
-                this.tokens.push(new Token("SPACE", space));
-            }
+    }
+    skipSpaces() {
+        let space = "";
+        while (this.isWhiteSpace()) {
+            space += this.formula[this.index++];
         }
-        getString() {
-            let buf = "";
-            while (true) {
-                const c = this.get();
-                this.next();
-                if (c == null) {
-                    break;
-                }
-                if (c === '"') {
-                    if (this.get() === '"') {
-                        // escape
-                        buf += '"';
-                        this.next();
-                        continue;
-                    }
-                    else {
-                        break;
-                    }
+        if (space !== "") {
+            this.tokens.push(new Token("SPACE", space));
+        }
+    }
+    getString() {
+        let buf = "";
+        while (true) {
+            const c = this.get();
+            this.next();
+            if (c == null) {
+                break;
+            }
+            if (c === '"') {
+                if (this.get() === '"') {
+                    // escape
+                    buf += '"';
+                    this.next();
+                    continue;
                 }
                 else {
-                    buf += c;
+                    break;
                 }
             }
-            return buf;
+            else {
+                buf += c;
+            }
         }
+        return buf;
     }
-    exports.Lexer = Lexer;
-    class Parser {
-        constructor(tokens) {
-            this.index = 0;
-            this.depth = 0;
-            this.tokens = tokens;
-        }
-        build() {
-            const { expr } = this.parse(false);
-            return expr;
-        }
-        parse(underFunction) {
-            const stack = [];
-            let lastOperator;
-            const complement = (hasNext = false) => {
-                if (lastOperator) {
-                    const outer = stack.pop();
-                    lastOperator.args.push(outer);
-                }
-                return { hasNext, expr: stack.shift() };
-            };
-            while (this.tokens.length > this.index) {
-                const token = this.tokens[this.index++];
-                if (token.type === "SPACE") {
-                    continue;
+}
+exports.Lexer = Lexer;
+class Parser {
+    constructor(tokens) {
+        this.index = 0;
+        this.depth = 0;
+        this.tokens = tokens;
+    }
+    build() {
+        const { expr } = this.parse(false);
+        return expr;
+    }
+    parse(underFunction) {
+        const stack = [];
+        let lastOperator;
+        const complement = (hasNext = false) => {
+            if (lastOperator) {
+                const outer = stack.pop();
+                lastOperator.args.push(outer);
+            }
+            return { hasNext, expr: stack.shift() };
+        };
+        while (this.tokens.length > this.index) {
+            const token = this.tokens[this.index++];
+            if (token.type === "SPACE") {
+                continue;
+            }
+            if (token.type === "COMMA") {
+                if (!underFunction) {
+                    throw new FormulaError("#ERROR!", "Invalid comma");
                 }
-                if (token.type === "COMMA") {
-                    if (!underFunction) {
-                        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") {
+                const expr = token.convert();
+                stack.push(expr);
+            }
+            else if (token.type === "FUNCTION") {
+                this.index++;
+                this.depth++;
+                const func = token.convert();
+                stack.push(func);
+                while (true) {
+                    const { expr, hasNext } = this.parse(true);
+                    if (expr) {
+                        func.args.push(expr);
                     }
-                    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") {
-                    const expr = token.convert();
-                    stack.push(expr);
-                }
-                else if (token.type === "FUNCTION") {
-                    this.index++;
-                    this.depth++;
-                    const func = token.convert();
-                    stack.push(func);
-                    while (true) {
-                        const { expr, hasNext } = this.parse(true);
-                        if (expr) {
-                            func.args.push(expr);
-                        }
-                        if (!hasNext) {
-                            break;
-                        }
+                    if (!hasNext) {
+                        break;
                     }
                 }
-                else if (token.type === "OPEN") {
-                    this.depth++;
-                    const { expr } = this.parse(false);
-                    stack.push(expr);
-                }
-                else if (token.type === "CLOSE") {
-                    if (this.depth-- === 0) {
-                        throw new FormulaError("#ERROR!", "Unexpected end paren");
-                    }
-                    return complement();
+            }
+            else if (token.type === "OPEN") {
+                this.depth++;
+                const { expr } = this.parse(false);
+                stack.push(expr);
+            }
+            else if (token.type === "CLOSE") {
+                if (this.depth-- === 0) {
+                    throw new FormulaError("#ERROR!", "Unexpected end paren");
                 }
-                else if (token.type === "INFIX_OPERATOR") {
-                    const operator = token.convert();
-                    let left = stack.pop();
-                    if (left == null) {
-                        if (operator.name === "minus" || operator.name === "add") {
-                            left = ZERO;
-                        }
-                        else {
-                            throw new FormulaError("#ERROR!", "Missing left expression");
-                        }
-                    }
-                    if (lastOperator == null) {
-                        operator.args.push(left);
-                        stack.unshift(operator);
-                    }
-                    else if (operator.precedence > lastOperator.precedence) {
-                        operator.args.push(left);
-                        lastOperator.args.push(operator);
-                        stack.unshift(lastOperator);
+                return complement();
+            }
+            else if (token.type === "INFIX_OPERATOR") {
+                const operator = token.convert();
+                let left = stack.pop();
+                if (left == null) {
+                    if (operator.name === "minus" || operator.name === "add") {
+                        left = ZERO;
                     }
                     else {
-                        const outer = stack.shift();
-                        operator.args.push(outer);
-                        lastOperator.args.push(left);
-                        stack.unshift(operator);
+                        throw new FormulaError("#ERROR!", "Missing left expression");
                     }
-                    lastOperator = operator;
                 }
-                else if (token.type === "PREFIX_OPERATOR") {
-                    const operator = token.convert();
-                    if (lastOperator) {
-                        lastOperator.args.push(operator);
-                    }
-                    else {
-                        stack.unshift(operator);
-                    }
-                    lastOperator = operator;
+                if (lastOperator == null) {
+                    operator.args.push(left);
+                    stack.unshift(operator);
+                }
+                else if (operator.precedence > lastOperator.precedence) {
+                    operator.args.push(left);
+                    lastOperator.args.push(operator);
+                    stack.unshift(lastOperator);
+                }
+                else {
+                    const outer = stack.shift();
+                    operator.args.push(outer);
+                    lastOperator.args.push(left);
+                    stack.unshift(operator);
                 }
+                lastOperator = operator;
+            }
+            else if (token.type === "PREFIX_OPERATOR") {
+                const operator = token.convert();
+                if (lastOperator) {
+                    lastOperator.args.push(operator);
+                }
+                else {
+                    stack.unshift(operator);
+                }
+                lastOperator = operator;
             }
-            return complement();
         }
+        return complement();
     }
-    exports.Parser = Parser;
-    const convertFormulaAbsolute = ({ value, table, slideY = 0, slideX = 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);
-            }
+}
+exports.Parser = Parser;
+const convertFormulaAbsolute = ({ value, table, slideY = 0, slideX = 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 value;
-    };
-    exports.convertFormulaAbsolute = convertFormulaAbsolute;
-});
+    }
+    return value;
+};
+exports.convertFormulaAbsolute = convertFormulaAbsolute;
 //# sourceMappingURL=evaluator.js.map