@affino/datagrid-formula-engine 0.1.1

package/dist/syntax/optimizer.js

@@ -0,0 +1,362 @@
+import { createFormulaSourceSpan, throwFormulaError, } from "./ast.js";
+import { normalizeFormulaFunctionName, } from "./functions.js";
+import { areFormulaValuesEqual, coerceFormulaValueToBoolean, coerceFormulaValueToNumber, compareFormulaValues, isFormulaErrorValue, isFormulaValuePresent, normalizeFormulaValue, } from "./values.js";
+function validateFormulaFunctionArity(functionDefinition, argsCount) {
+    const { arity } = functionDefinition;
+    if (typeof arity === "undefined") {
+        return;
+    }
+    if (typeof arity === "number") {
+        if (argsCount !== arity) {
+            throwFormulaError(`Function '${functionDefinition.name}' expects ${arity} argument(s), got ${argsCount}.`);
+        }
+        return;
+    }
+    if (argsCount < arity.min) {
+        throwFormulaError(`Function '${functionDefinition.name}' expects at least ${arity.min} argument(s), got ${argsCount}.`);
+    }
+    if (typeof arity.max === "number" && argsCount > arity.max) {
+        throwFormulaError(`Function '${functionDefinition.name}' expects at most ${arity.max} argument(s), got ${argsCount}.`);
+    }
+}
+export function collectFormulaIdentifiers(root, output) {
+    if (root.kind === "identifier") {
+        output.push(root.name);
+        return;
+    }
+    if (root.kind === "call") {
+        for (const arg of root.args) {
+            collectFormulaIdentifiers(arg, output);
+        }
+        return;
+    }
+    if (root.kind === "unary") {
+        collectFormulaIdentifiers(root.value, output);
+        return;
+    }
+    if (root.kind === "binary") {
+        collectFormulaIdentifiers(root.left, output);
+        collectFormulaIdentifiers(root.right, output);
+    }
+}
+export function validateFormulaFunctions(root, functionRegistry) {
+    if (root.kind === "call") {
+        const functionName = normalizeFormulaFunctionName(root.name);
+        const functionDefinition = functionRegistry.get(functionName);
+        if (!functionDefinition) {
+            throwFormulaError(`Unknown function '${root.name}'.`, root.span);
+        }
+        validateFormulaFunctionArity(functionDefinition, root.args.length);
+        if (functionName === "IFS" && root.args.length % 2 !== 0) {
+            throwFormulaError("Function 'IFS' expects an even number of arguments (condition/value pairs).", root.span);
+        }
+        for (const arg of root.args) {
+            validateFormulaFunctions(arg, functionRegistry);
+        }
+        return;
+    }
+    if (root.kind === "unary") {
+        validateFormulaFunctions(root.value, functionRegistry);
+        return;
+    }
+    if (root.kind === "binary") {
+        validateFormulaFunctions(root.left, functionRegistry);
+        validateFormulaFunctions(root.right, functionRegistry);
+    }
+}
+function createFormulaNumberNode(value) {
+    return {
+        kind: "number",
+        value: Number.isFinite(value) ? value : 0,
+        span: createFormulaSourceSpan(0, 0),
+    };
+}
+function createFormulaLiteralNode(value, span) {
+    const normalized = normalizeFormulaValue(value);
+    if (typeof normalized === "number") {
+        return {
+            kind: "number",
+            value: normalized,
+            span: span !== null && span !== void 0 ? span : createFormulaSourceSpan(0, 0),
+        };
+    }
+    return {
+        kind: "literal",
+        value: normalized,
+        span: span !== null && span !== void 0 ? span : createFormulaSourceSpan(0, 0),
+    };
+}
+function isFormulaLiteralNode(node) {
+    return node.kind === "number" || node.kind === "literal";
+}
+function getFormulaLiteralNodeValue(node) {
+    return node.kind === "number" ? node.value : node.value;
+}
+function coerceFormulaValueToDate(value) {
+    var _a;
+    const scalarValue = Array.isArray(value) ? ((_a = value[0]) !== null && _a !== void 0 ? _a : null) : value;
+    if (scalarValue === null) {
+        return null;
+    }
+    if (isFormulaErrorValue(scalarValue)) {
+        throwFormulaError(scalarValue.message);
+    }
+    if (scalarValue instanceof Date) {
+        return Number.isNaN(scalarValue.getTime()) ? null : scalarValue;
+    }
+    if (typeof scalarValue === "number") {
+        if (!Number.isFinite(scalarValue)) {
+            return null;
+        }
+        const date = new Date(scalarValue);
+        return Number.isNaN(date.getTime()) ? null : date;
+    }
+    if (typeof scalarValue === "string") {
+        const text = scalarValue.trim();
+        if (text.length === 0) {
+            return null;
+        }
+        const timestamp = Date.parse(text);
+        if (!Number.isFinite(timestamp)) {
+            return null;
+        }
+        const date = new Date(timestamp);
+        return Number.isNaN(date.getTime()) ? null : date;
+    }
+    return null;
+}
+export function foldFormulaConstants(root) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5;
+    if (root.kind === "number" || root.kind === "literal" || root.kind === "identifier") {
+        return root;
+    }
+    if (root.kind === "unary") {
+        const value = foldFormulaConstants(root.value);
+        if (!isFormulaLiteralNode(value)) {
+            return {
+                kind: "unary",
+                operator: root.operator,
+                value,
+                span: root.span,
+            };
+        }
+        const valueLiteral = getFormulaLiteralNodeValue(value);
+        if (root.operator === "-") {
+            return createFormulaLiteralNode(-coerceFormulaValueToNumber(valueLiteral), root.span);
+        }
+        if (root.operator === "+") {
+            return createFormulaLiteralNode(+coerceFormulaValueToNumber(valueLiteral), root.span);
+        }
+        return createFormulaLiteralNode(coerceFormulaValueToBoolean(valueLiteral) ? 0 : 1, root.span);
+    }
+    if (root.kind === "call") {
+        const args = root.args.map(arg => foldFormulaConstants(arg));
+        const normalizedFunctionName = normalizeFormulaFunctionName(root.name);
+        if (normalizedFunctionName === "IF") {
+            const condition = (_a = args[0]) !== null && _a !== void 0 ? _a : createFormulaNumberNode(0);
+            const whenTrue = (_b = args[1]) !== null && _b !== void 0 ? _b : createFormulaNumberNode(0);
+            const whenFalse = (_c = args[2]) !== null && _c !== void 0 ? _c : createFormulaNumberNode(0);
+            if (isFormulaLiteralNode(condition)) {
+                return coerceFormulaValueToBoolean(getFormulaLiteralNodeValue(condition))
+                    ? whenTrue
+                    : whenFalse;
+            }
+            return { kind: "call", name: root.name, args, span: root.span };
+        }
+        if (normalizedFunctionName === "IFS") {
+            for (let index = 0; index < args.length; index += 2) {
+                const condition = args[index];
+                if (!condition || !isFormulaLiteralNode(condition)) {
+                    return { kind: "call", name: root.name, args, span: root.span };
+                }
+                const value = (_d = args[index + 1]) !== null && _d !== void 0 ? _d : createFormulaNumberNode(0);
+                if (coerceFormulaValueToBoolean(getFormulaLiteralNodeValue(condition))) {
+                    return value;
+                }
+            }
+            return createFormulaNumberNode(0);
+        }
+        if (normalizedFunctionName === "COALESCE") {
+            for (const value of args) {
+                if (!isFormulaLiteralNode(value)) {
+                    return { kind: "call", name: root.name, args, span: root.span };
+                }
+                if (isFormulaValuePresent(getFormulaLiteralNodeValue(value))) {
+                    return value;
+                }
+            }
+            return createFormulaNumberNode(0);
+        }
+        if (!args.every(isFormulaLiteralNode)) {
+            return { kind: "call", name: root.name, args, span: root.span };
+        }
+        const literalArgs = args.map(arg => getFormulaLiteralNodeValue(arg));
+        if (normalizedFunctionName === "ABS") {
+            return createFormulaLiteralNode(Math.abs(coerceFormulaValueToNumber((_e = literalArgs[0]) !== null && _e !== void 0 ? _e : null)), root.span);
+        }
+        if (normalizedFunctionName === "AVG") {
+            if (literalArgs.length === 0) {
+                return createFormulaLiteralNode(0, root.span);
+            }
+            return createFormulaLiteralNode(literalArgs.reduce((sum, value) => sum + coerceFormulaValueToNumber(value), 0) / literalArgs.length, root.span);
+        }
+        if (normalizedFunctionName === "CEIL") {
+            return createFormulaLiteralNode(Math.ceil(coerceFormulaValueToNumber((_f = literalArgs[0]) !== null && _f !== void 0 ? _f : null)), root.span);
+        }
+        if (normalizedFunctionName === "CONCAT") {
+            return createFormulaLiteralNode(literalArgs
+                .map((value) => {
+                if (value === null) {
+                    return "";
+                }
+                if (value instanceof Date) {
+                    return Number.isNaN(value.getTime()) ? "" : value.toISOString();
+                }
+                return String(value);
+            })
+                .join(""), root.span);
+        }
+        if (normalizedFunctionName === "COUNT") {
+            return createFormulaLiteralNode(literalArgs.reduce((count, value) => (isFormulaValuePresent(value) ? count + 1 : count), 0), root.span);
+        }
+        if (normalizedFunctionName === "DATE") {
+            const year = Math.trunc(coerceFormulaValueToNumber((_g = literalArgs[0]) !== null && _g !== void 0 ? _g : null));
+            const month = Math.trunc(coerceFormulaValueToNumber((_h = literalArgs[1]) !== null && _h !== void 0 ? _h : null));
+            const day = Math.trunc(coerceFormulaValueToNumber((_j = literalArgs[2]) !== null && _j !== void 0 ? _j : null));
+            return createFormulaLiteralNode(new Date(Date.UTC(year, month - 1, day)), root.span);
+        }
+        if (normalizedFunctionName === "DAY") {
+            const date = coerceFormulaValueToDate((_k = literalArgs[0]) !== null && _k !== void 0 ? _k : null);
+            return createFormulaLiteralNode(date ? date.getUTCDate() : 0, root.span);
+        }
+        if (normalizedFunctionName === "FLOOR") {
+            return createFormulaLiteralNode(Math.floor(coerceFormulaValueToNumber((_l = literalArgs[0]) !== null && _l !== void 0 ? _l : null)), root.span);
+        }
+        if (normalizedFunctionName === "LEN") {
+            const value = (_m = literalArgs[0]) !== null && _m !== void 0 ? _m : null;
+            return createFormulaLiteralNode(value === null ? 0 : value instanceof Date ? (Number.isNaN(value.getTime()) ? 0 : value.toISOString().length) : String(value).length, root.span);
+        }
+        if (normalizedFunctionName === "LEFT") {
+            const value = (_o = literalArgs[0]) !== null && _o !== void 0 ? _o : null;
+            const text = value === null ? "" : String(value);
+            const count = Math.max(0, Math.trunc(coerceFormulaValueToNumber((_p = literalArgs[1]) !== null && _p !== void 0 ? _p : text.length)));
+            return createFormulaLiteralNode(text.slice(0, count), root.span);
+        }
+        if (normalizedFunctionName === "LOWER") {
+            const value = (_q = literalArgs[0]) !== null && _q !== void 0 ? _q : null;
+            return createFormulaLiteralNode(value === null ? "" : String(value).toLowerCase(), root.span);
+        }
+        if (normalizedFunctionName === "MID") {
+            const value = (_r = literalArgs[0]) !== null && _r !== void 0 ? _r : null;
+            const text = value === null ? "" : String(value);
+            const start = Math.max(1, Math.trunc(coerceFormulaValueToNumber((_s = literalArgs[1]) !== null && _s !== void 0 ? _s : 1)));
+            const count = Math.max(0, Math.trunc(coerceFormulaValueToNumber((_t = literalArgs[2]) !== null && _t !== void 0 ? _t : 0)));
+            return createFormulaLiteralNode(text.slice(start - 1, start - 1 + count), root.span);
+        }
+        if (normalizedFunctionName === "MOD") {
+            const left = coerceFormulaValueToNumber((_u = literalArgs[0]) !== null && _u !== void 0 ? _u : null);
+            const right = coerceFormulaValueToNumber((_v = literalArgs[1]) !== null && _v !== void 0 ? _v : null);
+            return createFormulaLiteralNode(right === 0 ? 0 : left % right, root.span);
+        }
+        if (normalizedFunctionName === "MONTH") {
+            const date = coerceFormulaValueToDate((_w = literalArgs[0]) !== null && _w !== void 0 ? _w : null);
+            return createFormulaLiteralNode(date ? date.getUTCMonth() + 1 : 0, root.span);
+        }
+        if (normalizedFunctionName === "POW") {
+            return createFormulaLiteralNode(Math.pow(coerceFormulaValueToNumber((_x = literalArgs[0]) !== null && _x !== void 0 ? _x : null), coerceFormulaValueToNumber((_y = literalArgs[1]) !== null && _y !== void 0 ? _y : null)), root.span);
+        }
+        if (normalizedFunctionName === "ROUND") {
+            const sourceValue = coerceFormulaValueToNumber((_z = literalArgs[0]) !== null && _z !== void 0 ? _z : null);
+            const digits = Math.max(0, Math.trunc(coerceFormulaValueToNumber((_0 = literalArgs[1]) !== null && _0 !== void 0 ? _0 : null)));
+            const factor = 10 ** digits;
+            return createFormulaLiteralNode(Math.round(sourceValue * factor) / factor, root.span);
+        }
+        if (normalizedFunctionName === "MIN") {
+            return createFormulaLiteralNode(literalArgs.length === 0 ? 0 : Math.min(...literalArgs.map(value => coerceFormulaValueToNumber(value))), root.span);
+        }
+        if (normalizedFunctionName === "MAX") {
+            return createFormulaLiteralNode(literalArgs.length === 0 ? 0 : Math.max(...literalArgs.map(value => coerceFormulaValueToNumber(value))), root.span);
+        }
+        if (normalizedFunctionName === "SUM") {
+            return createFormulaLiteralNode(literalArgs.reduce((sum, value) => sum + coerceFormulaValueToNumber(value), 0), root.span);
+        }
+        if (normalizedFunctionName === "RIGHT") {
+            const value = (_1 = literalArgs[0]) !== null && _1 !== void 0 ? _1 : null;
+            const text = value === null ? "" : String(value);
+            const count = Math.max(0, Math.trunc(coerceFormulaValueToNumber((_2 = literalArgs[1]) !== null && _2 !== void 0 ? _2 : text.length)));
+            return createFormulaLiteralNode(count >= text.length ? text : text.slice(text.length - count), root.span);
+        }
+        if (normalizedFunctionName === "TRIM") {
+            const value = (_3 = literalArgs[0]) !== null && _3 !== void 0 ? _3 : null;
+            return createFormulaLiteralNode(value === null ? "" : String(value).trim(), root.span);
+        }
+        if (normalizedFunctionName === "UPPER") {
+            const value = (_4 = literalArgs[0]) !== null && _4 !== void 0 ? _4 : null;
+            return createFormulaLiteralNode(value === null ? "" : String(value).toUpperCase(), root.span);
+        }
+        if (normalizedFunctionName === "YEAR") {
+            const date = coerceFormulaValueToDate((_5 = literalArgs[0]) !== null && _5 !== void 0 ? _5 : null);
+            return createFormulaLiteralNode(date ? date.getUTCFullYear() : 0, root.span);
+        }
+        return { kind: "call", name: root.name, args, span: root.span };
+    }
+    const left = foldFormulaConstants(root.left);
+    const right = foldFormulaConstants(root.right);
+    if (root.operator === "AND" && isFormulaLiteralNode(left)) {
+        if (!coerceFormulaValueToBoolean(getFormulaLiteralNodeValue(left))) {
+            return createFormulaLiteralNode(0, root.span);
+        }
+        if (isFormulaLiteralNode(right)) {
+            return createFormulaLiteralNode(coerceFormulaValueToBoolean(getFormulaLiteralNodeValue(right)) ? 1 : 0, root.span);
+        }
+        return { kind: "binary", operator: "AND", left, right, span: root.span };
+    }
+    if (root.operator === "OR" && isFormulaLiteralNode(left)) {
+        if (coerceFormulaValueToBoolean(getFormulaLiteralNodeValue(left))) {
+            return createFormulaLiteralNode(1, root.span);
+        }
+        if (isFormulaLiteralNode(right)) {
+            return createFormulaLiteralNode(coerceFormulaValueToBoolean(getFormulaLiteralNodeValue(right)) ? 1 : 0, root.span);
+        }
+        return { kind: "binary", operator: "OR", left, right, span: root.span };
+    }
+    if (!isFormulaLiteralNode(left) || !isFormulaLiteralNode(right)) {
+        return { kind: "binary", operator: root.operator, left, right, span: root.span };
+    }
+    const leftValue = getFormulaLiteralNodeValue(left);
+    const rightValue = getFormulaLiteralNodeValue(right);
+    if (root.operator === "+") {
+        return createFormulaLiteralNode(coerceFormulaValueToNumber(leftValue) + coerceFormulaValueToNumber(rightValue), root.span);
+    }
+    if (root.operator === "-") {
+        return createFormulaLiteralNode(coerceFormulaValueToNumber(leftValue) - coerceFormulaValueToNumber(rightValue), root.span);
+    }
+    if (root.operator === "*") {
+        return createFormulaLiteralNode(coerceFormulaValueToNumber(leftValue) * coerceFormulaValueToNumber(rightValue), root.span);
+    }
+    if (root.operator === "/") {
+        if (coerceFormulaValueToNumber(rightValue) === 0) {
+            return { kind: "binary", operator: "/", left, right, span: root.span };
+        }
+        return createFormulaLiteralNode(coerceFormulaValueToNumber(leftValue) / coerceFormulaValueToNumber(rightValue), root.span);
+    }
+    if (root.operator === ">") {
+        return createFormulaLiteralNode(compareFormulaValues(leftValue, rightValue) > 0 ? 1 : 0, root.span);
+    }
+    if (root.operator === "<") {
+        return createFormulaLiteralNode(compareFormulaValues(leftValue, rightValue) < 0 ? 1 : 0, root.span);
+    }
+    if (root.operator === ">=") {
+        return createFormulaLiteralNode(compareFormulaValues(leftValue, rightValue) >= 0 ? 1 : 0, root.span);
+    }
+    if (root.operator === "<=") {
+        return createFormulaLiteralNode(compareFormulaValues(leftValue, rightValue) <= 0 ? 1 : 0, root.span);
+    }
+    if (root.operator === "==") {
+        return createFormulaLiteralNode(areFormulaValuesEqual(leftValue, rightValue) ? 1 : 0, root.span);
+    }
+    if (root.operator === "!=") {
+        return createFormulaLiteralNode(areFormulaValuesEqual(leftValue, rightValue) ? 0 : 1, root.span);
+    }
+    return { kind: "binary", operator: root.operator, left, right, span: root.span };
+}

package/dist/syntax/parser.d.ts

@@ -0,0 +1,7 @@
+import type { DataGridFormulaAstNode } from "./ast.js";
+import type { DataGridFormulaToken } from "./tokenizer.js";
+import type { DataGridFormulaReferenceParserOptions } from "./types.js";
+export type { DataGridFormulaParseResult, DataGridFormulaDiagnosticsResult, DataGridFormulaExplainDependencyDomain, DataGridFormulaExplainDependency, DataGridFormulaExplainResult, DataGridFormulaFieldExplainResult, } from "./analysis.js";
+export { parseDataGridFormulaExpression, diagnoseDataGridFormulaExpression, explainDataGridFormulaExpression, explainDataGridFormulaFieldDefinition, } from "./analysis.js";
+export declare function parseFormula(tokens: readonly DataGridFormulaToken[], referenceParserOptions?: DataGridFormulaReferenceParserOptions): DataGridFormulaAstNode;
+//# sourceMappingURL=parser.d.ts.map

package/dist/syntax/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/syntax/parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AACtD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,YAAY,CAAA;AAOvE,YAAY,EACV,0BAA0B,EAC1B,gCAAgC,EAChC,sCAAsC,EACtC,gCAAgC,EAChC,4BAA4B,EAC5B,iCAAiC,GAClC,MAAM,eAAe,CAAA;AAEtB,OAAO,EACL,8BAA8B,EAC9B,iCAAiC,EACjC,gCAAgC,EAChC,qCAAqC,GACtC,MAAM,eAAe,CAAA;AAEtB,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,oBAAoB,EAAE,EACvC,sBAAsB,GAAE,qCAA0C,GACjE,sBAAsB,CAuQxB"}

package/dist/syntax/parser.js

@@ -0,0 +1,239 @@
+import { createFormulaSourceSpan, throwFormulaError, } from "./ast.js";
+import { parseDataGridFormulaIdentifier } from "./tokenizer.js";
+export { parseDataGridFormulaExpression, diagnoseDataGridFormulaExpression, explainDataGridFormulaExpression, explainDataGridFormulaFieldDefinition, } from "./analysis.js";
+export function parseFormula(tokens, referenceParserOptions = {}) {
+    let cursor = 0;
+    const peek = () => tokens[cursor];
+    const consume = () => {
+        const next = tokens[cursor];
+        if (!next) {
+            return undefined;
+        }
+        cursor += 1;
+        return next;
+    };
+    const parseExpression = () => parseOr();
+    const parsePrimary = () => {
+        const token = consume();
+        if (!token) {
+            throwFormulaError("Unexpected end of formula.", createFormulaSourceSpan(0, 0));
+        }
+        if (token.kind === "number") {
+            return {
+                kind: "number",
+                value: token.value,
+                span: createFormulaSourceSpan(token.position, token.end),
+            };
+        }
+        if (token.kind === "string") {
+            return {
+                kind: "literal",
+                value: token.value,
+                span: createFormulaSourceSpan(token.position, token.end),
+            };
+        }
+        if (token.kind === "identifier") {
+            const next = peek();
+            if (!next || next.kind !== "paren" || next.value !== "(") {
+                const keyword = token.value.toUpperCase();
+                if (keyword === "TRUE") {
+                    return {
+                        kind: "literal",
+                        value: true,
+                        span: createFormulaSourceSpan(token.position, token.end),
+                    };
+                }
+                if (keyword === "FALSE") {
+                    return {
+                        kind: "literal",
+                        value: false,
+                        span: createFormulaSourceSpan(token.position, token.end),
+                    };
+                }
+                if (keyword === "NULL") {
+                    return {
+                        kind: "literal",
+                        value: null,
+                        span: createFormulaSourceSpan(token.position, token.end),
+                    };
+                }
+                const parsedIdentifier = parseDataGridFormulaIdentifier(token.value, referenceParserOptions);
+                return {
+                    kind: "identifier",
+                    name: parsedIdentifier.name,
+                    sheetReference: parsedIdentifier.sheetReference,
+                    referenceName: parsedIdentifier.referenceName,
+                    rangeReferenceName: parsedIdentifier.rangeReferenceName,
+                    rowSelector: parsedIdentifier.rowSelector,
+                    span: createFormulaSourceSpan(token.position, token.end),
+                };
+            }
+            consume();
+            const args = [];
+            const possibleClose = peek();
+            if (possibleClose && possibleClose.kind === "paren" && possibleClose.value === ")") {
+                consume();
+                return {
+                    kind: "call",
+                    name: token.value,
+                    args,
+                    span: createFormulaSourceSpan(token.position, possibleClose.end),
+                };
+            }
+            while (true) {
+                args.push(parseExpression());
+                const delimiter = peek();
+                if (!delimiter || delimiter.kind !== "comma") {
+                    break;
+                }
+                consume();
+            }
+            const close = consume();
+            if (!close || close.kind !== "paren" || close.value !== ")") {
+                throwFormulaError(`Missing ')' for function call '${token.value}' at position ${token.position + 1}.`, createFormulaSourceSpan(token.position, token.end));
+            }
+            return {
+                kind: "call",
+                name: token.value,
+                args,
+                span: createFormulaSourceSpan(token.position, close.end),
+            };
+        }
+        if (token.kind === "paren" && token.value === "(") {
+            const nested = parseExpression();
+            const close = consume();
+            if (!close || close.kind !== "paren" || close.value !== ")") {
+                throwFormulaError(`Missing ')' for group at position ${token.position + 1}.`, createFormulaSourceSpan(token.position, token.end));
+            }
+            return nested;
+        }
+        throwFormulaError(`Unexpected token at position ${token.position + 1}.`, createFormulaSourceSpan(token.position, token.end));
+    };
+    const parseUnary = () => {
+        const token = peek();
+        if (token
+            && token.kind === "operator"
+            && (token.value === "-" || token.value === "+" || token.value === "NOT")) {
+            consume();
+            const value = parseUnary();
+            return {
+                kind: "unary",
+                operator: token.value,
+                value,
+                span: createFormulaSourceSpan(token.position, value.span.end),
+            };
+        }
+        return parsePrimary();
+    };
+    const parseMulDiv = () => {
+        let node = parseUnary();
+        while (true) {
+            const token = peek();
+            if (!token || token.kind !== "operator" || (token.value !== "*" && token.value !== "/")) {
+                break;
+            }
+            consume();
+            const right = parseUnary();
+            node = {
+                kind: "binary",
+                operator: token.value,
+                left: node,
+                right,
+                span: createFormulaSourceSpan(node.span.start, right.span.end),
+            };
+        }
+        return node;
+    };
+    const parseAddSub = () => {
+        let node = parseMulDiv();
+        while (true) {
+            const token = peek();
+            if (!token || token.kind !== "operator" || (token.value !== "+" && token.value !== "-")) {
+                break;
+            }
+            consume();
+            const right = parseMulDiv();
+            node = {
+                kind: "binary",
+                operator: token.value,
+                left: node,
+                right,
+                span: createFormulaSourceSpan(node.span.start, right.span.end),
+            };
+        }
+        return node;
+    };
+    const parseComparison = () => {
+        let node = parseAddSub();
+        while (true) {
+            const token = peek();
+            if (!token
+                || token.kind !== "operator"
+                || (token.value !== ">"
+                    && token.value !== "<"
+                    && token.value !== ">="
+                    && token.value !== "<="
+                    && token.value !== "=="
+                    && token.value !== "!=")) {
+                break;
+            }
+            consume();
+            const right = parseAddSub();
+            node = {
+                kind: "binary",
+                operator: token.value,
+                left: node,
+                right,
+                span: createFormulaSourceSpan(node.span.start, right.span.end),
+            };
+        }
+        return node;
+    };
+    const parseAnd = () => {
+        let node = parseComparison();
+        while (true) {
+            const token = peek();
+            if (!token || token.kind !== "operator" || token.value !== "AND") {
+                break;
+            }
+            consume();
+            const right = parseComparison();
+            node = {
+                kind: "binary",
+                operator: "AND",
+                left: node,
+                right,
+                span: createFormulaSourceSpan(node.span.start, right.span.end),
+            };
+        }
+        return node;
+    };
+    const parseOr = () => {
+        let node = parseAnd();
+        while (true) {
+            const token = peek();
+            if (!token || token.kind !== "operator" || token.value !== "OR") {
+                break;
+            }
+            consume();
+            const right = parseAnd();
+            node = {
+                kind: "binary",
+                operator: "OR",
+                left: node,
+                right,
+                span: createFormulaSourceSpan(node.span.start, right.span.end),
+            };
+        }
+        return node;
+    };
+    const root = parseExpression();
+    if (cursor < tokens.length) {
+        const token = tokens[cursor];
+        if (!token) {
+            throwFormulaError("Unexpected trailing expression.", createFormulaSourceSpan(0, 0));
+        }
+        throwFormulaError(`Unexpected token at position ${token.position + 1}.`, createFormulaSourceSpan(token.position, token.end));
+    }
+    return root;
+}

package/dist/syntax/tokenizer.d.ts

@@ -0,0 +1,14 @@
+import type { DataGridFormulaReferenceParserOptions, DataGridFormulaReferenceSegment, DataGridFormulaRowSelector, DataGridFormulaToken } from "./types.js";
+export type { DataGridFormulaToken, DataGridFormulaOperator, DataGridFormulaReferenceSegment, DataGridFormulaRowSelector, } from "./types.js";
+export interface DataGridParsedFormulaIdentifier {
+    name: string;
+    sheetReference: string | null;
+    referenceName: string;
+    rangeReferenceName: string | null;
+    rowSelector: DataGridFormulaRowSelector;
+}
+export declare function normalizeFormulaReference(reference: string): string;
+export declare function parseDataGridFormulaIdentifier(reference: string, options?: DataGridFormulaReferenceParserOptions): DataGridParsedFormulaIdentifier;
+export declare function parseFormulaReferenceSegments(reference: string): readonly DataGridFormulaReferenceSegment[];
+export declare function tokenizeFormula(formula: string, options?: DataGridFormulaReferenceParserOptions): readonly DataGridFormulaToken[];
+//# sourceMappingURL=tokenizer.d.ts.map

package/dist/syntax/tokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer.d.ts","sourceRoot":"","sources":["../../src/syntax/tokenizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,qCAAqC,EACrC,+BAA+B,EAE/B,0BAA0B,EAC1B,oBAAoB,EACrB,MAAM,YAAY,CAAA;AAGnB,YAAY,EACV,oBAAoB,EACpB,uBAAuB,EACvB,+BAA+B,EAC/B,0BAA0B,GAC3B,MAAM,YAAY,CAAA;AAEnB,MAAM,WAAW,+BAA+B;IAC9C,IAAI,EAAE,MAAM,CAAA;IACZ,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,aAAa,EAAE,MAAM,CAAA;IACrB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,WAAW,EAAE,0BAA0B,CAAA;CACxC;AA+ID,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAUnE;AAqsBD,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,qCAA0C,GAClD,+BAA+B,CA6BjC;AAED,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,MAAM,GAChB,SAAS,+BAA+B,EAAE,CAwB5C;AAED,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,qCAA0C,GAClD,SAAS,oBAAoB,EAAE,CAqIjC"}