@higher.archi/boe 1.0.0

package/dist/core/operators/transform/pad.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Pad Operators
+ *
+ * String padding operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.padEnd = exports.padStart = void 0;
+const operator_1 = require("../operator");
+/**
+ * Pad start - pads the beginning of a string
+ */
+exports.padStart = (0, operator_1.ternaryOp)('padStart', (str, length, padChar) => str.padStart(length, padChar), {
+    params: ['string', 'number', 'string'],
+    returns: 'string',
+    category: 'transform',
+    description: 'Pads the beginning of a string to a specified length',
+    aliases: ['lpad'],
+});
+/**
+ * Pad end - pads the end of a string
+ */
+exports.padEnd = (0, operator_1.ternaryOp)('padEnd', (str, length, padChar) => str.padEnd(length, padChar), {
+    params: ['string', 'number', 'string'],
+    returns: 'string',
+    category: 'transform',
+    description: 'Pads the end of a string to a specified length',
+    aliases: ['rpad'],
+});
+exports.default = [exports.padStart, exports.padEnd];
+//# sourceMappingURL=pad.js.map

package/dist/core/operators/transform/pad.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pad.js","sourceRoot":"","sources":["../../../../src/core/operators/transform/pad.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,0CAAwC;AAGxC;;GAEG;AACU,QAAA,QAAQ,GAAa,IAAA,oBAAS,EACzC,UAAU,EACV,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,EACvD;IACE,MAAM,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC;IACtC,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,sDAAsD;IACnE,OAAO,EAAE,CAAC,MAAM,CAAC;CAClB,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,MAAM,GAAa,IAAA,oBAAS,EACvC,QAAQ,EACR,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrD;IACE,MAAM,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC;IACtC,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,gDAAgD;IAC7D,OAAO,EAAE,CAAC,MAAM,CAAC;CAClB,CACF,CAAC;AAEF,kBAAe,CAAC,gBAAQ,EAAE,cAAM,CAAC,CAAC"}

package/dist/core/operators/transform/replace.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Replace Operators
+ *
+ * String replacement operations.
+ */
+import { Operator } from '../types';
+/**
+ * Replace - replaces first occurrence
+ */
+export declare const replace: Operator;
+/**
+ * Replace all - replaces all occurrences
+ */
+export declare const replaceAll: Operator;
+declare const _default: Operator<import("../types").OperatorParameter[], import("../types").OperatorReturnType>[];
+export default _default;
+//# sourceMappingURL=replace.d.ts.map

package/dist/core/operators/transform/replace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/transform/replace.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,QASrB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,QASxB,CAAC;;AAEF,wBAAqC"}

package/dist/core/operators/transform/replace.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Replace Operators
+ *
+ * String replacement operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceAll = exports.replace = void 0;
+const operator_1 = require("../operator");
+/**
+ * Replace - replaces first occurrence
+ */
+exports.replace = (0, operator_1.ternaryOp)('replace', (str, search, replacement) => str.replace(search, replacement), {
+    params: ['string', 'string', 'string'],
+    returns: 'string',
+    category: 'transform',
+    description: 'Replaces the first occurrence of a substring',
+});
+/**
+ * Replace all - replaces all occurrences
+ */
+exports.replaceAll = (0, operator_1.ternaryOp)('replaceAll', (str, search, replacement) => str.replaceAll(search, replacement), {
+    params: ['string', 'string', 'string'],
+    returns: 'string',
+    category: 'transform',
+    description: 'Replaces all occurrences of a substring',
+});
+exports.default = [exports.replace, exports.replaceAll];
+//# sourceMappingURL=replace.js.map

package/dist/core/operators/transform/replace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace.js","sourceRoot":"","sources":["../../../../src/core/operators/transform/replace.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,0CAAwC;AAGxC;;GAEG;AACU,QAAA,OAAO,GAAa,IAAA,oBAAS,EACxC,SAAS,EACT,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,WAAW,CAAC,EAC9D;IACE,MAAM,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC;IACtC,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,8CAA8C;CAC5D,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,UAAU,GAAa,IAAA,oBAAS,EAC3C,YAAY,EACZ,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC,EACjE;IACE,MAAM,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC;IACtC,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,yCAAyC;CACvD,CACF,CAAC;AAEF,kBAAe,CAAC,eAAO,EAAE,kBAAU,CAAC,CAAC"}

package/dist/core/operators/transform/substring.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Substring Operators
+ *
+ * String extraction operations.
+ */
+import { Operator } from '../types';
+/**
+ * Substring with start and end
+ */
+export declare const substring: Operator;
+/**
+ * Slice - similar to substring but handles negative indices
+ */
+export declare const slice: Operator;
+/**
+ * Left - get first n characters
+ */
+export declare const left: Operator;
+/**
+ * Right - get last n characters
+ */
+export declare const right: Operator;
+declare const _default: Operator<import("../types").OperatorParameter[], import("../types").OperatorReturnType>[];
+export default _default;
+//# sourceMappingURL=substring.d.ts.map

package/dist/core/operators/transform/substring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"substring.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/transform/substring.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,QAUvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,KAAK,EAAE,QASnB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,QAUlB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,KAAK,EAAE,QAUnB,CAAC;;AAEF,wBAA+C"}

package/dist/core/operators/transform/substring.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Substring Operators
+ *
+ * String extraction operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.right = exports.left = exports.slice = exports.substring = void 0;
+const operator_1 = require("../operator");
+/**
+ * Substring with start and end
+ */
+exports.substring = (0, operator_1.ternaryOp)('substring', (str, start, end) => str.substring(start, end), {
+    params: ['string', 'number', 'number'],
+    returns: 'string',
+    category: 'transform',
+    description: 'Extracts a portion of a string between start and end indices',
+    aliases: ['substr'],
+});
+/**
+ * Slice - similar to substring but handles negative indices
+ */
+exports.slice = (0, operator_1.ternaryOp)('slice', (str, start, end) => str.slice(start, end), {
+    params: ['string', 'number', 'number'],
+    returns: 'string',
+    category: 'transform',
+    description: 'Extracts a portion of a string (supports negative indices)',
+});
+/**
+ * Left - get first n characters
+ */
+exports.left = (0, operator_1.binaryOp)('left', (str, n) => str.slice(0, n), {
+    leftType: 'string',
+    rightType: 'number',
+    returns: 'string',
+    category: 'transform',
+    description: 'Returns the first n characters of a string',
+});
+/**
+ * Right - get last n characters
+ */
+exports.right = (0, operator_1.binaryOp)('right', (str, n) => str.slice(-n), {
+    leftType: 'string',
+    rightType: 'number',
+    returns: 'string',
+    category: 'transform',
+    description: 'Returns the last n characters of a string',
+});
+exports.default = [exports.substring, exports.slice, exports.left, exports.right];
+//# sourceMappingURL=substring.js.map

package/dist/core/operators/transform/substring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"substring.js","sourceRoot":"","sources":["../../../../src/core/operators/transform/substring.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,0CAAkD;AAGlD;;GAEG;AACU,QAAA,SAAS,GAAa,IAAA,oBAAS,EAC1C,WAAW,EACX,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,EAC9C;IACE,MAAM,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC;IACtC,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,8DAA8D;IAC3E,OAAO,EAAE,CAAC,QAAQ,CAAC;CACpB,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,KAAK,GAAa,IAAA,oBAAS,EACtC,OAAO,EACP,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,EAC1C;IACE,MAAM,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC;IACtC,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,4DAA4D;CAC1E,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,IAAI,GAAa,IAAA,mBAAQ,EACpC,MAAM,EACN,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAC3B;IACE,QAAQ,EAAE,QAAQ;IAClB,SAAS,EAAE,QAAQ;IACnB,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,4CAA4C;CAC1D,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,KAAK,GAAa,IAAA,mBAAQ,EACrC,OAAO,EACP,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EACzB;IACE,QAAQ,EAAE,QAAQ;IAClB,SAAS,EAAE,QAAQ;IACnB,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,2CAA2C;CACzD,CACF,CAAC;AAEF,kBAAe,CAAC,iBAAS,EAAE,aAAK,EAAE,YAAI,EAAE,aAAK,CAAC,CAAC"}

package/dist/core/operators/transform/trim.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Trim Operators
+ *
+ * String trimming operations.
+ */
+import { Operator } from '../types';
+/**
+ * Trim - removes whitespace from both ends
+ */
+export declare const trim: Operator;
+/**
+ * Trim start - removes whitespace from beginning
+ */
+export declare const trimStart: Operator;
+/**
+ * Trim end - removes whitespace from end
+ */
+export declare const trimEnd: Operator;
+declare const _default: Operator<import("../types").OperatorParameter[], import("../types").OperatorReturnType>[];
+export default _default;
+//# sourceMappingURL=trim.d.ts.map

package/dist/core/operators/transform/trim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trim.d.ts","sourceRoot":"","sources":["../../../../src/core/operators/transform/trim.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,QASlB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,QAUvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,QAUrB,CAAC;;AAEF,wBAA0C"}

package/dist/core/operators/transform/trim.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Trim Operators
+ *
+ * String trimming operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimEnd = exports.trimStart = exports.trim = void 0;
+const operator_1 = require("../operator");
+/**
+ * Trim - removes whitespace from both ends
+ */
+exports.trim = (0, operator_1.unaryOp)('trim', (a) => a.trim(), {
+    paramType: 'string',
+    returns: 'string',
+    category: 'transform',
+    description: 'Removes whitespace from both ends of a string',
+});
+/**
+ * Trim start - removes whitespace from beginning
+ */
+exports.trimStart = (0, operator_1.unaryOp)('trimStart', (a) => a.trimStart(), {
+    paramType: 'string',
+    returns: 'string',
+    category: 'transform',
+    description: 'Removes whitespace from the beginning of a string',
+    aliases: ['ltrim', 'trimLeft'],
+});
+/**
+ * Trim end - removes whitespace from end
+ */
+exports.trimEnd = (0, operator_1.unaryOp)('trimEnd', (a) => a.trimEnd(), {
+    paramType: 'string',
+    returns: 'string',
+    category: 'transform',
+    description: 'Removes whitespace from the end of a string',
+    aliases: ['rtrim', 'trimRight'],
+});
+exports.default = [exports.trim, exports.trimStart, exports.trimEnd];
+//# sourceMappingURL=trim.js.map

package/dist/core/operators/transform/trim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trim.js","sourceRoot":"","sources":["../../../../src/core/operators/transform/trim.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,0CAAsC;AAGtC;;GAEG;AACU,QAAA,IAAI,GAAa,IAAA,kBAAO,EACnC,MAAM,EACN,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,EACf;IACE,SAAS,EAAE,QAAQ;IACnB,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,+CAA+C;CAC7D,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,SAAS,GAAa,IAAA,kBAAO,EACxC,WAAW,EACX,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,EACpB;IACE,SAAS,EAAE,QAAQ;IACnB,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,mDAAmD;IAChE,OAAO,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC;CAC/B,CACF,CAAC;AAEF;;GAEG;AACU,QAAA,OAAO,GAAa,IAAA,kBAAO,EACtC,SAAS,EACT,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,EAClB;IACE,SAAS,EAAE,QAAQ;IACnB,OAAO,EAAE,QAAQ;IACjB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,6CAA6C;IAC1D,OAAO,EAAE,CAAC,OAAO,EAAE,WAAW,CAAC;CAChC,CACF,CAAC;AAEF,kBAAe,CAAC,YAAI,EAAE,iBAAS,EAAE,eAAO,CAAC,CAAC"}

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

@@ -0,0 +1,109 @@
+/**
+ * Core Operator Type System
+ *
+ * Provides a formal type structure for operators that enables
+ * compile-time validation, introspection, and documentation generation.
+ */
+/**
+ * Supported parameter types for operator inputs
+ */
+export type ParameterType = 'string' | 'number' | 'boolean' | 'date' | 'array' | 'any';
+/**
+ * Parameter descriptor for operator inputs
+ */
+export interface OperatorParameter {
+    /** Parameter name for documentation/debugging */
+    name: string;
+    /** Expected type of this parameter */
+    type: ParameterType;
+    /** Human-readable description */
+    description?: string;
+    /** Whether this parameter is optional */
+    optional?: boolean;
+}
+/**
+ * Arity classification for operators
+ */
+export type OperatorArity = 'unary' | 'binary' | 'ternary' | 'variadic';
+/**
+ * Return type classification
+ */
+export type OperatorReturnType = 'boolean' | 'number' | 'string' | 'date' | 'array' | 'any';
+/**
+ * Category for operator grouping
+ */
+export type OperatorCategory = 'comparison' | 'logical' | 'arithmetic' | 'string' | 'date' | 'array' | 'phonetic' | 'similarity' | 'transform';
+/**
+ * Core Operator descriptor type
+ *
+ * Represents a complete operator definition including metadata,
+ * parameter specifications, and implementation.
+ */
+export interface Operator<TParams extends OperatorParameter[] = OperatorParameter[], TReturn extends OperatorReturnType = OperatorReturnType> {
+    /** Unique operator name (e.g., 'equals', 'contains') */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Operator category for grouping */
+    category: OperatorCategory;
+    /** Arity classification */
+    arity: OperatorArity;
+    /** Parameter definitions */
+    parameters: TParams;
+    /** Return type */
+    returns: TReturn;
+    /** The actual implementation function */
+    implementation: (...args: any[]) => any;
+    /** Optional aliases for this operator */
+    aliases?: string[];
+    /** Supported input types (for polymorphic operators like equals) */
+    supportedTypes?: ParameterType[];
+}
+/**
+ * Type-specific operator implementation
+ * Used for polymorphic operators that work across multiple types
+ */
+export interface TypedImplementation<T = any> {
+    type: ParameterType;
+    implementation: (...args: T[]) => any;
+}
+/**
+ * Polymorphic operator with multiple type-specific implementations
+ */
+export interface PolymorphicOperator extends Omit<Operator, 'implementation'> {
+    /** Map of type -> implementation */
+    implementations: Record<ParameterType, (...args: any[]) => any>;
+    /** Default implementation for 'any' type */
+    defaultImplementation?: (...args: any[]) => any;
+}
+/**
+ * Result of operator validation
+ */
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+    warnings?: string[];
+}
+/**
+ * Operator documentation export format
+ */
+export interface OperatorDoc {
+    name: string;
+    description?: string;
+    category: OperatorCategory;
+    arity: OperatorArity;
+    parameters: OperatorParameter[];
+    returns: OperatorReturnType;
+    aliases?: string[];
+    supportedTypes?: ParameterType[];
+    examples?: OperatorExample[];
+}
+/**
+ * Example usage for documentation
+ */
+export interface OperatorExample {
+    input: any[];
+    output: any;
+    description?: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/core/operators/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Core Operator Type System
+ *
+ * Provides a formal type structure for operators that enables
+ * compile-time validation, introspection, and documentation generation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

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

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

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

@@ -0,0 +1,50 @@
+/**
+ * Custom error class for expression parsing errors.
+ *
+ * Provides detailed position information so users can locate
+ * exactly where in their expression the error occurred.
+ *
+ * Example error message:
+ *   ParseError: Unexpected character '@' at position 5
+ *   Input: $age @= 18
+ *              ^
+ */
+export declare class ParseError extends Error {
+    /**
+     * The character position in the input string where the error occurred.
+     * Zero-indexed from the start of the expression.
+     */
+    readonly position: number;
+    /**
+     * The original input string that was being parsed.
+     * Stored so we can generate helpful error messages.
+     */
+    readonly input?: string;
+    constructor(message: string, position: number, input?: string);
+}
+/**
+ * Error thrown during tokenization phase.
+ * Indicates a problem with the lexical structure of the input.
+ *
+ * Common causes:
+ * - Unterminated string literal
+ * - Invalid character
+ * - Malformed number
+ */
+export declare class TokenizeError extends ParseError {
+    constructor(message: string, position: number, input?: string);
+}
+/**
+ * Error thrown during the parsing phase.
+ * Indicates a problem with the syntactic structure.
+ *
+ * Common causes:
+ * - Unexpected token
+ * - Missing operand
+ * - Unbalanced parentheses
+ * - Invalid operator usage
+ */
+export declare class SyntaxError extends ParseError {
+    constructor(message: string, position: number, input?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/core/parser/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC;;;OAGG;IACH,SAAgB,QAAQ,EAAE,MAAM,CAAC;IAEjC;;;OAGG;IACH,SAAgB,KAAK,CAAC,EAAE,MAAM,CAAC;gBAEnB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;CAiB9D;AAED;;;;;;;;GAQG;AACH,qBAAa,aAAc,SAAQ,UAAU;gBAC/B,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;CAK9D;AAED;;;;;;;;;GASG;AACH,qBAAa,WAAY,SAAQ,UAAU;gBAC7B,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;CAK9D"}

package/dist/core/parser/errors.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyntaxError = exports.TokenizeError = exports.ParseError = void 0;
+/**
+ * Custom error class for expression parsing errors.
+ *
+ * Provides detailed position information so users can locate
+ * exactly where in their expression the error occurred.
+ *
+ * Example error message:
+ *   ParseError: Unexpected character '@' at position 5
+ *   Input: $age @= 18
+ *              ^
+ */
+class ParseError extends Error {
+    /**
+     * The character position in the input string where the error occurred.
+     * Zero-indexed from the start of the expression.
+     */
+    position;
+    /**
+     * The original input string that was being parsed.
+     * Stored so we can generate helpful error messages.
+     */
+    input;
+    constructor(message, position, input) {
+        // Build a detailed error message with position indicator
+        let fullMessage = `${message} at position ${position}`;
+        // If we have the input, show the problematic location
+        if (input !== undefined) {
+            fullMessage += `\nInput: ${input}\n       ${' '.repeat(position)}^`;
+        }
+        super(fullMessage);
+        this.name = 'ParseError';
+        this.position = position;
+        this.input = input;
+        // Maintain proper prototype chain for instanceof checks
+        Object.setPrototypeOf(this, ParseError.prototype);
+    }
+}
+exports.ParseError = ParseError;
+/**
+ * Error thrown during tokenization phase.
+ * Indicates a problem with the lexical structure of the input.
+ *
+ * Common causes:
+ * - Unterminated string literal
+ * - Invalid character
+ * - Malformed number
+ */
+class TokenizeError extends ParseError {
+    constructor(message, position, input) {
+        super(message, position, input);
+        this.name = 'TokenizeError';
+        Object.setPrototypeOf(this, TokenizeError.prototype);
+    }
+}
+exports.TokenizeError = TokenizeError;
+/**
+ * Error thrown during the parsing phase.
+ * Indicates a problem with the syntactic structure.
+ *
+ * Common causes:
+ * - Unexpected token
+ * - Missing operand
+ * - Unbalanced parentheses
+ * - Invalid operator usage
+ */
+class SyntaxError extends ParseError {
+    constructor(message, position, input) {
+        super(message, position, input);
+        this.name = 'SyntaxError';
+        Object.setPrototypeOf(this, SyntaxError.prototype);
+    }
+}
+exports.SyntaxError = SyntaxError;
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/core/parser/errors.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;GAUG;AACH,MAAa,UAAW,SAAQ,KAAK;IACnC;;;OAGG;IACa,QAAQ,CAAS;IAEjC;;;OAGG;IACa,KAAK,CAAU;IAE/B,YAAY,OAAe,EAAE,QAAgB,EAAE,KAAc;QAC3D,yDAAyD;QACzD,IAAI,WAAW,GAAG,GAAG,OAAO,gBAAgB,QAAQ,EAAE,CAAC;QAEvD,sDAAsD;QACtD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,WAAW,IAAI,YAAY,KAAK,YAAY,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC;QACtE,CAAC;QAED,KAAK,CAAC,WAAW,CAAC,CAAC;QACnB,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,wDAAwD;QACxD,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;IACpD,CAAC;CACF;AA9BD,gCA8BC;AAED;;;;;;;;GAQG;AACH,MAAa,aAAc,SAAQ,UAAU;IAC3C,YAAY,OAAe,EAAE,QAAgB,EAAE,KAAc;QAC3D,KAAK,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;QAChC,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;QAC5B,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IACvD,CAAC;CACF;AAND,sCAMC;AAED;;;;;;;;;GASG;AACH,MAAa,WAAY,SAAQ,UAAU;IACzC,YAAY,OAAe,EAAE,QAAgB,EAAE,KAAc;QAC3D,KAAK,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;QAChC,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC;QAC1B,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IACrD,CAAC;CACF;AAND,kCAMC"}

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

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ */
+import type { Condition } from '../types/condition';
+/**
+ * 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']]
+ */
+export declare function parseExpression(expression: string): Condition;
+/**
+ * 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
+ */
+export declare function isExpressionTuple(input: unknown): input is ['expr', 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
+ */
+export declare function processConditionInput(input: unknown): Condition;
+export type { Token, TokenType, OperatorInfo, OperatorTable } from './types';
+export { ParseError, TokenizeError, SyntaxError } from './errors';
+export { tokenize } from './tokenizer';
+export { buildOperatorTable, createDefaultOperatorTable, OPERATOR_DEFINITIONS, resolveAlias } from './operators';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/parser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAoBpD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAU7D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAO3E;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAK/D;AAOD,YAAY,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG7E,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGlE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,OAAO,EACL,kBAAkB,EAClB,0BAA0B,EAC1B,oBAAoB,EACpB,YAAY,EACb,MAAM,aAAa,CAAC"}