@routier/core 0.0.1-alpha.1 → 0.0.1-alpha.3

package/{src/expressions/parser.ts → dist/expressions/index.js}

@@ -1,5 +1,15 @@
-import { CompiledSchema, SchemaTypes } from "../schema";
-import { Expression, OperatorExpression, ComparatorExpression, ValueExpression, PropertyExpression, Filter, ParamsFilter, Operator } from "./types";
+var __webpack_modules__ = ({
+"./src/expressions/parser.ts": 
+/*!***********************************!*\
+  !*** ./src/expressions/parser.ts ***!
+  \***********************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  combineExpressions: () => (combineExpressions),
+  toExpression: () => (toExpression)
+});
+/* ESM import */var _types__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./types */ "./src/expressions/types.ts");
 
 // Pre-compiled regex patterns for better performance
 const METHOD_REGEX = /([a-zA-Z0-9_.]+)\.(startsWith|endsWith|includes)\(([^)]+)\)(\s*(===|==|!==|!=)\s*(true|false))?/;
@@ -7,142 +17,124 @@ const TRANSFORM_METHOD_REGEX = /([a-zA-Z0-9_.]+)\.(toLowerCase|toUpperCase|toLoc
 const EQUALITY_REGEX = /([^=!<>]+?)\s*(===|==|!==|!=)\s*(.+)/;
 const COMPARISON_REGEX = /([^=!<>]+?)\s*(>=|<=|>|<)\s*(.+)/;
 const PARAM_PATH_REGEX = /^([a-zA-Z0-9_.]+)/;
-
 // Pre-compiled regex patterns for comment removal
 const SINGLE_LINE_COMMENT_REGEX = /\/\/.*$/gm;
 const MULTI_LINE_COMMENT_REGEX = /\/\*[\s\S]*?\*\//g;
 const WHITESPACE_REGEX = /\s+/g;
-
 // need to have negated + strict
-const comparators: Record<string, ComparatorExpression> = {
-    startsWith: new ComparatorExpression({
+const comparators = {
+    startsWith: new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: "starts-with",
         negated: false,
         strict: false
     }),
-    endsWith: new ComparatorExpression({
+    endsWith: new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: "ends-with",
         negated: false,
         strict: false
     }),
-    includes: new ComparatorExpression({
+    includes: new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: "includes",
         negated: false,
         strict: false
     }),
-    "==": new ComparatorExpression({
+    "==": new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: "equals",
         negated: false,
         strict: false
     }),
-    "===": new ComparatorExpression({
+    "===": new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: "equals",
         negated: false,
         strict: true
     }),
-    "!=": new ComparatorExpression({
+    "!=": new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: "equals",
         negated: true,
         strict: false
     }),
-    "!==": new ComparatorExpression({
+    "!==": new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: "equals",
         negated: true,
         strict: true
     }),
-    ">=": new ComparatorExpression({
+    ">=": new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: "greater-than-equals",
         negated: false,
         strict: false
     }),
-    ">==": new ComparatorExpression({
+    ">==": new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: "greater-than-equals",
         negated: false,
         strict: true
     }),
-    "<=": new ComparatorExpression({
+    "<=": new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: "less-than-equals",
         negated: false,
         strict: false
     }),
-    "<==": new ComparatorExpression({
+    "<==": new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: "less-than-equals",
         negated: false,
         strict: true
     }),
-    ">": new ComparatorExpression({
+    ">": new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: "greater-than",
         negated: false,
         strict: false
     }),
-    "<": new ComparatorExpression({
+    "<": new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: "less-than",
         negated: false,
         strict: false
     })
-} as const;
-
+};
 // Optimized comparator lookup using Map
 const COMPARATOR_MAP = new Map(Object.entries(comparators));
-
 // Error message constants
 const ERROR_MESSAGES = {
-    COMPARATOR_NOT_FOUND: (value: string) => `Cannot find comparator: ${value}`,
-    PROPERTY_NOT_FOUND: (path: string) => `Error parsing query, could not find PropertyInfo for path: ${path}`,
-    PARAM_PATH_NOT_FOUND: (value: string, params: any) => `Cannot find path in params for .where(). Make sure parameters are not used inline.\r\nPath: ${value}, Params: ${JSON.stringify(params)}`
+    COMPARATOR_NOT_FOUND: (value) => `Cannot find comparator: ${value}`,
+    PROPERTY_NOT_FOUND: (path) => `Error parsing query, could not find PropertyInfo for path: ${path}`,
+    PARAM_PATH_NOT_FOUND: (value, params) => `Cannot find path in params for .where(). Make sure parameters are not used inline.\r\nPath: ${value}, Params: ${JSON.stringify(params)}`
 };
-
-export const combineExpressions = (...expressions: Expression[]): Expression => {
-
+const combineExpressions = (...expressions) => {
     if (expressions.length === 0) {
         throw new Error("combineExpressions requires at least 1 expression");
     }
-
-
     if (expressions.length === 1) {
         return expressions[0];
     }
-
     // Start with the first expression
     let result = expressions[0];
-
     // Loop through remaining expressions and combine them
     for (let i = 1; i < expressions.length; i++) {
-        result = new OperatorExpression({
+        result = new _types__WEBPACK_IMPORTED_MODULE_0__.OperatorExpression({
             operator: "&&",
             left: result,
             right: expressions[i]
         });
     }
-
     return result;
 };
-
-export const toExpression = <T extends any, P extends any>(schema: CompiledSchema<any>, fn: Filter<T> | ParamsFilter<T, P>, params?: P) => {
+const toExpression = (schema, fn, params) => {
     try {
-
         const stringifiedFunction = fn.toString();
-
         // Optimized string parsing
         const arrowIndex = stringifiedFunction.indexOf('=>');
         if (arrowIndex === -1) {
             throw new Error("Invalid Function");
         }
-
         const parameterNames = stringifiedFunction.substring(0, arrowIndex).trim();
         let expression = stringifiedFunction.substring(arrowIndex + 2).trim();
-
         // Remove JavaScript comments from the expression
         expression = expression
             .replace(SINGLE_LINE_COMMENT_REGEX, '') // Remove single-line comments
             .replace(MULTI_LINE_COMMENT_REGEX, '') // Remove multi-line comments
             .replace(WHITESPACE_REGEX, ' ') // Normalize whitespace
             .trim();
-
-        let parameterData: { name: string, data: P } | undefined = undefined;
-
+        let parameterData = undefined;
         if (params != null) {
-            let name: string;
+            let name;
             if (parameterNames.includes("[") && parameterNames.includes("]")) {
                 // Optimized parameter name extraction
                 const commaIndex = parameterNames.indexOf(",");
@@ -153,23 +145,20 @@ export const toExpression = <T extends any, P extends any>(schema: CompiledSchem
                     }
                 }
             }
-
             parameterData = {
                 name,
                 data: params
             };
         }
-
         return parseExpressionToTree(schema, expression, parameterData);
-    } catch (e) {
+    }
+    catch (e) {
         console.warn("Error parsing expression", e);
-        return Expression.NOT_PARSABLE;
+        return _types__WEBPACK_IMPORTED_MODULE_0__.Expression.NOT_PARSABLE;
     }
-}
-
-const parseExpressionToTree = <P extends any>(schema: CompiledSchema<any>, expression: string, params?: { name: string, data: P }) => {
-
-    const parse = (exp: string): Expression => {
+};
+const parseExpressionToTree = (schema, expression, params) => {
+    const parse = (exp) => {
         // Remove any wrapping parentheses
         exp = exp.trim();
         if (exp.startsWith('(') && exp.endsWith(')')) {
@@ -179,9 +168,11 @@ const parseExpressionToTree = <P extends any>(schema: CompiledSchema<any>, expre
                 const char = exp[i];
                 if (char === '(') {
                     depth++;
-                } else if (char === ')') {
+                }
+                else if (char === ')') {
                     depth--;
-                    if (depth < 0) break; // Early exit for invalid parentheses
+                    if (depth < 0)
+                        break; // Early exit for invalid parentheses
                 }
                 // Early exit if we find a closing parenthesis that's not the last character
                 if (depth === 0 && i !== exp.length - 1) {
@@ -198,57 +189,48 @@ const parseExpressionToTree = <P extends any>(schema: CompiledSchema<any>, expre
                 exp = exp.slice(1, -1).trim();
             }
         }
-
         // Parse based on the operator precedence
-        let operator: Operator | null = null, splitIndex = -1, depth = 0;
-
+        let operator = null, splitIndex = -1, depth = 0;
         for (let i = 0; i < exp.length - 1; i++) {
             const char = exp[i];
-            if (char === '(') depth++;
-            else if (char === ')') depth--;
+            if (char === '(')
+                depth++;
+            else if (char === ')')
+                depth--;
             else if (depth === 0) {
                 // Optimized operator detection using character comparison
                 if (char === '&' && exp[i + 1] === '&') {
                     operator = '&&';
                     splitIndex = i;
                     break; // AND takes precedence over OR
-                } else if (operator === null && char === '|' && exp[i + 1] === '|') {
+                }
+                else if (operator === null && char === '|' && exp[i + 1] === '|') {
                     operator = '||';
                     splitIndex = i;
                 }
             }
         }
-
         if (operator) {
             const left = exp.slice(0, splitIndex).trim();
             const right = exp.slice(splitIndex + 2).trim();
-
-            return new OperatorExpression({
+            return new _types__WEBPACK_IMPORTED_MODULE_0__.OperatorExpression({
                 operator,
                 left: parse(left),
                 right: parse(right)
             });
         }
-
         // If no operator, try to parse as a condition
         return parseCondition(schema, exp, params);
-    }
-
+    };
     return parse(expression);
-}
-
-const convertAndAssignValue = (valueExpression: unknown, propertyPathExpression: unknown) => {
-
+};
+const convertAndAssignValue = (valueExpression, propertyPathExpression) => {
     assertIsPropertyPathExpression(propertyPathExpression);
-
-    assertIsValueExpression(valueExpression)
-
+    assertIsValueExpression(valueExpression);
     const propertyType = propertyPathExpression.property.type;
-
     valueExpression.value = converters[propertyType](valueExpression.value);
-}
-
-const converters: Record<SchemaTypes, (value: unknown) => unknown> = {
+};
+const converters = {
     Array: v => v,
     Boolean: v => v == null ? v : Boolean(v),
     Computed: v => v,
@@ -259,43 +241,33 @@ const converters: Record<SchemaTypes, (value: unknown) => unknown> = {
     Object: v => v,
     String: v => v == null ? v : String(v)
 };
-
-const isExpression = (value: unknown): value is Expression => {
+const isExpression = (value) => {
     return typeof value === "object" && value !== null && "type" in value;
-}
-
-function assertIsExpression(value: unknown): asserts value is Expression {
+};
+function assertIsExpression(value) {
     if (isExpression(value) === false) {
-        throw new Error("Assertion Failed: Value is not a Expression")
+        throw new Error("Assertion Failed: Value is not a Expression");
     }
 }
-
-function assertIsPropertyPathExpression(value: unknown): asserts value is PropertyExpression {
-
+function assertIsPropertyPathExpression(value) {
     assertIsExpression(value);
-
     if (!("property" in value)) {
-        throw new Error("Assertion Failed: Value is not a PropertyPathExpression")
+        throw new Error("Assertion Failed: Value is not a PropertyPathExpression");
     }
 }
-
-function assertIsValueExpression(value: unknown): asserts value is ValueExpression {
-
+function assertIsValueExpression(value) {
     assertIsExpression(value);
-
     if (!("value" in value)) {
-        throw new Error("Assertion Failed: Value is not a ValueExpression")
+        throw new Error("Assertion Failed: Value is not a ValueExpression");
     }
 }
-
 // Helper function to detect if a string is a property path
-const isPropertyPath = (value: string): boolean => {
+const isPropertyPath = (value) => {
     return value.includes('.') && value.match(/^[a-zA-Z0-9_.]+$/) !== null;
 };
-
 // Helper function to determine if we need to swap the operator for reversed comparisons
-const getSwappedOperator = (operator: string): string => {
-    const swapMap: Record<string, string> = {
+const getSwappedOperator = (operator) => {
+    const swapMap = {
         '>': '<',
         '<': '>',
         '>=': '<=',
@@ -303,71 +275,59 @@ const getSwappedOperator = (operator: string): string => {
     };
     return swapMap[operator] || operator;
 };
-
-const parseCondition = <P extends any>(schema: CompiledSchema<any>, expression: string, params?: { name: string, data: P }): Expression => {
-
+const parseCondition = (schema, expression, params) => {
     // Optimized string operations - single trim operation
     const trimmed = expression.trim();
     const isNegation = trimmed.startsWith('!');
     const finalExpression = isNegation ? trimmed.slice(1).trim() : trimmed;
-
     // Enhanced pattern matching for complex expressions
     const methodMatch = finalExpression.match(METHOD_REGEX);
     const transformMethodMatch = finalExpression.match(TRANSFORM_METHOD_REGEX);
     const equalityMatch = finalExpression.match(EQUALITY_REGEX);
     const comparisonMatch = finalExpression.match(COMPARISON_REGEX);
-
     if (methodMatch) {
         // Handle .startsWith or .endsWith
         const comparator = getComparator(methodMatch[2]);
-
         if (isNegation) {
             comparator.negated = isNegation;
         }
-
         // Check if the left side is a parameter path
         const leftSide = methodMatch[1];
         const rightSide = methodMatch[3];
-
         if (params && leftSide.startsWith(params.name)) {
             // This is a parameter path on the left side (e.g., params.distinctPlayers.includes(entity.playerId))
             // For includes method, we need to swap left and right sides
             if (methodMatch[2] === 'includes') {
                 comparator.left = getValue(leftSide, params);
                 comparator.right = getProperty(schema, rightSide);
-            } else {
+            }
+            else {
                 // For other methods, return NOT_PARSABLE for now
-                return Expression.NOT_PARSABLE;
+                return _types__WEBPACK_IMPORTED_MODULE_0__.Expression.NOT_PARSABLE;
             }
-        } else {
+        }
+        else {
             // Normal case: property on left, value on right
             comparator.left = getProperty(schema, leftSide);
             comparator.right = getValue(rightSide, params);
         }
-
         // If the comparison is explicitly to false, mark it as negated
         if (methodMatch[6] === "false") {
             comparator.negated = true;
         }
-
         return comparator;
     }
-
     // Check for transformations on the value side (right side of comparison) - check this FIRST
     const valueTransformMatch = finalExpression.match(/([^=!<>]+?)\s*(===|==|!==|!=)\s*([^)]+)\.(toLowerCase|toUpperCase|toLocaleLowerCase|toLocaleUpperCase)\(\)/);
     if (valueTransformMatch) {
         const comparator = getComparator(valueTransformMatch[2]);
-
         if (isNegation) {
             comparator.negated = isNegation;
         }
-
         // Create the property expression for the left side (no transformer)
         const propertyExpression = getProperty(schema, valueTransformMatch[1].trim());
-
         // Create a ValueExpression for the right side with transformer
         const valueExpression = getValue(valueTransformMatch[3], params);
-
         // Set transformer and locale based on the method
         const method = valueTransformMatch[4];
         if (method === 'toLowerCase' || method === 'toLocaleLowerCase') {
@@ -375,30 +335,25 @@ const parseCondition = <P extends any>(schema: CompiledSchema<any>, expression:
             if (method === 'toLocaleLowerCase') {
                 valueExpression.locale = 'en-US';
             }
-        } else {
+        }
+        else {
             valueExpression.transformer = 'to-upper-case';
             if (method === 'toLocaleUpperCase') {
                 valueExpression.locale = 'en-US';
             }
         }
-
         comparator.left = propertyExpression;
         comparator.right = valueExpression;
-
         return comparator;
     }
-
     if (transformMethodMatch) {
         // Handle .toLowerCase or .toUpperCase on the property side
         const comparator = getComparator(transformMethodMatch[3]); // e.g., startsWith, endsWith, includes
-
         if (isNegation) {
             comparator.negated = isNegation;
         }
-
         // Create the property expression for the left side with transformer
         const propertyExpression = getProperty(schema, transformMethodMatch[1]);
-
         // Set transformer and locale based on the method
         const method = transformMethodMatch[2];
         if (method === 'toLowerCase' || method === 'toLocaleLowerCase') {
@@ -406,25 +361,22 @@ const parseCondition = <P extends any>(schema: CompiledSchema<any>, expression:
             if (method === 'toLocaleLowerCase') {
                 propertyExpression.locale = 'en-US'; // Default locale, could be extracted from method call
             }
-        } else {
+        }
+        else {
             propertyExpression.transformer = 'to-upper-case';
             if (method === 'toLocaleUpperCase') {
                 propertyExpression.locale = 'en-US'; // Default locale, could be extracted from method call
             }
         }
-
         // Create a ValueExpression for the right side
         let valueExpression = getValue(transformMethodMatch[4], params);
-
         // Check if the value also has a transformation (but only if it's not already handled by value-side check)
         const valueTransformMatch = transformMethodMatch[4].match(/^([^)]+)\.(toLowerCase|toUpperCase|toLocaleLowerCase|toLocaleUpperCase)\(\)$/);
-
         if (valueTransformMatch) {
             // Create a new ValueExpression with the base value and transformer
-            valueExpression = new ValueExpression({
+            valueExpression = new _types__WEBPACK_IMPORTED_MODULE_0__.ValueExpression({
                 value: valueTransformMatch[1].replace(/^["']|["']$/g, '') // Remove quotes
             });
-
             // Set transformer and locale based on the method
             const valueMethod = valueTransformMatch[2];
             if (valueMethod === 'toLowerCase' || valueMethod === 'toLocaleLowerCase') {
@@ -432,163 +384,135 @@ const parseCondition = <P extends any>(schema: CompiledSchema<any>, expression:
                 if (valueMethod === 'toLocaleLowerCase') {
                     valueExpression.locale = 'en-US'; // Default locale
                 }
-            } else {
+            }
+            else {
                 valueExpression.transformer = 'to-upper-case';
                 if (valueMethod === 'toLocaleUpperCase') {
                     valueExpression.locale = 'en-US'; // Default locale
                 }
             }
         }
-
         comparator.left = propertyExpression;
         comparator.right = valueExpression;
-
         // If the comparison is explicitly to false, mark it as negated
         if (transformMethodMatch[7] === "false") {
             comparator.negated = true;
         }
-
         return comparator;
     }
-
     if (equalityMatch) {
         const left = equalityMatch[1].trim();
         const operator = equalityMatch[2];
         const right = equalityMatch[3].trim();
-
         const leftIsProperty = isPropertyPath(left);
         const rightIsProperty = isPropertyPath(right);
-
         // Determine which side is the property and which is the value
-        let propertySide: string, valueSide: string, finalOperator: string;
-
+        let propertySide, valueSide, finalOperator;
         if (leftIsProperty && !rightIsProperty) {
             // Normal case: property === value
             propertySide = left;
             valueSide = right;
             finalOperator = operator;
-        } else if (!leftIsProperty && rightIsProperty) {
+        }
+        else if (!leftIsProperty && rightIsProperty) {
             // Reversed case: value === property
             propertySide = right;
             valueSide = left;
             finalOperator = operator;
-        } else {
+        }
+        else {
             // Both sides look like properties or neither does - assume left is property
             propertySide = left;
             valueSide = right;
             finalOperator = operator;
         }
-
         const comparator = getComparator(finalOperator);
-
         if (isNegation) {
             comparator.negated = isNegation;
         }
-
         comparator.left = getProperty(schema, propertySide);
         comparator.right = getValue(valueSide, params);
-
         convertAndAssignValue(comparator.right, comparator.left);
-
         return comparator;
     }
-
     if (comparisonMatch) {
         const left = comparisonMatch[1].trim();
         const operator = comparisonMatch[2];
         const right = comparisonMatch[3].trim();
-
         const leftIsProperty = isPropertyPath(left);
         const rightIsProperty = isPropertyPath(right);
-
         // Determine which side is the property and which is the value
-        let propertySide: string, valueSide: string, finalOperator: string;
-
+        let propertySide, valueSide, finalOperator;
         if (leftIsProperty && !rightIsProperty) {
             // Normal case: property > value
             propertySide = left;
             valueSide = right;
             finalOperator = operator;
-        } else if (!leftIsProperty && rightIsProperty) {
+        }
+        else if (!leftIsProperty && rightIsProperty) {
             // Reversed case: value > property -> property < value
             propertySide = right;
             valueSide = left;
             finalOperator = getSwappedOperator(operator);
-        } else {
+        }
+        else {
             // Both sides look like properties or neither does - assume left is property
             propertySide = left;
             valueSide = right;
             finalOperator = operator;
         }
-
         const comparator = getComparator(finalOperator);
-
         if (isNegation) {
             comparator.negated = isNegation;
         }
-
         comparator.left = getProperty(schema, propertySide);
         comparator.right = getValue(valueSide, params);
-
         convertAndAssignValue(comparator.right, comparator.left);
-
         return comparator;
     }
-
     // If we get here, the expression is too complex for the current parser
     // This is expected for complex real-world expressions
     throw new Error(`Unsupported expression format: ${finalExpression}`);
-}
-
-const getComparator = (value: string): ComparatorExpression => {
-
+};
+const getComparator = (value) => {
     const comparator = COMPARATOR_MAP.get(value);
-
     if (comparator == null) {
-        throw new Error(ERROR_MESSAGES.COMPARATOR_NOT_FOUND(value))
+        throw new Error(ERROR_MESSAGES.COMPARATOR_NOT_FOUND(value));
     }
-
     // Return a new instance to avoid modifying the cached one
-    return new ComparatorExpression({
+    return new _types__WEBPACK_IMPORTED_MODULE_0__.ComparatorExpression({
         comparator: comparator.comparator,
         negated: comparator.negated,
         strict: comparator.strict
     });
-}
-
-const getValue = <P extends any>(value: string, params?: { name: string, data: P }): ValueExpression => {
-
+};
+const getValue = (value, params) => {
     // Early return for string literals
     if (value.startsWith("\'") || value.startsWith("\"")) {
-        return new ValueExpression({
+        return new _types__WEBPACK_IMPORTED_MODULE_0__.ValueExpression({
             value: value.replace(/\"|\'/g, "")
         });
     }
-
     // Early return for null/undefined
     if (value === "null") {
-        return new ValueExpression({ value: null });
+        return new _types__WEBPACK_IMPORTED_MODULE_0__.ValueExpression({ value: null });
     }
-
     if (value === "undefined" || value === "void 0") {
-        return new ValueExpression({ value: undefined });
+        return new _types__WEBPACK_IMPORTED_MODULE_0__.ValueExpression({ value: undefined });
     }
-
     // Optimized number parsing with early return
     const numValue = +value;
     if (!isNaN(numValue) && isFinite(numValue)) {
-        return new ValueExpression({ value: numValue });
+        return new _types__WEBPACK_IMPORTED_MODULE_0__.ValueExpression({ value: numValue });
     }
-
     // Handle parameter paths if params are provided
     if (params != null) {
         // Check if this is a parameter path (starts with params.name)
         if (value.startsWith(params.name)) {
-            return new ValueExpression({
+            return new _types__WEBPACK_IMPORTED_MODULE_0__.ValueExpression({
                 value: getValueFromParams(value, params)
             });
         }
-
         // Check if this is a parameter path without the params prefix
         if (value.includes('.')) {
             // Try to extract the parameter path
@@ -597,65 +521,323 @@ const getValue = <P extends any>(value: string, params?: { name: string, data: P
                 const potentialParamPath = paramMatch[1];
                 try {
                     const paramValue = getValueFromParams(`${params.name}.${potentialParamPath}`, params);
-                    return new ValueExpression({ value: paramValue });
-                } catch (e) {
+                    return new _types__WEBPACK_IMPORTED_MODULE_0__.ValueExpression({ value: paramValue });
+                }
+                catch (e) {
                     // Not a parameter path, continue with normal parsing
                 }
             }
         }
     }
-
     // Default case: return as-is
-    return new ValueExpression({ value });
-}
-
-const getValueFromParams = <P extends any>(value: string, params: { name: string, data: P }) => {
-
+    return new _types__WEBPACK_IMPORTED_MODULE_0__.ValueExpression({ value });
+};
+const getValueFromParams = (value, params) => {
     const split = value.split('.');
-
     // Early exit for invalid paths
     if (split.length === 1) {
-        throw new Error(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND(value, params.data))
+        throw new Error(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND(value, params.data));
     }
-
-    let result = params.data as any;
-
+    let result = params.data;
     // For nested params - start from index 1 to skip the params prefix
     for (let i = 1; i < split.length; i++) {
         const name = split[i];
-
         if (name in result) {
             result = result[name];
             continue;
         }
-
-        throw new Error(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND(value, params.data))
+        throw new Error(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND(value, params.data));
     }
-
     return result;
-}
-
-const getProperty = (schema: CompiledSchema<any>, value: string): PropertyExpression => {
+};
+const getProperty = (schema, value) => {
     // Optimized string splitting - only split if we have the expected pattern
     if (!value.includes('.')) {
         throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(value));
     }
-
     const pathSplit = value.split(/[?!.]/g).slice(1);
     const pathString = pathSplit.join(".");
-
     // Early exit if no path found
     if (!pathString) {
         throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(value));
     }
-
     const found = schema.properties.find(w => w.getAssignmentPath() == pathString);
-
     if (found == null) {
         throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(value));
     }
+    return new _types__WEBPACK_IMPORTED_MODULE_0__.PropertyExpression({ property: found });
+};
+
 
-    return new PropertyExpression({ property: found });
+}),
+"./src/expressions/types.ts": 
+/*!**********************************!*\
+  !*** ./src/expressions/types.ts ***!
+  \**********************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  ComparatorExpression: () => (ComparatorExpression),
+  EmptyExpression: () => (EmptyExpression),
+  Expression: () => (Expression),
+  NotParsableExpression: () => (NotParsableExpression),
+  OperatorExpression: () => (OperatorExpression),
+  PropertyExpression: () => (PropertyExpression),
+  ValueExpression: () => (ValueExpression)
+});
+/**
+ * The base class for all expression types.
+ */
+class Expression {
+    /** The left-hand side of the expression (if applicable). */
+    left;
+    /** The right-hand side of the expression (if applicable). */
+    right;
+    constructor(left, right) {
+        this.left = left;
+        this.right = right;
+    }
+    static get EMPTY() {
+        return new EmptyExpression();
+    }
+    static get NOT_PARSABLE() {
+        return new NotParsableExpression();
+    }
+    static isEmpty(expression) {
+        return expression.type === "empty" || expression instanceof EmptyExpression;
+    }
+    static isNotParsable(expression) {
+        return expression.type === "not-parsable" || expression instanceof NotParsableExpression;
+    }
+}
+class EmptyExpression extends Expression {
+    type = "empty";
+}
+class NotParsableExpression extends Expression {
+    type = "not-parsable";
+}
+/**
+ * A class representing a comparison operation (e.g., equals, greater-than).
+ */
+class ComparatorExpression extends Expression {
+    /** The type of the expression (always 'comparator'). */
+    type = "comparator";
+    /** The comparator operation (e.g., equals, greater-than). */
+    comparator;
+    /** Whether the comparison is negated (e.g., not equals). */
+    negated;
+    /** Whether the comparison is strict (type-sensitive). */
+    strict;
+    constructor(options) {
+        super(options.left, options.right);
+        this.comparator = options.comparator;
+        this.negated = options.negated;
+        this.strict = options.strict;
+    }
+}
+/**
+ * A class representing a logical operator (e.g., &&, ||).
+ */
+class OperatorExpression extends Expression {
+    /** The type of the expression (always 'operator'). */
+    type = "operator";
+    /** The logical operator. */
+    operator;
+    constructor(options) {
+        super(options.left, options.right);
+        this.operator = options.operator;
+    }
+}
+/**
+ * A class representing a property path.
+ */
+class PropertyExpression extends Expression {
+    /** The type of the expression (always 'property'). */
+    type = "property";
+    /** The property info for the path. */
+    property;
+    transformer = null;
+    locale = null;
+    constructor(options) {
+        super();
+        this.property = options.property;
+    }
+}
+/**
+ * A class representing a literal value.
+ */
+class ValueExpression extends Expression {
+    /** The type of the expression (always 'value'). */
+    type = "value";
+    /** The literal value. */
+    value;
+    transformer = null;
+    locale = null;
+    constructor(options) {
+        super();
+        this.value = options.value;
+    }
 }
 
 
+}),
+"./src/expressions/utils.ts": 
+/*!**********************************!*\
+  !*** ./src/expressions/utils.ts ***!
+  \**********************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  forEach: () => (forEach),
+  getProperties: () => (getProperties),
+  isPropertyExpression: () => (isPropertyExpression)
+});
+/**
+ * Extracts all properties referenced in an expression
+ * @param expression The expression to analyze
+ * @returns Array of PropertyInfo objects referenced in the expression
+ */
+function getProperties(expression) {
+    const properties = [];
+    function traverse(expr) {
+        // If this is a property expression, add it to our collection
+        if (expr.type === "property") {
+            properties.push(expr.property);
+        }
+        // Traverse left and right expressions if they exist
+        if (expr.left) {
+            traverse(expr.left);
+        }
+        if (expr.right) {
+            traverse(expr.right);
+        }
+    }
+    traverse(expression);
+    return properties;
+}
+function isPropertyExpression(expression) {
+    return expression.type === "property";
+}
+function forEach(expression, callback) {
+    function traverse(expr) {
+        // Call the callback for this expression
+        // If callback returns false, stop traversing
+        if (!callback(expr)) {
+            return false;
+        }
+        // Traverse left and right expressions if they exist
+        if (expr.left) {
+            if (!traverse(expr.left)) {
+                return false;
+            }
+        }
+        if (expr.right) {
+            if (!traverse(expr.right)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    traverse(expression);
+}
+
+
+}),
+
+});
+/************************************************************************/
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+/************************************************************************/
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+
+/*!**********************************!*\
+  !*** ./src/expressions/index.ts ***!
+  \**********************************/
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  ComparatorExpression: () => (/* reexport safe */ _types__WEBPACK_IMPORTED_MODULE_1__.ComparatorExpression),
+  EmptyExpression: () => (/* reexport safe */ _types__WEBPACK_IMPORTED_MODULE_1__.EmptyExpression),
+  Expression: () => (/* reexport safe */ _types__WEBPACK_IMPORTED_MODULE_1__.Expression),
+  NotParsableExpression: () => (/* reexport safe */ _types__WEBPACK_IMPORTED_MODULE_1__.NotParsableExpression),
+  OperatorExpression: () => (/* reexport safe */ _types__WEBPACK_IMPORTED_MODULE_1__.OperatorExpression),
+  PropertyExpression: () => (/* reexport safe */ _types__WEBPACK_IMPORTED_MODULE_1__.PropertyExpression),
+  ValueExpression: () => (/* reexport safe */ _types__WEBPACK_IMPORTED_MODULE_1__.ValueExpression),
+  combineExpressions: () => (/* reexport safe */ _parser__WEBPACK_IMPORTED_MODULE_0__.combineExpressions),
+  forEach: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_2__.forEach),
+  getProperties: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_2__.getProperties),
+  isPropertyExpression: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_2__.isPropertyExpression),
+  toExpression: () => (/* reexport safe */ _parser__WEBPACK_IMPORTED_MODULE_0__.toExpression)
+});
+/* ESM import */var _parser__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./parser */ "./src/expressions/parser.ts");
+/* ESM import */var _types__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./types */ "./src/expressions/types.ts");
+/* ESM import */var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils */ "./src/expressions/utils.ts");
+
+
+
+
+})();
+
+var __webpack_exports__ComparatorExpression = __webpack_exports__.ComparatorExpression;
+var __webpack_exports__EmptyExpression = __webpack_exports__.EmptyExpression;
+var __webpack_exports__Expression = __webpack_exports__.Expression;
+var __webpack_exports__NotParsableExpression = __webpack_exports__.NotParsableExpression;
+var __webpack_exports__OperatorExpression = __webpack_exports__.OperatorExpression;
+var __webpack_exports__PropertyExpression = __webpack_exports__.PropertyExpression;
+var __webpack_exports__ValueExpression = __webpack_exports__.ValueExpression;
+var __webpack_exports__combineExpressions = __webpack_exports__.combineExpressions;
+var __webpack_exports__forEach = __webpack_exports__.forEach;
+var __webpack_exports__getProperties = __webpack_exports__.getProperties;
+var __webpack_exports__isPropertyExpression = __webpack_exports__.isPropertyExpression;
+var __webpack_exports__toExpression = __webpack_exports__.toExpression;
+export { __webpack_exports__ComparatorExpression as ComparatorExpression, __webpack_exports__EmptyExpression as EmptyExpression, __webpack_exports__Expression as Expression, __webpack_exports__NotParsableExpression as NotParsableExpression, __webpack_exports__OperatorExpression as OperatorExpression, __webpack_exports__PropertyExpression as PropertyExpression, __webpack_exports__ValueExpression as ValueExpression, __webpack_exports__combineExpressions as combineExpressions, __webpack_exports__forEach as forEach, __webpack_exports__getProperties as getProperties, __webpack_exports__isPropertyExpression as isPropertyExpression, __webpack_exports__toExpression as toExpression };
+
+//# sourceMappingURL=index.js.map