@higher.archi/boe 1.0.0

package/dist/core/parser/parser/function.parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.parser.js","sourceRoot":"","sources":["../../../../src/core/parser/parser/function.parser.ts"],"names":[],"mappings":";;AA2BA,8CAiEC;AA1FD,sCAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAgB,iBAAiB,CAC/B,KAAkB,EAClB,eAA6E;IAE7E,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;IAE9B,IAAI,SAAS,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QAClC,MAAM,IAAI,oBAAW,CACnB,oCAAoC,SAAS,CAAC,IAAI,EAAE,EACpD,SAAS,CAAC,QAAQ,EAClB,KAAK,CAAC,KAAK,CACZ,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC;IACjC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,wBAAwB;IAExC,gFAAgF;IAChF,+EAA+E;IAC/E,MAAM,aAAa,GAAG,SAAS,CAAC,SAAS,IAAI,QAAQ,CAAC;IAEtD,6BAA6B;IAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9B,IAAI,SAAS,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAChC,MAAM,IAAI,oBAAW,CACnB,qCAAqC,QAAQ,GAAG,EAChD,SAAS,CAAC,QAAQ,EAClB,KAAK,CAAC,KAAK,CACZ,CAAC;IACJ,CAAC;IACD,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc;IAE9B,kBAAkB;IAClB,MAAM,IAAI,GAAoB,EAAE,CAAC;IAEjC,wCAAwC;IACxC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAClC,uBAAuB;QACvB,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;QAErC,8CAA8C;QAC9C,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YACpC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc;YAC9B,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;QACvC,CAAC;IACH,CAAC;IAED,6BAA6B;IAC7B,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/B,IAAI,UAAU,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QACjC,MAAM,IAAI,oBAAW,CACnB,uCAAuC,EACvC,UAAU,CAAC,QAAQ,EACnB,KAAK,CAAC,KAAK,CACZ,CAAC;IACJ,CAAC;IACD,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc;IAE9B,gDAAgD;IAChD,sEAAsE;IACtE,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;IAC5B,CAAC;IAED,OAAO,CAAC,aAAa,EAAE,GAAG,IAAI,CAAC,CAAC;AAClC,CAAC;AAED,0EAA0E;AAC1E,mBAAmB;AACnB,0EAA0E;AAE1E;;GAEG;AACH,SAAS,IAAI,CAAC,KAAkB;IAC9B,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;AACtC,CAAC;AAED;;GAEG;AACH,SAAS,OAAO,CAAC,KAAkB;IACjC,IAAI,KAAK,CAAC,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC7C,KAAK,CAAC,QAAQ,EAAE,CAAC;IACnB,CAAC;AACH,CAAC"}

package/dist/core/parser/parser/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Parser Module
+ *
+ * Provides the Pratt parser implementation for parsing tokenized
+ * expressions into S-expression condition arrays.
+ *
+ * The parser handles:
+ *   - Operator precedence (*, / before +, -)
+ *   - Operator associativity (left vs right)
+ *   - Parenthesized grouping
+ *   - Function calls
+ *   - Multi-value shorthand ($x == 'a' or 'b' → in)
+ *   - Variadic flattening (a and b and c → ['and', a, b, c])
+ */
+export { parseExpressionFromTokens } from './expression.parser';
+export { parsePrimary } from './primary.parser';
+export { parseFunctionCall } from './function.parser';
+export type { ParserState, ParsedCondition, ParsedOperand } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/parser/parser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/parser/parser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC"}

package/dist/core/parser/parser/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Parser Module
+ *
+ * Provides the Pratt parser implementation for parsing tokenized
+ * expressions into S-expression condition arrays.
+ *
+ * The parser handles:
+ *   - Operator precedence (*, / before +, -)
+ *   - Operator associativity (left vs right)
+ *   - Parenthesized grouping
+ *   - Function calls
+ *   - Multi-value shorthand ($x == 'a' or 'b' → in)
+ *   - Variadic flattening (a and b and c → ['and', a, b, c])
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFunctionCall = exports.parsePrimary = exports.parseExpressionFromTokens = void 0;
+var expression_parser_1 = require("./expression.parser");
+Object.defineProperty(exports, "parseExpressionFromTokens", { enumerable: true, get: function () { return expression_parser_1.parseExpressionFromTokens; } });
+var primary_parser_1 = require("./primary.parser");
+Object.defineProperty(exports, "parsePrimary", { enumerable: true, get: function () { return primary_parser_1.parsePrimary; } });
+var function_parser_1 = require("./function.parser");
+Object.defineProperty(exports, "parseFunctionCall", { enumerable: true, get: function () { return function_parser_1.parseFunctionCall; } });
+//# sourceMappingURL=index.js.map

package/dist/core/parser/parser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/core/parser/parser/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAEH,yDAAgE;AAAvD,8HAAA,yBAAyB,OAAA;AAClC,mDAAgD;AAAvC,8GAAA,YAAY,OAAA;AACrB,qDAAsD;AAA7C,oHAAA,iBAAiB,OAAA"}

package/dist/core/parser/parser/primary.parser.d.ts

@@ -0,0 +1,17 @@
+import type { ParserState, ParsedOperand } from './types';
+/**
+ * Parses primary expressions - the "atoms" of an expression.
+ *
+ * Primary expressions are the highest precedence elements:
+ *   - Literals: numbers (42, 3.14, -5, +5), strings, booleans, null
+ *   - Percentages: 50% → 0.5, +300% → 3.0, -50% → -0.5
+ *   - Property references: $age, $user.name
+ *   - Parenthesized expressions: (...)
+ *   - Function calls: fn(arg1, arg2)
+ *   - Unary prefix operators: not, !
+ *
+ * This function is called by the expression parser when it needs
+ * the left-hand side of an expression or after consuming an operator.
+ */
+export declare function parsePrimary(state: ParserState, parseExpression: (state: ParserState, minPrecedence: number) => ParsedOperand): ParsedOperand;
+//# sourceMappingURL=primary.parser.d.ts.map

package/dist/core/parser/parser/primary.parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primary.parser.d.ts","sourceRoot":"","sources":["../../../../src/core/parser/parser/primary.parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAI1D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,WAAW,EAClB,eAAe,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,KAAK,aAAa,GAC5E,aAAa,CA0Gf"}

package/dist/core/parser/parser/primary.parser.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePrimary = parsePrimary;
+const errors_1 = require("../errors");
+const function_parser_1 = require("./function.parser");
+/**
+ * Parses primary expressions - the "atoms" of an expression.
+ *
+ * Primary expressions are the highest precedence elements:
+ *   - Literals: numbers (42, 3.14, -5, +5), strings, booleans, null
+ *   - Percentages: 50% → 0.5, +300% → 3.0, -50% → -0.5
+ *   - Property references: $age, $user.name
+ *   - Parenthesized expressions: (...)
+ *   - Function calls: fn(arg1, arg2)
+ *   - Unary prefix operators: not, !
+ *
+ * This function is called by the expression parser when it needs
+ * the left-hand side of an expression or after consuming an operator.
+ */
+function parsePrimary(state, parseExpression) {
+    const token = peek(state);
+    switch (token.type) {
+        // ─────────────────────────────────────────────────────────────────
+        // Literals
+        // ─────────────────────────────────────────────────────────────────
+        case 'NUMBER': {
+            advance(state);
+            const numStr = token.value;
+            // Handle percentage literals: 50% → 0.5, +300% → 3.0, -50% → -0.5
+            if (numStr.endsWith('%')) {
+                return parseFloat(numStr) / 100;
+            }
+            return parseFloat(numStr);
+        }
+        case 'STRING':
+            advance(state);
+            return token.value;
+        case 'BOOLEAN':
+            advance(state);
+            return token.value === 'true';
+        case 'NULL':
+            advance(state);
+            return null;
+        // ─────────────────────────────────────────────────────────────────
+        // Property References
+        // ─────────────────────────────────────────────────────────────────
+        case 'PROPERTY_REF':
+            advance(state);
+            return token.value; // Keep as string: '$age', '$user.name'
+        // ─────────────────────────────────────────────────────────────────
+        // Parenthesized Expressions
+        // ─────────────────────────────────────────────────────────────────
+        case 'LPAREN': {
+            advance(state); // consume '('
+            // Parse the inner expression with minimum precedence (0)
+            // so all operators are included
+            const expr = parseExpression(state, 0);
+            // Expect closing parenthesis
+            const closeParen = peek(state);
+            if (closeParen.type !== 'RPAREN') {
+                throw new errors_1.SyntaxError(`Expected ')' but found ${closeParen.type}`, closeParen.position, state.input);
+            }
+            advance(state); // consume ')'
+            return expr;
+        }
+        // ─────────────────────────────────────────────────────────────────
+        // Function Calls
+        // ─────────────────────────────────────────────────────────────────
+        case 'FUNCTION':
+            return (0, function_parser_1.parseFunctionCall)(state, parseExpression);
+        // ─────────────────────────────────────────────────────────────────
+        // Unary Prefix Operators (not, !)
+        // ─────────────────────────────────────────────────────────────────
+        case 'OPERATOR': {
+            const opInfo = state.operatorTable.get(token.value);
+            // Check if this is a unary prefix operator
+            if (opInfo && opInfo.arity === 'unary') {
+                advance(state); // consume operator
+                // Parse the operand (recursively, to handle chained: not not $x)
+                const operand = parsePrimary(state, parseExpression);
+                return [opInfo.canonical, operand];
+            }
+            // Not a unary operator - unexpected in primary position
+            throw new errors_1.SyntaxError(`Unexpected operator '${token.value}' at start of expression`, token.position, state.input);
+        }
+        // ─────────────────────────────────────────────────────────────────
+        // Unexpected Token
+        // ─────────────────────────────────────────────────────────────────
+        default:
+            throw new errors_1.SyntaxError(`Unexpected token ${token.type}: '${token.value}'`, token.position, state.input);
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════
+// Helper Functions
+// ═══════════════════════════════════════════════════════════════════════
+/**
+ * Returns the current token without advancing.
+ */
+function peek(state) {
+    return state.tokens[state.position];
+}
+/**
+ * Advances to the next token.
+ */
+function advance(state) {
+    if (state.position < state.tokens.length - 1) {
+        state.position++;
+    }
+}
+//# sourceMappingURL=primary.parser.js.map

package/dist/core/parser/parser/primary.parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primary.parser.js","sourceRoot":"","sources":["../../../../src/core/parser/parser/primary.parser.ts"],"names":[],"mappings":"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"}

package/dist/core/parser/parser/types.d.ts

@@ -0,0 +1,36 @@
+import type { Token, OperatorTable } from '../types';
+/**
+ * Internal parser state.
+ *
+ * The parser maintains a position in the token stream and advances
+ * as it consumes tokens. Unlike the scanner (which is immutable),
+ * the parser uses mutable state for simplicity since parsing is
+ * more complex and backtracking is rare.
+ */
+export interface ParserState {
+    /** The token stream from the tokenizer */
+    tokens: Token[];
+    /** Current position in the token stream */
+    position: number;
+    /** Operator table for precedence and alias lookup */
+    operatorTable: OperatorTable;
+    /** Original input string (for error messages) */
+    input: string;
+}
+/**
+ * The output from parsing - matches the existing Condition type.
+ *
+ * This is a type alias to make it clear what the parser produces.
+ * The actual type comes from the existing condition types.
+ */
+export type ParsedCondition = [string, ...any[]] | string | number | boolean | null;
+/**
+ * A parsed operand (value in a condition).
+ *
+ * Operands can be:
+ *   - Property refs: '$age', '$user.name'
+ *   - Literals: 42, "hello", true, null
+ *   - Nested conditions: ['add', '$x', 5]
+ */
+export type ParsedOperand = string | number | boolean | null | any[];
+//# sourceMappingURL=types.d.ts.map

package/dist/core/parser/parser/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/core/parser/parser/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAErD;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,0CAA0C;IAC1C,MAAM,EAAE,KAAK,EAAE,CAAC;IAEhB,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAC;IAEjB,qDAAqD;IACrD,aAAa,EAAE,aAAa,CAAC;IAE7B,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GACvB,CAAC,MAAM,EAAE,GAAG,GAAG,EAAE,CAAC,GAClB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,CAAC;AAET;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,GAAG,EAAE,CAAC"}

package/dist/core/parser/parser/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/core/parser/parser/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/core/parser/parser/types.ts"],"names":[],"mappings":""}

package/dist/core/parser/tokenizer/index.d.ts

@@ -0,0 +1,32 @@
+import type { OperatorTable, Token } from '../types';
+/**
+ * Main tokenization function.
+ *
+ * Converts an input string into a stream of tokens that the parser
+ * can process. Uses modular readers that each handle a specific
+ * token type.
+ *
+ * Reader Priority (Order Matters!):
+ * --------------------------------
+ * 1. Whitespace - skip it (doesn't produce tokens)
+ * 2. Property ref - starts with $
+ * 3. String - starts with ' or "
+ * 4. Number - starts with digit, or - followed by digit (in right context)
+ * 5. Symbol - operators like >, >=, (, )
+ * 6. Identifier - words like 'and', 'contains', 'daysAgo'
+ *
+ * Why this order?
+ * - Property refs start with $ which is unique
+ * - Strings start with quotes which is unique
+ * - Numbers are checked before symbols so -5 is a number, not minus then 5
+ * - Symbols before identifiers so >= is one token, not > followed by =
+ * - Identifiers last as the catch-all for words
+ *
+ * @param input - The expression string to tokenize
+ * @param operatorTable - Map of operator aliases to their info
+ * @returns Array of tokens ending with EOF
+ */
+export declare function tokenize(input: string, operatorTable: OperatorTable): Token[];
+export type { ScannerState, ReaderResult } from './types';
+export { createScanner } from './scanner';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/parser/tokenizer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/parser/tokenizer/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAYrD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,GAAG,KAAK,EAAE,CAyC7E;AAGD,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC"}

package/dist/core/parser/tokenizer/index.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScanner = void 0;
+exports.tokenize = tokenize;
+const scanner_1 = require("./scanner");
+const readers_1 = require("./readers");
+const errors_1 = require("../errors");
+/**
+ * Main tokenization function.
+ *
+ * Converts an input string into a stream of tokens that the parser
+ * can process. Uses modular readers that each handle a specific
+ * token type.
+ *
+ * Reader Priority (Order Matters!):
+ * --------------------------------
+ * 1. Whitespace - skip it (doesn't produce tokens)
+ * 2. Property ref - starts with $
+ * 3. String - starts with ' or "
+ * 4. Number - starts with digit, or - followed by digit (in right context)
+ * 5. Symbol - operators like >, >=, (, )
+ * 6. Identifier - words like 'and', 'contains', 'daysAgo'
+ *
+ * Why this order?
+ * - Property refs start with $ which is unique
+ * - Strings start with quotes which is unique
+ * - Numbers are checked before symbols so -5 is a number, not minus then 5
+ * - Symbols before identifiers so >= is one token, not > followed by =
+ * - Identifiers last as the catch-all for words
+ *
+ * @param input - The expression string to tokenize
+ * @param operatorTable - Map of operator aliases to their info
+ * @returns Array of tokens ending with EOF
+ */
+function tokenize(input, operatorTable) {
+    const tokens = [];
+    let state = (0, scanner_1.createScanner)(input);
+    while (!(0, scanner_1.isAtEnd)(state)) {
+        // Skip any whitespace
+        state = (0, readers_1.skipWhitespace)(state);
+        if ((0, scanner_1.isAtEnd)(state))
+            break;
+        // Get the last token (for number reader context)
+        const lastToken = tokens.length > 0 ? tokens[tokens.length - 1] : undefined;
+        // Try each reader in priority order
+        const result = (0, readers_1.readPropertyRef)(state) ||
+            (0, readers_1.readString)(state) ||
+            (0, readers_1.readNumber)(state, lastToken) ||
+            (0, readers_1.readSymbol)(state, operatorTable) ||
+            (0, readers_1.readIdentifier)(state, operatorTable);
+        if (!result) {
+            // No reader matched - unknown character
+            throw new errors_1.TokenizeError(`Unexpected character: '${(0, scanner_1.currentChar)(state)}'`, state.position, input);
+        }
+        tokens.push(result.token);
+        state = result.newState;
+    }
+    // Add EOF marker
+    tokens.push({
+        type: 'EOF',
+        value: '',
+        position: state.position
+    });
+    return tokens;
+}
+var scanner_2 = require("./scanner");
+Object.defineProperty(exports, "createScanner", { enumerable: true, get: function () { return scanner_2.createScanner; } });
+//# sourceMappingURL=index.js.map

package/dist/core/parser/tokenizer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/core/parser/tokenizer/index.ts"],"names":[],"mappings":";;;AAuCA,4BAyCC;AA/ED,uCAAgE;AAChE,uCAOmB;AACnB,sCAA0C;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,SAAgB,QAAQ,CAAC,KAAa,EAAE,aAA4B;IAClE,MAAM,MAAM,GAAY,EAAE,CAAC;IAC3B,IAAI,KAAK,GAAG,IAAA,uBAAa,EAAC,KAAK,CAAC,CAAC;IAEjC,OAAO,CAAC,IAAA,iBAAO,EAAC,KAAK,CAAC,EAAE,CAAC;QACvB,sBAAsB;QACtB,KAAK,GAAG,IAAA,wBAAc,EAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,IAAA,iBAAO,EAAC,KAAK,CAAC;YAAE,MAAM;QAE1B,iDAAiD;QACjD,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAE5E,oCAAoC;QACpC,MAAM,MAAM,GACV,IAAA,yBAAe,EAAC,KAAK,CAAC;YACtB,IAAA,oBAAU,EAAC,KAAK,CAAC;YACjB,IAAA,oBAAU,EAAC,KAAK,EAAE,SAAS,CAAC;YAC5B,IAAA,oBAAU,EAAC,KAAK,EAAE,aAAa,CAAC;YAChC,IAAA,wBAAc,EAAC,KAAK,EAAE,aAAa,CAAC,CAAC;QAEvC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,wCAAwC;YACxC,MAAM,IAAI,sBAAa,CACrB,0BAA0B,IAAA,qBAAW,EAAC,KAAK,CAAC,GAAG,EAC/C,KAAK,CAAC,QAAQ,EACd,KAAK,CACN,CAAC;QACJ,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC1B,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC;IAC1B,CAAC;IAED,iBAAiB;IACjB,MAAM,CAAC,IAAI,CAAC;QACV,IAAI,EAAE,KAAK;QACX,KAAK,EAAE,EAAE;QACT,QAAQ,EAAE,KAAK,CAAC,QAAQ;KACzB,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AAChB,CAAC;AAID,qCAA0C;AAAjC,wGAAA,aAAa,OAAA"}

package/dist/core/parser/tokenizer/readers/identifier.reader.d.ts

@@ -0,0 +1,30 @@
+import type { OperatorTable } from '../../types';
+import type { ReaderResult, ScannerState } from '../types';
+/**
+ * Reads word-based tokens: operators, functions, booleans, null.
+ *
+ * Classification logic determines what kind of token a word is:
+ *   1. 'true'/'false' → BOOLEAN literal
+ *   2. 'null' → NULL literal
+ *   3. Known operator word (and, or, contains, gt, etc.) → OPERATOR
+ *   4. Any other word followed by '(' → FUNCTION
+ *   5. Otherwise → treat as FUNCTION (parser will validate)
+ *
+ * Examples:
+ *   and        → OPERATOR('and', canonical: 'and')
+ *   contains   → OPERATOR('contains', canonical: 'contains')
+ *   gt         → OPERATOR('gt', canonical: 'greaterThan')
+ *   true       → BOOLEAN('true')
+ *   false      → BOOLEAN('false')
+ *   null       → NULL('null')
+ *   daysAgo(   → FUNCTION('daysAgo')
+ *   now(       → FUNCTION('now')
+ *
+ * Note on Unknown Words:
+ * ----------------------
+ * Words that aren't recognized operators might be function names.
+ * We check if the word is followed by '(' to classify it as FUNCTION.
+ * This allows custom functions to be used without modification.
+ */
+export declare function readIdentifier(state: ScannerState, operatorTable: OperatorTable): ReaderResult | null;
+//# sourceMappingURL=identifier.reader.d.ts.map

package/dist/core/parser/tokenizer/readers/identifier.reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifier.reader.d.ts","sourceRoot":"","sources":["../../../../../src/core/parser/tokenizer/readers/identifier.reader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,aAAa,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAe3D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,YAAY,EACnB,aAAa,EAAE,aAAa,GAC3B,YAAY,GAAG,IAAI,CAwErB"}

package/dist/core/parser/tokenizer/readers/identifier.reader.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readIdentifier = readIdentifier;
+const scanner_1 = require("../scanner");
+const whitespace_reader_1 = require("./whitespace.reader");
+/**
+ * Reserved words that map to literal values.
+ * These are always interpreted as their literal meaning,
+ * never as operators or functions.
+ */
+const LITERALS = {
+    true: 'BOOLEAN',
+    false: 'BOOLEAN',
+    null: 'NULL'
+};
+/**
+ * Reads word-based tokens: operators, functions, booleans, null.
+ *
+ * Classification logic determines what kind of token a word is:
+ *   1. 'true'/'false' → BOOLEAN literal
+ *   2. 'null' → NULL literal
+ *   3. Known operator word (and, or, contains, gt, etc.) → OPERATOR
+ *   4. Any other word followed by '(' → FUNCTION
+ *   5. Otherwise → treat as FUNCTION (parser will validate)
+ *
+ * Examples:
+ *   and        → OPERATOR('and', canonical: 'and')
+ *   contains   → OPERATOR('contains', canonical: 'contains')
+ *   gt         → OPERATOR('gt', canonical: 'greaterThan')
+ *   true       → BOOLEAN('true')
+ *   false      → BOOLEAN('false')
+ *   null       → NULL('null')
+ *   daysAgo(   → FUNCTION('daysAgo')
+ *   now(       → FUNCTION('now')
+ *
+ * Note on Unknown Words:
+ * ----------------------
+ * Words that aren't recognized operators might be function names.
+ * We check if the word is followed by '(' to classify it as FUNCTION.
+ * This allows custom functions to be used without modification.
+ */
+function readIdentifier(state, operatorTable) {
+    // Must start with a letter or underscore
+    if (!(0, scanner_1.isIdentifierStart)((0, scanner_1.peek)(state))) {
+        return null;
+    }
+    const startPosition = state.position;
+    // Read the full identifier
+    let value = '';
+    while (!(0, scanner_1.isAtEnd)(state) && (0, scanner_1.isIdentifierPart)((0, scanner_1.peek)(state))) {
+        value += (0, scanner_1.peek)(state);
+        state = (0, scanner_1.advance)(state);
+    }
+    // Check if it's a literal (true, false, null)
+    const literalType = LITERALS[value];
+    if (literalType) {
+        return {
+            token: {
+                type: literalType,
+                value,
+                position: startPosition
+            },
+            newState: state
+        };
+    }
+    // Check if followed by '(' - this makes it a function call
+    // This check must come BEFORE operator check so that gt($a, 5)
+    // treats 'gt' as a function, not an operator
+    const stateAfterWhitespace = (0, whitespace_reader_1.skipWhitespace)(state);
+    if ((0, scanner_1.peek)(stateAfterWhitespace) === '(') {
+        // It's a function call - use canonical name from operator table if available
+        const operatorInfo = operatorTable.get(value);
+        return {
+            token: {
+                type: 'FUNCTION',
+                value,
+                canonical: operatorInfo?.canonical,
+                position: startPosition
+            },
+            newState: state // Don't consume whitespace/paren - let tokenizer handle
+        };
+    }
+    // Check if it's a known operator (in infix position)
+    const operatorInfo = operatorTable.get(value);
+    if (operatorInfo) {
+        return {
+            token: {
+                type: 'OPERATOR',
+                value,
+                canonical: operatorInfo.canonical,
+                position: startPosition
+            },
+            newState: state
+        };
+    }
+    // Unknown identifier that's not followed by ( and not a known operator
+    // Treat it as a function anyway - parser will provide better error
+    // if used incorrectly. This allows forward-compatibility with new
+    // operators/functions without updating the parser.
+    return {
+        token: {
+            type: 'FUNCTION',
+            value,
+            position: startPosition
+        },
+        newState: state
+    };
+}
+//# sourceMappingURL=identifier.reader.js.map

package/dist/core/parser/tokenizer/readers/identifier.reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifier.reader.js","sourceRoot":"","sources":["../../../../../src/core/parser/tokenizer/readers/identifier.reader.ts"],"names":[],"mappings":";;AA0CA,wCA2EC;AAnHD,wCAAyF;AACzF,2DAAqD;AAErD;;;;GAIG;AACH,MAAM,QAAQ,GAA8B;IAC1C,IAAI,EAAE,SAAS;IACf,KAAK,EAAE,SAAS;IAChB,IAAI,EAAE,MAAM;CACb,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAgB,cAAc,CAC5B,KAAmB,EACnB,aAA4B;IAE5B,yCAAyC;IACzC,IAAI,CAAC,IAAA,2BAAiB,EAAC,IAAA,cAAI,EAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QACpC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,aAAa,GAAG,KAAK,CAAC,QAAQ,CAAC;IAErC,2BAA2B;IAC3B,IAAI,KAAK,GAAG,EAAE,CAAC;IACf,OAAO,CAAC,IAAA,iBAAO,EAAC,KAAK,CAAC,IAAI,IAAA,0BAAgB,EAAC,IAAA,cAAI,EAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QACxD,KAAK,IAAI,IAAA,cAAI,EAAC,KAAK,CAAC,CAAC;QACrB,KAAK,GAAG,IAAA,iBAAO,EAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,8CAA8C;IAC9C,MAAM,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IACpC,IAAI,WAAW,EAAE,CAAC;QAChB,OAAO;YACL,KAAK,EAAE;gBACL,IAAI,EAAE,WAAW;gBACjB,KAAK;gBACL,QAAQ,EAAE,aAAa;aACxB;YACD,QAAQ,EAAE,KAAK;SAChB,CAAC;IACJ,CAAC;IAED,2DAA2D;IAC3D,+DAA+D;IAC/D,6CAA6C;IAC7C,MAAM,oBAAoB,GAAG,IAAA,kCAAc,EAAC,KAAK,CAAC,CAAC;IACnD,IAAI,IAAA,cAAI,EAAC,oBAAoB,CAAC,KAAK,GAAG,EAAE,CAAC;QACvC,6EAA6E;QAC7E,MAAM,YAAY,GAAG,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC9C,OAAO;YACL,KAAK,EAAE;gBACL,IAAI,EAAE,UAAU;gBAChB,KAAK;gBACL,SAAS,EAAE,YAAY,EAAE,SAAS;gBAClC,QAAQ,EAAE,aAAa;aACxB;YACD,QAAQ,EAAE,KAAK,CAAC,wDAAwD;SACzE,CAAC;IACJ,CAAC;IAED,qDAAqD;IACrD,MAAM,YAAY,GAAG,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC9C,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO;YACL,KAAK,EAAE;gBACL,IAAI,EAAE,UAAU;gBAChB,KAAK;gBACL,SAAS,EAAE,YAAY,CAAC,SAAS;gBACjC,QAAQ,EAAE,aAAa;aACxB;YACD,QAAQ,EAAE,KAAK;SAChB,CAAC;IACJ,CAAC;IAED,uEAAuE;IACvE,mEAAmE;IACnE,kEAAkE;IAClE,mDAAmD;IACnD,OAAO;QACL,KAAK,EAAE;YACL,IAAI,EAAE,UAAU;YAChB,KAAK;YACL,QAAQ,EAAE,aAAa;SACxB;QACD,QAAQ,EAAE,KAAK;KAChB,CAAC;AACJ,CAAC"}

package/dist/core/parser/tokenizer/readers/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Token Readers
+ *
+ * Each reader is responsible for recognizing and consuming a specific
+ * type of token from the input stream. They are pure functions that:
+ *
+ *   1. Take a scanner state (and optionally context like operator table)
+ *   2. Return null if they don't match at the current position
+ *   3. Return { token, newState } if they do match
+ *
+ * The main tokenizer tries readers in a specific order until one matches.
+ * This module exports all readers for use by the tokenizer.
+ */
+export { skipWhitespace } from './whitespace.reader';
+export { readPropertyRef } from './property-ref.reader';
+export { readString } from './string.reader';
+export { readNumber } from './number.reader';
+export { readSymbol } from './symbol.reader';
+export { readIdentifier } from './identifier.reader';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/parser/tokenizer/readers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/core/parser/tokenizer/readers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/core/parser/tokenizer/readers/index.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Token Readers
+ *
+ * Each reader is responsible for recognizing and consuming a specific
+ * type of token from the input stream. They are pure functions that:
+ *
+ *   1. Take a scanner state (and optionally context like operator table)
+ *   2. Return null if they don't match at the current position
+ *   3. Return { token, newState } if they do match
+ *
+ * The main tokenizer tries readers in a specific order until one matches.
+ * This module exports all readers for use by the tokenizer.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readIdentifier = exports.readSymbol = exports.readNumber = exports.readString = exports.readPropertyRef = exports.skipWhitespace = void 0;
+var whitespace_reader_1 = require("./whitespace.reader");
+Object.defineProperty(exports, "skipWhitespace", { enumerable: true, get: function () { return whitespace_reader_1.skipWhitespace; } });
+var property_ref_reader_1 = require("./property-ref.reader");
+Object.defineProperty(exports, "readPropertyRef", { enumerable: true, get: function () { return property_ref_reader_1.readPropertyRef; } });
+var string_reader_1 = require("./string.reader");
+Object.defineProperty(exports, "readString", { enumerable: true, get: function () { return string_reader_1.readString; } });
+var number_reader_1 = require("./number.reader");
+Object.defineProperty(exports, "readNumber", { enumerable: true, get: function () { return number_reader_1.readNumber; } });
+var symbol_reader_1 = require("./symbol.reader");
+Object.defineProperty(exports, "readSymbol", { enumerable: true, get: function () { return symbol_reader_1.readSymbol; } });
+var identifier_reader_1 = require("./identifier.reader");
+Object.defineProperty(exports, "readIdentifier", { enumerable: true, get: function () { return identifier_reader_1.readIdentifier; } });
+//# sourceMappingURL=index.js.map

package/dist/core/parser/tokenizer/readers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/core/parser/tokenizer/readers/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AAEH,yDAAqD;AAA5C,mHAAA,cAAc,OAAA;AACvB,6DAAwD;AAA/C,sHAAA,eAAe,OAAA;AACxB,iDAA6C;AAApC,2GAAA,UAAU,OAAA;AACnB,iDAA6C;AAApC,2GAAA,UAAU,OAAA;AACnB,iDAA6C;AAApC,2GAAA,UAAU,OAAA;AACnB,yDAAqD;AAA5C,mHAAA,cAAc,OAAA"}

package/dist/core/parser/tokenizer/readers/number.reader.d.ts

@@ -0,0 +1,43 @@
+import type { Token } from '../../types';
+import type { ReaderResult, ScannerState } from '../types';
+/**
+ * Reads numeric literals (integers, decimals, and percentages).
+ *
+ * Supports:
+ *   - Integers: 42, 0, 123
+ *   - Decimals: 3.14, 0.5, 123.456
+ *   - Negative numbers: -5, -3.14 (when context appropriate)
+ *   - Positive numbers: +5, +3.14 (when context appropriate)
+ *   - Percentages: 50%, -50%, +300%, 0.5%
+ *
+ * Examples:
+ *   42      → NUMBER(42)
+ *   3.14    → NUMBER(3.14)
+ *   -5      → NUMBER(-5)  // only when used as value, not subtraction
+ *   +5      → NUMBER(+5)  // only when used as value, not addition
+ *   0.5     → NUMBER(0.5)
+ *   50%     → NUMBER(50%) // percentage literal
+ *   -50%    → NUMBER(-50%)
+ *   +300%   → NUMBER(+300%)
+ *
+ * Note on Sign Handling:
+ * ----------------------
+ * The +/- signs are ambiguous: "$a - 5" is subtraction, but
+ * "gt(-5, $x)" should treat -5 as a negative number literal.
+ *
+ * We handle signs in the number reader when:
+ *   - At the start of input
+ *   - After an opening paren or comma
+ *   - After an operator
+ *
+ * Note on Percentages:
+ * --------------------
+ * When `%` immediately follows digits (no space), it's a percentage literal.
+ * With spaces or operands, `%` is the modulo operator:
+ *   - 50%     → percentage (0.5)
+ *   - 50 % 2  → modulo operation
+ *
+ * The tokenizer provides context about what came before.
+ */
+export declare function readNumber(state: ScannerState, lastToken?: Token): ReaderResult | null;
+//# sourceMappingURL=number.reader.d.ts.map

package/dist/core/parser/tokenizer/readers/number.reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.reader.d.ts","sourceRoot":"","sources":["../../../../../src/core/parser/tokenizer/readers/number.reader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,YAAY,EACnB,SAAS,CAAC,EAAE,KAAK,GAChB,YAAY,GAAG,IAAI,CAoErB"}