@higher.archi/boe 1.0.0

package/dist/core/parser/index.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Expression Parser Module
+ *
+ * Parses human-readable expression strings into S-expression condition arrays.
+ *
+ * Usage:
+ * ──────
+ * The parser is invoked via the ['expr', string] format in conditions:
+ *
+ *   const rule = {
+ *     condition: ['expr', '$age >= 18 and $status == "active"']
+ *   };
+ *
+ * This gets parsed to:
+ *
+ *   ['and', ['greaterThanOrEquals', '$age', 18], ['equals', '$status', 'active']]
+ *
+ * Supported Syntax:
+ * ─────────────────
+ * - Infix: $a > 5, $name contains "test"
+ * - Prefix (functional): gt($a, 5), contains($name, "test")
+ * - All aliases: >, gt, greaterThan all work
+ * - Multi-value: $x == 'a' or 'b' or 'c' → in($x, ['a', 'b', 'c'])
+ *
+ * Architecture:
+ * ─────────────
+ * 1. Tokenizer converts string to token stream
+ * 2. Pratt parser converts tokens to S-expression array
+ *
+ * Both phases are modular with small, focused files for maintainability.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAlias = exports.OPERATOR_DEFINITIONS = exports.createDefaultOperatorTable = exports.buildOperatorTable = exports.tokenize = exports.SyntaxError = exports.TokenizeError = exports.ParseError = void 0;
+exports.parseExpression = parseExpression;
+exports.isExpressionTuple = isExpressionTuple;
+exports.processConditionInput = processConditionInput;
+const tokenizer_1 = require("./tokenizer");
+const parser_1 = require("./parser");
+const operators_1 = require("./operators");
+// Module-level cached operator table
+let cachedOperatorTable = null;
+/**
+ * Gets the operator table, creating it if needed.
+ * Cached for performance since it's static.
+ */
+function getOperatorTable() {
+    if (!cachedOperatorTable) {
+        cachedOperatorTable = (0, operators_1.createDefaultOperatorTable)();
+    }
+    return cachedOperatorTable;
+}
+/**
+ * Parses a human-readable expression string into a condition array.
+ *
+ * @param expression - The expression string to parse
+ * @returns The parsed condition in S-expression format
+ *
+ * @example
+ * parseExpression('$age >= 18')
+ * // Returns: ['greaterThanOrEquals', '$age', 18]
+ *
+ * @example
+ * parseExpression('$name contains "test" and $active')
+ * // Returns: ['and', ['contains', '$name', 'test'], '$active']
+ *
+ * @example
+ * parseExpression('$status == "a" or "b" or "c"')
+ * // Returns: ['in', '$status', ['a', 'b', 'c']]
+ */
+function parseExpression(expression) {
+    const operatorTable = getOperatorTable();
+    // Phase 1: Tokenize
+    const tokens = (0, tokenizer_1.tokenize)(expression, operatorTable);
+    // Phase 2: Parse
+    const result = (0, parser_1.parseExpressionFromTokens)(tokens, operatorTable, expression);
+    return result;
+}
+/**
+ * Checks if a condition input is an expression tuple ['expr', string].
+ *
+ * @param input - The condition input to check
+ * @returns True if it's an expression tuple
+ */
+function isExpressionTuple(input) {
+    return (Array.isArray(input) &&
+        input.length === 2 &&
+        input[0] === 'expr' &&
+        typeof input[1] === 'string');
+}
+/**
+ * Processes a condition input, parsing expression tuples if present.
+ *
+ * If the input is ['expr', string], parses the string.
+ * Otherwise returns the input unchanged.
+ *
+ * @param input - The condition input (array or expression tuple)
+ * @returns The processed condition
+ */
+function processConditionInput(input) {
+    if (isExpressionTuple(input)) {
+        return parseExpression(input[1]);
+    }
+    return input;
+}
+// Errors
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "ParseError", { enumerable: true, get: function () { return errors_1.ParseError; } });
+Object.defineProperty(exports, "TokenizeError", { enumerable: true, get: function () { return errors_1.TokenizeError; } });
+Object.defineProperty(exports, "SyntaxError", { enumerable: true, get: function () { return errors_1.SyntaxError; } });
+// Tokenizer (for advanced use cases)
+var tokenizer_2 = require("./tokenizer");
+Object.defineProperty(exports, "tokenize", { enumerable: true, get: function () { return tokenizer_2.tokenize; } });
+// Operators (for extending the parser)
+var operators_2 = require("./operators");
+Object.defineProperty(exports, "buildOperatorTable", { enumerable: true, get: function () { return operators_2.buildOperatorTable; } });
+Object.defineProperty(exports, "createDefaultOperatorTable", { enumerable: true, get: function () { return operators_2.createDefaultOperatorTable; } });
+Object.defineProperty(exports, "OPERATOR_DEFINITIONS", { enumerable: true, get: function () { return operators_2.OPERATOR_DEFINITIONS; } });
+Object.defineProperty(exports, "resolveAlias", { enumerable: true, get: function () { return operators_2.resolveAlias; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/parser/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;;;AAwCH,0CAUC;AAQD,8CAOC;AAWD,sDAKC;AA7ED,2CAAuC;AACvC,qCAAqD;AACrD,2CAAyD;AAEzD,qCAAqC;AACrC,IAAI,mBAAmB,GAAyB,IAAI,CAAC;AAErD;;;GAGG;AACH,SAAS,gBAAgB;IACvB,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACzB,mBAAmB,GAAG,IAAA,sCAA0B,GAAE,CAAC;IACrD,CAAC;IACD,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,eAAe,CAAC,UAAkB;IAChD,MAAM,aAAa,GAAG,gBAAgB,EAAE,CAAC;IAEzC,oBAAoB;IACpB,MAAM,MAAM,GAAG,IAAA,oBAAQ,EAAC,UAAU,EAAE,aAAa,CAAC,CAAC;IAEnD,iBAAiB;IACjB,MAAM,MAAM,GAAG,IAAA,kCAAyB,EAAC,MAAM,EAAE,aAAa,EAAE,UAAU,CAAC,CAAC;IAE5E,OAAO,MAAmB,CAAC;AAC7B,CAAC;AAED;;;;;GAKG;AACH,SAAgB,iBAAiB,CAAC,KAAc;IAC9C,OAAO,CACL,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACpB,KAAK,CAAC,MAAM,KAAK,CAAC;QAClB,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM;QACnB,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,CAC7B,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,qBAAqB,CAAC,KAAc;IAClD,IAAI,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACnC,CAAC;IACD,OAAO,KAAkB,CAAC;AAC5B,CAAC;AASD,SAAS;AACT,mCAAkE;AAAzD,oGAAA,UAAU,OAAA;AAAE,uGAAA,aAAa,OAAA;AAAE,qGAAA,WAAW,OAAA;AAE/C,qCAAqC;AACrC,yCAAuC;AAA9B,qGAAA,QAAQ,OAAA;AAEjB,uCAAuC;AACvC,yCAKqB;AAJnB,+GAAA,kBAAkB,OAAA;AAClB,uHAAA,0BAA0B,OAAA;AAC1B,iHAAA,oBAAoB,OAAA;AACpB,yGAAA,YAAY,OAAA"}

package/dist/core/parser/operators/aliases.d.ts

@@ -0,0 +1,50 @@
+import type { OperatorInfo } from '../types';
+/**
+ * Operator Alias Definitions
+ *
+ * This file defines all the aliases for each operator. An alias is any
+ * way the operator can be written in an expression:
+ *   - Symbol form: >, >=, ==, &&, ||
+ *   - Short form: gt, gte, eq, and, or
+ *   - Full name: greaterThan, greaterThanOrEquals, equals
+ *
+ * Each entry maps to an OperatorInfo with:
+ *   - canonical: The official operator name used in output
+ *   - precedence: Binding power (higher = tighter)
+ *   - associativity: How to group same-precedence operators
+ *   - arity: Number of operands the operator takes
+ *
+ * Note: This is a static definition. For dynamic operators from the
+ * registry, see operator-table.ts which can merge these with registry ops.
+ */
+/**
+ * Type alias for the operator definition entries.
+ * Omits 'canonical' since we derive it from the key.
+ */
+type OperatorDef = Omit<OperatorInfo, 'canonical'>;
+/**
+ * Core operators with all their aliases.
+ *
+ * Structure: { canonicalName: { def, aliases[] } }
+ *
+ * The canonical name is the one that appears in the output S-expression.
+ * All aliases resolve to this canonical name.
+ */
+export declare const OPERATOR_DEFINITIONS: Record<string, {
+    def: OperatorDef;
+    aliases: string[];
+}>;
+/**
+ * Gets the canonical name for any operator alias.
+ *
+ * @param alias - Any form of the operator (symbol, short, or full)
+ * @returns The canonical operator name, or undefined if not found
+ *
+ * Examples:
+ *   resolveAlias('>') → 'greaterThan'
+ *   resolveAlias('gt') → 'greaterThan'
+ *   resolveAlias('greaterThan') → 'greaterThan'
+ */
+export declare function resolveAlias(alias: string): string | undefined;
+export {};
+//# sourceMappingURL=aliases.d.ts.map

package/dist/core/parser/operators/aliases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aliases.d.ts","sourceRoot":"","sources":["../../../../src/core/parser/operators/aliases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAU7C;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;GAGG;AACH,KAAK,WAAW,GAAG,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;AAEnD;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CACvC,MAAM,EACN;IAAE,GAAG,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CA6RxC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAc9D"}

package/dist/core/parser/operators/aliases.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPERATOR_DEFINITIONS = void 0;
+exports.resolveAlias = resolveAlias;
+const precedence_1 = require("./precedence");
+/**
+ * Core operators with all their aliases.
+ *
+ * Structure: { canonicalName: { def, aliases[] } }
+ *
+ * The canonical name is the one that appears in the output S-expression.
+ * All aliases resolve to this canonical name.
+ */
+exports.OPERATOR_DEFINITIONS = {
+    // ═══════════════════════════════════════════════════════════════════
+    // LOGICAL OPERATORS
+    // ═══════════════════════════════════════════════════════════════════
+    and: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_AND,
+            associativity: 'left',
+            arity: 'variadic' // and($a, $b, $c) flattens to ['and', $a, $b, $c]
+        },
+        aliases: ['&&']
+    },
+    or: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_OR,
+            associativity: 'left',
+            arity: 'variadic' // or($a, $b, $c) flattens to ['or', $a, $b, $c]
+        },
+        aliases: ['||']
+    },
+    not: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_NOT,
+            associativity: 'right',
+            arity: 'unary'
+        },
+        aliases: ['!']
+    },
+    // ═══════════════════════════════════════════════════════════════════
+    // COMPARISON OPERATORS - Relational
+    // ═══════════════════════════════════════════════════════════════════
+    greaterThan: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: ['>', 'gt']
+    },
+    greaterThanOrEquals: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: ['>=', 'gte']
+    },
+    lessThan: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: ['<', 'lt']
+    },
+    lessThanOrEquals: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: ['<=', 'lte']
+    },
+    // ═══════════════════════════════════════════════════════════════════
+    // COMPARISON OPERATORS - Equality
+    // ═══════════════════════════════════════════════════════════════════
+    equals: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: ['==', 'eq']
+    },
+    notEquals: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: ['!=', 'neq', 'ne']
+    },
+    // ═══════════════════════════════════════════════════════════════════
+    // COMPARISON OPERATORS - String
+    // ═══════════════════════════════════════════════════════════════════
+    contains: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: []
+    },
+    startsWith: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: []
+    },
+    endsWith: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: []
+    },
+    matches: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: []
+    },
+    // ═══════════════════════════════════════════════════════════════════
+    // COMPARISON OPERATORS - String (Case-Insensitive)
+    // ═══════════════════════════════════════════════════════════════════
+    containsIgnoreCase: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: ['icontains']
+    },
+    startsWithIgnoreCase: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: ['istartsWith', 'istartswith']
+    },
+    endsWithIgnoreCase: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: ['iendsWith', 'iendswith']
+    },
+    equalsIgnoreCase: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: ['iequals', 'ieq']
+    },
+    notEqualsIgnoreCase: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: ['inotEquals', 'ineq']
+    },
+    // ═══════════════════════════════════════════════════════════════════
+    // COMPARISON OPERATORS - Membership
+    // ═══════════════════════════════════════════════════════════════════
+    in: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary' // $x in [1, 2, 3]
+        },
+        aliases: []
+    },
+    notIn: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: []
+    },
+    // ═══════════════════════════════════════════════════════════════════
+    // COMPARISON OPERATORS - Temporal
+    // ═══════════════════════════════════════════════════════════════════
+    isBefore: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: []
+    },
+    isAfter: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'binary'
+        },
+        aliases: []
+    },
+    isBetween: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_COMPARISON,
+            associativity: 'none',
+            arity: 'ternary' // $date isBetween $start and $end
+        },
+        aliases: []
+    },
+    // ═══════════════════════════════════════════════════════════════════
+    // ARITHMETIC OPERATORS
+    // ═══════════════════════════════════════════════════════════════════
+    add: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_ADDITIVE,
+            associativity: 'left',
+            arity: 'binary'
+        },
+        aliases: ['+']
+    },
+    subtract: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_ADDITIVE,
+            associativity: 'left',
+            arity: 'binary'
+        },
+        aliases: ['-']
+    },
+    multiply: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_MULTIPLICATIVE,
+            associativity: 'left',
+            arity: 'binary'
+        },
+        aliases: ['*']
+    },
+    divide: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_MULTIPLICATIVE,
+            associativity: 'left',
+            arity: 'binary'
+        },
+        aliases: ['/']
+    },
+    modulo: {
+        def: {
+            precedence: precedence_1.PRECEDENCE_MULTIPLICATIVE,
+            associativity: 'left',
+            arity: 'binary'
+        },
+        aliases: ['%', 'mod']
+    }
+};
+/**
+ * Gets the canonical name for any operator alias.
+ *
+ * @param alias - Any form of the operator (symbol, short, or full)
+ * @returns The canonical operator name, or undefined if not found
+ *
+ * Examples:
+ *   resolveAlias('>') → 'greaterThan'
+ *   resolveAlias('gt') → 'greaterThan'
+ *   resolveAlias('greaterThan') → 'greaterThan'
+ */
+function resolveAlias(alias) {
+    // Check if it's already a canonical name
+    if (exports.OPERATOR_DEFINITIONS[alias]) {
+        return alias;
+    }
+    // Search through all operators for this alias
+    for (const [canonical, { aliases }] of Object.entries(exports.OPERATOR_DEFINITIONS)) {
+        if (aliases.includes(alias)) {
+            return canonical;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=aliases.js.map

package/dist/core/parser/operators/aliases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aliases.js","sourceRoot":"","sources":["../../../../src/core/parser/operators/aliases.ts"],"names":[],"mappings":";;;AAuVA,oCAcC;AApWD,6CAOsB;AA2BtB;;;;;;;GAOG;AACU,QAAA,oBAAoB,GAG7B;IACF,sEAAsE;IACtE,oBAAoB;IACpB,sEAAsE;IAEtE,GAAG,EAAE;QACH,GAAG,EAAE;YACH,UAAU,EAAE,2BAAc;YAC1B,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,UAAU,CAAC,kDAAkD;SACrE;QACD,OAAO,EAAE,CAAC,IAAI,CAAC;KAChB;IAED,EAAE,EAAE;QACF,GAAG,EAAE;YACH,UAAU,EAAE,0BAAa;YACzB,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,UAAU,CAAC,gDAAgD;SACnE;QACD,OAAO,EAAE,CAAC,IAAI,CAAC;KAChB;IAED,GAAG,EAAE;QACH,GAAG,EAAE;YACH,UAAU,EAAE,2BAAc;YAC1B,aAAa,EAAE,OAAO;YACtB,KAAK,EAAE,OAAO;SACf;QACD,OAAO,EAAE,CAAC,GAAG,CAAC;KACf;IAED,sEAAsE;IACtE,oCAAoC;IACpC,sEAAsE;IAEtE,WAAW,EAAE;QACX,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC;KACrB;IAED,mBAAmB,EAAE;QACnB,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC;KACvB;IAED,QAAQ,EAAE;QACR,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC;KACrB;IAED,gBAAgB,EAAE;QAChB,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC;KACvB;IAED,sEAAsE;IACtE,kCAAkC;IAClC,sEAAsE;IAEtE,MAAM,EAAE;QACN,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;KACtB;IAED,SAAS,EAAE;QACT,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC;KAC7B;IAED,sEAAsE;IACtE,gCAAgC;IAChC,sEAAsE;IAEtE,QAAQ,EAAE;QACR,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,EAAE;KACZ;IAED,UAAU,EAAE;QACV,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,EAAE;KACZ;IAED,QAAQ,EAAE;QACR,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,EAAE;KACZ;IAED,OAAO,EAAE;QACP,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,EAAE;KACZ;IAED,sEAAsE;IACtE,mDAAmD;IACnD,sEAAsE;IAEtE,kBAAkB,EAAE;QAClB,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,WAAW,CAAC;KACvB;IAED,oBAAoB,EAAE;QACpB,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC;KACxC;IAED,kBAAkB,EAAE;QAClB,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC;KACpC;IAED,gBAAgB,EAAE;QAChB,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,SAAS,EAAE,KAAK,CAAC;KAC5B;IAED,mBAAmB,EAAE;QACnB,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,YAAY,EAAE,MAAM,CAAC;KAChC;IAED,sEAAsE;IACtE,oCAAoC;IACpC,sEAAsE;IAEtE,EAAE,EAAE;QACF,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ,CAAC,kBAAkB;SACnC;QACD,OAAO,EAAE,EAAE;KACZ;IAED,KAAK,EAAE;QACL,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,EAAE;KACZ;IAED,sEAAsE;IACtE,kCAAkC;IAClC,sEAAsE;IAEtE,QAAQ,EAAE;QACR,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,EAAE;KACZ;IAED,OAAO,EAAE;QACP,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,EAAE;KACZ;IAED,SAAS,EAAE;QACT,GAAG,EAAE;YACH,UAAU,EAAE,kCAAqB;YACjC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,SAAS,CAAC,kCAAkC;SACpD;QACD,OAAO,EAAE,EAAE;KACZ;IAED,sEAAsE;IACtE,uBAAuB;IACvB,sEAAsE;IAEtE,GAAG,EAAE;QACH,GAAG,EAAE;YACH,UAAU,EAAE,gCAAmB;YAC/B,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,GAAG,CAAC;KACf;IAED,QAAQ,EAAE;QACR,GAAG,EAAE;YACH,UAAU,EAAE,gCAAmB;YAC/B,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,GAAG,CAAC;KACf;IAED,QAAQ,EAAE;QACR,GAAG,EAAE;YACH,UAAU,EAAE,sCAAyB;YACrC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,GAAG,CAAC;KACf;IAED,MAAM,EAAE;QACN,GAAG,EAAE;YACH,UAAU,EAAE,sCAAyB;YACrC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,GAAG,CAAC;KACf;IAED,MAAM,EAAE;QACN,GAAG,EAAE;YACH,UAAU,EAAE,sCAAyB;YACrC,aAAa,EAAE,MAAM;YACrB,KAAK,EAAE,QAAQ;SAChB;QACD,OAAO,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC;KACtB;CACF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,SAAgB,YAAY,CAAC,KAAa;IACxC,yCAAyC;IACzC,IAAI,4BAAoB,CAAC,KAAK,CAAC,EAAE,CAAC;QAChC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,8CAA8C;IAC9C,KAAK,MAAM,CAAC,SAAS,EAAE,EAAE,OAAO,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,4BAAoB,CAAC,EAAE,CAAC;QAC5E,IAAI,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC"}

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

@@ -0,0 +1,17 @@
+/**
+ * Operator Module
+ *
+ * This module handles operator definitions, aliases, and precedence.
+ * It provides the operator table used by both the tokenizer and parser.
+ *
+ * Key concepts:
+ *   - Canonical name: The official operator name (e.g., 'greaterThan')
+ *   - Alias: Any form that resolves to the canonical (e.g., '>', 'gt')
+ *   - Precedence: Binding power (higher = binds tighter)
+ *   - Associativity: How same-precedence ops group (left, right, none)
+ */
+export { buildOperatorTable, createDefaultOperatorTable, isKnownOperator, getCanonicalName } from './operator-table';
+export { OPERATOR_DEFINITIONS, resolveAlias } from './aliases';
+export { PRECEDENCE_OR, PRECEDENCE_AND, PRECEDENCE_NOT, PRECEDENCE_COMPARISON, PRECEDENCE_ADDITIVE, PRECEDENCE_MULTIPLICATIVE, PRECEDENCE_UNARY, PRECEDENCE_PRIMARY, getPrecedenceForCategory } from './precedence';
+export type { OperatorCategory } from './precedence';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/parser/operators/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,kBAAkB,EAClB,0BAA0B,EAC1B,eAAe,EACf,gBAAgB,EACjB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE/D,OAAO,EACL,aAAa,EACb,cAAc,EACd,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,yBAAyB,EACzB,gBAAgB,EAChB,kBAAkB,EAClB,wBAAwB,EACzB,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

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

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Operator Module
+ *
+ * This module handles operator definitions, aliases, and precedence.
+ * It provides the operator table used by both the tokenizer and parser.
+ *
+ * Key concepts:
+ *   - Canonical name: The official operator name (e.g., 'greaterThan')
+ *   - Alias: Any form that resolves to the canonical (e.g., '>', 'gt')
+ *   - Precedence: Binding power (higher = binds tighter)
+ *   - Associativity: How same-precedence ops group (left, right, none)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrecedenceForCategory = exports.PRECEDENCE_PRIMARY = exports.PRECEDENCE_UNARY = exports.PRECEDENCE_MULTIPLICATIVE = exports.PRECEDENCE_ADDITIVE = exports.PRECEDENCE_COMPARISON = exports.PRECEDENCE_NOT = exports.PRECEDENCE_AND = exports.PRECEDENCE_OR = exports.resolveAlias = exports.OPERATOR_DEFINITIONS = exports.getCanonicalName = exports.isKnownOperator = exports.createDefaultOperatorTable = exports.buildOperatorTable = void 0;
+var operator_table_1 = require("./operator-table");
+Object.defineProperty(exports, "buildOperatorTable", { enumerable: true, get: function () { return operator_table_1.buildOperatorTable; } });
+Object.defineProperty(exports, "createDefaultOperatorTable", { enumerable: true, get: function () { return operator_table_1.createDefaultOperatorTable; } });
+Object.defineProperty(exports, "isKnownOperator", { enumerable: true, get: function () { return operator_table_1.isKnownOperator; } });
+Object.defineProperty(exports, "getCanonicalName", { enumerable: true, get: function () { return operator_table_1.getCanonicalName; } });
+var aliases_1 = require("./aliases");
+Object.defineProperty(exports, "OPERATOR_DEFINITIONS", { enumerable: true, get: function () { return aliases_1.OPERATOR_DEFINITIONS; } });
+Object.defineProperty(exports, "resolveAlias", { enumerable: true, get: function () { return aliases_1.resolveAlias; } });
+var precedence_1 = require("./precedence");
+Object.defineProperty(exports, "PRECEDENCE_OR", { enumerable: true, get: function () { return precedence_1.PRECEDENCE_OR; } });
+Object.defineProperty(exports, "PRECEDENCE_AND", { enumerable: true, get: function () { return precedence_1.PRECEDENCE_AND; } });
+Object.defineProperty(exports, "PRECEDENCE_NOT", { enumerable: true, get: function () { return precedence_1.PRECEDENCE_NOT; } });
+Object.defineProperty(exports, "PRECEDENCE_COMPARISON", { enumerable: true, get: function () { return precedence_1.PRECEDENCE_COMPARISON; } });
+Object.defineProperty(exports, "PRECEDENCE_ADDITIVE", { enumerable: true, get: function () { return precedence_1.PRECEDENCE_ADDITIVE; } });
+Object.defineProperty(exports, "PRECEDENCE_MULTIPLICATIVE", { enumerable: true, get: function () { return precedence_1.PRECEDENCE_MULTIPLICATIVE; } });
+Object.defineProperty(exports, "PRECEDENCE_UNARY", { enumerable: true, get: function () { return precedence_1.PRECEDENCE_UNARY; } });
+Object.defineProperty(exports, "PRECEDENCE_PRIMARY", { enumerable: true, get: function () { return precedence_1.PRECEDENCE_PRIMARY; } });
+Object.defineProperty(exports, "getPrecedenceForCategory", { enumerable: true, get: function () { return precedence_1.getPrecedenceForCategory; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/core/parser/operators/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAEH,mDAK0B;AAJxB,oHAAA,kBAAkB,OAAA;AAClB,4HAAA,0BAA0B,OAAA;AAC1B,iHAAA,eAAe,OAAA;AACf,kHAAA,gBAAgB,OAAA;AAGlB,qCAA+D;AAAtD,+GAAA,oBAAoB,OAAA;AAAE,uGAAA,YAAY,OAAA;AAE3C,2CAUsB;AATpB,2GAAA,aAAa,OAAA;AACb,4GAAA,cAAc,OAAA;AACd,4GAAA,cAAc,OAAA;AACd,mHAAA,qBAAqB,OAAA;AACrB,iHAAA,mBAAmB,OAAA;AACnB,uHAAA,yBAAyB,OAAA;AACzB,8GAAA,gBAAgB,OAAA;AAChB,gHAAA,kBAAkB,OAAA;AAClB,sHAAA,wBAAwB,OAAA"}

package/dist/core/parser/operators/operator-table.d.ts

@@ -0,0 +1,33 @@
+import type { OperatorTable } from '../types';
+/**
+ * Builds the operator lookup table.
+ *
+ * The table maps every possible operator form (symbol, short name,
+ * full name) to its OperatorInfo. This allows O(1) lookup when
+ * tokenizing and parsing.
+ *
+ * Sources:
+ *   1. Static definitions in aliases.ts (core operators)
+ *   2. Dynamic operators from the registry (temporal, custom, etc.)
+ *
+ * @param registryOperators - Optional map of additional operators from registry
+ * @returns Complete operator table with all aliases resolved
+ */
+export declare function buildOperatorTable(registryOperators?: Map<string, {
+    aliases?: string[];
+}>): OperatorTable;
+/**
+ * Creates a default operator table with just the static definitions.
+ * Use this when you don't have access to the full operator registry.
+ */
+export declare function createDefaultOperatorTable(): OperatorTable;
+/**
+ * Checks if a string is a known operator (in any form).
+ */
+export declare function isKnownOperator(table: OperatorTable, name: string): boolean;
+/**
+ * Gets the canonical name for an operator, or returns the input
+ * if it's not a known operator (might be a function).
+ */
+export declare function getCanonicalName(table: OperatorTable, name: string): string;
+//# sourceMappingURL=operator-table.d.ts.map

package/dist/core/parser/operators/operator-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator-table.d.ts","sourceRoot":"","sources":["../../../../src/core/parser/operators/operator-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,aAAa,EAAE,MAAM,UAAU,CAAC;AAI5D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,GACtD,aAAa,CAwDf;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,aAAa,CAE1D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,MAAM,GACX,OAAO,CAET;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,MAAM,GACX,MAAM,CAGR"}