@halleyassist/rule-parser 1.0.18 → 1.0.19

package/dist/rule-parser.browser.js

@@ -0,0 +1,3571 @@
+(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.RuleParser = 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){
+"use strict";
+// https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_Form
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+syntax ::= RULE_EOL* rule+
+rule ::= " "* "<" rule-name ">" " "* "::=" firstExpression otherExpression* " "* RULE_EOL+ " "*
+firstExpression ::= " "* list
+otherExpression ::= " "* "|" " "* list
+RULE_EOL ::= "\r" | "\n"
+list ::= term " "* list | term
+term ::= literal | "<" rule-name ">"
+literal ::= '"' RULE_CHARACTER1* '"' | "'" RULE_CHARACTER2* "'"
+RULE_CHARACTER ::= " " | RULE_LETTER | RULE_DIGIT | RULE_SYMBOL
+RULE_LETTER ::= "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z"
+RULE_DIGIT ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
+RULE_SYMBOL ::= "-" | "_" | "!" | "#" | "$" | "%" | "&" | "(" | ")" | "*" | "+" | "," | "-" | "." | "/" | ":" | ";" | "<" | "=" | ">" | "?" | "@" | "[" | "\" | "]" | "^" | "_" | "`" | "{" | "|" | "}" | "~"
+RULE_CHARACTER1 ::= RULE_CHARACTER | "'"
+RULE_CHARACTER2 ::= RULE_CHARACTER | '"'
+rule-name ::= RULE_LETTER RULE_CHAR*
+RULE_CHAR ::= RULE_LETTER | RULE_DIGIT | "_" | "-"
+*/
+const SemanticHelpers_1 = require("../SemanticHelpers");
+const Parser_1 = require("../Parser");
+var BNF;
+(function (BNF) {
+    BNF.RULES = [
+        {
+            name: 'syntax',
+            bnf: [['RULE_EOL*', 'rule+']]
+        },
+        {
+            name: 'rule',
+            bnf: [
+                [
+                    '" "*',
+                    '"<"',
+                    'rule-name',
+                    '">"',
+                    '" "*',
+                    '"::="',
+                    'firstExpression',
+                    'otherExpression*',
+                    '" "*',
+                    'RULE_EOL+',
+                    '" "*'
+                ]
+            ]
+        },
+        {
+            name: 'firstExpression',
+            bnf: [['" "*', 'list']]
+        },
+        {
+            name: 'otherExpression',
+            bnf: [['" "*', '"|"', '" "*', 'list']]
+        },
+        {
+            name: 'RULE_EOL',
+            bnf: [['"\\r"'], ['"\\n"']]
+        },
+        {
+            name: 'list',
+            bnf: [['term', '" "*', 'list'], ['term']]
+        },
+        {
+            name: 'term',
+            bnf: [['literal'], ['"<"', 'rule-name', '">"']]
+        },
+        {
+            name: 'literal',
+            bnf: [[`'"'`, 'RULE_CHARACTER1*', `'"'`], [`"'"`, 'RULE_CHARACTER2*', `"'"`]]
+        },
+        {
+            name: 'RULE_CHARACTER',
+            bnf: [['" "'], ['RULE_LETTER'], ['RULE_DIGIT'], ['RULE_SYMBOL']]
+        },
+        {
+            name: 'RULE_LETTER',
+            bnf: [
+                ['"A"'],
+                ['"B"'],
+                ['"C"'],
+                ['"D"'],
+                ['"E"'],
+                ['"F"'],
+                ['"G"'],
+                ['"H"'],
+                ['"I"'],
+                ['"J"'],
+                ['"K"'],
+                ['"L"'],
+                ['"M"'],
+                ['"N"'],
+                ['"O"'],
+                ['"P"'],
+                ['"Q"'],
+                ['"R"'],
+                ['"S"'],
+                ['"T"'],
+                ['"U"'],
+                ['"V"'],
+                ['"W"'],
+                ['"X"'],
+                ['"Y"'],
+                ['"Z"'],
+                ['"a"'],
+                ['"b"'],
+                ['"c"'],
+                ['"d"'],
+                ['"e"'],
+                ['"f"'],
+                ['"g"'],
+                ['"h"'],
+                ['"i"'],
+                ['"j"'],
+                ['"k"'],
+                ['"l"'],
+                ['"m"'],
+                ['"n"'],
+                ['"o"'],
+                ['"p"'],
+                ['"q"'],
+                ['"r"'],
+                ['"s"'],
+                ['"t"'],
+                ['"u"'],
+                ['"v"'],
+                ['"w"'],
+                ['"x"'],
+                ['"y"'],
+                ['"z"']
+            ]
+        },
+        {
+            name: 'RULE_DIGIT',
+            bnf: [['"0"'], ['"1"'], ['"2"'], ['"3"'], ['"4"'], ['"5"'], ['"6"'], ['"7"'], ['"8"'], ['"9"']]
+        },
+        {
+            name: 'RULE_SYMBOL',
+            bnf: [
+                ['"-"'],
+                ['"_"'],
+                ['"!"'],
+                ['"#"'],
+                ['"$"'],
+                ['"%"'],
+                ['"&"'],
+                ['"("'],
+                ['")"'],
+                ['"*"'],
+                ['"+"'],
+                ['","'],
+                ['"-"'],
+                ['"."'],
+                ['"/"'],
+                ['":"'],
+                ['";"'],
+                ['"<"'],
+                ['"="'],
+                ['">"'],
+                ['"?"'],
+                ['"@"'],
+                ['"["'],
+                ['"\\"'],
+                ['"]"'],
+                ['"^"'],
+                ['"_"'],
+                ['"`"'],
+                ['"{"'],
+                ['"|"'],
+                ['"}"'],
+                ['"~"']
+            ]
+        },
+        {
+            name: 'RULE_CHARACTER1',
+            bnf: [['RULE_CHARACTER'], [`"'"`]]
+        },
+        {
+            name: 'RULE_CHARACTER2',
+            bnf: [['RULE_CHARACTER'], [`'"'`]]
+        },
+        {
+            name: 'rule-name',
+            bnf: [['RULE_LETTER', 'RULE_CHAR*']]
+        },
+        {
+            name: 'RULE_CHAR',
+            bnf: [['RULE_LETTER'], ['RULE_DIGIT'], ['"_"'], ['"-"']]
+        }
+    ];
+    BNF.defaultParser = new Parser_1.Parser(BNF.RULES, { debug: false });
+    function getAllTerms(expr) {
+        let terms = (0, SemanticHelpers_1.findChildrenByType)(expr, 'term').map(term => {
+            return (0, SemanticHelpers_1.findChildrenByType)(term, 'literal').concat((0, SemanticHelpers_1.findChildrenByType)(term, 'rule-name'))[0].text;
+        });
+        for (const exprItem of (0, SemanticHelpers_1.findChildrenByType)(expr, 'list')) {
+            terms = terms.concat(getAllTerms(exprItem));
+        }
+        return terms;
+    }
+    function getRules(source, parser = BNF.defaultParser) {
+        let ast = parser.getAST(source);
+        if (!ast)
+            throw new Error('Could not parse ' + source);
+        if (ast.errors && ast.errors.length) {
+            throw ast.errors[0];
+        }
+        let rules = (0, SemanticHelpers_1.findChildrenByType)(ast, 'rule');
+        let ret = rules.map((rule) => {
+            let name = (0, SemanticHelpers_1.findChildrenByType)(rule, 'rule-name')[0].text;
+            let expressions = (0, SemanticHelpers_1.findChildrenByType)(rule, 'firstExpression').concat((0, SemanticHelpers_1.findChildrenByType)(rule, 'otherExpression'));
+            let bnf = [];
+            for (const expr of expressions) {
+                bnf.push(getAllTerms(expr));
+            }
+            return {
+                name: name,
+                bnf
+            };
+        });
+        if (!ret.some(x => x.name == 'EOL')) {
+            ret.push({
+                name: 'EOL',
+                bnf: [['"\\r\\n"', '"\\r"', '"\\n"']]
+            });
+        }
+        return ret;
+    }
+    BNF.getRules = getRules;
+    function Transform(source, subParser = BNF.defaultParser) {
+        return getRules(source.join(''), subParser);
+    }
+    BNF.Transform = Transform;
+    class Parser extends Parser_1.Parser {
+        constructor(source, options) {
+            const subParser = options && options.debugRulesParser === true ? new Parser_1.Parser(BNF.RULES, { debug: true }) : BNF.defaultParser;
+            super(getRules(source, subParser), options);
+            this.source = source;
+        }
+        emitSource() {
+            return this.source;
+        }
+    }
+    BNF.Parser = Parser;
+})(BNF || (BNF = {}));
+exports.default = BNF;
+
+},{"../Parser":5,"../SemanticHelpers":7}],2:[function(require,module,exports){
+"use strict";
+// https://www.w3.org/TR/REC-xml/#NT-Name
+// http://www.bottlecaps.de/rr/ui
+Object.defineProperty(exports, "__esModule", { value: true });
+// Grammar	::=	Production*
+// Production	::=	NCName '::=' Choice
+// NCName	::=	[http://www.w3.org/TR/xml-names/#NT-NCName]
+// Choice	::=	SequenceOrDifference ( '|' SequenceOrDifference )*
+// SequenceOrDifference	::=	(Item ( '-' Item | Item* ))?
+// Item	::=	Primary ( '?' | '*' | '+' )?
+// Primary	::=	NCName | StringLiteral | CharCode | CharClass | '(' Choice ')'
+// StringLiteral	::=	'"' [^"]* '"' | "'" [^']* "'"
+// CharCode	::=	'#x' [0-9a-fA-F]+
+// CharClass	::=	'[' '^'? ( RULE_Char | CharCode | CharRange | CharCodeRange )+ ']'
+// RULE_Char	::=	[http://www.w3.org/TR/xml#NT-RULE_Char]
+// CharRange	::=	RULE_Char '-' ( RULE_Char - ']' )
+// CharCodeRange	::=	CharCode '-' CharCode
+// RULE_WHITESPACE	::=	RULE_S | Comment
+// RULE_S	::=	#x9 | #xA | #xD | #x20
+// Comment	::=	'/*' ( [^*] | '*'+ [^*/] )* '*'* '*/'
+const TokenError_1 = require("../TokenError");
+const Parser_1 = require("../Parser");
+var BNF;
+(function (BNF) {
+    BNF.RULES = [
+        {
+            name: 'Grammar',
+            bnf: [['RULE_S*', 'Attributes?', 'RULE_S*', '%Atomic*', 'EOF']]
+        },
+        {
+            name: '%Atomic',
+            bnf: [['Production', 'RULE_S*']],
+            fragment: true
+        },
+        {
+            name: 'Production',
+            bnf: [
+                [
+                    'NCName',
+                    'RULE_S*',
+                    '"::="',
+                    'RULE_WHITESPACE*',
+                    '%Choice',
+                    'RULE_WHITESPACE*',
+                    'Attributes?',
+                    'RULE_EOL+',
+                    'RULE_S*'
+                ]
+            ]
+        },
+        {
+            name: 'NCName',
+            bnf: [[/[a-zA-Z][a-zA-Z_0-9]*/]]
+        },
+        {
+            name: 'Attributes',
+            bnf: [['"{"', 'Attribute', '%Attributes*', 'RULE_S*', '"}"']]
+        },
+        {
+            name: '%Attributes',
+            bnf: [['RULE_S*', '","', 'Attribute']],
+            fragment: true
+        },
+        {
+            name: 'Attribute',
+            bnf: [['RULE_S*', 'NCName', 'RULE_WHITESPACE*', '"="', 'RULE_WHITESPACE*', 'AttributeValue']]
+        },
+        {
+            name: 'AttributeValue',
+            bnf: [['NCName'], [/[1-9][0-9]*/]]
+        },
+        {
+            name: '%Choice',
+            bnf: [['SequenceOrDifference', '%_Choice_1*']],
+            fragment: true
+        },
+        {
+            name: '%_Choice_1',
+            bnf: [['RULE_S*', '"|"', 'RULE_S*', 'SequenceOrDifference']],
+            fragment: true
+        },
+        {
+            name: 'SequenceOrDifference',
+            bnf: [['%Item', 'RULE_WHITESPACE*', '%_Item_1?']]
+        },
+        {
+            name: '%_Item_1',
+            bnf: [['Minus', '%Item'], ['%Item*']],
+            fragment: true
+        },
+        {
+            name: 'Minus',
+            bnf: [['"-"']]
+        },
+        {
+            name: '%Item',
+            bnf: [['RULE_WHITESPACE*', 'PrimaryPreDecoration?', '%Primary', 'PrimaryDecoration?']],
+            fragment: true
+        },
+        {
+            name: 'PrimaryDecoration',
+            bnf: [['"?"'], ['"*"'], ['"+"']]
+        },
+        {
+            name: 'PrimaryPreDecoration',
+            bnf: [['"&"'], ['"!"'], ['"~"']]
+        },
+        {
+            name: '%Primary',
+            bnf: [['NCName'], ['StringLiteral'], ['CharCode'], ['CharClass'], ['SubItem']],
+            fragment: true
+        },
+        {
+            name: 'SubItem',
+            bnf: [['"("', 'RULE_S*', '%Choice', 'RULE_S*', '")"']]
+        },
+        {
+            name: 'StringLiteral',
+            bnf: [[`'"'`, /[^"]*/, `'"'`], [`"'"`, /[^']*/, `"'"`]]
+        },
+        {
+            name: 'CharCode',
+            bnf: [['"#x"', /[0-9a-zA-Z]+/]]
+        },
+        {
+            name: 'CharClass',
+            bnf: [["'['", "'^'?", '%RULE_CharClass_1+', '"]"']]
+        },
+        {
+            name: '%RULE_CharClass_1',
+            bnf: [['CharCodeRange'], ['CharRange'], ['CharCode'], ['RULE_Char']],
+            fragment: true
+        },
+        {
+            name: 'RULE_Char',
+            bnf: [[/\x09/], [/\x0A/], [/\x0D/], [/[\x20-\x5c]/], [/[\x5e-\uD7FF]/], [/[\uE000-\uFFFD]/]]
+        },
+        {
+            name: 'CharRange',
+            bnf: [['RULE_Char', '"-"', 'RULE_Char']]
+        },
+        {
+            name: 'CharCodeRange',
+            bnf: [['CharCode', '"-"', 'CharCode']]
+        },
+        {
+            name: 'RULE_WHITESPACE',
+            bnf: [['%RULE_WHITESPACE_CHAR*'], ['Comment', 'RULE_WHITESPACE*']]
+        },
+        {
+            name: 'RULE_S',
+            bnf: [['RULE_WHITESPACE', 'RULE_S*'], ['RULE_EOL', 'RULE_S*']]
+        },
+        {
+            name: '%RULE_WHITESPACE_CHAR',
+            bnf: [[/\x09/], [/\x20/]],
+            fragment: true
+        },
+        {
+            name: 'Comment',
+            bnf: [['"/*"', '%RULE_Comment_Body*', '"*/"']]
+        },
+        {
+            name: '%RULE_Comment_Body',
+            bnf: [[/[^*]/], ['"*"+', /[^/]*/]],
+            fragment: true
+        },
+        {
+            name: 'RULE_EOL',
+            bnf: [[/\x0D/, /\x0A/], [/\x0A/], [/\x0D/]]
+        },
+        {
+            name: 'Link',
+            bnf: [["'['", 'Url', "']'"]]
+        },
+        {
+            name: 'Url',
+            bnf: [[/[^\x5D:/?#]/, '"://"', /[^\x5D#]+/, '%Url1?']]
+        },
+        {
+            name: '%Url1',
+            bnf: [['"#"', 'NCName']],
+            fragment: true
+        }
+    ];
+    BNF.defaultParser = new Parser_1.Parser(BNF.RULES, { debug: false });
+    const preDecorationRE = /^(!|&)/;
+    const decorationRE = /(\?|\+|\*)$/;
+    const subExpressionRE = /^%/;
+    function getBNFRule(name, parser) {
+        if (typeof name == 'string') {
+            let decoration = decorationRE.exec(name);
+            let preDecoration = preDecorationRE.exec(name);
+            let preDecorationText = preDecoration ? preDecoration[0] : '';
+            let decorationText = decoration ? decoration[0] + ' ' : '';
+            let subexpression = subExpressionRE.test(name);
+            if (subexpression) {
+                let lonely = isLonelyRule(name, parser);
+                if (lonely)
+                    return preDecorationText + getBNFBody(name, parser) + decorationText;
+                return preDecorationText + '(' + getBNFBody(name, parser) + ')' + decorationText;
+            }
+            return name.replace(preDecorationRE, preDecorationText);
+        }
+        else {
+            return name.source
+                .replace(/\\(?:x|u)([a-zA-Z0-9]+)/g, '#x$1')
+                .replace(/\[\\(?:x|u)([a-zA-Z0-9]+)-\\(?:x|u)([a-zA-Z0-9]+)\]/g, '[#x$1-#x$2]');
+        }
+    }
+    /// Returns true if the rule is a string literal or regular expression without a descendant tree
+    function isLonelyRule(name, parser) {
+        let rule = (0, Parser_1.findRuleByName)(name, parser);
+        return (rule &&
+            rule.bnf.length == 1 &&
+            rule.bnf[0].length == 1 &&
+            (rule.bnf[0][0] instanceof RegExp || rule.bnf[0][0][0] == '"' || rule.bnf[0][0][0] == "'"));
+    }
+    function getBNFChoice(rules, parser) {
+        return rules.map(x => getBNFRule(x, parser)).join(' ');
+    }
+    function getBNFBody(name, parser) {
+        let rule = (0, Parser_1.findRuleByName)(name, parser);
+        if (rule)
+            return rule.bnf.map(x => getBNFChoice(x, parser)).join(' | ');
+        return 'RULE_NOT_FOUND {' + name + '}';
+    }
+    function emit(parser) {
+        let acumulator = [];
+        for (const l of parser.grammarRules) {
+            if (!/^%/.test(l.name)) {
+                let recover = l.recover ? ' { recoverUntil=' + l.recover + ' }' : '';
+                acumulator.push(l.name + ' ::= ' + getBNFBody(l.name, parser) + recover);
+            }
+        }
+        return acumulator.join('\n');
+    }
+    BNF.emit = emit;
+    function restar(total, resta) {
+        console.log('reberia restar ' + resta + ' a ' + total);
+        throw new Error('Difference not supported yet');
+    }
+    function convertRegex(txt) {
+        return new RegExp(txt
+            .replace(/#x([a-zA-Z0-9]{4})/g, '\\u$1')
+            .replace(/#x([a-zA-Z0-9]{3})/g, '\\u0$1')
+            .replace(/#x([a-zA-Z0-9]{2})/g, '\\x$1')
+            .replace(/#x([a-zA-Z0-9]{1})/g, '\\x0$1'));
+    }
+    function getSubItems(tmpRules, seq, parentName, optionIndex, parentAttributes, isSingleSequence = false) {
+        let anterior = null;
+        let bnfSeq = [];
+        const children = seq.children;
+        let subitemIndex = 0; // Track subitems within this sequence
+        let itemPosition = 0; // Track all items for position-based naming
+        for (let i = 0; i < children.length; i++) {
+            const x = children[i];
+            if (x.type == 'Minus') {
+                restar(anterior, x);
+            }
+            let decoration = children[i + 1];
+            decoration = (decoration && decoration.type == 'PrimaryDecoration' && decoration.text) || '';
+            let preDecoration = '';
+            if (anterior && anterior.type == 'PrimaryPreDecoration') {
+                preDecoration = anterior.text;
+            }
+            let pinned = preDecoration == '~' ? 1 : undefined;
+            if (pinned) {
+                preDecoration = '';
+            }
+            switch (x.type) {
+                case 'SubItem':
+                    subitemIndex++;
+                    itemPosition++; // Increment position for SubItems
+                    let name;
+                    // Build the fragment name by appending to parentName
+                    const prefix = parentName.startsWith('%') ? '' : '%';
+                    if (isSingleSequence) {
+                        // Single sequence: use position-based naming
+                        name = prefix + parentName + '[' + itemPosition + ']';
+                    }
+                    else {
+                        // Multiple sequences: use option-based naming
+                        if (subitemIndex === 1) {
+                            name = prefix + parentName + '[' + optionIndex + ']';
+                        }
+                        else {
+                            name = prefix + parentName + '[' + optionIndex + '][' + subitemIndex + ']';
+                        }
+                    }
+                    createRule(tmpRules, x, name, parentAttributes);
+                    bnfSeq.push(preDecoration + name + decoration);
+                    break;
+                case 'NCName':
+                    itemPosition++; // Increment position for NCNames
+                    bnfSeq.push(preDecoration + x.text + decoration);
+                    break;
+                case 'StringLiteral':
+                    itemPosition++; // Increment position for StringLiterals
+                    if (decoration || preDecoration || !/^['"/()a-zA-Z0-9&_.:=,+*\-\^\\]+$/.test(x.text)) {
+                        bnfSeq.push(preDecoration + x.text + decoration);
+                    }
+                    else {
+                        for (const c of x.text.slice(1, -1)) {
+                            if (parentAttributes && parentAttributes["ignoreCase"] == "true" && /[a-zA-Z]/.test(c)) {
+                                bnfSeq.push(new RegExp("[" + c.toUpperCase() + c.toLowerCase() + "]"));
+                            }
+                            else {
+                                bnfSeq.push(new RegExp((0, Parser_1.escapeRegExp)(c)));
+                            }
+                        }
+                    }
+                    break;
+                case 'CharCode':
+                case 'CharClass':
+                    itemPosition++; // Increment position for CharCode/CharClass
+                    if (decoration || preDecoration) {
+                        subitemIndex++;
+                        let name;
+                        // Build the fragment name by appending to parentName
+                        const prefix = parentName.startsWith('%') ? '' : '%';
+                        if (isSingleSequence) {
+                            // Single sequence: use position-based naming
+                            name = prefix + parentName + '[' + itemPosition + ']';
+                        }
+                        else {
+                            // Multiple sequences: use option-based naming
+                            if (subitemIndex === 1) {
+                                name = prefix + parentName + '[' + optionIndex + ']';
+                            }
+                            else {
+                                name = prefix + parentName + '[' + optionIndex + '][' + subitemIndex + ']';
+                            }
+                        }
+                        let newRule = {
+                            name,
+                            bnf: [[convertRegex(x.text)]],
+                            pinned
+                        };
+                        tmpRules.push(newRule);
+                        bnfSeq.push(preDecoration + newRule.name + decoration);
+                    }
+                    else {
+                        bnfSeq.push(convertRegex(x.text));
+                    }
+                    break;
+                case 'PrimaryPreDecoration':
+                case 'PrimaryDecoration':
+                    break;
+                default:
+                    throw new Error(' HOW SHOULD I PARSE THIS? ' + x.type + ' -> ' + JSON.stringify(x.text));
+            }
+            anterior = x;
+        }
+        return bnfSeq;
+    }
+    function createRule(tmpRules, token, name, parentAttributes = undefined) {
+        let attrNode = token.children.filter(x => x.type == 'Attributes')[0];
+        let attributes = {};
+        if (attrNode) {
+            for (const x of attrNode.children) {
+                let attrName = x.children.filter(x => x.type == 'NCName')[0].text;
+                if (attrName in attributes) {
+                    throw new TokenError_1.TokenError('Duplicated attribute ' + attrName, x);
+                }
+                else {
+                    attributes[attrName] = x.children.filter(x => x.type == 'AttributeValue')[0].text;
+                }
+            }
+        }
+        let sequences = token.children.filter(x => x.type == 'SequenceOrDifference');
+        // Determine if this rule has a single sequence (no alternatives)
+        const isSingleSequence = sequences.length === 1;
+        let bnf = sequences.map((s, optionIndex) => getSubItems(tmpRules, s, name, optionIndex + 1, parentAttributes ? parentAttributes : attributes, isSingleSequence));
+        let rule = {
+            name,
+            bnf
+        };
+        if (name.indexOf('%') == 0)
+            rule.fragment = true;
+        if (attributes['recoverUntil']) {
+            rule.recover = attributes['recoverUntil'];
+            if (rule.bnf.length > 1)
+                throw new TokenError_1.TokenError('only one-option productions are suitable for error recovering', token);
+        }
+        if ('pin' in attributes) {
+            let num = parseInt(attributes['pin']);
+            if (!isNaN(num)) {
+                rule.pinned = num;
+            }
+            if (rule.bnf.length > 1)
+                throw new TokenError_1.TokenError('only one-option productions are suitable for pinning', token);
+        }
+        if ('ws' in attributes) {
+            rule.implicitWs = attributes['ws'] != 'explicit';
+        }
+        else {
+            rule.implicitWs = null;
+        }
+        rule.fragment = rule.fragment || attributes['fragment'] == 'true';
+        rule.simplifyWhenOneChildren = attributes['simplifyWhenOneChildren'] == 'true';
+        tmpRules.push(rule);
+    }
+    function getRules(source, parser = BNF.defaultParser) {
+        let ast = parser.getAST(source);
+        if (!ast)
+            throw new Error('Could not parse ' + source);
+        if (ast.errors && ast.errors.length) {
+            throw ast.errors[0];
+        }
+        let implicitWs = null;
+        let attrNode = ast.children.filter(x => x.type == 'Attributes')[0];
+        let attributes = {};
+        if (attrNode) {
+            for (const x of attrNode.children) {
+                let attrName = x.children.filter(x => x.type == 'NCName')[0].text;
+                if (attrName in attributes) {
+                    throw new TokenError_1.TokenError('Duplicated attribute ' + attrName, x);
+                }
+                else {
+                    attributes[attrName] = x.children.filter(x => x.type == 'AttributeValue')[0].text;
+                }
+            }
+        }
+        implicitWs = attributes['ws'] == 'implicit';
+        let tmpRules = [];
+        ast.children.filter(x => x.type == 'Production').map((x) => {
+            let name = x.children.filter(x => x.type == 'NCName')[0].text;
+            createRule(tmpRules, x, name);
+        });
+        for (const rule of tmpRules) {
+            if (rule.implicitWs === null)
+                rule.implicitWs = implicitWs;
+        }
+        return tmpRules;
+    }
+    BNF.getRules = getRules;
+    function Transform(source, subParser = BNF.defaultParser) {
+        return getRules(source.join(''), subParser);
+    }
+    BNF.Transform = Transform;
+    class Parser extends Parser_1.Parser {
+        constructor(source, options) {
+            const subParser = options && options.debugRulesParser === true ? new Parser_1.Parser(BNF.RULES, { debug: true }) : BNF.defaultParser;
+            super(getRules(source, subParser), options);
+        }
+        emitSource() {
+            return emit(this);
+        }
+    }
+    BNF.Parser = Parser;
+})(BNF || (BNF = {}));
+exports.default = BNF;
+
+},{"../Parser":5,"../TokenError":8}],3:[function(require,module,exports){
+"use strict";
+// https://www.w3.org/TR/REC-xml/#NT-Name
+// http://www.bottlecaps.de/rr/ui
+Object.defineProperty(exports, "__esModule", { value: true });
+// Grammar	::=	Production*
+// Production	::=	NCName '::=' Choice
+// NCName	::=	[http://www.w3.org/TR/xml-names/#NT-NCName]
+// Choice	::=	SequenceOrDifference ( '|' SequenceOrDifference )*
+// SequenceOrDifference	::=	(Item ( '-' Item | Item* ))?
+// Item	::=	Primary ( '?' | '*' | '+' )?
+// Primary	::=	NCName | StringLiteral | CharCode | CharClass | '(' Choice ')'
+// StringLiteral	::=	'"' [^"]* '"' | "'" [^']* "'"
+// CharCode	::=	'#x' [0-9a-fA-F]+
+// CharClass	::=	'[' '^'? ( RULE_Char | CharCode | CharRange | CharCodeRange )+ ']'
+// RULE_Char	::=	[http://www.w3.org/TR/xml#NT-RULE_Char]
+// CharRange	::=	RULE_Char '-' ( RULE_Char - ']' )
+// CharCodeRange	::=	CharCode '-' CharCode
+// RULE_WHITESPACE	::=	RULE_S | Comment
+// RULE_S	::=	#x9 | #xA | #xD | #x20
+// Comment	::=	'/*' ( [^*] | '*'+ [^*/] )* '*'* '*/'
+const Parser_1 = require("../Parser");
+var BNF;
+(function (BNF) {
+    BNF.RULES = [
+        {
+            name: 'Grammar',
+            bnf: [['RULE_S*', '%Atomic*', 'EOF']]
+        },
+        {
+            name: '%Atomic',
+            bnf: [['Production', 'RULE_S*']],
+            fragment: true
+        },
+        {
+            name: 'Production',
+            bnf: [['NCName', 'RULE_S*', 'ProductionOperator', 'RULE_WHITESPACE*', 'Choice', 'RULE_WHITESPACE*', 'RULE_EOL+', 'RULE_S*']]
+        },
+        {
+            name: 'ProductionOperator',
+            bnf: [['"::="'], ['"||="']]
+        },
+        {
+            name: 'NCName',
+            bnf: [[/[a-zA-Z][a-zA-Z_0-9]*/]]
+        },
+        {
+            name: 'Choice',
+            bnf: [['SequenceOrDifference', '%_Choice_1*']],
+            fragment: true
+        },
+        {
+            name: '%_Choice_1',
+            bnf: [['RULE_WHITESPACE*', '"|"', 'RULE_WHITESPACE*', 'SequenceOrDifference']],
+            fragment: true
+        },
+        {
+            name: 'SequenceOrDifference',
+            bnf: [['Item', 'RULE_WHITESPACE*', '%_Item_1?']]
+        },
+        {
+            name: '%_Item_1',
+            bnf: [['Minus', 'Item'], ['Item*']],
+            fragment: true
+        },
+        {
+            name: 'Minus',
+            bnf: [['"-"']]
+        },
+        {
+            name: 'Item',
+            bnf: [['RULE_WHITESPACE*', '%Primary', 'PrimaryDecoration?']],
+            fragment: true
+        },
+        {
+            name: 'PrimaryDecoration',
+            bnf: [['"?"'], ['"*"'], ['"+"']]
+        },
+        {
+            name: 'DecorationName',
+            bnf: [['"ebnf://"', /[^\x5D#]+/]]
+        },
+        {
+            name: '%Primary',
+            bnf: [['NCName'], ['StringLiteral'], ['CharCode'], ['CharClass'], ['SubItem']],
+            fragment: true
+        },
+        {
+            name: 'SubItem',
+            bnf: [['"("', 'RULE_WHITESPACE*', 'Choice', 'RULE_WHITESPACE*', '")"']]
+        },
+        {
+            name: 'StringLiteral',
+            bnf: [[`'"'`, /[^"]*/, `'"'`], [`"'"`, /[^']*/, `"'"`]],
+            pinned: 1
+        },
+        {
+            name: 'CharCode',
+            bnf: [['"#x"', /[0-9a-zA-Z]+/]]
+        },
+        {
+            name: 'CharClass',
+            bnf: [["'['", "'^'?", '%RULE_CharClass_1+', '"]"']]
+        },
+        {
+            name: '%RULE_CharClass_1',
+            bnf: [['CharCodeRange'], ['CharRange'], ['CharCode'], ['RULE_Char']],
+            fragment: true
+        },
+        {
+            name: 'RULE_Char',
+            bnf: [[/\x09/], [/\x0A/], [/\x0D/], [/[\x20-\x5c]/], [/[\x5e-\uD7FF]/], [/[\uE000-\uFFFD]/]]
+        },
+        {
+            name: 'CharRange',
+            bnf: [['RULE_Char', '"-"', 'RULE_Char']]
+        },
+        {
+            name: 'CharCodeRange',
+            bnf: [['CharCode', '"-"', 'CharCode']]
+        },
+        {
+            name: 'RULE_WHITESPACE',
+            bnf: [['%RULE_WHITESPACE_CHAR*'], ['Comment', 'RULE_WHITESPACE*']]
+        },
+        {
+            name: 'RULE_S',
+            bnf: [['RULE_WHITESPACE', 'RULE_S*'], ['RULE_EOL', 'RULE_S*']]
+        },
+        {
+            name: '%RULE_WHITESPACE_CHAR',
+            bnf: [[/\x09/], [/\x20/]],
+            fragment: true
+        },
+        {
+            name: 'Comment',
+            bnf: [['"/*"', '%RULE_Comment_Body*', '"*/"']]
+        },
+        {
+            name: '%RULE_Comment_Body',
+            bnf: [['!"*/"', /[^*]/]],
+            fragment: true
+        },
+        {
+            name: 'RULE_EOL',
+            bnf: [[/\x0D/, /\x0A/], [/\x0A/], [/\x0D/]]
+        },
+        {
+            name: 'Link',
+            bnf: [["'['", 'Url', "']'"]]
+        },
+        {
+            name: 'Url',
+            bnf: [[/[^\x5D:/?#]/, '"://"', /[^\x5D#]+/, '%Url1?']]
+        },
+        {
+            name: '%Url1',
+            bnf: [['"#"', 'NCName']],
+            fragment: true
+        }
+    ];
+    BNF.defaultParser = new Parser_1.Parser(BNF.RULES, { debug: false });
+    const preDecorationRE = /^(!|&)/;
+    const decorationRE = /(\?|\+|\*)$/;
+    const subExpressionRE = /^%/;
+    function getBNFRule(name, parser) {
+        if (typeof name == 'string') {
+            if (preDecorationRE.test(name))
+                return '';
+            let subexpression = subExpressionRE.test(name);
+            if (subexpression) {
+                let decoration = decorationRE.exec(name);
+                let decorationText = decoration ? decoration[0] + ' ' : '';
+                let lonely = isLonelyRule(name, parser);
+                if (lonely)
+                    return getBNFBody(name, parser) + decorationText;
+                return '(' + getBNFBody(name, parser) + ')' + decorationText;
+            }
+            return name;
+        }
+        else {
+            return name.source
+                .replace(/\\(?:x|u)([a-zA-Z0-9]+)/g, '#x$1')
+                .replace(/\[\\(?:x|u)([a-zA-Z0-9]+)-\\(?:x|u)([a-zA-Z0-9]+)\]/g, '[#x$1-#x$2]');
+        }
+    }
+    /// Returns true if the rule is a string literal or regular expression without a descendant tree
+    function isLonelyRule(name, parser) {
+        let rule = (0, Parser_1.findRuleByName)(name, parser);
+        return (rule &&
+            rule.bnf.length == 1 &&
+            rule.bnf[0].length == 1 &&
+            (rule.bnf[0][0] instanceof RegExp || rule.bnf[0][0][0] == '"' || rule.bnf[0][0][0] == "'"));
+    }
+    function getBNFChoice(rules, parser) {
+        return rules.map(x => getBNFRule(x, parser)).join(' ');
+    }
+    function getBNFBody(name, parser) {
+        let rule = (0, Parser_1.findRuleByName)(name, parser);
+        if (rule)
+            return rule.bnf.map(x => getBNFChoice(x, parser)).join(' | ');
+        return 'RULE_NOT_FOUND {' + name + '}';
+    }
+    function emit(parser) {
+        let acumulator = [];
+        for (const l of parser.grammarRules) {
+            if (!/^%/.test(l.name)) {
+                let recover = l.recover ? ' /* { recoverUntil=' + l.recover + ' } */' : '';
+                acumulator.push(l.name + ' ::= ' + getBNFBody(l.name, parser) + recover);
+            }
+        }
+        return acumulator.join('\n');
+    }
+    BNF.emit = emit;
+    function restar(total, resta) {
+        console.log('reberia restar ' + resta + ' a ' + total);
+        throw new Error('Difference not supported yet');
+    }
+    function convertRegex(txt, caseInsensitive = false) {
+        const pattern = txt
+            .replace(/#x([a-zA-Z0-9]{4})/g, '\\u$1')
+            .replace(/#x([a-zA-Z0-9]{3})/g, '\\u0$1')
+            .replace(/#x([a-zA-Z0-9]{2})/g, '\\x$1')
+            .replace(/#x([a-zA-Z0-9]{1})/g, '\\x0$1');
+        return new RegExp(pattern, caseInsensitive ? 'i' : '');
+    }
+    function getSubItems(tmpRules, seq, parentName, optionIndex, caseInsensitive = false, isSingleSequence = false) {
+        let anterior = null;
+        let bnfSeq = [];
+        const children = seq.children;
+        let subitemIndex = 0; // Track subitems within this sequence
+        let itemPosition = 0; // Track all items (including literals, NCNames, SubItems) for position-based naming
+        for (let i = 0; i < children.length; i++) {
+            const x = children[i];
+            if (x.type == 'Minus') {
+                restar(anterior, x);
+            }
+            let decoration = children[i + 1];
+            decoration = (decoration && decoration.type == 'PrimaryDecoration' && decoration.text) || '';
+            let preDecoration = '';
+            switch (x.type) {
+                case 'SubItem':
+                    subitemIndex++;
+                    itemPosition++; // Increment position for SubItems
+                    let name;
+                    // Build the fragment name by appending to parentName
+                    const prefix = parentName.startsWith('%') ? '' : '%';
+                    if (isSingleSequence) {
+                        // Single sequence: use position-based naming
+                        name = prefix + parentName + '[' + itemPosition + ']';
+                    }
+                    else {
+                        // Multiple sequences: use option-based naming
+                        if (subitemIndex === 1) {
+                            name = prefix + parentName + '[' + optionIndex + ']';
+                        }
+                        else {
+                            name = prefix + parentName + '[' + optionIndex + '][' + subitemIndex + ']';
+                        }
+                    }
+                    createRule(tmpRules, x, name, caseInsensitive);
+                    bnfSeq.push(preDecoration + name + decoration);
+                    break;
+                case 'NCName':
+                    itemPosition++; // Increment position for NCNames
+                    bnfSeq.push(preDecoration + x.text + decoration);
+                    break;
+                case 'StringLiteral':
+                    itemPosition++; // Increment position for StringLiterals
+                    if (caseInsensitive) {
+                        // For case insensitive string literals, convert each character to a case-insensitive regex
+                        const literalText = x.text.slice(1, -1); // Remove quotes
+                        for (const c of literalText) {
+                            if (/[a-zA-Z]/.test(c)) {
+                                bnfSeq.push(new RegExp('[' + c.toUpperCase() + c.toLowerCase() + ']'));
+                            }
+                            else {
+                                bnfSeq.push(new RegExp((0, Parser_1.escapeRegExp)(c)));
+                            }
+                        }
+                    }
+                    else {
+                        bnfSeq.push(preDecoration + x.text + decoration);
+                    }
+                    break;
+                case 'CharCode':
+                case 'CharClass':
+                    itemPosition++; // Increment position for CharCode/CharClass
+                    if (decoration || preDecoration) {
+                        subitemIndex++;
+                        let name;
+                        // Build the fragment name by appending to parentName
+                        const prefix = parentName.startsWith('%') ? '' : '%';
+                        if (isSingleSequence) {
+                            // Single sequence: use position-based naming
+                            name = prefix + parentName + '[' + itemPosition + ']';
+                        }
+                        else {
+                            // Multiple sequences: use option-based naming
+                            if (subitemIndex === 1) {
+                                name = prefix + parentName + '[' + optionIndex + ']';
+                            }
+                            else {
+                                name = prefix + parentName + '[' + optionIndex + '][' + subitemIndex + ']';
+                            }
+                        }
+                        let newRule = {
+                            name,
+                            bnf: [[convertRegex(x.text, caseInsensitive)]]
+                        };
+                        tmpRules.push(newRule);
+                        bnfSeq.push(preDecoration + newRule.name + decoration);
+                    }
+                    else {
+                        bnfSeq.push(convertRegex(x.text, caseInsensitive));
+                    }
+                    break;
+                case 'PrimaryDecoration':
+                    break;
+                default:
+                    throw new Error(' HOW SHOULD I PARSE THIS? ' + x.type + ' -> ' + JSON.stringify(x.text));
+            }
+            anterior = x;
+        }
+        return bnfSeq;
+    }
+    function createRule(tmpRules, token, name, caseInsensitive = false) {
+        // Check if this production uses the case insensitive operator ||=
+        const operatorNode = token.children.find(x => x.type == 'ProductionOperator');
+        const isCaseInsensitive = caseInsensitive || (operatorNode && operatorNode.text === '||=');
+        let sequences = token.children.filter(x => x.type == 'SequenceOrDifference');
+        // Determine if this rule has a single sequence (no alternatives)
+        const isSingleSequence = sequences.length === 1;
+        let bnf = sequences.map((s, optionIndex) => getSubItems(tmpRules, s, name, optionIndex + 1, isCaseInsensitive, isSingleSequence));
+        let rule = {
+            name,
+            bnf
+        };
+        let recover = null;
+        for (const x of bnf) {
+            recover = recover || x['recover'];
+            delete x['recover'];
+        }
+        if (name.indexOf('%') == 0)
+            rule.fragment = true;
+        if (recover)
+            rule.recover = recover;
+        tmpRules.push(rule);
+    }
+    function getRules(source, parser = BNF.defaultParser) {
+        let ast = parser.getAST(source);
+        if (!ast)
+            throw new Error('Could not parse ' + source);
+        if (ast.errors && ast.errors.length) {
+            throw ast.errors[0];
+        }
+        let tmpRules = [];
+        ast.children.filter(x => x.type == 'Production').map((x) => {
+            let name = x.children.filter(x => x.type == 'NCName')[0].text;
+            createRule(tmpRules, x, name);
+        });
+        return tmpRules;
+    }
+    BNF.getRules = getRules;
+    function Transform(source, subParser = BNF.defaultParser) {
+        return getRules(source.join(''), subParser);
+    }
+    BNF.Transform = Transform;
+    class Parser extends Parser_1.Parser {
+        constructor(source, options) {
+            const subParser = options && options.debugRulesParser === true ? new Parser_1.Parser(BNF.RULES, { debug: true }) : BNF.defaultParser;
+            super(getRules(source, subParser), options);
+        }
+        emitSource() {
+            return emit(this);
+        }
+    }
+    BNF.Parser = Parser;
+})(BNF || (BNF = {}));
+exports.default = BNF;
+
+},{"../Parser":5}],4:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Custom = exports.W3C = exports.BNF = void 0;
+var BNF_1 = require("./BNF");
+Object.defineProperty(exports, "BNF", { enumerable: true, get: function () { return BNF_1.default; } });
+var W3CEBNF_1 = require("./W3CEBNF");
+Object.defineProperty(exports, "W3C", { enumerable: true, get: function () { return W3CEBNF_1.default; } });
+var Custom_1 = require("./Custom");
+Object.defineProperty(exports, "Custom", { enumerable: true, get: function () { return Custom_1.default; } });
+
+},{"./BNF":1,"./Custom":2,"./W3CEBNF":3}],5:[function(require,module,exports){
+"use strict";
+// https://www.ics.uci.edu/~pattis/ICS-33/lectures/ebnf.pdf
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+exports.readToken = readToken;
+exports.escapeRegExp = escapeRegExp;
+exports.parseRuleName = parseRuleName;
+exports.findRuleByName = findRuleByName;
+const UPPER_SNAKE_RE = /^[A-Z0-9_]+$/;
+const decorationRE = /(\?|\+|\*)$/;
+const preDecorationRE = /^(@|&|!)/;
+const WS_RULE = 'WS';
+const TokenError_1 = require("./TokenError");
+const ParsingError_1 = require("./ParsingError");
+function readToken(txt, expr) {
+    let result = expr.exec(txt);
+    if (result && result.index == 0) {
+        if (result[0].length == 0 && expr.source.length > 0)
+            return null;
+        return {
+            type: null,
+            text: result[0],
+            rest: txt.substr(result[0].length),
+            start: 0,
+            end: result[0].length - 1,
+            fullText: result[0],
+            errors: [],
+            children: [],
+            parent: null
+        };
+    }
+    return null;
+}
+function escapeRegExp(str) {
+    return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+}
+function fixRest(token) {
+    token.rest = '';
+    if (token.children) {
+        for (const c of token.children) {
+            fixRest(c);
+        }
+    }
+}
+function fixPositions(token, start) {
+    token.start += start;
+    token.end += start;
+    if (token.children) {
+        for (const c of token.children) {
+            fixPositions(c, token.start);
+        }
+    }
+}
+function agregateErrors(errors, token) {
+    if (token.errors && token.errors.length) {
+        for (const err of token.errors) {
+            errors.push(err);
+        }
+    }
+    if (token.children) {
+        for (const tok of token.children) {
+            agregateErrors(errors, tok);
+        }
+    }
+}
+function parseRuleName(name) {
+    let postDecoration = decorationRE.exec(name);
+    let preDecoration = preDecorationRE.exec(name);
+    let postDecorationText = (postDecoration && postDecoration[0]) || '';
+    let preDecorationText = (preDecoration && preDecoration[0]) || '';
+    let out = {
+        raw: name,
+        name: name.replace(decorationRE, '').replace(preDecorationRE, ''),
+        isOptional: postDecorationText == '?' || postDecorationText == '*',
+        allowRepetition: postDecorationText == '+' || postDecorationText == '*',
+        atLeastOne: postDecorationText == '+',
+        lookupPositive: preDecorationText == '&',
+        lookupNegative: preDecorationText == '!',
+        pinned: preDecorationText == '@',
+        lookup: false,
+        isLiteral: false
+    };
+    out.isLiteral = out.name[0] == "'" || out.name[0] == '"';
+    out.lookup = out.lookupNegative || out.lookupPositive;
+    return out;
+}
+function findRuleByName(name, parser) {
+    let parsed = parseRuleName(name);
+    return parser.cachedRules[parsed.name] || null;
+}
+/// Removes all the nodes starting with 'RULE_'
+function stripRules(token, re) {
+    if (token.children) {
+        let localRules = token.children.filter(x => x.type && re.test(x.type));
+        for (let i = 0; i < localRules.length; i++) {
+            let indexOnChildren = token.children.indexOf(localRules[i]);
+            if (indexOnChildren != -1) {
+                token.children.splice(indexOnChildren, 1);
+            }
+        }
+        for (const c of token.children) {
+            stripRules(c, re);
+        }
+    }
+}
+const ignoreMissingRules = ['EOF'];
+class Parser {
+    constructor(grammarRules, options) {
+        this.grammarRules = grammarRules;
+        this.options = options;
+        this.furthestFailure = null;
+        this.originalInput = '';
+        this.parseStack = []; // Track parsing context
+        this.cachedRules = {};
+        this.debug = options ? options.debug === true : false;
+        let errors = [];
+        let neededRules = [];
+        for (const rule of grammarRules) {
+            let parsedName = parseRuleName(rule.name);
+            if (parsedName.name in this.cachedRules) {
+                errors.push('Duplicated rule ' + parsedName.name);
+                continue;
+            }
+            else {
+                this.cachedRules[parsedName.name] = rule;
+            }
+            if (!rule.bnf || !rule.bnf.length) {
+                let error = 'Missing rule content, rule: ' + rule.name;
+                if (errors.indexOf(error) == -1)
+                    errors.push(error);
+            }
+            else {
+                for (const options of rule.bnf) {
+                    if (typeof options[0] === 'string') {
+                        let parsed = parseRuleName(options[0]);
+                        if (parsed.name == rule.name) {
+                            let error = 'Left recursion is not allowed, rule: ' + rule.name;
+                            if (errors.indexOf(error) == -1)
+                                errors.push(error);
+                        }
+                    }
+                    for (const option of options) {
+                        if (typeof option == 'string') {
+                            let name = parseRuleName(option);
+                            if (!name.isLiteral &&
+                                neededRules.indexOf(name.name) == -1 &&
+                                ignoreMissingRules.indexOf(name.name) == -1)
+                                neededRules.push(name.name);
+                        }
+                    }
+                }
+            }
+            if (WS_RULE == rule.name)
+                rule.implicitWs = false;
+            if (rule.implicitWs) {
+                if (neededRules.indexOf(WS_RULE) == -1)
+                    neededRules.push(WS_RULE);
+            }
+            if (rule.recover) {
+                if (neededRules.indexOf(rule.recover) == -1)
+                    neededRules.push(rule.recover);
+            }
+        }
+        for (const ruleName of neededRules) {
+            if (!(ruleName in this.cachedRules)) {
+                errors.push('Missing rule ' + ruleName);
+            }
+        }
+        if (errors.length)
+            throw new Error(errors.join('\n'));
+    }
+    getAST(txt, target) {
+        if (!target) {
+            target = this.grammarRules.filter(x => !x.fragment && x.name.indexOf('%') != 0)[0].name;
+        }
+        // Reset failure tracking for each new parse
+        this.furthestFailure = null;
+        this.originalInput = txt;
+        this.parseStack = [];
+        let result = this.parse(txt, target, 0, 0);
+        if (result) {
+            agregateErrors(result.errors, result);
+            fixPositions(result, 0);
+            // REMOVE ALL THE TAGS MATCHING /^%/
+            stripRules(result, /^%/);
+            if (!this.options || !this.options.keepUpperRules)
+                stripRules(result, UPPER_SNAKE_RE);
+            let rest = result.rest;
+            if (rest) {
+                new TokenError_1.TokenError('Unexpected end of input: \n' + rest, result);
+            }
+            fixRest(result);
+            result.rest = rest;
+        }
+        else {
+            // Parsing failed completely - throw ParsingError
+            if (this.furthestFailure) {
+                const position = this.calculatePosition(this.originalInput, this.furthestFailure.offset);
+                const found = this.furthestFailure.found;
+                // Extract parent-most rules first
+                const parentMostRules = this.extractParentMostRules(this.furthestFailure.tree);
+                // Build failure tree starting from the parent-most failing rules
+                const failureTree = this.buildFailureTree(this.furthestFailure.tree, parentMostRules, this.furthestFailure.regexMap);
+                throw new ParsingError_1.ParsingError('Failed to parse input', position, parentMostRules, found, failureTree);
+            }
+            else {
+                // Fallback if no failure was tracked
+                throw new ParsingError_1.ParsingError('Failed to parse input', { offset: 0, line: 1, column: 1 }, [target], txt.length > 0 ? txt.charAt(0) : 'end of input');
+            }
+        }
+        return result;
+    }
+    emitSource() {
+        return 'CANNOT EMIT SOURCE FROM BASE Parser';
+    }
+    calculatePosition(txt, offset) {
+        let line = 1;
+        let column = 1;
+        for (let i = 0; i < offset && i < txt.length; i++) {
+            // Handle \r\n as a single line ending
+            if (txt[i] === '\r' && i + 1 < txt.length && txt[i + 1] === '\n') {
+                line++;
+                column = 1;
+                i++; // Skip the \n
+            }
+            else if (txt[i] === '\n' || txt[i] === '\r') {
+                line++;
+                column = 1;
+            }
+            else {
+                column++;
+            }
+        }
+        return { offset, line, column };
+    }
+    recordFailure(offset, expected) {
+        const expectedKey = expected instanceof RegExp ? expected.source : expected;
+        if (!this.furthestFailure || offset > this.furthestFailure.offset) {
+            // This is a new furthest failure
+            let found;
+            if (offset >= this.originalInput.length) {
+                found = 'end of input';
+            }
+            else {
+                // Extract a meaningful token/substring from the failure position
+                const remaining = this.originalInput.substring(offset);
+                // Skip whitespace using replace
+                const trimmed = remaining.replace(/^\s+/, '');
+                if (trimmed.length === 0) {
+                    found = 'end of input';
+                }
+                else {
+                    // Try to extract a word/token (alphanumeric + some symbols)
+                    const match = trimmed.match(/^[^\s\}\]\),;]+/);
+                    if (match && match[0].length > 0) {
+                        found = match[0];
+                    }
+                    else {
+                        // Fallback to first character after whitespace
+                        found = trimmed.charAt(0);
+                    }
+                }
+            }
+            this.furthestFailure = {
+                offset,
+                expected: new Set([expectedKey]),
+                found,
+                tree: new Map(),
+                regexMap: new Map()
+            };
+            // Store regex instance if it's a RegExp
+            if (expected instanceof RegExp) {
+                this.furthestFailure.regexMap.set(expected.source, expected);
+            }
+            this.recordParentChildRelationship(expected);
+            this.furthestFailure.expected.add(expectedKey);
+        }
+        else if (offset === this.furthestFailure.offset) {
+            // Same position, add to expected set
+            this.furthestFailure.expected.add(expectedKey);
+            // Store regex instance if it's a RegExp
+            if (expected instanceof RegExp) {
+                this.furthestFailure.regexMap.set(expected.source, expected);
+            }
+            this.recordParentChildRelationship(expected);
+        }
+    }
+    recordParentChildRelationship(expected) {
+        if (!this.furthestFailure)
+            return;
+        if (this.parseStack.length > 0) {
+            const parent = this.parseStack[this.parseStack.length - 1];
+            if (!this.furthestFailure.tree.has(parent)) {
+                this.furthestFailure.tree.set(parent, new Set());
+            }
+            this.furthestFailure.tree.get(parent).add(expected);
+        }
+        else {
+            // No parent, this is a top-level failure
+            if (!this.furthestFailure.tree.has('__ROOT__')) {
+                this.furthestFailure.tree.set('__ROOT__', new Set());
+            }
+            this.furthestFailure.tree.get('__ROOT__').add(expected);
+        }
+    }
+    extractParentMostRules(tree) {
+        // The "parent most failing option" is the rule we were trying to match
+        // when all its alternatives failed. In the tree structure, this is typically
+        // the direct child of the top-most parent that has alternatives.
+        // Helper to get string name from value
+        const getName = (value) => value instanceof RegExp ? value.source : value;
+        // If we have __ROOT__, find its direct children that have alternatives
+        if (tree.has('__ROOT__')) {
+            const rootChildren = Array.from(tree.get('__ROOT__')).map(getName);
+            // Return root children that have their own children (alternatives)
+            const result = rootChildren.filter(child => tree.has(child) && tree.get(child).size > 0);
+            if (result.length > 0) {
+                return result;
+            }
+            // If none have children, return the root children themselves
+            return rootChildren;
+        }
+        // Find the top-most parent (not a child of any other parent)
+        const allChildren = new Set();
+        const allParents = new Set();
+        for (const [parent, children] of tree.entries()) {
+            allParents.add(parent);
+            for (const child of children) {
+                allChildren.add(getName(child));
+            }
+        }
+        const topMostParents = Array.from(allParents).filter(parent => !allChildren.has(parent));
+        // For each top-most parent, get its direct children that have alternatives
+        const result = [];
+        for (const parent of topMostParents) {
+            if (tree.has(parent)) {
+                const children = Array.from(tree.get(parent));
+                for (const child of children) {
+                    const childName = getName(child);
+                    if (tree.has(childName) && tree.get(childName).size > 0) {
+                        result.push(childName);
+                    }
+                }
+            }
+        }
+        if (result.length > 0) {
+            return result;
+        }
+        // Fallback: return top-most parents
+        if (topMostParents.length > 0) {
+            return topMostParents;
+        }
+        // Last fallback: return all unique rules
+        return Array.from(new Set([...allParents, ...allChildren]));
+    }
+    /**
+     * Determines if a value represents a terminal/literal rather than a non-terminal rule.
+     */
+    isLiteralOrTerminal(value) {
+        if (value instanceof RegExp) {
+            return true;
+        }
+        // Check if it's a literal (starts with " or ')
+        if (value.startsWith('"') || value.startsWith("'")) {
+            return true;
+        }
+        // Check if it's a regex pattern (starts with [ or contains #x followed by hex digits)
+        if (value.startsWith('[') || /\#x[0-9a-fA-F]/.test(value)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Extracts the expected value from a terminal/literal.
+     * - For string literals (quoted), removes the quotes and returns the content
+     * - For regex patterns, returns the RegExp instance
+     */
+    extractExpectedValue(value, regexMap) {
+        if (value instanceof RegExp) {
+            return value;
+        }
+        // If it's a string literal (starts with " or '), parse it to remove quotes
+        if (value.startsWith('"')) {
+            try {
+                return JSON.parse(value);
+            }
+            catch (_a) {
+                return value;
+            }
+        }
+        else if (value.startsWith("'")) {
+            // Single-quoted string - remove quotes
+            return value.replace(/^'(.+)'$/, '$1').replace(/\\'/g, "'");
+        }
+        // Check if this is a regex pattern string that we have a RegExp instance for
+        if (regexMap.has(value)) {
+            return regexMap.get(value);
+        }
+        // For other terminals, return as-is
+        return value;
+    }
+    buildFailureTree(tree, startRules, regexMap) {
+        const buildNode = (value) => {
+            const name = value instanceof RegExp ? value.source : value;
+            const node = { name };
+            if (tree.has(name)) {
+                const children = Array.from(tree.get(name));
+                if (children.length > 0) {
+                    // If this rule has exactly one child and that child is a terminal,
+                    // set expected to that terminal instead of creating children
+                    if (children.length === 1 && this.isLiteralOrTerminal(children[0])) {
+                        node.expected = this.extractExpectedValue(children[0], regexMap || new Map());
+                    }
+                    else {
+                        // Build child nodes
+                        const childNodes = children.map(child => buildNode(child));
+                        // Check if this node should be flattened:
+                        // If it has exactly one child AND that child has an expected value (is terminal)
+                        if (childNodes.length === 1 && childNodes[0].expected !== undefined && childNodes[0].children === undefined) {
+                            node.expected = childNodes[0].expected;
+                        }
+                        else {
+                            node.children = childNodes;
+                        }
+                    }
+                }
+            }
+            else if (this.isLiteralOrTerminal(value)) {
+                // If this is a terminal/literal with no children, set expected to itself
+                node.expected = this.extractExpectedValue(value, regexMap || new Map());
+            }
+            return node;
+        };
+        // If startRules are provided, start from those rules
+        if (startRules && startRules.length > 0) {
+            return startRules.map(rule => buildNode(rule));
+        }
+        // Start from root if it exists, otherwise from parent-most rules
+        if (tree.has('__ROOT__')) {
+            const rootChildren = Array.from(tree.get('__ROOT__'));
+            return rootChildren.map(child => buildNode(child));
+        }
+        // Find parent-most rules (rules that are not children of other rules)
+        const allChildren = new Set();
+        for (const children of tree.values()) {
+            for (const child of children) {
+                const childName = child instanceof RegExp ? child.source : child;
+                allChildren.add(childName);
+            }
+        }
+        const parentMost = Array.from(tree.keys()).filter(parent => !allChildren.has(parent));
+        return parentMost.map(parent => buildNode(parent));
+    }
+    parse(txt, target, recursion = 0, offset = 0) {
+        let out = null;
+        let type = parseRuleName(target);
+        let expr;
+        let printable = this.debug && /*!isLiteral &*/ !UPPER_SNAKE_RE.test(type.name);
+        printable &&
+            console.log(new Array(recursion).join('│  ') + 'Trying to get ' + target + ' from ' + JSON.stringify(txt.split('\n')[0]));
+        let realType = type.name;
+        let targetLex = findRuleByName(type.name, this);
+        if (type.name == 'EOF') {
+            if (txt.length) {
+                this.recordFailure(offset, 'EOF');
+                return null;
+            }
+            else if (txt.length == 0) {
+                return {
+                    type: 'EOF',
+                    text: '',
+                    rest: '',
+                    start: 0,
+                    end: 0,
+                    fullText: '',
+                    errors: [],
+                    children: [],
+                    parent: null
+                };
+            }
+        }
+        try {
+            if (!targetLex && type.isLiteral) {
+                let src = type.name.trim();
+                if (src.startsWith('"')) {
+                    src = JSON.parse(src);
+                }
+                else if (src.startsWith("'")) {
+                    src = src.replace(/^'(.+)'$/, '$1').replace(/\\'/g, "'");
+                }
+                if (src === '') {
+                    return {
+                        type: '%%EMPTY%%',
+                        text: '',
+                        rest: txt,
+                        start: 0,
+                        end: 0,
+                        fullText: '',
+                        errors: [],
+                        children: [],
+                        parent: null
+                    };
+                }
+                expr = new RegExp(escapeRegExp(src));
+                realType = null;
+            }
+        }
+        catch (e) {
+            if (e instanceof ReferenceError) {
+                console.error(e);
+            }
+            this.recordFailure(offset, target);
+            return null;
+        }
+        if (expr) {
+            let result = readToken(txt, expr);
+            if (result) {
+                result.type = realType;
+                return result;
+            }
+            else {
+                // Literal or regex match failed
+                this.recordFailure(offset, type.isLiteral ? type.name : target);
+            }
+        }
+        else {
+            let options = targetLex.bnf;
+            if (options instanceof Array) {
+                // Push this rule onto the parse stack
+                this.parseStack.push(type.name);
+                optionsLoop: for (const phases of options) {
+                    if (out)
+                        break;
+                    let pinned = null;
+                    let tmp = {
+                        type: type.name,
+                        text: '',
+                        children: [],
+                        end: 0,
+                        errors: [],
+                        fullText: '',
+                        parent: null,
+                        start: 0,
+                        rest: txt
+                    };
+                    if (targetLex.fragment)
+                        tmp.fragment = true;
+                    let tmpTxt = txt;
+                    let position = 0;
+                    let allOptional = phases.length > 0;
+                    let foundSomething = false;
+                    for (let i = 0; i < phases.length; i++) {
+                        if (typeof phases[i] == 'string') {
+                            let localTarget = parseRuleName(phases[i]);
+                            allOptional = allOptional && localTarget.isOptional;
+                            let got;
+                            let foundAtLeastOne = false;
+                            do {
+                                got = null;
+                                if (targetLex.implicitWs) {
+                                    got = this.parse(tmpTxt, localTarget.name, recursion + 1, offset + position);
+                                    if (!got) {
+                                        let WS;
+                                        do {
+                                            WS = this.parse(tmpTxt, WS_RULE, recursion + 1, offset + position);
+                                            if (WS) {
+                                                tmp.text = tmp.text + WS.text;
+                                                tmp.end = tmp.text.length;
+                                                WS.parent = tmp;
+                                                tmp.children.push(WS);
+                                                tmpTxt = tmpTxt.substr(WS.text.length);
+                                                position += WS.text.length;
+                                            }
+                                            else {
+                                                break;
+                                            }
+                                        } while (WS && WS.text.length);
+                                    }
+                                }
+                                got = got || this.parse(tmpTxt, localTarget.name, recursion + 1, offset + position);
+                                // rule ::= "true" ![a-zA-Z]
+                                // negative lookup, if it does not match, we should continue
+                                if (localTarget.lookupNegative) {
+                                    if (got)
+                                        continue optionsLoop; /* cancel this path */
+                                    break;
+                                }
+                                if (localTarget.lookupPositive) {
+                                    if (!got)
+                                        continue optionsLoop;
+                                }
+                                if (!got) {
+                                    if (localTarget.isOptional)
+                                        break;
+                                    if (localTarget.atLeastOne && foundAtLeastOne)
+                                        break;
+                                    // Record this failure for error reporting
+                                    this.recordFailure(offset + position, localTarget.name);
+                                }
+                                if (got && targetLex.pinned == i + 1) {
+                                    pinned = got;
+                                    printable && console.log(new Array(recursion + 1).join('│  ') + '└─ ' + got.type + ' PINNED');
+                                }
+                                if (!got)
+                                    got = this.parseRecovery(targetLex, tmpTxt, recursion + 1, offset + position);
+                                if (!got) {
+                                    if (pinned) {
+                                        out = tmp;
+                                        got = {
+                                            type: 'SyntaxError',
+                                            text: tmpTxt,
+                                            children: [],
+                                            end: tmpTxt.length,
+                                            errors: [],
+                                            fullText: '',
+                                            parent: null,
+                                            start: 0,
+                                            rest: ''
+                                        };
+                                        if (tmpTxt.length) {
+                                            new TokenError_1.TokenError(`Unexpected end of input. Expecting ${localTarget.name} Got: ${tmpTxt}`, got);
+                                        }
+                                        else {
+                                            new TokenError_1.TokenError(`Unexpected end of input. Missing ${localTarget.name}`, got);
+                                        }
+                                        printable &&
+                                            console.log(new Array(recursion + 1).join('│  ') + '└─ ' + got.type + ' ' + JSON.stringify(got.text));
+                                    }
+                                    else {
+                                        continue optionsLoop;
+                                    }
+                                }
+                                foundAtLeastOne = true;
+                                foundSomething = true;
+                                if (got.type == '%%EMPTY%%') {
+                                    break;
+                                }
+                                got.start += position;
+                                got.end += position;
+                                if (!localTarget.lookupPositive && got.type) {
+                                    if (got.fragment) {
+                                        if (got.children) {
+                                            for (const x of got.children) {
+                                                x.start += position;
+                                                x.end += position;
+                                                x.parent = tmp;
+                                                tmp.children.push(x);
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        got.parent = tmp;
+                                        tmp.children.push(got);
+                                    }
+                                }
+                                if (localTarget.lookup)
+                                    got.lookup = true;
+                                printable &&
+                                    console.log(new Array(recursion + 1).join('│  ') + '└─ ' + got.type + ' ' + JSON.stringify(got.text));
+                                // Eat it from the input stream, only if it is not a lookup
+                                if (!localTarget.lookup && !got.lookup) {
+                                    tmp.text = tmp.text + got.text;
+                                    tmp.end = tmp.text.length;
+                                    tmpTxt = tmpTxt.substr(got.text.length);
+                                    position += got.text.length;
+                                }
+                                tmp.rest = tmpTxt;
+                            } while (got && localTarget.allowRepetition && tmpTxt.length && !got.lookup);
+                        } /* IS A REGEXP */
+                        else {
+                            let got = readToken(tmpTxt, phases[i]);
+                            if (!got) {
+                                this.recordFailure(offset + position, phases[i]);
+                                continue optionsLoop;
+                            }
+                            printable &&
+                                console.log(new Array(recursion + 1).join('│  ') + '└> ' + JSON.stringify(got.text) + phases[i].source);
+                            foundSomething = true;
+                            got.start += position;
+                            got.end += position;
+                            tmp.text = tmp.text + got.text;
+                            tmp.end = tmp.text.length;
+                            tmpTxt = tmpTxt.substr(got.text.length);
+                            position += got.text.length;
+                            tmp.rest = tmpTxt;
+                        }
+                    }
+                    if (foundSomething) {
+                        out = tmp;
+                        printable &&
+                            console.log(new Array(recursion).join('│  ') + '├<─┴< PUSHING ' + out.type + ' ' + JSON.stringify(out.text));
+                    }
+                }
+                // Pop this rule from the parse stack
+                this.parseStack.pop();
+            }
+            if (out && targetLex.simplifyWhenOneChildren && out.children.length == 1) {
+                out = out.children[0];
+            }
+        }
+        if (!out) {
+            printable && console.log(target + ' NOT RESOLVED FROM ' + txt);
+        }
+        return out;
+    }
+    parseRecovery(recoverableToken, tmpTxt, recursion, offset) {
+        if (recoverableToken.recover && tmpTxt.length) {
+            let printable = this.debug;
+            printable &&
+                console.log(new Array(recursion + 1).join('│  ') +
+                    'Trying to recover until token ' +
+                    recoverableToken.recover +
+                    ' from ' +
+                    JSON.stringify(tmpTxt.split('\n')[0] + tmpTxt.split('\n')[1]));
+            let tmp = {
+                type: 'SyntaxError',
+                text: '',
+                children: [],
+                end: 0,
+                errors: [],
+                fullText: '',
+                parent: null,
+                start: 0,
+                rest: ''
+            };
+            let got;
+            let currentOffset = offset;
+            do {
+                got = this.parse(tmpTxt, recoverableToken.recover, recursion + 1, currentOffset);
+                if (got) {
+                    new TokenError_1.TokenError('Unexpected input: "' + tmp.text + `" Expecting: ${recoverableToken.name}`, tmp);
+                    break;
+                }
+                else {
+                    tmp.text = tmp.text + tmpTxt[0];
+                    tmp.end = tmp.text.length;
+                    tmpTxt = tmpTxt.substr(1);
+                    currentOffset++;
+                }
+            } while (!got && tmpTxt.length > 0);
+            if (tmp.text.length > 0 && got) {
+                printable && console.log(new Array(recursion + 1).join('│  ') + 'Recovered text: ' + JSON.stringify(tmp.text));
+                return tmp;
+            }
+        }
+        return null;
+    }
+}
+exports.Parser = Parser;
+exports.default = Parser;
+
+},{"./ParsingError":6,"./TokenError":8}],6:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParsingError = void 0;
+class ParsingError extends Error {
+    constructor(message, position, expected, found, failureTree) {
+        super(message);
+        this.name = 'ParsingError';
+        this.position = position;
+        this.expected = expected;
+        this.found = found;
+        this.failureTree = failureTree;
+        // Maintain proper prototype chain for instanceof checks
+        Object.setPrototypeOf(this, ParsingError.prototype);
+    }
+    toString() {
+        const { line, column, offset } = this.position;
+        let msg = `${this.name}: ${this.message}\n`;
+        msg += `  at line ${line}, column ${column} (offset ${offset})\n`;
+        msg += `  Expected: ${this.expected.join(', ')}\n`;
+        msg += `  Found: ${this.found}`;
+        return msg;
+    }
+}
+exports.ParsingError = ParsingError;
+
+},{}],7:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findChildrenByType = findChildrenByType;
+/**
+ * Finds all the direct childs of a specifyed type
+ */
+function findChildrenByType(token, type) {
+    return token.children ? token.children.filter(x => x.type == type) : [];
+}
+
+},{}],8:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenError = void 0;
+class TokenError extends Error {
+    constructor(message, token) {
+        super(message);
+        this.message = message;
+        this.token = token;
+        if (token && token.errors)
+            token.errors.push(this);
+        else
+            throw this;
+    }
+    inspect() {
+        return 'SyntaxError: ' + this.message;
+    }
+}
+exports.TokenError = TokenError;
+
+},{}],9:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParsingError = exports.TokenError = exports.Parser = void 0;
+var Parser_1 = require("./Parser");
+Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return Parser_1.Parser; } });
+var TokenError_1 = require("./TokenError");
+Object.defineProperty(exports, "TokenError", { enumerable: true, get: function () { return TokenError_1.TokenError; } });
+var ParsingError_1 = require("./ParsingError");
+Object.defineProperty(exports, "ParsingError", { enumerable: true, get: function () { return ParsingError_1.ParsingError; } });
+exports.Grammars = require("./Grammars");
+
+},{"./Grammars":4,"./Parser":5,"./ParsingError":6,"./TokenError":8}],10:[function(require,module,exports){
+// Browser entry point that uses production files
+module.exports = require('./RuleParser.production')
+
+},{"./RuleParser.production":12}],11:[function(require,module,exports){
+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":"arithmetic_operand","bnf":[["fcall"],["number_time"],["number"]]},{"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","bnf":[["false"],["true"],["array"],["time_period"],["number_time"],["number"],["number_tod"],["string"]]},{"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_number[1]","bnf":[["number_time"],["number"]],"fragment":true},{"name":"%between_number[2][1]","bnf":[["WS+",/[Aa]/,/[Nn]/,/[Dd]/,"WS+"]],"fragment":true},{"name":"%between_number[2][2]","bnf":[["WS*",/\-/,"WS*"]],"fragment":true},{"name":"%between_number[2]","bnf":[["%between_number[2][1]"],["%between_number[2][2]"]],"fragment":true},{"name":"%between_number[3]","bnf":[["number_time"],["number"]],"fragment":true},{"name":"between_number","bnf":[["%between_number[1]","%between_number[2]","%between_number[3]"]]},{"name":"%between_number_time[2][1]","bnf":[["WS+",/[Aa]/,/[Nn]/,/[Dd]/,"WS+"]],"fragment":true},{"name":"%between_number_time[2][2]","bnf":[["WS*",/\-/,"WS*"]],"fragment":true},{"name":"%between_number_time[2]","bnf":[["%between_number_time[2][1]"],["%between_number_time[2][2]"]],"fragment":true},{"name":"%between_number_time[4]","bnf":[["WS+","dow_range"]],"fragment":true},{"name":"between_number_time","bnf":[["number_time","%between_number_time[2]","number_time","%between_number_time[4]?"]]},{"name":"%between_tod[2][1]","bnf":[["WS+",/[Aa]/,/[Nn]/,/[Dd]/,"WS+"]],"fragment":true},{"name":"%between_tod[2]","bnf":[["%between_tod[2][1]"]],"fragment":true},{"name":"%between_tod[4]","bnf":[["WS+","dow_range"]],"fragment":true},{"name":"between_tod","bnf":[["number_tod","%between_tod[2]","number_tod","%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[4]","bnf":[["WS+",/[Tt]/,/[Oo]/,"WS+","dow"]],"fragment":true},{"name":"dow_range","bnf":[[/[Oo]/,/[Nn]/,"WS+","dow","%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":"%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"]],"fragment":true},{"name":"time_period_ago","bnf":[["number_time","%time_period_ago[2]*","WS+","AGO"]]},{"name":"%time_period_ago_between[2]","bnf":[["WS+","number_time"]],"fragment":true},{"name":"time_period_ago_between","bnf":[["number_time","%time_period_ago_between[2]*","WS+","AGO","WS+","between_tod_only"]]},{"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]/]]}]
+},{}],12:[function(require,module,exports){
+const {Parser} = require('ebnf/dist/Parser.js'), {ParsingError} = require('ebnf');
+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) {
+        let ret;
+        if (!ParserCache) {
+            ParserCache = new Parser(ParserRules, { debug: false });
+        }
+        try {
+            ret = ParserCache.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) {
+            return {
+                start: normalizeDow(dowRange.children[0].text),
+                end: normalizeDow(dowRange.children[0].text)
+            };
+        } else if (dowRange.children.length === 2) {
+            return {
+                start: normalizeDow(dowRange.children[0].text),
+                end: normalizeDow(dowRange.children[1].text)
+            };
+        } 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') {
+                        const number = parseFloat(child.children[0].text);
+                        const unit = child.children[1].text.toUpperCase();
+                        components.push([
+                            number,
+                            unit
+                        ]);
+                        totalSeconds += RuleParser.__parseValue(child);
+                    }
+                }
+                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 betweenTodOnly = null;
+                for (let i = 0; i < tp.children.length; i++) {
+                    if (tp.children[i].type === 'number_time') {
+                        totalSeconds += RuleParser.__parseValue(tp.children[i]);
+                    } else if (tp.children[i].type === 'between_tod_only') {
+                        betweenTodOnly = tp.children[i];
+                    }
+                }
+                if (!betweenTodOnly) {
+                    throw new Error('time_period_ago_between requires between_tod_only child');
+                }
+                const betweenTod = betweenTodOnly.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
+                ];
+            }
+        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[1]);
+                if (betweenNumberTime.children.length > 2 && betweenNumberTime.children[2].type === 'dow_range') {
+                    const dow = RuleParser._parseDowRange(betweenNumberTime.children[2]);
+                    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 '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.children[0]));
+                }
+                return ret;
+            }
+        default:
+            throw new Error(`Unknown value type ${ type }`);
+        }
+    }
+    static _parseValue(value) {
+        const child = value.children[0];
+        const type = child.type;
+        switch (type) {
+        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':
+            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[1])
+                                ]
+                            ];
+                        }
+                    }
+                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[1])
+                        ]
+                    ];
+                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 {ParsingError} = require('ebnf');
+                const {RuleParseError} = require('./errors/RuleParseError');
+                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 {RuleParseError} = require('./errors/RuleParseError');
+                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.ParsingError = require('ebnf').ParsingError;
+module.exports.RuleParseError = require('./errors/RuleParseError').RuleParseError;
+},{"./RuleParser.production.ebnf.js":11,"./errors/ErrorAnalyzer":13,"./errors/RuleParseError":14,"ebnf":9,"ebnf/dist/Parser.js":5}],13:[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":14,"ebnf":9}],14:[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 };
+
+},{}]},{},[10])(10)
+});