@halleyassist/rule-templater 0.0.7 → 0.0.8

package/dist/rule-templater.browser.js

@@ -1,122 +1,1691 @@
 (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.RuleTemplater = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
-const {Grammars} = require('ebnf');
-
-const grammar = `
-statement_main       ::= statement EOF
-logical_operator     ||= AND | OR
-statement            ::= expression (logical_operator expression)*
-expression           ::= not_expression | standard_expression | parenthesis_expression
-parenthesis_expression ::= BEGIN_PARENTHESIS WS* statement WS* END_PARENTHESIS
-not_expression       ||= NOT (result | parenthesis_expression)
-standard_expression  ||= result ((WS* eq_approx) | (WS* basic_rhs) | ((WS+ IS)? WS+ between) | (WS+ in_expr))?
-basic_rhs            ::= operator WS* result
-eq_approx            ::= eq_operator WS* "~" WS* result
-
-PLUS                 ::= "+"
-MINUS                ::= "-"
-MULTIPLY             ::= "*"
-DIVIDE               ::= "/"
-MODULUS              ::= "%"
-DEFAULT_VAL          ::= "??"
-arithmetic_operator  ::= PLUS | MINUS | MULTIPLY | DIVIDE | MODULUS | DEFAULT_VAL
-
-number_atom          ::= number
-number_time_atom     ::= number_time
-tod_atom             ::= number_tod
-dow_atom             ::= dow
-
-arithmetic_operand   ::= fcall | number_time_atom | number_atom
-arithmetic_result    ::= arithmetic_operand WS* arithmetic_operator WS* (arithmetic_result | arithmetic_operand)
-
-simple_result        ::= fcall | value
-result               ::= arithmetic_result | simple_result
-
-value_atom           ::= false | true | array | time_period | number_time_atom | number_atom | tod_atom | string
-value                ::= value_atom
-
-BEGIN_ARRAY          ::= WS* #x5B WS*  /* [ */
-BEGIN_OBJECT         ::= WS* #x7B WS*  /* { */
-END_ARRAY            ::= WS* #x5D WS*  /* ] */
-END_OBJECT           ::= WS* #x7D WS*  /* } */
-NAME_SEPARATOR       ::= WS* #x3A WS*  /* : */
-VALUE_SEPARATOR      ::= WS* #x2C WS*  /* , */
-WS                   ::= [#x20#x09#x0A#x0D]
-
-operator             ::= GTE | LTE | GT | LT | EQ | NEQ
-eq_operator          ::= EQ | NEQ
-
-BEGIN_ARGUMENT       ::= "("
-END_ARGUMENT         ::= ")"
-BEGIN_PARENTHESIS    ::= "("
-END_PARENTHESIS      ::= ")"
-
-BEGIN_IN             ||= "IN"
-in_expr              ::= BEGIN_IN WS* BEGIN_PARENTHESIS WS* arguments END_PARENTHESIS
-
-argument             ::= statement WS*
-arguments            ::= argument (WS* "," WS* argument)*
-fname                ::= [A-Za-z0-9]+
-fcall                ::= fname WS* BEGIN_ARGUMENT WS* arguments? END_ARGUMENT
-
-between_dash_or_and  ||= (WS+ "AND" WS+) | (WS* "-" WS*)
-
-between_number_inner ::= number_atom | number_time_atom
-between_number       ||= between_number_inner between_dash_or_and between_number_inner
-
-between_number_time_inner ::= number_time_atom
-between_number_time  ||= between_number_time_inner between_dash_or_and between_number_time_inner (WS+ dow_range)?
-
-between_tod_inner    ::= tod_atom
-between_tod          ||= between_tod_inner (WS+ "AND" WS+) between_tod_inner (WS+ dow_range)?
-
-between              ||= "BETWEEN" WS+ (between_number | between_tod)
-
-dow                  ||= "MONDAY" | "MON" | "TUESDAY" | "TUE" | "WEDNESDAY" | "WED" | "THURSDAY" | "THU" | "THUR" | "FRIDAY" | "FRI" | "SATURDAY" | "SAT" | "SUNDAY" | "SUN"
-
-dow_range_inner      ::= dow_atom
-dow_range            ||= "ON" WS+ dow_range_inner (WS+ "TO" WS+ dow_range_inner)?
-
-between_time_only    ||= "BETWEEN" WS+ between_number_time
-between_tod_only     ||= "BETWEEN" WS+ between_tod
-between_time_only_atom ::= between_time_only
-between_tod_only_atom  ::= between_tod_only
-
-AND                  ||= (WS* "&&" WS*) | (WS+ "AND" WS+)
-OR                   ||= (WS* "||" WS*) | (WS+ "OR" WS+)
-AGO                  ||= "AGO"
-GT                   ::= ">"
-LT                   ::= "<"
-GTE                  ::= ">="
-LTE                  ::= "<="
-IS                   ||= "is"
-EQ                   ::= "==" | "="
-NEQ                  ::= "!="
-NOT                  ||= ("!" WS*) | ("not" WS+)
-
-false                ||= "FALSE"
-null                 ||= "null"
-true                 ||= "TRUE"
-
-array                ::= BEGIN_ARRAY (value (VALUE_SEPARATOR value)*)? END_ARRAY
-
-unit                 ||= "seconds" | "minutes" | "hours" | "weeks" | "days" | "second" | "minute" | "week" | "hour" | "day" | "mins" | "min"
-
-number               ::= "-"? ([0-9]+) ("." [0-9]+)? ("e" ("-" | "+")? ("0" | [1-9] [0-9]*))?
-number_time          ::= number WS+ unit
-number_tod           ::= ([0-9]+) ":" ([0-9]+)
-
-time_period_ago      ||= number_time_atom (WS+ number_time_atom)* WS+ AGO
-time_period_ago_between ||= number_time_atom (WS+ number_time_atom)* WS+ AGO WS+ (between_time_only_atom | between_tod_only_atom)
-time_period_const    ||= "today" | time_period_ago
-time_period          ::= time_period_ago_between | time_period_const | between_tod_only | between_time_only
+module.exports=[{"name":"statement_main","bnf":[["statement","EOF"]]},{"name":"logical_operator","bnf":[["AND"],["OR"]]},{"name":"%statement[2]","bnf":[["logical_operator","expression"]],"fragment":true},{"name":"statement","bnf":[["expression","%statement[2]*"]]},{"name":"expression","bnf":[["not_expression"],["standard_expression"],["parenthesis_expression"]]},{"name":"parenthesis_expression","bnf":[["BEGIN_PARENTHESIS","WS*","statement","WS*","END_PARENTHESIS"]]},{"name":"%not_expression[2]","bnf":[["result"],["parenthesis_expression"]],"fragment":true},{"name":"not_expression","bnf":[["NOT","%not_expression[2]"]]},{"name":"%standard_expression[2][1]","bnf":[["WS*","eq_approx"]],"fragment":true},{"name":"%standard_expression[2][2]","bnf":[["WS*","basic_rhs"]],"fragment":true},{"name":"%standard_expression[2][3][1]","bnf":[["WS+","IS"]],"fragment":true},{"name":"%standard_expression[2][3]","bnf":[["%standard_expression[2][3][1]?","WS+","between"]],"fragment":true},{"name":"%standard_expression[2][4]","bnf":[["WS+","in_expr"]],"fragment":true},{"name":"%standard_expression[2]","bnf":[["%standard_expression[2][1]"],["%standard_expression[2][2]"],["%standard_expression[2][3]"],["%standard_expression[2][4]"]],"fragment":true},{"name":"standard_expression","bnf":[["result","%standard_expression[2]?"]]},{"name":"basic_rhs","bnf":[["operator","WS*","result"]]},{"name":"eq_approx","bnf":[["eq_operator","WS*","\"~\"","WS*","result"]]},{"name":"PLUS","bnf":[["\"+\""]]},{"name":"MINUS","bnf":[["\"-\""]]},{"name":"MULTIPLY","bnf":[["\"*\""]]},{"name":"DIVIDE","bnf":[["\"/\""]]},{"name":"MODULUS","bnf":[["\"%\""]]},{"name":"DEFAULT_VAL","bnf":[["\"??\""]]},{"name":"arithmetic_operator","bnf":[["PLUS"],["MINUS"],["MULTIPLY"],["DIVIDE"],["MODULUS"],["DEFAULT_VAL"]]},{"name":"number_atom","bnf":[["number"]]},{"name":"number_time_atom","bnf":[["number_time"]]},{"name":"tod_atom","bnf":[["number_tod"]]},{"name":"dow_atom","bnf":[["dow"]]},{"name":"arithmetic_operand","bnf":[["fcall"],["number_time_atom"],["number_atom"]]},{"name":"%arithmetic_result[5]","bnf":[["arithmetic_result"],["arithmetic_operand"]],"fragment":true},{"name":"arithmetic_result","bnf":[["arithmetic_operand","WS*","arithmetic_operator","WS*","%arithmetic_result[5]"]]},{"name":"simple_result","bnf":[["fcall"],["value"]]},{"name":"result","bnf":[["arithmetic_result"],["simple_result"]]},{"name":"value_atom","bnf":[["false"],["true"],["array"],["time_period"],["number_time_atom"],["number_atom"],["tod_atom"],["string"]]},{"name":"value","bnf":[["value_atom"]]},{"name":"BEGIN_ARRAY","bnf":[["WS*",/\x5B/,"WS*"]]},{"name":"BEGIN_OBJECT","bnf":[["WS*",/\x7B/,"WS*"]]},{"name":"END_ARRAY","bnf":[["WS*",/\x5D/,"WS*"]]},{"name":"END_OBJECT","bnf":[["WS*",/\x7D/,"WS*"]]},{"name":"NAME_SEPARATOR","bnf":[["WS*",/\x3A/,"WS*"]]},{"name":"VALUE_SEPARATOR","bnf":[["WS*",/\x2C/,"WS*"]]},{"name":"WS","bnf":[[/[\x20\x09\x0A\x0D]/]]},{"name":"operator","bnf":[["GTE"],["LTE"],["GT"],["LT"],["EQ"],["NEQ"]]},{"name":"eq_operator","bnf":[["EQ"],["NEQ"]]},{"name":"BEGIN_ARGUMENT","bnf":[["\"(\""]]},{"name":"END_ARGUMENT","bnf":[["\")\""]]},{"name":"BEGIN_PARENTHESIS","bnf":[["\"(\""]]},{"name":"END_PARENTHESIS","bnf":[["\")\""]]},{"name":"BEGIN_IN","bnf":[[/[Ii]/,/[Nn]/]]},{"name":"in_expr","bnf":[["BEGIN_IN","WS*","BEGIN_PARENTHESIS","WS*","arguments","END_PARENTHESIS"]]},{"name":"argument","bnf":[["statement","WS*"]]},{"name":"%arguments[2]","bnf":[["WS*","\",\"","WS*","argument"]],"fragment":true},{"name":"arguments","bnf":[["argument","%arguments[2]*"]]},{"name":"%fname[1]","bnf":[[/[A-Za-z0-9]/]]},{"name":"fname","bnf":[["%fname[1]+"]]},{"name":"fcall","bnf":[["fname","WS*","BEGIN_ARGUMENT","WS*","arguments?","END_ARGUMENT"]]},{"name":"%between_dash_or_and[1]","bnf":[["WS+",/[Aa]/,/[Nn]/,/[Dd]/,"WS+"]],"fragment":true},{"name":"%between_dash_or_and[2]","bnf":[["WS*",/\-/,"WS*"]],"fragment":true},{"name":"between_dash_or_and","bnf":[["%between_dash_or_and[1]"],["%between_dash_or_and[2]"]]},{"name":"between_number_inner","bnf":[["number_atom"],["number_time_atom"]]},{"name":"between_number","bnf":[["between_number_inner","between_dash_or_and","between_number_inner"]]},{"name":"between_number_time_inner","bnf":[["number_time_atom"]]},{"name":"%between_number_time[4]","bnf":[["WS+","dow_range"]],"fragment":true},{"name":"between_number_time","bnf":[["between_number_time_inner","between_dash_or_and","between_number_time_inner","%between_number_time[4]?"]]},{"name":"between_tod_inner","bnf":[["tod_atom"]]},{"name":"%between_tod[2]","bnf":[["WS+",/[Aa]/,/[Nn]/,/[Dd]/,"WS+"]],"fragment":true},{"name":"%between_tod[4]","bnf":[["WS+","dow_range"]],"fragment":true},{"name":"between_tod","bnf":[["between_tod_inner","%between_tod[2]","between_tod_inner","%between_tod[4]?"]]},{"name":"%between[3]","bnf":[["between_number"],["between_tod"]],"fragment":true},{"name":"between","bnf":[[/[Bb]/,/[Ee]/,/[Tt]/,/[Ww]/,/[Ee]/,/[Ee]/,/[Nn]/,"WS+","%between[3]"]]},{"name":"dow","bnf":[[/[Mm]/,/[Oo]/,/[Nn]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Mm]/,/[Oo]/,/[Nn]/],[/[Tt]/,/[Uu]/,/[Ee]/,/[Ss]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Tt]/,/[Uu]/,/[Ee]/],[/[Ww]/,/[Ee]/,/[Dd]/,/[Nn]/,/[Ee]/,/[Ss]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Ww]/,/[Ee]/,/[Dd]/],[/[Tt]/,/[Hh]/,/[Uu]/,/[Rr]/,/[Ss]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Tt]/,/[Hh]/,/[Uu]/],[/[Tt]/,/[Hh]/,/[Uu]/,/[Rr]/],[/[Ff]/,/[Rr]/,/[Ii]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Ff]/,/[Rr]/,/[Ii]/],[/[Ss]/,/[Aa]/,/[Tt]/,/[Uu]/,/[Rr]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Ss]/,/[Aa]/,/[Tt]/],[/[Ss]/,/[Uu]/,/[Nn]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Ss]/,/[Uu]/,/[Nn]/]]},{"name":"dow_range_inner","bnf":[["dow_atom"]]},{"name":"%dow_range[4]","bnf":[["WS+",/[Tt]/,/[Oo]/,"WS+","dow_range_inner"]],"fragment":true},{"name":"dow_range","bnf":[[/[Oo]/,/[Nn]/,"WS+","dow_range_inner","%dow_range[4]?"]]},{"name":"between_time_only","bnf":[[/[Bb]/,/[Ee]/,/[Tt]/,/[Ww]/,/[Ee]/,/[Ee]/,/[Nn]/,"WS+","between_number_time"]]},{"name":"between_tod_only","bnf":[[/[Bb]/,/[Ee]/,/[Tt]/,/[Ww]/,/[Ee]/,/[Ee]/,/[Nn]/,"WS+","between_tod"]]},{"name":"between_time_only_atom","bnf":[["between_time_only"]]},{"name":"between_tod_only_atom","bnf":[["between_tod_only"]]},{"name":"%AND[1]","bnf":[["WS*",/&/,/&/,"WS*"]],"fragment":true},{"name":"%AND[2]","bnf":[["WS+",/[Aa]/,/[Nn]/,/[Dd]/,"WS+"]],"fragment":true},{"name":"AND","bnf":[["%AND[1]"],["%AND[2]"]]},{"name":"%OR[1]","bnf":[["WS*",/\|/,/\|/,"WS*"]],"fragment":true},{"name":"%OR[2]","bnf":[["WS+",/[Oo]/,/[Rr]/,"WS+"]],"fragment":true},{"name":"OR","bnf":[["%OR[1]"],["%OR[2]"]]},{"name":"AGO","bnf":[[/[Aa]/,/[Gg]/,/[Oo]/]]},{"name":"GT","bnf":[["\">\""]]},{"name":"LT","bnf":[["\"<\""]]},{"name":"GTE","bnf":[["\">=\""]]},{"name":"LTE","bnf":[["\"<=\""]]},{"name":"IS","bnf":[[/[Ii]/,/[Ss]/]]},{"name":"EQ","bnf":[["\"==\""],["\"=\""]]},{"name":"NEQ","bnf":[["\"!=\""]]},{"name":"%NOT[1]","bnf":[[/!/,"WS*"]],"fragment":true},{"name":"%NOT[2]","bnf":[[/[Nn]/,/[Oo]/,/[Tt]/,"WS+"]],"fragment":true},{"name":"NOT","bnf":[["%NOT[1]"],["%NOT[2]"]]},{"name":"false","bnf":[[/[Ff]/,/[Aa]/,/[Ll]/,/[Ss]/,/[Ee]/]]},{"name":"null","bnf":[[/[Nn]/,/[Uu]/,/[Ll]/,/[Ll]/]]},{"name":"true","bnf":[[/[Tt]/,/[Rr]/,/[Uu]/,/[Ee]/]]},{"name":"%array[2][2]","bnf":[["VALUE_SEPARATOR","value"]],"fragment":true},{"name":"%array[2]","bnf":[["value","%array[2][2]*"]],"fragment":true},{"name":"array","bnf":[["BEGIN_ARRAY","%array[2]?","END_ARRAY"]]},{"name":"unit","bnf":[[/[Ss]/,/[Ee]/,/[Cc]/,/[Oo]/,/[Nn]/,/[Dd]/,/[Ss]/],[/[Mm]/,/[Ii]/,/[Nn]/,/[Uu]/,/[Tt]/,/[Ee]/,/[Ss]/],[/[Hh]/,/[Oo]/,/[Uu]/,/[Rr]/,/[Ss]/],[/[Ww]/,/[Ee]/,/[Ee]/,/[Kk]/,/[Ss]/],[/[Dd]/,/[Aa]/,/[Yy]/,/[Ss]/],[/[Ss]/,/[Ee]/,/[Cc]/,/[Oo]/,/[Nn]/,/[Dd]/],[/[Mm]/,/[Ii]/,/[Nn]/,/[Uu]/,/[Tt]/,/[Ee]/],[/[Ww]/,/[Ee]/,/[Ee]/,/[Kk]/],[/[Hh]/,/[Oo]/,/[Uu]/,/[Rr]/],[/[Dd]/,/[Aa]/,/[Yy]/],[/[Mm]/,/[Ii]/,/[Nn]/,/[Ss]/],[/[Mm]/,/[Ii]/,/[Nn]/]]},{"name":"%number[2][1]","bnf":[[/[0-9]/]]},{"name":"%number[2]","bnf":[["%number[2][1]+"]],"fragment":true},{"name":"%number[3][2]","bnf":[[/[0-9]/]]},{"name":"%number[3]","bnf":[["\".\"","%number[3][2]+"]],"fragment":true},{"name":"%number[4][2]","bnf":[["\"-\""],["\"+\""]],"fragment":true},{"name":"%number[4][3][2]","bnf":[[/[0-9]/]]},{"name":"%number[4][3]","bnf":[["\"0\""],[/[1-9]/,"%number[4][3][2]*"]],"fragment":true},{"name":"%number[4]","bnf":[["\"e\"","%number[4][2]?","%number[4][3]"]],"fragment":true},{"name":"number","bnf":[["\"-\"?","%number[2]","%number[3]?","%number[4]?"]]},{"name":"number_time","bnf":[["number","WS+","unit"]]},{"name":"%number_tod[1][1]","bnf":[[/[0-9]/]]},{"name":"%number_tod[1]","bnf":[["%number_tod[1][1]+"]],"fragment":true},{"name":"%number_tod[3][1]","bnf":[[/[0-9]/]]},{"name":"%number_tod[3]","bnf":[["%number_tod[3][1]+"]],"fragment":true},{"name":"number_tod","bnf":[["%number_tod[1]","\":\"","%number_tod[3]"]]},{"name":"%time_period_ago[2]","bnf":[["WS+","number_time_atom"]],"fragment":true},{"name":"time_period_ago","bnf":[["number_time_atom","%time_period_ago[2]*","WS+","AGO"]]},{"name":"%time_period_ago_between[2]","bnf":[["WS+","number_time_atom"]],"fragment":true},{"name":"%time_period_ago_between[6]","bnf":[["between_time_only_atom"],["between_tod_only_atom"]],"fragment":true},{"name":"time_period_ago_between","bnf":[["number_time_atom","%time_period_ago_between[2]*","WS+","AGO","WS+","%time_period_ago_between[6]"]]},{"name":"time_period_const","bnf":[[/[Tt]/,/[Oo]/,/[Dd]/,/[Aa]/,/[Yy]/],["time_period_ago"]]},{"name":"time_period","bnf":[["time_period_ago_between"],["time_period_const"],["between_tod_only"],["between_time_only"]]},{"name":"%string[2][1]","bnf":[[/[\x20-\x21]/],[/[\x23-\x5B]/],[/[\x5D-\uFFFF]/]],"fragment":true},{"name":"%string[2][2]","bnf":[[/\x22/],[/\x5C/],[/\x2F/],[/\x62/],[/\x66/],[/\x6E/],[/\x72/],[/\x74/],[/\x75/,"HEXDIG","HEXDIG","HEXDIG","HEXDIG"]],"fragment":true},{"name":"%string[2]","bnf":[["%string[2][1]"],[/\x5C/,"%string[2][2]"]],"fragment":true},{"name":"string","bnf":[["'\"'","%string[2]*","'\"'"]]},{"name":"HEXDIG","bnf":[[/[a-fA-F0-9]/]]}]
+},{}],2:[function(require,module,exports){
+const {Parser} = require('ebnf/dist/Parser.js'),
+      {ParsingError} = require('ebnf'),
+      assert = require('assert'),
+      RuleParseError = require('./errors/RuleParseError')
 
-string               ::= '"' (([#x20-#x21] | [#x23-#x5B] | [#x5D-#xFFFF]) | #x5C (#x22 | #x5C | #x2F | #x62 | #x66 | #x6E | #x72 | #x74 | #x75 HEXDIG HEXDIG HEXDIG HEXDIG))* '"'
-HEXDIG               ::= [a-fA-F0-9]
-`
+let ParserRules = require('./RuleParser.production.ebnf.js')
+let ParserCache;
 
-module.exports = Grammars.W3C.getRules(grammar);
+const { ErrorAnalyzer } = require('./errors/ErrorAnalyzer');
 
-},{"ebnf":10}],2:[function(require,module,exports){
+const ArithmeticOperators = {
+    "+": 'MathAdd',
+    "-": 'MathSub',
+    "/": 'MathDiv',
+    "*": 'MathMul',
+    "%": 'MathMod',
+    "??": "Default"
+}
+
+const OperatorFn = {
+    ">": "Gt",
+    "<": "Lt",
+    ">=": "Gte",
+    "<=": "Lte",
+    "==": "Eq",
+    "=": "Eq",
+    "!=": "Neq"
+}
+
+const LogicalOperators = {
+    "&&": 'And',
+    "AND": 'And',
+    "||": 'Or',
+    "OR": 'Or',
+}
+
+// Map abbreviations to canonical uppercase full form
+const DOW_MAP = {
+    'MON': 'MONDAY',
+    'TUE': 'TUESDAY',
+    'WED': 'WEDNESDAY',
+    'THU': 'THURSDAY',
+    'THUR': 'THURSDAY',
+    'FRI': 'FRIDAY',
+    'SAT': 'SATURDAY',
+    'SUN': 'SUNDAY',
+};
+
+// Valid full day names
+const VALID_DAYS = new Set(['MONDAY', 'TUESDAY', 'WEDNESDAY', 'THURSDAY', 'FRIDAY', 'SATURDAY', 'SUNDAY']);
+
+const normalizeDow = (text) => {
+    const upper = text.toUpperCase();
+    // Check if it's an abbreviation first
+    if (upper in DOW_MAP) {
+        return DOW_MAP[upper];
+    }
+    // Otherwise, check if it's a valid full name
+    if (VALID_DAYS.has(upper)) {
+        return upper;
+    }
+    throw new Error(`Invalid day of week: ${text}`);
+};
+
+const Epsilon = 0.01
+
+class RuleParser {
+    static toAst(txt, parser = null){
+        let ret
+
+        if(!parser) {
+            if(!ParserCache){
+                ParserCache = new Parser(ParserRules, {debug: false})
+            }
+            parser = ParserCache
+        }
+
+        try {
+            ret = parser.getAST(txt.trim(), 'statement_main');
+        } catch (e) {
+            // If ebnf throws ParsingError, convert it to RuleParseError with helpful error code
+            if (e instanceof ParsingError) {
+                throw ErrorAnalyzer.analyzeParseFailure(txt, e);
+            }
+            throw e;
+        }
+        
+        if(ret){
+            return ret.children[0]
+        }
+        
+        // If parsing failed without throwing (shouldn't happen with new ebnf), throw error
+        throw ErrorAnalyzer.analyzeParseFailure(txt);
+    }
+    static _parseArgument(argument){
+        assert(argument.type === 'argument')
+        const child = argument.children[0]
+        return RuleParser._buildExpressionGroup(child)
+    }
+    static _parseFcall(fcall){
+        const fname = fcall.children[0]
+        const ret = [fname.text]
+        if(fcall.children.length != 1){
+            const args = fcall.children[1]
+            for(const a of args.children){
+                ret.push(RuleParser._parseArgument(a))
+            }
+        }
+        return ret
+    }
+    static _parseDowRange(dowRange) {
+        // dow_range can have 1 or 2 children (single day or range)
+        if (dowRange.children.length === 1) {
+            // Single day: ON MONDAY - return just the day string
+            // New structure: dow_range -> dow_range_inner -> dow_atom -> dow
+            const dayText = RuleParser.__parseValue(dowRange.children[0])
+            return { start: dayText, end: dayText };
+        } else if (dowRange.children.length === 2) {
+            // Range: ON MONDAY TO FRIDAY - return both start and end days
+            const startDay = RuleParser.__parseValue(dowRange.children[0])
+            const endDay = RuleParser.__parseValue(dowRange.children[1])
+            return { start: startDay, end: endDay };
+        } else {
+            throw new Error(`Invalid dow_range with ${dowRange.children.length} children`);
+        }
+    }
+    static _addDowToTods(startTod, endTod, dowRange) {
+        if (dowRange && dowRange.type === 'dow_range') {
+            const dow = RuleParser._parseDowRange(dowRange)
+            startTod.dow = dow.start
+            endTod.dow = dow.end
+        }
+    }
+    static _parseTimePeriod(tp){
+        switch(tp.type){
+            case 'time_period_const':
+                // Check if this is a time_period_ago (has children)
+                if (tp.children && tp.children.length > 0 && tp.children[0].type === 'time_period_ago') {
+                    const timePeriodAgo = tp.children[0]
+                    // Extract all number_time children and sum them up
+                    let totalSeconds = 0
+                    const components = []
+                    for (const child of timePeriodAgo.children) {
+                        if (child.type === 'number_time_atom') {
+                            // New structure: number_time_atom -> number_time -> number, unit
+                            const numberTime = child.children[0]
+                            const number = parseFloat(numberTime.children[0].text)
+                            const unit = numberTime.children[1].text.toUpperCase()
+                            components.push([number, unit])
+                            // Parse the value to get seconds
+                            totalSeconds += RuleParser.__parseValue(numberTime)
+                        }
+                    }
+                    // If there's only one component, use its number and unit
+                    // Otherwise, use the total in seconds and "SECONDS" as the unit
+                    if (components.length === 1) {
+                        return ["TimePeriodConstAgo", components[0][0], components[0][1]]
+                    } else {
+                        return ["TimePeriodConstAgo", totalSeconds, "SECONDS"]
+                    }
+                }
+                return ["TimePeriodConst", tp.text]
+            case 'time_period_ago_between': {
+                // time_period_ago_between has: number_time_atom (WS+ number_time_atom)* WS+ AGO WS+ (between_time_only | between_tod_only)
+                // We need to extract all number_time children and sum them up, then return TimePeriodBetweenAgo
+                let totalSeconds = 0
+                let betweenNode = null
+                let isBetweenTod = false
+                
+                // Find all number_time_atom children and the between node (either between_time_only or between_tod_only)
+                for (let i = 0; i < tp.children.length; i++) {
+                    if (tp.children[i].type === 'number_time_atom') {
+                        // New structure: number_time_atom -> number_time
+                        totalSeconds += RuleParser.__parseValue(tp.children[i].children[0])
+                    } else if (tp.children[i].type === 'between_time_only' || tp.children[i].type === 'between_time_only_atom') {
+                        betweenNode = tp.children[i].type === 'between_time_only_atom' ? tp.children[i].children[0] : tp.children[i]
+                        isBetweenTod = false
+                    } else if (tp.children[i].type === 'between_tod_only' || tp.children[i].type === 'between_tod_only_atom') {
+                        betweenNode = tp.children[i].type === 'between_tod_only_atom' ? tp.children[i].children[0] : tp.children[i]
+                        isBetweenTod = true
+                    }
+                }
+                
+                // This should always be present based on the grammar, but check defensively
+                if (!betweenNode) {
+                    throw new Error('time_period_ago_between requires between_time_only or between_tod_only child')
+                }
+                
+                if (isBetweenTod) {
+                    const betweenTod = betweenNode.children[0]
+                    // between_tod has inline separator, so: children[0] = first tod_inner, children[1] = second tod_inner, children[2] = optional dow_range
+                    let startTod = RuleParser.__parseValue(betweenTod.children[0])
+                    let endTod = RuleParser.__parseValue(betweenTod.children[1])
+                    
+                    // Check if there's a dow_range at betweenTod.children[2]
+                    // Note: startTod and endTod should always be objects from number_tod parsing
+                    if (betweenTod.children.length > 2) {
+                        RuleParser._addDowToTods(startTod, endTod, betweenTod.children[2])
+                    }
+                    
+                    return ["TimePeriodBetweenAgo", totalSeconds, startTod, endTod]
+                } else {
+                    const betweenNumberTime = betweenNode.children[0]
+                    // between_number_time has: children[0] = first time_inner, children[1] = separator, children[2] = second time_inner, children[3] = optional dow_range
+                    const startValue = RuleParser.__parseValue(betweenNumberTime.children[0])
+                    const endValue = RuleParser.__parseValue(betweenNumberTime.children[2])
+                    
+                    // Check if there's a dow_range at betweenNumberTime.children[3]
+                    if (betweenNumberTime.children.length > 3 && betweenNumberTime.children[3].type === 'dow_range') {
+                        const dow = RuleParser._parseDowRange(betweenNumberTime.children[3])
+                        if (dow.start === dow.end) {
+                            // Single day: ["TimePeriodBetweenAgo", totalSeconds, start, end, "MONDAY"]
+                            return ["TimePeriodBetweenAgo", totalSeconds, startValue, endValue, dow.start]
+                        } else {
+                            // Range: ["TimePeriodBetweenAgo", totalSeconds, start, end, "MONDAY", "FRIDAY"]
+                            return ["TimePeriodBetweenAgo", totalSeconds, startValue, endValue, dow.start, dow.end]
+                        }
+                    }
+                    
+                    return ["TimePeriodBetweenAgo", totalSeconds, startValue, endValue]
+                }
+            }
+            case 'between_tod_only': {
+                // between_tod_only has children[0] = between_tod node
+                const betweenTod = tp.children[0]
+                // between_tod has inline separator, so: children[0] = first tod_inner, children[1] = second tod_inner, children[2] = optional dow_range
+                let startTod = RuleParser.__parseValue(betweenTod.children[0])
+                let endTod = RuleParser.__parseValue(betweenTod.children[1])
+                
+                // Check if there's a dow_range at betweenTod.children[2]
+                if (betweenTod.children.length > 2) {
+                    if(typeof startTod === 'number') startTod = {seconds: startTod, dow: null}
+                    if(typeof endTod === 'number') endTod = {seconds: endTod, dow: null}
+                    RuleParser._addDowToTods(startTod, endTod, betweenTod.children[2])
+                }
+                
+                return ["TimePeriodBetween", startTod, endTod]
+            }
+            case 'between_time_only': {
+                // between_time_only has children[0] = between_number_time node
+                const betweenNumberTime = tp.children[0]
+                // between_number_time has: children[0] = first time_inner, children[1] = separator, children[2] = second time_inner, children[3] = optional dow_range
+                const startValue = RuleParser.__parseValue(betweenNumberTime.children[0])
+                const endValue = RuleParser.__parseValue(betweenNumberTime.children[2])
+                
+                // Check if there's a dow_range at betweenNumberTime.children[3]
+                // If DOW filters are provided, append them as additional parameters
+                if (betweenNumberTime.children.length > 3 && betweenNumberTime.children[3].type === 'dow_range') {
+                    const dow = RuleParser._parseDowRange(betweenNumberTime.children[3])
+                    if (dow.start === dow.end) {
+                        // Single day: ["TimePeriodBetween", start, end, "MONDAY"]
+                        return ["TimePeriodBetween", startValue, endValue, dow.start]
+                    } else {
+                        // Range: ["TimePeriodBetween", start, end, "MONDAY", "FRIDAY"]
+                        return ["TimePeriodBetween", startValue, endValue, dow.start, dow.end]
+                    }
+                }
+                
+                return ["TimePeriodBetween", startValue, endValue]
+            }
+        }
+    }
+    static __parseValue(child){
+        const type = child.type
+        switch(type){
+            case 'value': {
+                // Arrays have value nodes as children - unwrap to get value_atom
+                return RuleParser.__parseValue(child.children[0])
+            }
+            case 'value_atom': {
+                // New layer: unwrap value_atom to get the actual atomic type
+                return RuleParser.__parseValue(child.children[0])
+            }
+            case 'number_atom':
+            case 'number_time_atom':
+            case 'tod_atom':
+            case 'dow_atom':
+            case 'between_tod_inner':
+            case 'between_number_inner':
+            case 'between_number_time_inner':
+            case 'dow_range_inner': {
+                // New layer: unwrap atom wrappers to get the actual leaf nodes
+                return RuleParser.__parseValue(child.children[0])
+            }
+            case 'string': {
+                const str = child.text
+                return str.slice(1, -1)
+            }
+            case 'number':
+                return parseFloat(child.text)
+            case 'number_tod': {
+                const tokens = child.text.split(':')
+                if (tokens.length !== 2) {
+                    throw new Error(`Invalid time of day, ${child.text} should be ##:##`)
+                }
+                const hours = parseInt(tokens[0])
+                const minutes = parseInt(tokens[1])
+                const tod = hours * 100 + minutes
+                const ret = { hours, minutes, tod }
+                if (!isNaN(tod) && ret.hours >= 0 && ret.hours < 24 && ret.minutes >= 0 && ret.minutes < 60) {
+                    return ret
+                }
+                throw new Error(`Invalid time of day, ${child.text} -> [${tokens.join(', ')}] -> ${hours}h${minutes}m -> ${tod}`)
+            }
+            case 'number_time': {
+                const nt = child
+                const mult = parseFloat(nt.children[0].text)
+                switch(nt.children[1].text.toUpperCase()){
+                    case 'SECONDS':
+                    case 'SECOND':
+                        return mult
+                    case 'MINUTES':
+                    case 'MINUTE':
+                    case 'MINS':
+                    case 'MIN':
+                        return mult * 60
+                    case 'HOURS':
+                    case 'HOUR':
+                        return mult * 60 * 60
+                    case 'DAYS':
+                    case 'DAY':
+                        return mult * 60 * 60 * 24
+                    case 'WEEKS':
+                    case 'WEEK':
+                        return mult * 60 * 60 * 24 * 7
+                }
+                throw new Error(`Invalid exponent ${nt.children[1].text}`)
+            }
+            case 'true':
+                return true
+            case 'false':
+                return false
+            case 'array': {
+                const ret = []
+                for(const c of child.children){
+                    ret.push(RuleParser.__parseValue(c))
+                }
+                return ret;
+            }
+            case 'dow': {
+                return normalizeDow(child.text)
+            }
+            default:
+                throw new Error(`Unknown value type ${type}`)
+        }
+    }
+    static _parseValue(value){
+        const child = value.children[0]
+        
+        const type = child.type
+        switch(type){
+            case 'value_atom': {
+                // New layer: unwrap value_atom to get the actual atomic type
+                const atomChild = child.children[0]
+                if (atomChild.type === 'time_period') {
+                    const tp = atomChild.children[0]
+                    return RuleParser._parseTimePeriod(tp)
+                }
+                return ['Value', RuleParser.__parseValue(atomChild)]
+            }
+            case 'time_period': {
+                // Old structure (shouldn't happen with new EBNF)
+                const tp = child.children[0]
+                return RuleParser._parseTimePeriod(tp)
+            }
+            default:
+                return ['Value', RuleParser.__parseValue(child)]
+        }
+    }
+    static _parseSimpleResult(result){
+        assert(result.children.length == 1)
+        const child = result.children[0]
+        const type = child.type
+        switch(type){
+            case 'fcall':
+                return RuleParser._parseFcall(child)
+            case 'value':
+                return RuleParser._parseValue(child)
+        }
+        return null
+    }
+    static _parseArithmeticOperand(operand){
+        assert(operand.children.length == 1)
+        const child = operand.children[0]
+        const type = child.type
+        switch(type){
+            case 'fcall':
+                return RuleParser._parseFcall(child)
+            case 'number_atom':
+            case 'number_time_atom': {
+                // New layer: unwrap atom wrappers to get the actual leaf nodes
+                return ['Value', RuleParser.__parseValue(child.children[0])]
+            }
+            case 'number':
+                return ['Value', parseFloat(child.text)]
+            case 'number_time':
+                return ['Value', RuleParser.__parseValue(child)]
+        }
+        throw new Error(`Unknown arithmetic operand type ${type}`)
+    }
+    static _isConstantValue(expr){
+        // Check if an expression is a constant value (not just numbers, but any literal)
+        return Array.isArray(expr) && expr.length === 2 && expr[0] === 'Value'
+    }
+    
+    static _isConstantNumberValue(expr){
+        // Check if an expression is a constant numeric value
+        return Array.isArray(expr) && expr.length === 2 && expr[0] === 'Value' && typeof expr[1] === 'number'
+    }
+    
+    static _evaluateConstantArithmetic(operator, leftValue, rightValue){
+        // Evaluate constant arithmetic operations at parse time
+        switch(operator){
+            case 'MathAdd':
+                return leftValue + rightValue
+            case 'MathSub':
+                return leftValue - rightValue
+            case 'MathMul':
+                return leftValue * rightValue
+            case 'MathDiv':
+                return leftValue / rightValue
+            case 'MathMod':
+                return leftValue % rightValue
+            default:
+                return null
+        }
+    }
+    
+    static _parseArithmeticResult(result){
+        assert(result.children.length == 3)
+        const partA = RuleParser._parseArithmeticOperand(result.children[0])
+        const operatorFn = ArithmeticOperators[result.children[1].text]
+        const partB = RuleParser.__parseArithmeticResult(result, 2)
+
+        // Compile out constant expressions
+        if (RuleParser._isConstantNumberValue(partA) && RuleParser._isConstantNumberValue(partB)) {
+            const result = RuleParser._evaluateConstantArithmetic(operatorFn, partA[1], partB[1])
+            if (result !== null) {
+                return ['Value', result]
+            }
+        }
+
+        return [operatorFn, partA, partB]
+    }
+
+    static __parseArithmeticResult(result, idx){
+        const child = result.children[idx]
+        const type = child.type
+        switch(type){
+            case 'arithmetic_operand':
+                return RuleParser._parseArithmeticOperand(child)
+            case 'arithmetic_result':
+                return RuleParser._parseArithmeticResult(child)
+        }
+        
+        throw new Error(`Unknown arithmetic result node ${type}`)
+    }
+
+    static __parseResult(result, idx){
+        const child = result.children[idx]
+        const type = child.type
+        switch(type){
+            case 'simple_result':
+                return RuleParser._parseSimpleResult(child)
+            case 'arithmetic_result':
+                return RuleParser._parseArithmeticResult(child)
+        }
+        
+        throw new Error(`Unknown result node ${type}`)
+    }
+    static _parseResult(result){
+        assert(result.children.length == 1)
+
+        return RuleParser.__parseResult(result, 0)
+    }
+    static _parseStdExpression(expr){
+        assert(expr.type === 'standard_expression')
+        switch(expr.children.length){
+            case 1:
+                return RuleParser._parseResult(expr.children[0])
+            case 2: {
+                const rhs = expr.children[1]
+                switch(rhs.type){
+                    case 'between_tod': {
+                        // Direct between_tod (without wrapping between node)
+                        // between_tod has inline separator, so: children[0] = first tod_inner, children[1] = second tod_inner, children[2] = optional dow_range
+                        const startTod = RuleParser.__parseValue(rhs.children[0])
+                        const endTod = RuleParser.__parseValue(rhs.children[1])
+                        
+                        // Check if there's a dow_range (children[2])
+                        if (rhs.children.length > 2) {
+                            RuleParser._addDowToTods(startTod, endTod, rhs.children[2])
+                        }
+                        
+                        return ['Between', RuleParser._parseResult(expr.children[0]), ['Value', startTod], ['Value', endTod]]
+                    }
+                    case 'between': {
+                        // between wraps either between_number or between_tod
+                        const betweenChild = rhs.children[0]
+                        if (betweenChild.type === 'between_tod') {
+                            // between_tod has inline separator, so: children[0] = first tod_inner, children[1] = second tod_inner, children[2] = optional dow_range
+                            const startTod = RuleParser.__parseValue(betweenChild.children[0])
+                            const endTod = RuleParser.__parseValue(betweenChild.children[1])
+                            
+                            // Check if there's a dow_range (children[2])
+                            if (betweenChild.children.length > 2) {
+                                RuleParser._addDowToTods(startTod, endTod, betweenChild.children[2])
+                            }
+                            
+                            return ['Between', RuleParser._parseResult(expr.children[0]), ['Value', startTod], ['Value', endTod]]
+                        } else {
+                            // between_number has: children[0] = first number_inner, children[1] = separator, children[2] = second number_inner
+                            return ['Between', RuleParser._parseResult(expr.children[0]), ['Value', RuleParser.__parseValue(betweenChild.children[0])], ['Value', RuleParser.__parseValue(betweenChild.children[2])]]
+                        }
+                    }
+                    case 'between_number':
+                        // between_number has: children[0] = first number_inner, children[1] = separator, children[2] = second number_inner
+                        return ['Between', RuleParser._parseResult(expr.children[0]), ['Value', RuleParser.__parseValue(rhs.children[0].children[0])], ['Value', RuleParser.__parseValue(rhs.children[0].children[2])]]
+                    case 'basic_rhs':
+                        return [OperatorFn[rhs.children[0].text], RuleParser._parseResult(expr.children[0]), RuleParser._parseResult(rhs.children[1])]
+                    case 'eq_approx': {
+                        const rhsValue = RuleParser._parseResult(rhs.children[1])
+                        assert(rhsValue[0] === 'Value')
+                        const ret = ['Between', RuleParser._parseResult(expr.children[0]), ['Value', rhsValue[1] - Epsilon], ['Value', rhsValue[1] + Epsilon]]
+                        if(rhs.children[0].text === '!='){
+                            return ['Not', ret]
+                        }
+                        return ret
+                    }
+                    case 'in_expr': {
+                        // in_expr has children[0] = arguments node
+                        // ArrayIn now takes 2 parameters:
+                        // Parameter 1: haystack array (the array to be searched)
+                        // Parameter 2: the needle (the value to search for)
+                        const args = rhs.children[0]
+                        const haystack = []
+                        for(const a of args.children){
+                            haystack.push(RuleParser._parseArgument(a))
+                        }
+                        const needle = RuleParser._parseResult(expr.children[0])
+                        
+                        // Check if all haystack values are constants
+                        const allConstants = haystack.every(item => RuleParser._isConstantValue(item))
+                        
+                        let haystackExpr
+                        if (allConstants) {
+                            // All constants: use ["Value", [array of constants]]
+                            const constantArray = haystack.map(item => item[1])
+                            haystackExpr = ['Value', constantArray]
+                        } else {
+                            // Has non-constants: use ["Array", arg1, arg2, ...]
+                            haystackExpr = ['Array', ...haystack]
+                        }
+                        
+                        return ['ArrayIn', haystackExpr, needle]
+                    }
+
+                    default:
+                        throw new Error(`unable to parse std expression, unknown rhs type ${rhs.type}`)
+                }
+            }
+                
+            default:
+                throw new Error(`unable to parse std expression, unknown number of children ${expr.children.length}`)
+        }
+    }
+    static buildLogical(members, fn){
+        return [fn, ...members]
+    }
+    static _buildExpressionGroup(ast){
+        let ret = []
+        let currentLogical = null
+        for(const expr of ast.children){
+            if(expr.type == 'logical_operator') {
+                const logicalOperator = expr.text.trim()
+                const operatorFn = LogicalOperators[logicalOperator.toUpperCase()]
+                assert(operatorFn, `Unknown logical operator ${logicalOperator}`)
+                if(currentLogical === null || currentLogical !== operatorFn){
+                    if(ret.length > 1){
+                        ret = [RuleParser.buildLogical(ret, currentLogical)]
+                    }
+                    currentLogical = operatorFn
+                }
+            }else{
+                ret.push(RuleParser._exprToIL(expr))
+            }
+        }
+        if(ret.length == 0){
+            throw new Error('invalid rule')
+        }
+        if(ret.length == 1){
+            return ret[0]
+        }
+        return RuleParser.buildLogical(ret, currentLogical)
+    }
+    static _parseParenthesisExpression(expr){
+        return RuleParser._buildExpressionGroup(expr.children[0])
+    }
+    static _exprToIL(expr){
+        assert(expr.type === 'expression')
+        assert(expr.children.length === 1)
+        const eInner = expr.children[0]
+        switch(eInner.type){
+            case 'standard_expression':
+                return RuleParser._parseStdExpression(eInner)
+            case 'not_expression': {
+                const child = eInner.children[0]
+                let result
+                switch(child.type){
+                    case 'parenthesis_expression':
+                        result = RuleParser._parseParenthesisExpression(child)
+                        break;
+                    default:
+                        result = RuleParser._parseResult(child)
+                }
+                return ['Not', result]
+            }
+            case 'parenthesis_expression':
+            return RuleParser._parseParenthesisExpression(eInner)
+            default:
+                throw new Error(`unknown type of expression ${eInner.type}`)
+        }
+    }
+    static toIL(txt){
+        try {
+            const ast = RuleParser.toAst(txt)
+            if(!ast) throw new Error(`failed to parse ${txt}`)
+            return RuleParser._buildExpressionGroup(ast)
+        } catch (e) {
+            // If it's already a RuleParseError, just re-throw it
+            if (e.name === 'RuleParseError') {
+                throw e;
+            }
+            
+            // Check if it's a validation error we can map to a specific code
+            if (e.message && e.message.includes('Invalid time of day')) {
+                // Extract the invalid time from the error message
+                const match = e.message.match(/Invalid time of day[,:]?\s*([0-9:]+)/);
+                const badTod = match ? match[1] : 'invalid';
+                
+                // Calculate position (simplified - at end of input)
+                const lines = txt.trim().split('\n');
+                const position = {
+                    line: lines.length,
+                    column: lines[lines.length - 1].length + 1,
+                    offset: txt.trim().length
+                };
+                
+                throw new RuleParseError(
+                    "BAD_TOD",
+                    `Invalid time of day: ${badTod}`,
+                    "Time of day must be in HH:MM format with hours 0-23 and minutes 0-59, e.g. 08:30, 14:00, 23:59.",
+                    position,
+                    badTod,
+                    ["HH:MM"],
+                    txt.trim().substring(Math.max(0, txt.trim().length - 50))
+                );
+            }
+            
+            // Check if it's a day of week error
+            if (e.message && e.message.includes('Invalid day of week')) {
+                const match = e.message.match(/Invalid day of week[,:]?\s*(\w+)/);
+                const badDow = match ? match[1] : 'invalid';
+                
+                const lines = txt.trim().split('\n');
+                const position = {
+                    line: lines.length,
+                    column: lines[lines.length - 1].length + 1,
+                    offset: txt.trim().length
+                };
+                
+                throw new RuleParseError(
+                    "BAD_DOW",
+                    `Invalid day of week: ${badDow}`,
+                    "Valid days are: MONDAY/MON, TUESDAY/TUE, WEDNESDAY/WED, THURSDAY/THU, FRIDAY/FRI, SATURDAY/SAT, SUNDAY/SUN.",
+                    position,
+                    badDow,
+                    ["MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"],
+                    txt.trim().substring(Math.max(0, txt.trim().length - 50))
+                );
+            }
+            
+            // For other errors, re-throw
+            throw e;
+        }
+    }
+}
+module.exports = RuleParser
+module.exports.ParserRules = ParserRules
+module.exports.ParsingError = ParsingError
+module.exports.RuleParseError = RuleParseError
+
+},{"./RuleParser.production.ebnf.js":1,"./errors/ErrorAnalyzer":3,"./errors/RuleParseError":4,"assert":undefined,"ebnf":13,"ebnf/dist/Parser.js":9}],3:[function(require,module,exports){
+const { ParsingError } = require('ebnf');
+const RuleParseError = require('./RuleParseError');
+
+/**
+ * Analyzes parsing errors and maps them to user-friendly error codes
+ */
+class ErrorAnalyzer {
+  /**
+   * Analyze a ParsingError and return a user-friendly RuleParseError
+   * @param {string} input - The input string that failed to parse
+   * @param {ParsingError} parsingError - The ParsingError from the parser (optional)
+   * @returns {RuleParseError} - A user-friendly error with error code
+   */
+  static analyzeParseFailure(input, parsingError = null) {
+    const trimmedInput = input.trim();
+    
+    // Check for empty or missing expression first (fast path)
+    if (!trimmedInput) {
+      const position = { line: 1, column: 1, offset: 0 };
+      return new RuleParseError(
+        "MISSING_EXPRESSION",
+        "Empty or missing expression.",
+        "Provide a valid rule expression.",
+        position,
+        "empty input",
+        ["expression"],
+        ""
+      );
+    }
+    
+    // If we have a ParsingError, use its information
+    if (parsingError && parsingError instanceof ParsingError) {
+      return this._analyzeFromParsingError(input, parsingError);
+    }
+    
+    // Fallback to string-based analysis (for validation errors)
+    const lines = trimmedInput.split('\n');
+    const line = lines.length;
+    const lastLine = lines[lines.length - 1] || '';
+    const column = lastLine.length + 1;
+    const offset = trimmedInput.length;
+    
+    const position = { line, column, offset };
+    
+    // Get snippet (last 50 chars or the whole input if shorter)
+    const snippetStart = Math.max(0, trimmedInput.length - 50);
+    const snippet = (snippetStart > 0 ? '...' : '') + trimmedInput.substring(snippetStart);
+    
+    // Analyze the error pattern
+    const errorInfo = this._detectErrorPattern(trimmedInput, position, snippet);
+    
+    return new RuleParseError(
+      errorInfo.code,
+      errorInfo.message,
+      errorInfo.hint,
+      position,
+      errorInfo.found,
+      errorInfo.expected,
+      snippet
+    );
+  }
+
+  /**
+   * Analyze error using ParsingError exception data
+   * @private
+   */
+  static _analyzeFromParsingError(input, err) {
+    const position = err.position;
+    const expected = err.expected || [];
+    const found = err.found || '';
+    const failureTree = err.failureTree || [];
+    
+    // Get snippet around error position
+    const snippetStart = Math.max(0, position.offset - 20);
+    const snippetEnd = Math.min(input.length, position.offset + 30);
+    const snippet = (snippetStart > 0 ? '...' : '') + 
+                    input.substring(snippetStart, snippetEnd) +
+                    (snippetEnd < input.length ? '...' : '');
+    
+    // Analyze what was expected to determine error type using failureTree
+    const errorInfo = this._detectErrorFromFailureTree(input, position, expected, found, failureTree);
+    
+    return new RuleParseError(
+      errorInfo.code,
+      errorInfo.message,
+      errorInfo.hint,
+      position,
+      found,
+      expected,
+      snippet
+    );
+  }
+
+  /**
+   * Detect error type from failureTree
+   * @private
+   */
+  static _detectErrorFromFailureTree(input, position, expected, found, failureTree) {
+    const beforeError = input.substring(0, position.offset);
+    
+    // Helper to check if a name exists in the failure tree
+    const hasFailure = (name) => {
+      const search = (nodes) => {
+        if (!Array.isArray(nodes)) return false;
+        for (const node of nodes) {
+          if (node.name === name) return true;
+          if (node.children && search(node.children)) return true;
+        }
+        return false;
+      };
+      return search(failureTree);
+    };
+    
+    // Helper to check if a name exists at top level only
+    const hasTopLevelFailure = (name) => {
+      if (!Array.isArray(failureTree)) return false;
+      return failureTree.some(node => node.name === name);
+    };
+    
+    // PRIORITY 1: Check for unterminated string FIRST (before any balance checks)
+    // This must be checked early because unclosed strings can confuse other detections
+    if (this._hasUnterminatedString(input)) {
+      return {
+        code: "UNTERMINATED_STRING",
+        message: "Unterminated string literal.",
+        hint: "String literals must be enclosed in double quotes, e.g. \"hello world\".",
+      };
+    }
+    
+    // PRIORITY 2: Check for bad number format
+    const badNum = this._findBadNumber(input);
+    if (badNum) {
+      return {
+        code: "BAD_NUMBER",
+        message: `Invalid number format: ${badNum}`,
+        hint: "Numbers must be valid integers or decimals, e.g. 42, 3.14, -5, 1.5e10.",
+      };
+    }
+    
+    // PRIORITY 3: Check for token-level issues (extra characters after valid tokens)
+    // This must be checked before END_ARGUMENT/END_ARRAY to catch cases like WEDNESDAYY
+    const tokenError = this._detectExtraCharactersAfterToken(input, position, beforeError, found);
+    if (tokenError) {
+      return tokenError;
+    }
+    
+    // PRIORITY 4: Check for specific parser contexts (function calls, arrays)
+    // But first check if we have bracket/paren imbalance that's more specific
+    
+    // Check bracket balance first for extra brackets
+    const bracketBalance = this._checkBracketBalance(input);
+    if (bracketBalance < 0) {
+      // Extra closing bracket - this is more specific than function call context
+      return {
+        code: "UNMATCHED_BRACKET",
+        message: "Extra closing bracket detected.",
+        hint: "Every closing ']' must have a matching opening '['. Remove the extra closing bracket.",
+      };
+    }
+    
+    // Check paren balance for certain cases
+    const parenBalance = this._checkParenBalance(input);
+    if (parenBalance < 0) {
+      // Extra closing paren - this is more specific than function call context
+      return {
+        code: "UNMATCHED_PAREN",
+        message: "Extra closing parenthesis detected.",
+        hint: "Every closing ')' must have a matching opening '('. Remove the extra closing parenthesis.",
+      };
+    }
+    
+    // Check if parser was expecting END_ARGUMENT (closing paren for function)
+    // This indicates we're inside a function call context
+    if (hasFailure('END_ARGUMENT')) {
+      return {
+        code: "BAD_FUNCTION_CALL",
+        message: "Invalid function call syntax.",
+        hint: "Function calls must have matching parentheses, e.g. func() or func(arg1, arg2).",
+      };
+    }
+    
+    // Check if parser was expecting END_ARRAY (closing bracket)
+    // This indicates we're inside an array context
+    if (hasFailure('END_ARRAY')) {
+      return {
+        code: "BAD_ARRAY_SYNTAX",
+        message: "Invalid array syntax.",
+        hint: "Arrays must be enclosed in brackets with comma-separated values, e.g. [1, 2, 3].",
+      };
+    }
+    
+    // PRIORITY 5: Check for dangling operators
+    
+    // Check for dangling logical operator (check input pattern directly)
+    if (found === "end of input") {
+      const trimmed = input.trim();
+      if (/&&\s*$/.test(trimmed)) {
+        return {
+          code: "DANGLING_LOGICAL_OPERATOR",
+          message: "Logical operator '&&' at end of expression.",
+          hint: "Logical operators (&&, ||, AND, OR) must be followed by an expression.",
+        };
+      }
+      if (/\|\|\s*$/.test(trimmed)) {
+        return {
+          code: "DANGLING_LOGICAL_OPERATOR",
+          message: "Logical operator '||' at end of expression.",
+          hint: "Logical operators (&&, ||, AND, OR) must be followed by an expression.",
+        };
+      }
+      if (/\bAND\b\s*$/i.test(trimmed)) {
+        return {
+          code: "DANGLING_LOGICAL_OPERATOR",
+          message: "Logical operator 'AND' at end of expression.",
+          hint: "Logical operators (&&, ||, AND, OR) must be followed by an expression.",
+        };
+      }
+      if (/\bOR\b\s*$/i.test(trimmed)) {
+        return {
+          code: "DANGLING_LOGICAL_OPERATOR",
+          message: "Logical operator 'OR' at end of expression.",
+          hint: "Logical operators (&&, ||, AND, OR) must be followed by an expression.",
+        };
+      }
+    }
+    
+    // Check for BETWEEN - if we see BETWEEN in input with incomplete syntax
+    if (/\bBETWEEN\b/i.test(input)) {
+      // Check if BETWEEN is incomplete or missing AND
+      if (found === "end of input" || /\bBETWEEN\s+\d+\s*$/i.test(beforeError.trim())) {
+        return {
+          code: "BAD_BETWEEN_SYNTAX",
+          message: "Invalid BETWEEN syntax.",
+          hint: "BETWEEN requires two values: 'expr BETWEEN value1 AND value2' or 'expr BETWEEN value1-value2'.",
+        };
+      }
+    }
+    
+    // Check if parser expected BEGIN_ARGUMENT - could be missing RHS after operator
+    if (hasTopLevelFailure('BEGIN_ARGUMENT')) {
+      const trimmed = beforeError.trim();
+      // If found is a comparison operator, this is likely missing RHS
+      if (found.match(/^[><=!]/)) {
+        return {
+          code: "MISSING_RHS_AFTER_OPERATOR",
+          message: `Expected a value after '${found}'.`,
+          hint: "Comparison operators must be followed by a value, e.g. temp > 25, name == \"bob\".",
+        };
+      }
+      
+      // Also check if beforeError ends with comparison operator
+      const compOps = ['>=', '<=', '==', '!=', '>', '<', '=', '==~', '!=~'];
+      for (const op of compOps) {
+        if (trimmed.endsWith(op)) {
+          return {
+            code: "MISSING_RHS_AFTER_OPERATOR",
+            message: `Expected a value after '${op}'.`,
+            hint: "Comparison operators must be followed by a value, e.g. temp > 25, name == \"bob\".",
+          };
+        }
+      }
+    }
+    
+    // Check for value/result expected (could be missing RHS)
+    if ((hasFailure('value') || hasFailure('result') || hasFailure('simple_result')) && found === "end of input") {
+      // Check for comparison operator
+      const trimmed = beforeError.trim();
+      const compOps = ['>=', '<=', '==', '!=', '>', '<', '=', '==~', '!=~'];
+      
+      for (const op of compOps) {
+        if (trimmed.endsWith(op)) {
+          return {
+            code: "MISSING_RHS_AFTER_OPERATOR",
+            message: `Expected a value after '${op}'.`,
+            hint: "Comparison operators must be followed by a value, e.g. temp > 25, name == \"bob\".",
+          };
+        }
+      }
+    }
+    
+    // PRIORITY 6: Final fallback - general balance checks for unclosed parens/brackets
+    // (Note: extra closing parens/brackets were already checked in PRIORITY 4)
+    
+    // Check for unclosed parentheses (only if not already handled)
+    if (parenBalance > 0 && found === "end of input") {
+      // Check if this looks like a function call context
+      const looksLikeFunction = /[a-zA-Z_][a-zA-Z0-9_]*\s*\([^)]*$/.test(input);
+      const message = looksLikeFunction 
+        ? "Unclosed parenthesis in function call."
+        : "Unclosed parenthesis detected.";
+      
+      return {
+        code: "UNMATCHED_PAREN",
+        message: message,
+        hint: "Every opening '(' must have a matching closing ')'. Check your expression for missing closing parentheses.",
+      };
+    }
+    
+    // Check for unclosed brackets (only if not already handled)
+    if (bracketBalance > 0 && found === "end of input") {
+      // Check if this looks like an array context
+      const looksLikeArray = /\[[^\]]*$/.test(input);
+      const message = looksLikeArray
+        ? "Unclosed bracket in array."
+        : "Unclosed bracket detected.";
+      
+      return {
+        code: "UNMATCHED_BRACKET",
+        message: message,
+        hint: "Every opening '[' must have a matching closing ']'. Check your array syntax.",
+      };
+    }
+    
+    // Default to unexpected token
+    const foundDesc = found === "end of input" ? "end of input" : `'${found}'`;
+    return {
+      code: "UNEXPECTED_TOKEN",
+      message: `Unexpected ${foundDesc} at position ${position.offset}.`,
+      hint: "Check your syntax. Common issues include missing operators, invalid characters, or malformed expressions.",
+    };
+  }
+  
+  /**
+   * Detect extra characters after a valid token (e.g., WEDNESDAYY has extra Y after WEDNESDAY)
+   * @private
+   */
+  static _detectExtraCharactersAfterToken(input, position, beforeError, found) {
+    // First, check for invalid day of week patterns
+    // Pattern: "ON" followed by partial day name
+    const onMatch = /\bON\s+(\w+)$/i.exec(beforeError);
+    if (onMatch) {
+      const partial = onMatch[1].toUpperCase();
+      // Check if this looks like a partial day name or invalid day
+      // Note: THUR is not included because it's not actually supported by the parser
+      const validDays = ['MONDAY', 'MON', 'TUESDAY', 'TUE', 'WEDNESDAY', 'WED', 
+                        'THURSDAY', 'THU', 'FRIDAY', 'FRI', 'SATURDAY', 
+                        'SAT', 'SUNDAY', 'SUN'];
+      
+      if (!validDays.includes(partial)) {
+        // This might be part of an invalid day name
+        // Combine with found to get the full attempted day name if found is alphabetic
+        const fullAttempt = partial + (found && found !== "end of input" && found.match(/^[A-Z]/i) ? found : "");
+        
+        // Check if it looks like a misspelled day
+        const possibleMisspelling = validDays.some(day => {
+          // Check for similarity (starts with same letter, length close)
+          return day.startsWith(partial.charAt(0)) && 
+                 Math.abs(day.length - fullAttempt.length) <= 3;
+        });
+        
+        if (possibleMisspelling || fullAttempt.length >= 3) {
+          return {
+            code: "BAD_DOW",
+            message: `Invalid day of week: ${fullAttempt}`,
+            hint: "Valid days are: MONDAY/MON, TUESDAY/TUE, WEDNESDAY/WED, THURSDAY/THU, FRIDAY/FRI, SATURDAY/SAT, SUNDAY/SUN.",
+          };
+        }
+      }
+    }
+    
+    // Check for time of day patterns right before error
+    const todMatch = /(\d{1,2}):(-?\d{1,2})?$/.exec(beforeError);
+    if (todMatch || (beforeError.match(/\d+:$/) && found && found.match(/^-?\d+/))) {
+      // Looks like we're in a time of day context
+      // Extract the full time attempt
+      let fullTime = todMatch ? todMatch[0] : '';
+      if (!todMatch && beforeError.match(/\d+:$/)) {
+        // We have a number: before and digits after
+        const num = beforeError.match(/\d+:$/)[0];
+        const minutes = found.match(/^-?\d+/)[0];
+        fullTime = num + minutes;
+      }
+      
+      // Check if it's a bad time
+      const timePattern = /(\d{1,2}):(-?\d{1,2})/;
+      const timeMatch = timePattern.exec(fullTime);
+      if (timeMatch) {
+        const hours = parseInt(timeMatch[1], 10);
+        const minutes = parseInt(timeMatch[2], 10);
+        if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
+          return {
+            code: "BAD_TOD",
+            message: `Invalid time of day: ${timeMatch[0]}`,
+            hint: "Time of day must be in HH:MM format with hours 0-23 and minutes 0-59, e.g. 08:30, 14:00, 23:59.",
+          };
+        }
+      }
+    }
+    
+    // List of known valid tokens (keywords, days of week, etc.)
+    const validTokens = [
+      // Days of week
+      'MONDAY', 'MON', 'TUESDAY', 'TUE', 'WEDNESDAY', 'WED', 
+      'THURSDAY', 'THU', 'THUR', 'FRIDAY', 'FRI', 'SATURDAY', 
+      'SAT', 'SUNDAY', 'SUN',
+      // Keywords
+      'BETWEEN', 'AND', 'OR', 'NOT', 'IN', 'ON'
+    ];
+    
+    // Check if any valid token appears right before the error position
+    for (const token of validTokens) {
+      if (beforeError.toUpperCase().endsWith(token)) {
+        // Found a valid token right before error - check if we have extra characters
+        if (found && found.length > 0 && found !== "end of input" && found.match(/^[A-Z]/i)) {
+          // We have alphabetic characters after a valid token
+          const extraChars = found.charAt(0);
+          return {
+            code: "UNEXPECTED_TOKEN",
+            message: `Unexpected characters after '${token}'. Remove the extra '${extraChars}'.`,
+            hint: `'${token}' is a valid keyword. Remove any extra characters that follow it.`,
+          };
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Detect the error pattern in the input (fallback for non-ParsingError cases)
+   * @private
+   * @param {string} input - The input to analyze
+   * @param {Object} position - Position information
+   * @param {string} snippet - Code snippet
+   * @returns {Object} Error information
+   */
+  static _detectErrorPattern(input, position, snippet) {
+    // Check for unterminated string first (this affects other checks)
+    if (this._hasUnterminatedString(input)) {
+      return {
+        code: "UNTERMINATED_STRING",
+        message: "Unterminated string literal.",
+        hint: "String literals must be enclosed in double quotes, e.g. \"hello world\".",
+        found: "end of input",
+        expected: ["\""]
+      };
+    }
+
+    // Check for dangling logical operators
+    const danglingOp = this._findDanglingLogicalOperator(input);
+    if (danglingOp) {
+      return {
+        code: "DANGLING_LOGICAL_OPERATOR",
+        message: `Logical operator '${danglingOp}' at end of expression.`,
+        hint: "Logical operators (&&, ||, AND, OR) must be followed by an expression.",
+        found: danglingOp,
+        expected: ["expression", "function call", "value"]
+      };
+    }
+
+    // Check for missing RHS after comparison operator
+    const danglingCompOp = this._findDanglingComparisonOperator(input);
+    if (danglingCompOp) {
+      return {
+        code: "MISSING_RHS_AFTER_OPERATOR",
+        message: `Expected a value after '${danglingCompOp}'.`,
+        hint: "Comparison operators must be followed by a value, e.g. temp > 25, name == \"bob\".",
+        found: "end of input",
+        expected: ["value", "function call", "number", "string"]
+      };
+    }
+
+    // Check for bad BETWEEN syntax
+    if (this._hasBadBetweenSyntax(input)) {
+      return {
+        code: "BAD_BETWEEN_SYNTAX",
+        message: "Invalid BETWEEN syntax.",
+        hint: "BETWEEN requires two values: 'expr BETWEEN value1 AND value2' or 'expr BETWEEN value1-value2'.",
+        found: "incomplete BETWEEN expression",
+        expected: ["BETWEEN value1 AND value2"]
+      };
+    }
+
+    // Check for bad time of day (TOD) format
+    const badTod = this._findBadTimeOfDay(input);
+    if (badTod) {
+      return {
+        code: "BAD_TOD",
+        message: `Invalid time of day: ${badTod.value}`,
+        hint: "Time of day must be in HH:MM format with hours 0-23 and minutes 0-59, e.g. 08:30, 14:00, 23:59.",
+        found: badTod.value,
+        expected: ["HH:MM"]
+      };
+    }
+
+    // Check for bad day of week (DOW)
+    const badDow = this._findBadDayOfWeek(input);
+    if (badDow) {
+      return {
+        code: "BAD_DOW",
+        message: `Invalid day of week: ${badDow}`,
+        hint: "Valid days are: MONDAY/MON, TUESDAY/TUE, WEDNESDAY/WED, THURSDAY/THU, FRIDAY/FRI, SATURDAY/SAT, SUNDAY/SUN.",
+        found: badDow,
+        expected: ["MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"]
+      };
+    }
+
+    // Check for bad number format
+    const badNumber = this._findBadNumber(input);
+    if (badNumber) {
+      return {
+        code: "BAD_NUMBER",
+        message: `Invalid number format: ${badNumber}`,
+        hint: "Numbers must be valid integers or decimals, e.g. 42, 3.14, -5, 1.5e10.",
+        found: badNumber,
+        expected: ["valid number"]
+      };
+    }
+
+    // Check for bad function call syntax (more specific than general paren check)
+    if (this._hasBadFunctionCall(input)) {
+      return {
+        code: "BAD_FUNCTION_CALL",
+        message: "Invalid function call syntax.",
+        hint: "Function calls must have matching parentheses, e.g. func() or func(arg1, arg2).",
+        found: "incomplete function call",
+        expected: [")"]
+      };
+    }
+
+    // Check for bad array syntax (more specific than general bracket check)
+    if (this._hasBadArraySyntax(input)) {
+      return {
+        code: "BAD_ARRAY_SYNTAX",
+        message: "Invalid array syntax.",
+        hint: "Arrays must be enclosed in brackets with comma-separated values, e.g. [1, 2, 3].",
+        found: "incomplete array",
+        expected: ["]", ","]
+      };
+    }
+
+    // Check for unmatched parentheses (general check)
+    const parenBalance = this._checkParenBalance(input);
+    if (parenBalance > 0) {
+      return {
+        code: "UNMATCHED_PAREN",
+        message: "Unclosed parenthesis detected.",
+        hint: "Every opening '(' must have a matching closing ')'. Check your expression for missing closing parentheses.",
+        found: "end of input",
+        expected: [")"]
+      };
+    } else if (parenBalance < 0) {
+      const closeIndex = this._findExtraCloseParen(input);
+      return {
+        code: "UNMATCHED_PAREN",
+        message: "Extra closing parenthesis detected.",
+        hint: "Every closing ')' must have a matching opening '('. Remove the extra closing parenthesis.",
+        found: ")",
+        expected: ["expression", "operator"]
+      };
+    }
+
+    // Check for unmatched brackets (general check)
+    const bracketBalance = this._checkBracketBalance(input);
+    if (bracketBalance > 0) {
+      return {
+        code: "UNMATCHED_BRACKET",
+        message: "Unclosed bracket detected.",
+        hint: "Every opening '[' must have a matching closing ']'. Check your array syntax.",
+        found: "end of input",
+        expected: ["]"]
+      };
+    } else if (bracketBalance < 0) {
+      return {
+        code: "UNMATCHED_BRACKET",
+        message: "Extra closing bracket detected.",
+        hint: "Every closing ']' must have a matching opening '['. Remove the extra closing bracket.",
+        found: "]",
+        expected: ["expression", "operator"]
+      };
+    }
+
+    // Check for multiple expressions without logical operators
+    if (this._hasMultipleExpressionsWithoutOperator(input)) {
+      return {
+        code: "UNEXPECTED_TOKEN",
+        message: "Multiple expressions without logical operator.",
+        hint: "Use logical operators (&&, ||, AND, OR) to combine multiple expressions.",
+        found: "expression",
+        expected: ["&&", "||", "AND", "OR"]
+      };
+    }
+
+    // Default to unexpected token
+    const found = this._getLastToken(input) || "unknown token";
+    return {
+      code: "UNEXPECTED_TOKEN",
+      message: `Unexpected token: ${found}`,
+      hint: "Check your syntax. Common issues include missing operators, invalid characters, or malformed expressions.",
+      found: found,
+      expected: ["valid expression"]
+    };
+  }
+
+  /**
+   * Check if string is properly terminated
+   * @private
+   * @param {string} input - Input to check
+   * @returns {boolean} True if string is unterminated
+   */
+  static _hasUnterminatedString(input) {
+    let inString = false;
+    let i = 0;
+    while (i < input.length) {
+      const char = input[i];
+      
+      if (char === '"') {
+        if (!inString) {
+          inString = true;
+        } else {
+          // Check if this quote is escaped by counting preceding backslashes
+          let backslashCount = 0;
+          let j = i - 1;
+          while (j >= 0 && input[j] === '\\') {
+            backslashCount++;
+            j--;
+          }
+          // If even number of backslashes (including 0), the quote is not escaped
+          if (backslashCount % 2 === 0) {
+            inString = false;
+          }
+        }
+      }
+      i++;
+    }
+    return inString;
+  }
+
+  /**
+   * Check parenthesis balance
+   * @private
+   * @param {string} input - Input to check
+   * @returns {number} Balance (positive = unclosed, negative = extra closing)
+   */
+  static _checkParenBalance(input) {
+    let balance = 0;
+    let inString = false;
+    let i = 0;
+    while (i < input.length) {
+      const char = input[i];
+      
+      if (char === '"') {
+        if (!inString) {
+          inString = true;
+        } else {
+          // Check if this quote is escaped
+          let backslashCount = 0;
+          let j = i - 1;
+          while (j >= 0 && input[j] === '\\') {
+            backslashCount++;
+            j--;
+          }
+          if (backslashCount % 2 === 0) {
+            inString = false;
+          }
+        }
+      }
+      
+      // Only count parentheses outside of strings
+      if (!inString) {
+        if (char === '(') balance++;
+        else if (char === ')') balance--;
+      }
+      i++;
+    }
+    return balance;
+  }
+
+  /**
+   * Find position of extra closing paren
+   * @private
+   */
+  static _findExtraCloseParen(input) {
+    let balance = 0;
+    let inString = false;
+    let i = 0;
+    while (i < input.length) {
+      const char = input[i];
+      
+      if (char === '"') {
+        if (!inString) {
+          inString = true;
+        } else {
+          // Check if this quote is escaped
+          let backslashCount = 0;
+          let j = i - 1;
+          while (j >= 0 && input[j] === '\\') {
+            backslashCount++;
+            j--;
+          }
+          if (backslashCount % 2 === 0) {
+            inString = false;
+          }
+        }
+      }
+      
+      if (!inString) {
+        if (char === '(') balance++;
+        else if (char === ')') {
+          balance--;
+          if (balance < 0) return i;
+        }
+      }
+      i++;
+    }
+    return -1;
+  }
+
+  /**
+   * Check bracket balance
+   * @private
+   * @param {string} input - Input to check
+   * @returns {number} Balance (positive = unclosed, negative = extra closing)
+   */
+  static _checkBracketBalance(input) {
+    let balance = 0;
+    let inString = false;
+    let i = 0;
+    while (i < input.length) {
+      const char = input[i];
+      
+      if (char === '"') {
+        if (!inString) {
+          inString = true;
+        } else {
+          // Check if this quote is escaped
+          let backslashCount = 0;
+          let j = i - 1;
+          while (j >= 0 && input[j] === '\\') {
+            backslashCount++;
+            j--;
+          }
+          if (backslashCount % 2 === 0) {
+            inString = false;
+          }
+        }
+      }
+      
+      if (!inString) {
+        if (char === '[') balance++;
+        else if (char === ']') balance--;
+      }
+      i++;
+    }
+    return balance;
+  }
+
+  static _findDanglingLogicalOperator(input) {
+    const trimmed = input.trim();
+    const logicalOps = [
+      { pattern: /&&\s*$/, op: '&&' },
+      { pattern: /\|\|\s*$/, op: '||' },
+      { pattern: /\bAND\b\s*$/i, op: 'AND' },
+      { pattern: /\bOR\b\s*$/i, op: 'OR' }
+    ];
+    
+    for (const { pattern, op } of logicalOps) {
+      if (pattern.test(trimmed)) {
+        return op;
+      }
+    }
+    return null;
+  }
+
+  static _findDanglingComparisonOperator(input) {
+    const trimmed = input.trim();
+    const compOps = ['>=', '<=', '==', '!=', '>', '<', '=', '==~', '!=~'];
+    
+    for (const op of compOps) {
+      const pattern = new RegExp(`${this._escapeRegex(op)}\\s*$`);
+      if (pattern.test(trimmed)) {
+        return op;
+      }
+    }
+    return null;
+  }
+
+  static _hasBadBetweenSyntax(input) {
+    // Check if BETWEEN keyword exists but not followed by proper syntax
+    if (/\bBETWEEN\b/i.test(input)) {
+      // Check for valid BETWEEN patterns
+      const hasValidBetweenAnd = /\bBETWEEN\s+\S+\s+AND\s+\S+/i.test(input);
+      const hasValidBetweenDash = /\bBETWEEN\s+\S+-\s*\S+/i.test(input);
+      return !hasValidBetweenAnd && !hasValidBetweenDash;
+    }
+    return false;
+  }
+
+  static _hasBadFunctionCall(input) {
+    // Only return true if:
+    // 1. We have a function pattern (identifier followed by open paren)
+    // 2. The parentheses are unbalanced
+    // 3. There are NO array brackets (so we don't confuse arrays with function calls)
+    // 4. The imbalance is specifically in a function call context
+    
+    const funcPattern = /[a-zA-Z0-9]+\s*\(/;
+    const hasArrayBracket = /\[/.test(input);
+    
+    if (!funcPattern.test(input) || hasArrayBracket) {
+      return false;
+    }
+    
+    const parenBalance = this._checkParenBalance(input);
+    if (parenBalance > 0) {
+      // We have unclosed parens in what looks like a function call
+      // Make sure it's not just a general parenthesis expression
+      // by checking if the first occurrence of ( is preceded by an identifier
+      const firstParenMatch = input.match(/^[^(]*([a-zA-Z0-9]+)\s*\(/);
+      if (firstParenMatch) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+
+  static _hasBadArraySyntax(input) {
+    // Only return true if:
+    // 1. We have an array bracket [
+    // 2. The brackets are unbalanced
+    // 3. It's clearly in an array context (inside function args or standalone)
+    
+    if (!/\[/.test(input)) {
+      return false;
+    }
+    
+    const bracketBalance = this._checkBracketBalance(input);
+    if (bracketBalance > 0) {
+      // We have unclosed brackets - this is likely an array issue
+      return true;
+    }
+    
+    return false;
+  }
+
+  static _hasMultipleExpressionsWithoutOperator(input) {
+    // Detect patterns like "A() B()" without && or || between them
+    // Check if there's no logical operator between function calls
+    const betweenPattern = /\)\s+(?!&&|\|\||AND|OR|BETWEEN)/i;
+    if (betweenPattern.test(input)) {
+      // Make sure the next thing after ) is an identifier (suggesting another expression)
+      return /\)\s+[a-zA-Z]/.test(input);
+    }
+    return false;
+  }
+
+  static _getLastToken(input) {
+    const trimmed = input.trim();
+    // Get last 20 characters or the whole string if shorter
+    const lastPart = trimmed.substring(Math.max(0, trimmed.length - 20));
+    return lastPart;
+  }
+
+  /**
+   * Check for invalid time of day format (e.g., 25:00, 12:60)
+   * @private
+   */
+  static _findBadTimeOfDay(input) {
+    // Look for patterns like HH:MM where hours or minutes are out of range or negative
+    const todPattern = /\b(-?\d{1,2}):(-?\d{1,2})\b/g;
+    let match;
+    
+    while ((match = todPattern.exec(input)) !== null) {
+      const hours = parseInt(match[1], 10);
+      const minutes = parseInt(match[2], 10);
+      const fullMatch = match[0];
+      
+      // Check if hours or minutes are out of valid range or negative
+      if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
+        return { value: fullMatch, hours, minutes };
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Check for invalid day of week
+   * @private
+   */
+  static _findBadDayOfWeek(input) {
+    // Look for ON keyword followed by potential day name
+    const onPattern = /\bON\s+([A-Z]+)/i;
+    const match = onPattern.exec(input);
+    
+    if (match) {
+      const dayCandidate = match[1].toUpperCase();
+      const validDays = ['MONDAY', 'MON', 'TUESDAY', 'TUE', 'WEDNESDAY', 'WED', 
+                         'THURSDAY', 'THU', 'THUR', 'FRIDAY', 'FRI', 'SATURDAY', 
+                         'SAT', 'SUNDAY', 'SUN'];
+      
+      if (!validDays.includes(dayCandidate)) {
+        return dayCandidate;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Check for invalid number format (e.g., 1.2.3, 123abc)
+   * @private
+   */
+  static _findBadNumber(input) {
+    // Look for malformed numbers - multiple decimal points or numbers followed by letters
+    const badNumberPatterns = [
+      /\b\d+\.\d+\.\d+/,  // Multiple decimal points like 1.2.3
+      /\b\d+[a-zA-Z]+\d*/,  // Numbers with letters mixed in like 123abc
+      /\b\d+\.\d+[a-zA-Z]+/  // Decimals with letters like 1.5abc
+    ];
+    
+    for (const pattern of badNumberPatterns) {
+      const match = pattern.exec(input);
+      if (match) {
+        return match[0];
+      }
+    }
+    return null;
+  }
+
+  static _escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+}
+
+module.exports = { ErrorAnalyzer };
+
+},{"./RuleParseError":4,"ebnf":13}],4:[function(require,module,exports){
+/**
+ * Represents a user-friendly rule parsing error with error codes
+ */
+class RuleParseError extends Error {
+  /**
+   * Create a RuleParseError
+   * @param {string} code - Error code for programmatic handling
+   * @param {string} message - Human-readable error message
+   * @param {string} hint - Helpful suggestion for fixing the error
+   * @param {Object} position - Position information with line, column, and offset
+   * @param {string} found - What was found at error position
+   * @param {Array<string>} expected - What was expected
+   * @param {string} snippet - Code snippet showing error location
+   */
+  constructor(code, message, hint, position, found, expected, snippet) {
+    super(message);
+    this.name = 'RuleParseError';
+    this.code = code;
+    this.hint = hint;
+    this.line = position.line;
+    this.column = position.column;
+    this.offset = position.offset;
+    this.found = found;
+    this.expected = expected;
+    this.snippet = snippet;
+    
+    // Maintain proper prototype chain for instanceof checks
+    Object.setPrototypeOf(this, RuleParseError.prototype);
+  }
+
+  toString() {
+    let msg = `${this.name} [${this.code}]: ${this.message}\n`;
+    msg += `  at line ${this.line}, column ${this.column} (offset ${this.offset})\n`;
+    if (this.snippet) {
+      msg += `  ${this.snippet}\n`;
+    }
+    if (this.hint) {
+      msg += `  Hint: ${this.hint}\n`;
+    }
+    if (this.found) {
+      msg += `  Found: ${this.found}\n`;
+    }
+    if (this.expected && this.expected.length) {
+      msg += `  Expected: ${this.expected.join(', ')}`;
+    }
+    return msg;
+  }
+
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      hint: this.hint,
+      line: this.line,
+      column: this.column,
+      offset: this.offset,
+      found: this.found,
+      expected: this.expected,
+      snippet: this.snippet
+    };
+  }
+}
+
+module.exports = RuleParseError;
+
+},{}],5:[function(require,module,exports){
 "use strict";
 // https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_Form
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -365,7 +1934,7 @@ var BNF;
 })(BNF || (BNF = {}));
 exports.default = BNF;
 
-},{"../Parser":6,"../SemanticHelpers":8}],3:[function(require,module,exports){
+},{"../Parser":9,"../SemanticHelpers":11}],6:[function(require,module,exports){
 "use strict";
 // https://www.w3.org/TR/REC-xml/#NT-Name
 // http://www.bottlecaps.de/rr/ui
@@ -820,7 +2389,7 @@ var BNF;
 })(BNF || (BNF = {}));
 exports.default = BNF;
 
-},{"../Parser":6,"../TokenError":9}],4:[function(require,module,exports){
+},{"../Parser":9,"../TokenError":12}],7:[function(require,module,exports){
 "use strict";
 // https://www.w3.org/TR/REC-xml/#NT-Name
 // http://www.bottlecaps.de/rr/ui
@@ -1201,7 +2770,7 @@ var BNF;
 })(BNF || (BNF = {}));
 exports.default = BNF;
 
-},{"../Parser":6}],5:[function(require,module,exports){
+},{"../Parser":9}],8:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Custom = exports.W3C = exports.BNF = void 0;
@@ -1212,7 +2781,7 @@ Object.defineProperty(exports, "W3C", { enumerable: true, get: function () { ret
 var Custom_1 = require("./Custom");
 Object.defineProperty(exports, "Custom", { enumerable: true, get: function () { return Custom_1.default; } });
 
-},{"./BNF":2,"./Custom":3,"./W3CEBNF":4}],6:[function(require,module,exports){
+},{"./BNF":5,"./Custom":6,"./W3CEBNF":7}],9:[function(require,module,exports){
 "use strict";
 // https://www.ics.uci.edu/~pattis/ICS-33/lectures/ebnf.pdf
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -1964,7 +3533,7 @@ class Parser {
 exports.Parser = Parser;
 exports.default = Parser;
 
-},{"./ParsingError":7,"./TokenError":9}],7:[function(require,module,exports){
+},{"./ParsingError":10,"./TokenError":12}],10:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParsingError = void 0;
@@ -1990,7 +3559,7 @@ class ParsingError extends Error {
 }
 exports.ParsingError = ParsingError;
 
-},{}],8:[function(require,module,exports){
+},{}],11:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findChildrenByType = findChildrenByType;
@@ -2001,7 +3570,7 @@ function findChildrenByType(token, type) {
     return token.children ? token.children.filter(x => x.type == type) : [];
 }
 
-},{}],9:[function(require,module,exports){
+},{}],12:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenError = void 0;
@@ -2021,7 +3590,7 @@ class TokenError extends Error {
 }
 exports.TokenError = TokenError;
 
-},{}],10:[function(require,module,exports){
+},{}],13:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParsingError = exports.TokenError = exports.Parser = void 0;
@@ -2033,17 +3602,17 @@ var ParsingError_1 = require("./ParsingError");
 Object.defineProperty(exports, "ParsingError", { enumerable: true, get: function () { return ParsingError_1.ParsingError; } });
 exports.Grammars = require("./Grammars");
 
-},{"./Grammars":5,"./Parser":6,"./ParsingError":7,"./TokenError":9}],11:[function(require,module,exports){
+},{"./Grammars":8,"./Parser":9,"./ParsingError":10,"./TokenError":12}],14:[function(require,module,exports){
 module.exports=[{"name":"TEMPLATE_BEGIN","bnf":[["\"${\""]]},{"name":"TEMPLATE_END","bnf":[["\"}\""]]},{"name":"PIPE","bnf":[["\"|\""]]},{"name":"%IDENT[2]","bnf":[[/[A-Za-z0-9_]/]]},{"name":"IDENT","bnf":[[/[A-Za-z_]/,"%IDENT[2]*"]]},{"name":"DOT","bnf":[["\".\""]]},{"name":"template_value","bnf":[["TEMPLATE_BEGIN","WS*","template_expr","WS*","TEMPLATE_END"]]},{"name":"%template_expr[2]","bnf":[["WS*","template_pipe","WS*","template_filter_call"]],"fragment":true},{"name":"template_expr","bnf":[["template_path","%template_expr[2]*"]]},{"name":"template_pipe","bnf":[["PIPE"]]},{"name":"%template_path[2]","bnf":[["WS*","DOT","WS*","IDENT"]],"fragment":true},{"name":"template_path","bnf":[["IDENT","%template_path[2]*"]]},{"name":"%template_filter_call[2]","bnf":[["WS*","BEGIN_ARGUMENT","WS*","template_filter_args?","WS*","END_ARGUMENT"]],"fragment":true},{"name":"template_filter_call","bnf":[["template_filter_name","%template_filter_call[2]?"]]},{"name":"template_filter_name","bnf":[["IDENT"]]},{"name":"%template_filter_args[2]","bnf":[["WS*","\",\"","WS*","template_filter_arg"]],"fragment":true},{"name":"template_filter_args","bnf":[["template_filter_arg","%template_filter_args[2]*"]]},{"name":"template_filter_arg","bnf":[["value"],["template_value"]]},{"name":"number_atom","bnf":[["number"],["template_value"]]},{"name":"number_time_atom","bnf":[["number_time"],["template_value","WS+","unit"],["template_value"]]},{"name":"tod_atom","bnf":[["number_tod"],["template_value"]]},{"name":"dow_atom","bnf":[["dow"],["template_value"]]},{"name":"between_time_only_atom","bnf":[["between_time_only"],["template_value"]]},{"name":"between_tod_only_atom","bnf":[["between_tod_only"],["template_value"]]}]
-},{}],12:[function(require,module,exports){
+},{}],15:[function(require,module,exports){
 module.exports = require('./RuleTemplater.production.js');
-},{"./RuleTemplater.production.js":13}],13:[function(require,module,exports){
-// Note: We import the internal RuleParser.ebnf to extend the grammar with template rules.
-// This creates coupling to the internal structure of @halleyassist/rule-parser.
-const RuleParserRules = require('@halleyassist/rule-parser/src/RuleParser.ebnf'),
-      TemplateGrammar = require('./RuleTemplate.production.ebnf.js'),
+},{"./RuleTemplater.production.js":16}],16:[function(require,module,exports){
+// Note: We are coupled closely with the ebnf grammar structure of rule-parser
+const TemplateGrammar = require('./RuleTemplate.production.ebnf.js'),
       TemplateFilters = require('./TemplateFilters'),
-        {Parser} = require('ebnf');
+      RuleParser = require('@halleyassist/rule-parser'),
+      RuleParserRules = RuleParser.ParserRules,
+      {Parser} = require('ebnf');
 
 let ParserCache = null;
 
@@ -2109,7 +3678,7 @@ class RuleTemplate {
             ParserCache = new Parser(ParserRules, {debug: false})
         }
 
-        const ast = ParserCache.getAST(ruleTemplate.trim(), 'statement_main');
+        const ast = RuleParser.toAst(ruleTemplate.trim(), ParserCache);
         return new RuleTemplate(ruleTemplate, ast);
     }
 
@@ -2445,7 +4014,7 @@ module.exports = RuleTemplate;
 module.exports.ParserRules = ParserRules;
 module.exports.VariableTypes = VariableTypes;
 module.exports.TemplateFilters = TemplateFilters;
-},{"./RuleTemplate.production.ebnf.js":11,"./TemplateFilters":14,"@halleyassist/rule-parser/src/RuleParser.ebnf":1,"ebnf":10}],14:[function(require,module,exports){
+},{"./RuleTemplate.production.ebnf.js":14,"./TemplateFilters":17,"@halleyassist/rule-parser":2,"ebnf":13}],17:[function(require,module,exports){
 /*
 Template filters are functions that transform variable values.
 They are applied in the template syntax as ${variable|filter} or ${variable|filter1|filter2}
@@ -2509,5 +4078,5 @@ const TemplateFilters = {
 }
 
 module.exports = TemplateFilters;
-},{}]},{},[12])(12)
+},{}]},{},[15])(15)
 });