npm - @halleyassist/rule-templater - Versions diffs - 0.0.7 → 0.0.9 - Mend

@halleyassist/rule-templater 0.0.7 → 0.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/rule-templater.browser.js +1744 -134
package/package.json +3 -3
package/src/RuleTemplater.js +6 -6
package/src/RuleTemplater.production.js +6 -6

package/dist/rule-templater.browser.js CHANGED Viewed

@@ -1,122 +1,1732 @@
 (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'), RuleParseError = require('./errors/RuleParseError');
+let ParserRules = require('./RuleParser.production.ebnf.js');
+let ParserCache;
+const {ErrorAnalyzer} = require('./errors/ErrorAnalyzer');
+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'
+};
+const DOW_MAP = {
+    'MON': 'MONDAY',
+    'TUE': 'TUESDAY',
+    'WED': 'WEDNESDAY',
+    'THU': 'THURSDAY',
+    'THUR': 'THURSDAY',
+    'FRI': 'FRIDAY',
+    'SAT': 'SATURDAY',
+    'SUN': 'SUNDAY'
+};
+const VALID_DAYS = new Set([
+    'MONDAY',
+    'TUESDAY',
+    'WEDNESDAY',
+    'THURSDAY',
+    'FRIDAY',
+    'SATURDAY',
+    'SUNDAY'
+]);
+const normalizeDow = text => {
+    const upper = text.toUpperCase();
+    if (upper in DOW_MAP) {
+        return DOW_MAP[upper];
+    }
+    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 (e instanceof ParsingError) {
+                throw ErrorAnalyzer.analyzeParseFailure(txt, e);
+            }
+            throw e;
+        }
+        if (ret) {
+            return ret.children[0];
+        }
+        throw ErrorAnalyzer.analyzeParseFailure(txt);
+    }
+    static _parseArgument(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) {
+        if (dowRange.children.length === 1) {
+            const dayText = RuleParser.__parseValue(dowRange.children[0]);
+            return {
+                start: dayText,
+                end: dayText
+            };
+        } else if (dowRange.children.length === 2) {
+            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':
+            if (tp.children && tp.children.length > 0 && tp.children[0].type === 'time_period_ago') {
+                const timePeriodAgo = tp.children[0];
+                let totalSeconds = 0;
+                const components = [];
+                for (const child of timePeriodAgo.children) {
+                    if (child.type === 'number_time_atom') {
+                        const numberTime = child.children[0];
+                        const number = parseFloat(numberTime.children[0].text);
+                        const unit = numberTime.children[1].text.toUpperCase();
+                        components.push([
+                            number,
+                            unit
+                        ]);
+                        totalSeconds += RuleParser.__parseValue(numberTime);
+                    }
+                }
+                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': {
+                let totalSeconds = 0;
+                let betweenNode = null;
+                let isBetweenTod = false;
+                for (let i = 0; i < tp.children.length; i++) {
+                    if (tp.children[i].type === 'number_time_atom') {
+                        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;
+                    }
+                }
+                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];
+                    let startTod = RuleParser.__parseValue(betweenTod.children[0]);
+                    let endTod = RuleParser.__parseValue(betweenTod.children[1]);
+                    if (betweenTod.children.length > 2) {
+                        RuleParser._addDowToTods(startTod, endTod, betweenTod.children[2]);
+                    }
+                    return [
+                        'TimePeriodBetweenAgo',
+                        totalSeconds,
+                        startTod,
+                        endTod
+                    ];
+                } else {
+                    const betweenNumberTime = betweenNode.children[0];
+                    const startValue = RuleParser.__parseValue(betweenNumberTime.children[0]);
+                    const endValue = RuleParser.__parseValue(betweenNumberTime.children[2]);
+                    if (betweenNumberTime.children.length > 3 && betweenNumberTime.children[3].type === 'dow_range') {
+                        const dow = RuleParser._parseDowRange(betweenNumberTime.children[3]);
+                        if (dow.start === dow.end) {
+                            return [
+                                'TimePeriodBetweenAgo',
+                                totalSeconds,
+                                startValue,
+                                endValue,
+                                dow.start
+                            ];
+                        } else {
+                            return [
+                                'TimePeriodBetweenAgo',
+                                totalSeconds,
+                                startValue,
+                                endValue,
+                                dow.start,
+                                dow.end
+                            ];
+                        }
+                    }
+                    return [
+                        'TimePeriodBetweenAgo',
+                        totalSeconds,
+                        startValue,
+                        endValue
+                    ];
+                }
+            }
+        case 'between_tod_only': {
+                const betweenTod = tp.children[0];
+                let startTod = RuleParser.__parseValue(betweenTod.children[0]);
+                let endTod = RuleParser.__parseValue(betweenTod.children[1]);
+                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': {
+                const betweenNumberTime = tp.children[0];
+                const startValue = RuleParser.__parseValue(betweenNumberTime.children[0]);
+                const endValue = RuleParser.__parseValue(betweenNumberTime.children[2]);
+                if (betweenNumberTime.children.length > 3 && betweenNumberTime.children[3].type === 'dow_range') {
+                    const dow = RuleParser._parseDowRange(betweenNumberTime.children[3]);
+                    if (dow.start === dow.end) {
+                        return [
+                            'TimePeriodBetween',
+                            startValue,
+                            endValue,
+                            dow.start
+                        ];
+                    } else {
+                        return [
+                            'TimePeriodBetween',
+                            startValue,
+                            endValue,
+                            dow.start,
+                            dow.end
+                        ];
+                    }
+                }
+                return [
+                    'TimePeriodBetween',
+                    startValue,
+                    endValue
+                ];
+            }
+        }
+    }
+    static __parseValue(child) {
+        const type = child.type;
+        switch (type) {
+        case 'value': {
+                return RuleParser.__parseValue(child.children[0]);
+            }
+        case 'value_atom': {
+                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': {
+                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': {
+                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': {
+                const tp = child.children[0];
+                return RuleParser._parseTimePeriod(tp);
+            }
+        default:
+            return [
+                'Value',
+                RuleParser.__parseValue(child)
+            ];
+        }
+    }
+    static _parseSimpleResult(result) {
+        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) {
+        const child = operand.children[0];
+        const type = child.type;
+        switch (type) {
+        case 'fcall':
+            return RuleParser._parseFcall(child);
+        case 'number_atom':
+        case 'number_time_atom': {
+                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) {
+        return Array.isArray(expr) && expr.length === 2 && expr[0] === 'Value';
+    }
+    static _isConstantNumberValue(expr) {
+        return Array.isArray(expr) && expr.length === 2 && expr[0] === 'Value' && typeof expr[1] === 'number';
+    }
+    static _evaluateConstantArithmetic(operator, leftValue, rightValue) {
+        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) {
+        const partA = RuleParser._parseArithmeticOperand(result.children[0]);
+        const operatorFn = ArithmeticOperators[result.children[1].text];
+        const partB = RuleParser.__parseArithmeticResult(result, 2);
+        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) {
+        return RuleParser.__parseResult(result, 0);
+    }
+    static _parseStdExpression(expr) {
+        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': {
+                        const startTod = RuleParser.__parseValue(rhs.children[0]);
+                        const endTod = RuleParser.__parseValue(rhs.children[1]);
+                        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': {
+                        const betweenChild = rhs.children[0];
+                        if (betweenChild.type === 'between_tod') {
+                            const startTod = RuleParser.__parseValue(betweenChild.children[0]);
+                            const endTod = RuleParser.__parseValue(betweenChild.children[1]);
+                            if (betweenChild.children.length > 2) {
+                                RuleParser._addDowToTods(startTod, endTod, betweenChild.children[2]);
+                            }
+                            return [
+                                'Between',
+                                RuleParser._parseResult(expr.children[0]),
+                                [
+                                    'Value',
+                                    startTod
+                                ],
+                                [
+                                    'Value',
+                                    endTod
+                                ]
+                            ];
+                        } else {
+                            return [
+                                'Between',
+                                RuleParser._parseResult(expr.children[0]),
+                                [
+                                    'Value',
+                                    RuleParser.__parseValue(betweenChild.children[0])
+                                ],
+                                [
+                                    'Value',
+                                    RuleParser.__parseValue(betweenChild.children[2])
+                                ]
+                            ];
+                        }
+                    }
+                case 'between_number':
+                    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]);
+                        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': {
+                        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]);
+                        const allConstants = haystack.every(item => RuleParser._isConstantValue(item));
+                        let haystackExpr;
+                        if (allConstants) {
+                            const constantArray = haystack.map(item => item[1]);
+                            haystackExpr = [
+                                'Value',
+                                constantArray
+                            ];
+                        } else {
+                            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()];
+                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) {
+        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 (e.name === 'RuleParseError') {
+                throw e;
+            }
+            if (e.message && e.message.includes('Invalid time of day')) {
+                const match = e.message.match(/Invalid time of day[,:]?\s*([0-9:]+)/);
+                const badTod = 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_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)));
+            }
+            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)));
+            }
+            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,"ebnf":13,"ebnf/dist/Parser.js":9}],3:[function(require,module,exports){
+const { ParsingError } = require('ebnf');
+const RuleParseError = require('./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]
-`
+/**
+ * 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
+    );
+  }
-module.exports = Grammars.W3C.getRules(grammar);
+  /**
+   * 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
+    );
+  }
-},{"ebnf":10}],2:[function(require,module,exports){
+  /**
+   * 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 +1975,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 +2430,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 +2811,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 +2822,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 +3574,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 +3600,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 +3611,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 +3631,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 +3643,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 +3719,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 +4055,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 +4119,5 @@ const TemplateFilters = {
 }
 module.exports = TemplateFilters;
-},{}]},{},[12])(12)
+},{}]},{},[15])(15)
 });