@higher.archi/boe 1.0.0

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

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNumber = readNumber;
+const scanner_1 = require("../scanner");
+/**
+ * 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.
+ */
+function readNumber(state, lastToken) {
+    const char = (0, scanner_1.peek)(state);
+    const startPosition = state.position;
+    // Check if this is a potential number
+    let sign = '';
+    if (char === '-' || char === '+') {
+        // Sign character - could be sign or arithmetic operator
+        // It's a sign if:
+        //   - At start of input (no previous token)
+        //   - After ( or ,
+        //   - After an operator
+        const isSignContext = !lastToken ||
+            lastToken.type === 'LPAREN' ||
+            lastToken.type === 'COMMA' ||
+            lastToken.type === 'OPERATOR';
+        if (!isSignContext) {
+            // This should be treated as arithmetic operator
+            return null;
+        }
+        // Check if followed by a digit
+        const nextChar = (0, scanner_1.peekAhead)(state, 1);
+        if (!(0, scanner_1.isDigit)(nextChar)) {
+            // Not a number (might be unary operator)
+            return null;
+        }
+        sign = char;
+        state = (0, scanner_1.advance)(state); // consume the sign
+    }
+    else if (!(0, scanner_1.isDigit)(char)) {
+        // Doesn't start with digit or sign
+        return null;
+    }
+    // Read the integer part
+    let value = sign;
+    value += readDigits(state).value;
+    state = readDigits(state).newState;
+    // Check for decimal point
+    if ((0, scanner_1.peek)(state) === '.' && (0, scanner_1.isDigit)((0, scanner_1.peekAhead)(state, 1))) {
+        value += '.';
+        state = (0, scanner_1.advance)(state); // consume the dot
+        // Read fractional part
+        const fractional = readDigits(state);
+        value += fractional.value;
+        state = fractional.newState;
+    }
+    // Check for percentage suffix (greedy: 50% is percentage, not modulo)
+    if ((0, scanner_1.peek)(state) === '%') {
+        value += '%';
+        state = (0, scanner_1.advance)(state); // consume the percent sign
+    }
+    return {
+        token: {
+            type: 'NUMBER',
+            value,
+            position: startPosition
+        },
+        newState: state
+    };
+}
+/**
+ * Reads a sequence of digit characters.
+ * Returns the digits as a string and the updated state.
+ */
+function readDigits(state) {
+    let value = '';
+    while (!(0, scanner_1.isAtEnd)(state) && (0, scanner_1.isDigit)((0, scanner_1.peek)(state))) {
+        value += (0, scanner_1.peek)(state);
+        state = (0, scanner_1.advance)(state);
+    }
+    return { value, newState: state };
+}
+//# sourceMappingURL=number.reader.js.map

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

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

package/dist/core/parser/tokenizer/readers/property-ref.reader.d.ts

@@ -0,0 +1,20 @@
+import type { ReaderResult, ScannerState } from '../types';
+/**
+ * Reads property references that start with $.
+ *
+ * Grammar: '$' identifier ('.' identifier)*
+ *
+ * Property references are used to access values from the fact context.
+ * They support dot notation for nested property access.
+ *
+ * Examples:
+ *   $age            → PROPERTY_REF('$age')
+ *   $user.name      → PROPERTY_REF('$user.name')
+ *   $user.address.city → PROPERTY_REF('$user.address.city')
+ *   $item.0         → PROPERTY_REF('$item.0')  // array index
+ *
+ * Note: The $ prefix distinguishes property refs from other identifiers.
+ * Without it, "age" would be ambiguous (operator? function? value?).
+ */
+export declare function readPropertyRef(state: ScannerState): ReaderResult | null;
+//# sourceMappingURL=property-ref.reader.d.ts.map

package/dist/core/parser/tokenizer/readers/property-ref.reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"property-ref.reader.d.ts","sourceRoot":"","sources":["../../../../../src/core/parser/tokenizer/readers/property-ref.reader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG3D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,GAAG,IAAI,CAoDxE"}

package/dist/core/parser/tokenizer/readers/property-ref.reader.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPropertyRef = readPropertyRef;
+const scanner_1 = require("../scanner");
+/**
+ * Reads property references that start with $.
+ *
+ * Grammar: '$' identifier ('.' identifier)*
+ *
+ * Property references are used to access values from the fact context.
+ * They support dot notation for nested property access.
+ *
+ * Examples:
+ *   $age            → PROPERTY_REF('$age')
+ *   $user.name      → PROPERTY_REF('$user.name')
+ *   $user.address.city → PROPERTY_REF('$user.address.city')
+ *   $item.0         → PROPERTY_REF('$item.0')  // array index
+ *
+ * Note: The $ prefix distinguishes property refs from other identifiers.
+ * Without it, "age" would be ambiguous (operator? function? value?).
+ */
+function readPropertyRef(state) {
+    // Must start with $
+    if ((0, scanner_1.peek)(state) !== '$') {
+        return null;
+    }
+    const startPosition = state.position;
+    let value = '$';
+    state = (0, scanner_1.advance)(state); // consume the $
+    // Read the first identifier segment
+    // Note: After $, we need at least one valid identifier character
+    if ((0, scanner_1.isAtEnd)(state) || !isValidPropertyStart((0, scanner_1.peek)(state))) {
+        // Just a lone $ - this will be caught as an error by the tokenizer
+        return null;
+    }
+    // Read first segment (the main property name)
+    const firstSegment = readIdentifierSegment(state);
+    value += firstSegment.value;
+    state = firstSegment.newState;
+    // Read any additional dot-separated segments
+    // These can be property names OR numeric indices (for arrays)
+    while (!(0, scanner_1.isAtEnd)(state) && (0, scanner_1.peek)(state) === '.') {
+        value += '.';
+        state = (0, scanner_1.advance)(state); // consume the dot
+        // After a dot, we need another segment
+        if ((0, scanner_1.isAtEnd)(state)) {
+            // Trailing dot - include it and let parser handle the error
+            break;
+        }
+        const segment = readPropertySegment(state);
+        if (segment.value.length === 0) {
+            // Empty segment after dot - let parser handle
+            break;
+        }
+        value += segment.value;
+        state = segment.newState;
+    }
+    return {
+        token: {
+            type: 'PROPERTY_REF',
+            value,
+            position: startPosition
+        },
+        newState: state
+    };
+}
+/**
+ * Checks if a character can start a property name after $.
+ * Property names start with letter or underscore (not digit).
+ */
+function isValidPropertyStart(char) {
+    return (0, scanner_1.isIdentifierStart)(char);
+}
+/**
+ * Reads a single identifier segment (letters, digits, underscores).
+ */
+function readIdentifierSegment(state) {
+    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);
+    }
+    return { value, newState: state };
+}
+/**
+ * Reads a property segment after a dot.
+ * Can be an identifier OR a numeric index.
+ *
+ * Examples:
+ *   .name  → 'name' (property)
+ *   .0     → '0' (array index)
+ *   .items → 'items' (property)
+ */
+function readPropertySegment(state) {
+    let value = '';
+    const char = (0, scanner_1.peek)(state);
+    // Check if it's a digit (array index) or identifier start
+    if (char >= '0' && char <= '9') {
+        // Read numeric index
+        while (!(0, scanner_1.isAtEnd)(state) && (0, scanner_1.peek)(state) >= '0' && (0, scanner_1.peek)(state) <= '9') {
+            value += (0, scanner_1.peek)(state);
+            state = (0, scanner_1.advance)(state);
+        }
+    }
+    else if ((0, scanner_1.isIdentifierStart)(char)) {
+        // Read identifier
+        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);
+        }
+    }
+    return { value, newState: state };
+}
+//# sourceMappingURL=property-ref.reader.js.map

package/dist/core/parser/tokenizer/readers/property-ref.reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"property-ref.reader.js","sourceRoot":"","sources":["../../../../../src/core/parser/tokenizer/readers/property-ref.reader.ts"],"names":[],"mappings":";;AAoBA,0CAoDC;AAvED,wCAAyF;AAEzF;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,eAAe,CAAC,KAAmB;IACjD,oBAAoB;IACpB,IAAI,IAAA,cAAI,EAAC,KAAK,CAAC,KAAK,GAAG,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,aAAa,GAAG,KAAK,CAAC,QAAQ,CAAC;IACrC,IAAI,KAAK,GAAG,GAAG,CAAC;IAChB,KAAK,GAAG,IAAA,iBAAO,EAAC,KAAK,CAAC,CAAC,CAAC,gBAAgB;IAExC,oCAAoC;IACpC,iEAAiE;IACjE,IAAI,IAAA,iBAAO,EAAC,KAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAA,cAAI,EAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QACzD,mEAAmE;QACnE,OAAO,IAAI,CAAC;IACd,CAAC;IAED,8CAA8C;IAC9C,MAAM,YAAY,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAClD,KAAK,IAAI,YAAY,CAAC,KAAK,CAAC;IAC5B,KAAK,GAAG,YAAY,CAAC,QAAQ,CAAC;IAE9B,6CAA6C;IAC7C,8DAA8D;IAC9D,OAAO,CAAC,IAAA,iBAAO,EAAC,KAAK,CAAC,IAAI,IAAA,cAAI,EAAC,KAAK,CAAC,KAAK,GAAG,EAAE,CAAC;QAC9C,KAAK,IAAI,GAAG,CAAC;QACb,KAAK,GAAG,IAAA,iBAAO,EAAC,KAAK,CAAC,CAAC,CAAC,kBAAkB;QAE1C,uCAAuC;QACvC,IAAI,IAAA,iBAAO,EAAC,KAAK,CAAC,EAAE,CAAC;YACnB,4DAA4D;YAC5D,MAAM;QACR,CAAC;QAED,MAAM,OAAO,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAC3C,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/B,8CAA8C;YAC9C,MAAM;QACR,CAAC;QAED,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC;QACvB,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC;IAC3B,CAAC;IAED,OAAO;QACL,KAAK,EAAE;YACL,IAAI,EAAE,cAAc;YACpB,KAAK;YACL,QAAQ,EAAE,aAAa;SACxB;QACD,QAAQ,EAAE,KAAK;KAChB,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,oBAAoB,CAAC,IAAY;IACxC,OAAO,IAAA,2BAAiB,EAAC,IAAI,CAAC,CAAC;AACjC,CAAC;AAED;;GAEG;AACH,SAAS,qBAAqB,CAC5B,KAAmB;IAEnB,IAAI,KAAK,GAAG,EAAE,CAAC;IAEf,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,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;AACpC,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,mBAAmB,CAC1B,KAAmB;IAEnB,IAAI,KAAK,GAAG,EAAE,CAAC;IACf,MAAM,IAAI,GAAG,IAAA,cAAI,EAAC,KAAK,CAAC,CAAC;IAEzB,0DAA0D;IAC1D,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,EAAE,CAAC;QAC/B,qBAAqB;QACrB,OAAO,CAAC,IAAA,iBAAO,EAAC,KAAK,CAAC,IAAI,IAAA,cAAI,EAAC,KAAK,CAAC,IAAI,GAAG,IAAI,IAAA,cAAI,EAAC,KAAK,CAAC,IAAI,GAAG,EAAE,CAAC;YACnE,KAAK,IAAI,IAAA,cAAI,EAAC,KAAK,CAAC,CAAC;YACrB,KAAK,GAAG,IAAA,iBAAO,EAAC,KAAK,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;SAAM,IAAI,IAAA,2BAAiB,EAAC,IAAI,CAAC,EAAE,CAAC;QACnC,kBAAkB;QAClB,OAAO,CAAC,IAAA,iBAAO,EAAC,KAAK,CAAC,IAAI,IAAA,0BAAgB,EAAC,IAAA,cAAI,EAAC,KAAK,CAAC,CAAC,EAAE,CAAC;YACxD,KAAK,IAAI,IAAA,cAAI,EAAC,KAAK,CAAC,CAAC;YACrB,KAAK,GAAG,IAAA,iBAAO,EAAC,KAAK,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;AACpC,CAAC"}

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

@@ -0,0 +1,22 @@
+import type { ReaderResult, ScannerState } from '../types';
+/**
+ * Reads string literals with single or double quotes.
+ *
+ * Supports common escape sequences:
+ *   \'  - single quote
+ *   \"  - double quote
+ *   \\  - backslash
+ *   \n  - newline
+ *   \t  - tab
+ *   \r  - carriage return
+ *
+ * Examples:
+ *   'hello'     → STRING('hello')
+ *   "world"     → STRING('world')
+ *   'it\'s'     → STRING("it's")
+ *   "say \"hi\"" → STRING('say "hi"')
+ *
+ * The returned value is the unescaped string content (without quotes).
+ */
+export declare function readString(state: ScannerState): ReaderResult | null;
+//# sourceMappingURL=string.reader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string.reader.d.ts","sourceRoot":"","sources":["../../../../../src/core/parser/tokenizer/readers/string.reader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAI3D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,GAAG,IAAI,CA0DnE"}

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readString = readString;
+const scanner_1 = require("../scanner");
+const errors_1 = require("../../errors");
+/**
+ * Reads string literals with single or double quotes.
+ *
+ * Supports common escape sequences:
+ *   \'  - single quote
+ *   \"  - double quote
+ *   \\  - backslash
+ *   \n  - newline
+ *   \t  - tab
+ *   \r  - carriage return
+ *
+ * Examples:
+ *   'hello'     → STRING('hello')
+ *   "world"     → STRING('world')
+ *   'it\'s'     → STRING("it's")
+ *   "say \"hi\"" → STRING('say "hi"')
+ *
+ * The returned value is the unescaped string content (without quotes).
+ */
+function readString(state) {
+    const quote = (0, scanner_1.peek)(state);
+    // Must start with a quote character
+    if (quote !== '"' && quote !== "'") {
+        return null;
+    }
+    const startPosition = state.position;
+    state = (0, scanner_1.advance)(state); // consume opening quote
+    let value = '';
+    while (!(0, scanner_1.isAtEnd)(state)) {
+        const char = (0, scanner_1.peek)(state);
+        // Found the closing quote - we're done
+        if (char === quote) {
+            state = (0, scanner_1.advance)(state); // consume closing quote
+            return {
+                token: {
+                    type: 'STRING',
+                    value,
+                    position: startPosition
+                },
+                newState: state
+            };
+        }
+        // Handle escape sequences
+        if (char === '\\') {
+            state = (0, scanner_1.advance)(state); // consume backslash
+            if ((0, scanner_1.isAtEnd)(state)) {
+                throw new errors_1.TokenizeError('Unterminated string: unexpected end after escape character', state.position, state.input);
+            }
+            const escaped = (0, scanner_1.peek)(state);
+            value += resolveEscape(escaped);
+            state = (0, scanner_1.advance)(state);
+            continue;
+        }
+        // Regular character - add to value
+        value += char;
+        state = (0, scanner_1.advance)(state);
+    }
+    // Reached end of input without closing quote
+    throw new errors_1.TokenizeError(`Unterminated string literal starting with ${quote}`, startPosition, state.input);
+}
+/**
+ * Resolves an escape sequence to its actual character.
+ *
+ * For unknown escape sequences, we return the character as-is
+ * (with the backslash consumed). This is lenient behavior that
+ * allows things like \x to just be 'x'.
+ */
+function resolveEscape(char) {
+    switch (char) {
+        case "'":
+            return "'";
+        case '"':
+            return '"';
+        case '\\':
+            return '\\';
+        case 'n':
+            return '\n';
+        case 't':
+            return '\t';
+        case 'r':
+            return '\r';
+        default:
+            // Unknown escape - be lenient and return the character
+            // This allows '\x' to become 'x' rather than throwing an error
+            return char;
+    }
+}
+//# sourceMappingURL=string.reader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string.reader.js","sourceRoot":"","sources":["../../../../../src/core/parser/tokenizer/readers/string.reader.ts"],"names":[],"mappings":";;AAuBA,gCA0DC;AAhFD,wCAAoD;AACpD,yCAA6C;AAE7C;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,UAAU,CAAC,KAAmB;IAC5C,MAAM,KAAK,GAAG,IAAA,cAAI,EAAC,KAAK,CAAC,CAAC;IAE1B,oCAAoC;IACpC,IAAI,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK,GAAG,EAAE,CAAC;QACnC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,aAAa,GAAG,KAAK,CAAC,QAAQ,CAAC;IACrC,KAAK,GAAG,IAAA,iBAAO,EAAC,KAAK,CAAC,CAAC,CAAC,wBAAwB;IAEhD,IAAI,KAAK,GAAG,EAAE,CAAC;IAEf,OAAO,CAAC,IAAA,iBAAO,EAAC,KAAK,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,GAAG,IAAA,cAAI,EAAC,KAAK,CAAC,CAAC;QAEzB,uCAAuC;QACvC,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;YACnB,KAAK,GAAG,IAAA,iBAAO,EAAC,KAAK,CAAC,CAAC,CAAC,wBAAwB;YAChD,OAAO;gBACL,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,KAAK;oBACL,QAAQ,EAAE,aAAa;iBACxB;gBACD,QAAQ,EAAE,KAAK;aAChB,CAAC;QACJ,CAAC;QAED,0BAA0B;QAC1B,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAClB,KAAK,GAAG,IAAA,iBAAO,EAAC,KAAK,CAAC,CAAC,CAAC,oBAAoB;YAE5C,IAAI,IAAA,iBAAO,EAAC,KAAK,CAAC,EAAE,CAAC;gBACnB,MAAM,IAAI,sBAAa,CACrB,4DAA4D,EAC5D,KAAK,CAAC,QAAQ,EACd,KAAK,CAAC,KAAK,CACZ,CAAC;YACJ,CAAC;YAED,MAAM,OAAO,GAAG,IAAA,cAAI,EAAC,KAAK,CAAC,CAAC;YAC5B,KAAK,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;YAChC,KAAK,GAAG,IAAA,iBAAO,EAAC,KAAK,CAAC,CAAC;YACvB,SAAS;QACX,CAAC;QAED,mCAAmC;QACnC,KAAK,IAAI,IAAI,CAAC;QACd,KAAK,GAAG,IAAA,iBAAO,EAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,6CAA6C;IAC7C,MAAM,IAAI,sBAAa,CACrB,6CAA6C,KAAK,EAAE,EACpD,aAAa,EACb,KAAK,CAAC,KAAK,CACZ,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,aAAa,CAAC,IAAY;IACjC,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,GAAG;YACN,OAAO,GAAG,CAAC;QACb,KAAK,GAAG;YACN,OAAO,GAAG,CAAC;QACb,KAAK,IAAI;YACP,OAAO,IAAI,CAAC;QACd,KAAK,GAAG;YACN,OAAO,IAAI,CAAC;QACd,KAAK,GAAG;YACN,OAAO,IAAI,CAAC;QACd,KAAK,GAAG;YACN,OAAO,IAAI,CAAC;QACd;YACE,uDAAuD;YACvD,+DAA+D;YAC/D,OAAO,IAAI,CAAC;IAChB,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,22 @@
+import type { OperatorTable } from '../../types';
+import type { ReaderResult, ScannerState } from '../types';
+/**
+ * Reads symbolic operators and punctuation.
+ *
+ * This reader handles:
+ *   - Comparison symbols: >, >=, <, <=, ==, !=
+ *   - Logical symbols: &&, ||, !
+ *   - Arithmetic symbols: +, -, *, /, %
+ *   - Punctuation: (, ), ,
+ *
+ * Important: Multi-character symbols (>=, <=, ==, !=, &&, ||)
+ * must be checked BEFORE their single-character prefixes.
+ *
+ * Examples:
+ *   >     → OPERATOR('>', canonical: 'greaterThan')
+ *   >=    → OPERATOR('>=', canonical: 'greaterThanOrEquals')
+ *   (     → LPAREN('(')
+ *   ,     → COMMA(',')
+ */
+export declare function readSymbol(state: ScannerState, operatorTable: OperatorTable): ReaderResult | null;
+//# sourceMappingURL=symbol.reader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"symbol.reader.d.ts","sourceRoot":"","sources":["../../../../../src/core/parser/tokenizer/readers/symbol.reader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAqC3D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,YAAY,EACnB,aAAa,EAAE,aAAa,GAC3B,YAAY,GAAG,IAAI,CA0DrB"}

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSymbol = readSymbol;
+const scanner_1 = require("../scanner");
+/**
+ * Symbol operators and punctuation that we recognize.
+ *
+ * Order matters! Longer symbols must come first so ">=" is
+ * matched before ">". We sort by length descending.
+ *
+ * Categories:
+ *   - Comparison: ==, !=, >=, <=, >, <
+ *   - Logical: &&, ||
+ *   - Arithmetic: +, -, *, /, %
+ *   - Punctuation: (, ), ,
+ *   - Negation: !
+ */
+const PUNCTUATION = ['(', ')', ','];
+const SYMBOL_OPERATORS = [
+    // Two-character (must check first)
+    '==',
+    '!=',
+    '>=',
+    '<=',
+    '&&',
+    '||',
+    // Single-character
+    '>',
+    '<',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '!'
+];
+/**
+ * Reads symbolic operators and punctuation.
+ *
+ * This reader handles:
+ *   - Comparison symbols: >, >=, <, <=, ==, !=
+ *   - Logical symbols: &&, ||, !
+ *   - Arithmetic symbols: +, -, *, /, %
+ *   - Punctuation: (, ), ,
+ *
+ * Important: Multi-character symbols (>=, <=, ==, !=, &&, ||)
+ * must be checked BEFORE their single-character prefixes.
+ *
+ * Examples:
+ *   >     → OPERATOR('>', canonical: 'greaterThan')
+ *   >=    → OPERATOR('>=', canonical: 'greaterThanOrEquals')
+ *   (     → LPAREN('(')
+ *   ,     → COMMA(',')
+ */
+function readSymbol(state, operatorTable) {
+    const startPosition = state.position;
+    const remaining = (0, scanner_1.remainingInput)(state);
+    // Check punctuation first (these are not operators)
+    for (const punct of PUNCTUATION) {
+        if (remaining.startsWith(punct)) {
+            const tokenType = punct === '('
+                ? 'LPAREN'
+                : punct === ')'
+                    ? 'RPAREN'
+                    : 'COMMA';
+            return {
+                token: {
+                    type: tokenType,
+                    value: punct,
+                    position: startPosition
+                },
+                newState: (0, scanner_1.advanceBy)(state, punct.length)
+            };
+        }
+    }
+    // Check symbol operators (longer ones first)
+    for (const symbol of SYMBOL_OPERATORS) {
+        if (remaining.startsWith(symbol)) {
+            // Look up in operator table to get canonical name
+            const operatorInfo = operatorTable.get(symbol);
+            if (operatorInfo) {
+                return {
+                    token: {
+                        type: 'OPERATOR',
+                        value: symbol,
+                        canonical: operatorInfo.canonical,
+                        position: startPosition
+                    },
+                    newState: (0, scanner_1.advanceBy)(state, symbol.length)
+                };
+            }
+            // Symbol exists but not in operator table
+            // Still return it as operator, parser will validate
+            return {
+                token: {
+                    type: 'OPERATOR',
+                    value: symbol,
+                    position: startPosition
+                },
+                newState: (0, scanner_1.advanceBy)(state, symbol.length)
+            };
+        }
+    }
+    // Not a recognized symbol
+    return null;
+}
+//# sourceMappingURL=symbol.reader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"symbol.reader.js","sourceRoot":"","sources":["../../../../../src/core/parser/tokenizer/readers/symbol.reader.ts"],"names":[],"mappings":";;AAwDA,gCA6DC;AAnHD,wCAAuD;AAEvD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAU,CAAC;AAE7C,MAAM,gBAAgB,GAAG;IACvB,mCAAmC;IACnC,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,mBAAmB;IACnB,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;CACK,CAAC;AAEX;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,UAAU,CACxB,KAAmB,EACnB,aAA4B;IAE5B,MAAM,aAAa,GAAG,KAAK,CAAC,QAAQ,CAAC;IACrC,MAAM,SAAS,GAAG,IAAA,wBAAc,EAAC,KAAK,CAAC,CAAC;IAExC,oDAAoD;IACpD,KAAK,MAAM,KAAK,IAAI,WAAW,EAAE,CAAC;QAChC,IAAI,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YAChC,MAAM,SAAS,GACb,KAAK,KAAK,GAAG;gBACX,CAAC,CAAC,QAAQ;gBACV,CAAC,CAAC,KAAK,KAAK,GAAG;oBACb,CAAC,CAAC,QAAQ;oBACV,CAAC,CAAC,OAAO,CAAC;YAEhB,OAAO;gBACL,KAAK,EAAE;oBACL,IAAI,EAAE,SAAS;oBACf,KAAK,EAAE,KAAK;oBACZ,QAAQ,EAAE,aAAa;iBACxB;gBACD,QAAQ,EAAE,IAAA,mBAAS,EAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC;aACzC,CAAC;QACJ,CAAC;IACH,CAAC;IAED,6CAA6C;IAC7C,KAAK,MAAM,MAAM,IAAI,gBAAgB,EAAE,CAAC;QACtC,IAAI,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YACjC,kDAAkD;YAClD,MAAM,YAAY,GAAG,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAE/C,IAAI,YAAY,EAAE,CAAC;gBACjB,OAAO;oBACL,KAAK,EAAE;wBACL,IAAI,EAAE,UAAU;wBAChB,KAAK,EAAE,MAAM;wBACb,SAAS,EAAE,YAAY,CAAC,SAAS;wBACjC,QAAQ,EAAE,aAAa;qBACxB;oBACD,QAAQ,EAAE,IAAA,mBAAS,EAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC;iBAC1C,CAAC;YACJ,CAAC;YAED,0CAA0C;YAC1C,oDAAoD;YACpD,OAAO;gBACL,KAAK,EAAE;oBACL,IAAI,EAAE,UAAU;oBAChB,KAAK,EAAE,MAAM;oBACb,QAAQ,EAAE,aAAa;iBACxB;gBACD,QAAQ,EAAE,IAAA,mBAAS,EAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC;aAC1C,CAAC;QACJ,CAAC;IACH,CAAC;IAED,0BAA0B;IAC1B,OAAO,IAAI,CAAC;AACd,CAAC"}

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

@@ -0,0 +1,12 @@
+import type { ScannerState } from '../types';
+/**
+ * Skips whitespace characters (spaces, tabs, newlines).
+ *
+ * Unlike other readers, this doesn't return a token.
+ * It simply advances the scanner past any whitespace.
+ *
+ * Whitespace is semantically insignificant in expressions,
+ * so we just consume it and move on.
+ */
+export declare function skipWhitespace(state: ScannerState): ScannerState;
+//# sourceMappingURL=whitespace.reader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"whitespace.reader.d.ts","sourceRoot":"","sources":["../../../../../src/core/parser/tokenizer/readers/whitespace.reader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAKhE"}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skipWhitespace = skipWhitespace;
+const scanner_1 = require("../scanner");
+/**
+ * Skips whitespace characters (spaces, tabs, newlines).
+ *
+ * Unlike other readers, this doesn't return a token.
+ * It simply advances the scanner past any whitespace.
+ *
+ * Whitespace is semantically insignificant in expressions,
+ * so we just consume it and move on.
+ */
+function skipWhitespace(state) {
+    while (!(0, scanner_1.isAtEnd)(state) && (0, scanner_1.isWhitespace)((0, scanner_1.peek)(state))) {
+        state = (0, scanner_1.advance)(state);
+    }
+    return state;
+}
+//# sourceMappingURL=whitespace.reader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"whitespace.reader.js","sourceRoot":"","sources":["../../../../../src/core/parser/tokenizer/readers/whitespace.reader.ts"],"names":[],"mappings":";;AAYA,wCAKC;AAhBD,wCAAkE;AAElE;;;;;;;;GAQG;AACH,SAAgB,cAAc,CAAC,KAAmB;IAChD,OAAO,CAAC,IAAA,iBAAO,EAAC,KAAK,CAAC,IAAI,IAAA,sBAAY,EAAC,IAAA,cAAI,EAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QACpD,KAAK,GAAG,IAAA,iBAAO,EAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

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

@@ -0,0 +1,74 @@
+import type { ScannerState } from './types';
+/**
+ * Low-level character scanning utilities.
+ *
+ * These functions provide the basic operations for moving through
+ * the input string. All functions are pure - they don't mutate
+ * state but instead return new values.
+ *
+ * Usage pattern:
+ *   let state = createScanner("$age > 18");
+ *   while (!isAtEnd(state)) {
+ *     const char = peek(state);
+ *     // process char...
+ *     state = advance(state);
+ *   }
+ */
+/**
+ * Creates a new scanner state starting at position 0.
+ */
+export declare function createScanner(input: string): ScannerState;
+/**
+ * Returns the character at the current position without advancing.
+ * Returns empty string if at end of input.
+ */
+export declare function peek(state: ScannerState): string;
+/**
+ * Returns the character n positions ahead of current position.
+ * Returns empty string if that position is past end of input.
+ *
+ * Useful for lookahead when deciding between tokens like '>' vs '>='.
+ */
+export declare function peekAhead(state: ScannerState, n: number): string;
+/**
+ * Returns a new state with position advanced by 1.
+ * Does not advance past the end of input.
+ */
+export declare function advance(state: ScannerState): ScannerState;
+/**
+ * Returns a new state with position advanced by n characters.
+ * Will not advance past the end of input.
+ */
+export declare function advanceBy(state: ScannerState, n: number): ScannerState;
+/**
+ * Checks if we've reached the end of the input.
+ */
+export declare function isAtEnd(state: ScannerState): boolean;
+/**
+ * Returns the current character (same as peek, but more descriptive name).
+ */
+export declare function currentChar(state: ScannerState): string;
+/**
+ * Returns the remaining unprocessed input from current position.
+ * Useful for debugging and lookahead matching.
+ */
+export declare function remainingInput(state: ScannerState): string;
+/**
+ * Helper predicates for character classification.
+ * Used by the individual readers to identify token boundaries.
+ */
+export declare function isWhitespace(char: string): boolean;
+export declare function isDigit(char: string): boolean;
+export declare function isAlpha(char: string): boolean;
+export declare function isAlphaNumeric(char: string): boolean;
+/**
+ * Checks if a character can start an identifier.
+ * Identifiers start with a letter or underscore.
+ */
+export declare function isIdentifierStart(char: string): boolean;
+/**
+ * Checks if a character can continue an identifier.
+ * Identifiers can contain letters, digits, and underscores.
+ */
+export declare function isIdentifierPart(char: string): boolean;
+//# sourceMappingURL=scanner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scanner.d.ts","sourceRoot":"","sources":["../../../../src/core/parser/tokenizer/scanner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;;;;;;;;;;;;GAcG;AAEH;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAKzD;AAED;;;GAGG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAKhD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAMhE;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAQzD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,CAMtE;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAEvD;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAE1D;AAED;;;GAGG;AAEH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD"}