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

package/dist/formula/evaluator.js

@@ -1,541 +1,567 @@
-import { rangeToArea } from "../lib/structs";
-import { a2p, x2c } from "../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;
-};
-export class FormulaError {
-    constructor(code, message, error) {
-        this.code = code;
-        this.message = message;
-        this.error = error;
-    }
-}
-class Entity {
-    constructor(value) {
-        this.value = value;
-    }
-}
-export class Value extends Entity {
-    evaluate({}) {
-        return this.value;
-    }
-}
-export class Unreferenced extends Entity {
-    evaluate({}) {
-        throw new FormulaError("#REF!", `Reference does not exist.`);
-    }
-}
-export class InvalidRef extends Entity {
-    evaluate({}) {
-        throw new FormulaError("#NAME?", `Invalid ref: ${this.value}`);
-    }
-}
-export class Ref extends Entity {
-    constructor(value) {
-        super(value.toUpperCase());
-    }
-    evaluate({ table }) {
-        const { y, x } = 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;
+(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;
         }
-        return this.value;
     }
-}
-export class Range extends Entity {
-    constructor(value) {
-        super(value.toUpperCase());
+    exports.FormulaError = FormulaError;
+    class Entity {
+        constructor(value) {
+            this.value = value;
+        }
     }
-    evaluate({ table }) {
-        const area = rangeToArea(this.complementRange(table));
-        return table.trim(area);
+    class Value extends Entity {
+        evaluate({}) {
+            return this.value;
+        }
     }
-    idRange(table) {
-        return this.value
-            .split(":")
-            .map((ref) => table.getIdByAddress(ref))
-            .join(":");
+    exports.Value = Value;
+    class Unreferenced extends Entity {
+        evaluate({}) {
+            throw new FormulaError("#REF!", `Reference does not exist.`);
+        }
     }
-    complementRange(table) {
-        const cells = this.value.split(":");
-        let [start = "", end = ""] = cells;
-        if (!start.match(/[1-9]\d*/)) {
-            start += "1";
+    exports.Unreferenced = Unreferenced;
+    class InvalidRef extends Entity {
+        evaluate({}) {
+            throw new FormulaError("#NAME?", `Invalid ref: ${this.value}`);
         }
-        if (!start.match(/[a-zA-Z]/)) {
-            start = "A" + start;
+    }
+    exports.InvalidRef = InvalidRef;
+    class Ref extends Entity {
+        constructor(value) {
+            super(value.toUpperCase());
         }
-        if (!end.match(/[1-9]\d*/)) {
-            end += table.getNumRows();
+        evaluate({ table }) {
+            const { y, x } = (0, converters_1.a2p)(this.value);
+            return table.trim({ top: y, left: x, bottom: y, right: x });
         }
-        if (!end.match(/[a-zA-Z]/)) {
-            end = x2c(table.getNumCols() + 1) + end;
+        id(table) {
+            const id = table.getIdByAddress(this.value);
+            if (id) {
+                return id;
+            }
+            return this.value;
         }
-        return `${start}:${end}`;
-    }
-}
-export 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!";
+    exports.Ref = Ref;
+    class Range extends Entity {
+        constructor(value) {
+            super(value.toUpperCase());
         }
-        return table.getIdByAddress(address);
-    }
-}
-export 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);
-    }
-}
-export 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();
-    }
-}
-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",
-};
-export 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);
+        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";
+            }
+            if (!start.match(/[a-zA-Z]/)) {
+                start = "A" + start;
+            }
+            if (!end.match(/[1-9]\d*/)) {
+                end += table.getNumRows();
             }
-            case "PREFIX_OPERATOR": {
-                const name = PREFIX_FUNCTION_NAME_MAP[this.entity];
-                return new Function(name, this.precedence);
+            if (!end.match(/[a-zA-Z]/)) {
+                end = (0, converters_1.x2c)(table.getNumCols() + 1) + end;
             }
-            case "FUNCTION":
-                return new Function(this.entity);
-            case "UNREFERENCED":
-                return new Unreferenced(this.entity);
-            case "INVALID_REF":
-                return new InvalidRef(this.entity);
+            return `${start}:${end}`;
         }
     }
-}
-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 };
-export 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;
+    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);
+        }
     }
-    get(base = 0) {
-        const c = this.formula[this.index + base];
-        return c;
+    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);
+        }
     }
-    getToken(base = 0) {
-        return this.tokens[this.tokens.length + base];
+    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();
+        }
     }
-    stringifyToId(table, slideY = 0, slideX = 0) {
-        return this.tokens
-            .map((t) => {
-            switch (t.type) {
+    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":
-                    if (typeof t.entity === "number" || typeof t.entity === "boolean") {
-                        return t.entity;
-                    }
-                    return `"${t.entity}"`;
+                    return new Value(this.entity);
                 case "ID":
-                    return new Id(t.entity).slide(table, slideY, slideX);
+                    return new Id(this.entity);
                 case "ID_RANGE":
-                    return new IdRange(t.entity).slide(table, slideY, slideX);
+                    return new IdRange(this.entity);
                 case "REF":
-                    return new Ref(t.entity).id(table);
+                    return new Ref(this.entity);
                 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);
+                    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 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;
+    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);
                 }
-                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);
+                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);
+                }
+                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;
-                    }
-                    this.tokens.push(TOKEN_GT);
-                    continue;
-                case "<":
-                    if (this.get() === "=") {
-                        this.next();
-                        this.tokens.push(TOKEN_LTE);
+                    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;
                     }
-                    if (this.get() === ">") {
-                        this.next();
-                        this.tokens.push(TOKEN_NE);
+                    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));
                         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) {
+                } // 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 (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 (c == null || c.match(/[ +\-/*^&=<>),]/)) {
+                        if (buf.length === 0) {
+                            break;
                         }
-                        else if (buf.indexOf(":") !== -1) {
-                            this.tokens.push(new Token("RANGE", buf));
+                        if (buf.match(/^[+-]?(\d*[.])?\d+$/)) {
+                            this.tokens.push(new Token("VALUE", parseFloat(buf)));
                         }
                         else {
                             // @ts-ignore
-                            if (isNaN(buf[buf.length - 1])) {
-                                this.tokens.push(new Token("INVALID_REF", buf));
+                            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));
                             }
                             else {
-                                this.tokens.push(new Token("REF", buf));
+                                // @ts-ignore
+                                if (isNaN(buf[buf.length - 1])) {
+                                    this.tokens.push(new Token("INVALID_REF", buf));
+                                }
+                                else {
+                                    this.tokens.push(new Token("REF", buf));
+                                }
                             }
                         }
+                        break;
                     }
-                    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));
-        }
-    }
-    getString() {
-        let buf = "";
-        while (true) {
-            const c = this.get();
-            this.next();
-            if (c == null) {
-                break;
-            }
-            if (c === '"') {
-                if (this.get() === '"') {
-                    // escape
-                    buf += '"';
+                    buf += c;
                     this.next();
-                    continue;
-                }
-                else {
-                    break;
                 }
             }
-            else {
-                buf += c;
-            }
         }
-        return buf;
-    }
-}
-export 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);
+        skipSpaces() {
+            let space = "";
+            while (this.isWhiteSpace()) {
+                space += this.formula[this.index++];
             }
-            return { hasNext, expr: stack.shift() };
-        };
-        while (this.tokens.length > this.index) {
-            const token = this.tokens[this.index++];
-            if (token.type === "SPACE") {
-                continue;
+            if (space !== "") {
+                this.tokens.push(new Token("SPACE", space));
             }
-            if (token.type === "COMMA") {
-                if (!underFunction) {
-                    throw new FormulaError("#ERROR!", "Invalid comma");
+        }
+        getString() {
+            let buf = "";
+            while (true) {
+                const c = this.get();
+                this.next();
+                if (c == null) {
+                    break;
                 }
-                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 (c === '"') {
+                    if (this.get() === '"') {
+                        // escape
+                        buf += '"';
+                        this.next();
+                        continue;
                     }
-                    if (!hasNext) {
+                    else {
                         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");
+                else {
+                    buf += c;
                 }
-                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 {
-                        throw new FormulaError("#ERROR!", "Missing left expression");
+            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;
+                }
+                if (token.type === "COMMA") {
+                    if (!underFunction) {
+                        throw new FormulaError("#ERROR!", "Invalid comma");
                     }
+                    return complement(true);
                 }
-                if (lastOperator == null) {
-                    operator.args.push(left);
-                    stack.unshift(operator);
+                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 (operator.precedence > lastOperator.precedence) {
-                    operator.args.push(left);
-                    lastOperator.args.push(operator);
-                    stack.unshift(lastOperator);
+                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;
+                        }
+                    }
                 }
-                else {
-                    const outer = stack.shift();
-                    operator.args.push(outer);
-                    lastOperator.args.push(left);
-                    stack.unshift(operator);
+                else if (token.type === "OPEN") {
+                    this.depth++;
+                    const { expr } = this.parse(false);
+                    stack.push(expr);
                 }
-                lastOperator = operator;
-            }
-            else if (token.type === "PREFIX_OPERATOR") {
-                const operator = token.convert();
-                if (lastOperator) {
-                    lastOperator.args.push(operator);
+                else if (token.type === "CLOSE") {
+                    if (this.depth-- === 0) {
+                        throw new FormulaError("#ERROR!", "Unexpected end paren");
+                    }
+                    return complement();
                 }
-                else {
-                    stack.unshift(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") {
+                            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);
+                    }
+                    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;
                 }
-                lastOperator = operator;
             }
+            return complement();
         }
-        return complement();
     }
-}
-export 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;
-};
+        return value;
+    };
+    exports.convertFormulaAbsolute = convertFormulaAbsolute;
+});
 //# sourceMappingURL=evaluator.js.map