@halleyassist/rule-templater 0.0.1 → 0.0.4

package/dist/rule-templater.browser.js

@@ -0,0 +1,2453 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.RuleTemplater = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+const {Grammars} = require('ebnf');
+
+const grammar = `
+statement_main       ::= statement EOF
+logical_operator     ||= AND | OR
+statement            ::= expression (logical_operator expression)*
+expression           ::= not_expression | standard_expression | parenthesis_expression
+parenthesis_expression ::= BEGIN_PARENTHESIS WS* statement WS* END_PARENTHESIS
+not_expression       ||= NOT (result | parenthesis_expression)
+standard_expression  ||= result ((WS* eq_approx) | (WS* basic_rhs) | ((WS+ IS)? WS+ between) | (WS+ in_expr))?
+basic_rhs            ::= operator WS* result
+eq_approx            ::= eq_operator WS* "~" WS* result
+
+PLUS                 ::= "+"
+MINUS                ::= "-"
+MULTIPLY             ::= "*"
+DIVIDE               ::= "/"
+MODULUS              ::= "%"
+DEFAULT_VAL          ::= "??"
+arithmetic_operator  ::= PLUS | MINUS | MULTIPLY | DIVIDE | MODULUS | DEFAULT_VAL
+
+number_atom          ::= number
+number_time_atom     ::= number_time
+tod_atom             ::= number_tod
+dow_atom             ::= dow
+
+arithmetic_operand   ::= fcall | number_time_atom | number_atom
+arithmetic_result    ::= arithmetic_operand WS* arithmetic_operator WS* (arithmetic_result | arithmetic_operand)
+
+simple_result        ::= fcall | value
+result               ::= arithmetic_result | simple_result
+
+value_atom           ::= false | true | array | time_period | number_time_atom | number_atom | tod_atom | string
+value                ::= value_atom
+
+BEGIN_ARRAY          ::= WS* #x5B WS*  /* [ */
+BEGIN_OBJECT         ::= WS* #x7B WS*  /* { */
+END_ARRAY            ::= WS* #x5D WS*  /* ] */
+END_OBJECT           ::= WS* #x7D WS*  /* } */
+NAME_SEPARATOR       ::= WS* #x3A WS*  /* : */
+VALUE_SEPARATOR      ::= WS* #x2C WS*  /* , */
+WS                   ::= [#x20#x09#x0A#x0D]
+
+operator             ::= GTE | LTE | GT | LT | EQ | NEQ
+eq_operator          ::= EQ | NEQ
+
+BEGIN_ARGUMENT       ::= "("
+END_ARGUMENT         ::= ")"
+BEGIN_PARENTHESIS    ::= "("
+END_PARENTHESIS      ::= ")"
+
+BEGIN_IN             ||= "IN"
+in_expr              ::= BEGIN_IN WS* BEGIN_PARENTHESIS WS* arguments END_PARENTHESIS
+
+argument             ::= statement WS*
+arguments            ::= argument (WS* "," WS* argument)*
+fname                ::= [A-Za-z0-9]+
+fcall                ::= fname WS* BEGIN_ARGUMENT WS* arguments? END_ARGUMENT
+
+between_dash_or_and  ||= (WS+ "AND" WS+) | (WS* "-" WS*)
+
+between_number_inner ::= number_atom | number_time_atom
+between_number       ||= between_number_inner between_dash_or_and between_number_inner
+
+between_number_time_inner ::= number_time_atom
+between_number_time  ||= between_number_time_inner between_dash_or_and between_number_time_inner (WS+ dow_range)?
+
+between_tod_inner    ::= tod_atom
+between_tod          ||= between_tod_inner (WS+ "AND" WS+) between_tod_inner (WS+ dow_range)?
+
+between              ||= "BETWEEN" WS+ (between_number | between_tod)
+
+dow                  ||= "MONDAY" | "MON" | "TUESDAY" | "TUE" | "WEDNESDAY" | "WED" | "THURSDAY" | "THU" | "THUR" | "FRIDAY" | "FRI" | "SATURDAY" | "SAT" | "SUNDAY" | "SUN"
+
+dow_range_inner      ::= dow_atom
+dow_range            ||= "ON" WS+ dow_range_inner (WS+ "TO" WS+ dow_range_inner)?
+
+between_time_only    ||= "BETWEEN" WS+ between_number_time
+between_tod_only     ||= "BETWEEN" WS+ between_tod
+
+AND                  ||= (WS* "&&" WS*) | (WS+ "AND" WS+)
+OR                   ||= (WS* "||" WS*) | (WS+ "OR" WS+)
+AGO                  ||= "AGO"
+GT                   ::= ">"
+LT                   ::= "<"
+GTE                  ::= ">="
+LTE                  ::= "<="
+IS                   ||= "is"
+EQ                   ::= "==" | "="
+NEQ                  ::= "!="
+NOT                  ||= ("!" WS*) | ("not" WS+)
+
+false                ||= "FALSE"
+null                 ||= "null"
+true                 ||= "TRUE"
+
+array                ::= BEGIN_ARRAY (value (VALUE_SEPARATOR value)*)? END_ARRAY
+
+unit                 ||= "seconds" | "minutes" | "hours" | "weeks" | "days" | "second" | "minute" | "week" | "hour" | "day" | "mins" | "min"
+
+number               ::= "-"? ([0-9]+) ("." [0-9]+)? ("e" ("-" | "+")? ("0" | [1-9] [0-9]*))?
+number_time          ::= number WS+ unit
+number_tod           ::= ([0-9]+) ":" ([0-9]+)
+
+time_period_ago      ||= number_time_atom (WS+ number_time_atom)* WS+ AGO
+time_period_ago_between ||= number_time_atom (WS+ number_time_atom)* WS+ AGO WS+ between_tod_only
+time_period_const    ||= "today" | time_period_ago
+time_period          ::= time_period_ago_between | time_period_const | between_tod_only | between_time_only
+
+string               ::= '"' (([#x20-#x21] | [#x23-#x5B] | [#x5D-#xFFFF]) | #x5C (#x22 | #x5C | #x2F | #x62 | #x66 | #x6E | #x72 | #x74 | #x75 HEXDIG HEXDIG HEXDIG HEXDIG))* '"'
+HEXDIG               ::= [a-fA-F0-9]
+`
+
+module.exports = Grammars.W3C.getRules(grammar);
+
+},{"ebnf":10}],2:[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":6,"../SemanticHelpers":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 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":6,"../TokenError":9}],4:[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":6}],5:[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":2,"./Custom":3,"./W3CEBNF":4}],6:[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":7,"./TokenError":9}],7:[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;
+
+},{}],8:[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) : [];
+}
+
+},{}],9:[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;
+
+},{}],10:[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":5,"./Parser":6,"./ParsingError":7,"./TokenError":9}],11:[function(require,module,exports){
+module.exports=[{"name":"TEMPLATE_BEGIN","bnf":[["\"${\""]]},{"name":"TEMPLATE_END","bnf":[["\"}\""]]},{"name":"PIPE","bnf":[["\"|\""]]},{"name":"%IDENT[2]","bnf":[[/[A-Za-z0-9_]/]]},{"name":"IDENT","bnf":[[/[A-Za-z_]/,"%IDENT[2]*"]]},{"name":"DOT","bnf":[["\".\""]]},{"name":"template_value","bnf":[["TEMPLATE_BEGIN","WS*","template_expr","WS*","TEMPLATE_END"]]},{"name":"%template_expr[2]","bnf":[["WS*","template_pipe","WS*","template_filter_call"]],"fragment":true},{"name":"template_expr","bnf":[["template_path","%template_expr[2]*"]]},{"name":"template_pipe","bnf":[["PIPE"]]},{"name":"%template_path[2]","bnf":[["WS*","DOT","WS*","IDENT"]],"fragment":true},{"name":"template_path","bnf":[["IDENT","%template_path[2]*"]]},{"name":"%template_filter_call[2]","bnf":[["WS*","BEGIN_ARGUMENT","WS*","template_filter_args?","WS*","END_ARGUMENT"]],"fragment":true},{"name":"template_filter_call","bnf":[["template_filter_name","%template_filter_call[2]?"]]},{"name":"template_filter_name","bnf":[["IDENT"]]},{"name":"%template_filter_args[2]","bnf":[["WS*","\",\"","WS*","template_filter_arg"]],"fragment":true},{"name":"template_filter_args","bnf":[["template_filter_arg","%template_filter_args[2]*"]]},{"name":"template_filter_arg","bnf":[["value"],["template_value"]]},{"name":"number_atom","bnf":[["number"],["template_value"]]},{"name":"number_time_atom","bnf":[["number_time"],["template_value"]]},{"name":"tod_atom","bnf":[["number_tod"],["template_value"]]},{"name":"dow_atom","bnf":[["dow"],["template_value"]]},{"name":"between_time_only_atom","bnf":[["between_time_only"],["template_value"]]},{"name":"between_tod_only_atom","bnf":[["between_tod_only"],["template_value"]]}]
+},{}],12:[function(require,module,exports){
+module.exports = require('./RuleTemplater.production.js');
+},{"./RuleTemplater.production.js":13}],13:[function(require,module,exports){
+// Note: We import the internal RuleParser.ebnf to extend the grammar with template rules.
+// This creates coupling to the internal structure of @halleyassist/rule-parser.
+const RuleParserRules = require('@halleyassist/rule-parser/src/RuleParser.ebnf'),
+      TemplateGrammar = require('./RuleTemplate.production.ebnf.js'),
+      TemplateFilters = require('./TemplateFilters'),
+        {Parser} = require('ebnf');
+
+let ParserCache = null;
+
+const VariableTypes = [
+    'string',
+    'number',
+    'boolean',
+    'object',
+    'time period',
+    'time value',
+    'string array',
+    'number array',
+    'boolean array',
+    'object array'
+]
+
+const AllowedTypeMapping = {
+    'string': ['string_atom', 'string_concat'],
+    'number': ['number_atom', 'math_expr'],
+    'boolean': ['boolean_atom', 'boolean_expr'],
+    'time period': ['time_period_atom'],
+    'time value': ['time_value_atom', 'tod_atom'],
+    'string array': ['string_array'],
+    'number array': ['number_array'],
+    'boolean array': ['boolean_array'],
+    'object': ['object_atom'],
+    'object array': ['object_array']
+};
+
+// Merge the base grammar with template-specific grammar rules
+const extendedGrammar = [...RuleParserRules]
+for(const rule of TemplateGrammar){
+    const idx = extendedGrammar.findIndex(r => r.name === rule.name);
+    if(idx !== -1){
+        extendedGrammar[idx] = rule;
+    } else {
+        extendedGrammar.push(rule);
+    }
+}
+
+// Add template_value as an alternative to value_atom so templates can be parsed
+const valueAtomIdx = extendedGrammar.findIndex(r => r.name === 'value_atom');
+if (valueAtomIdx !== -1) {
+    extendedGrammar[valueAtomIdx].bnf.push(['template_value']);
+}
+
+// Export the parser rules for potential external use
+const ParserRules = extendedGrammar;
+
+class RuleTemplate {
+    constructor(ruleTemplateText, ast) {
+        this.ruleTemplateText = ruleTemplateText;
+        this.ast = ast;
+    }
+
+    /**
+     * Parse a rule template string and return a RuleTemplate instance
+     * @param {string} ruleTemplate - The template string to parse
+     * @returns {RuleTemplate} Instance with AST and template text
+     */
+    static parse(ruleTemplate){
+        if(!ParserCache){
+            ParserCache = new Parser(ParserRules, {debug: false})
+        }
+
+        const ast = ParserCache.getAST(ruleTemplate.trim(), 'statement_main');
+        return new RuleTemplate(ruleTemplate, ast);
+    }
+
+    /**
+     * Extract variables from the template using the AST
+     * @returns {Array} Array of {name, filters: []} objects
+     */
+    extractVariables(){
+        const variables = [];
+        const seen = new Set();
+        
+        const traverse = (node) => {
+            if (!node) return;
+            
+            // Check if this is a template_value node
+            if (node.type === 'template_value') {
+                // Extract the variable information
+                const varInfo = this._extractVariableFromNode(node);
+                if (varInfo && !seen.has(varInfo.name)) {
+                    seen.add(varInfo.name);
+                    variables.push(varInfo);
+                }
+            }
+            
+            // Traverse children
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+        
+        traverse(this.ast);
+        return variables;
+    }
+
+    /**
+     * Extract variable name and filters from a template_value AST node
+     * @private
+     */
+    _extractVariableFromNode(node) {
+        if (node.type !== 'template_value') return null;
+        
+        // Find the template_expr child
+        const templateExpr = node.children?.find(c => c.type === 'template_expr');
+        if (!templateExpr) return null;
+        
+        // Extract the path (variable name)
+        const templatePath = templateExpr.children?.find(c => c.type === 'template_path');
+        if (!templatePath || !templatePath.text) return null;
+        
+        const name = templatePath.text.trim();
+        
+        // Extract filters
+        const filters = [];
+        for (const child of templateExpr.children || []) {
+            if (child.type === 'template_filter_call') {
+                const filterName = this._extractFilterName(child);
+                if (filterName) {
+                    filters.push(filterName);
+                }
+            }
+        }
+        
+        return { name, filters };
+    }
+
+    /**
+     * Extract filter name from template_filter_call node
+     * @private
+     */
+    _extractFilterName(node) {
+        const filterNameNode = node.children?.find(c => c.type === 'template_filter_name');
+        if (!filterNameNode || !filterNameNode.text) return null;
+        
+        return filterNameNode.text.trim();
+    }
+
+    /**
+     * Validate variable types against the AST
+     * @param {Object} variables - Object mapping variable names to {type} objects
+     * @returns {Object} Object with validation results: {valid: boolean, errors: []}
+     */
+    validate(variables) {
+        if (!variables || typeof variables !== 'object') {
+            return {
+                valid: false,
+                errors: ['Variables must be provided as an object']
+            };
+        }
+
+        const errors = [];
+        const extractedVars = this.extractVariables();
+        
+        for (const varInfo of extractedVars) {
+            const varName = varInfo.name;
+            
+            // Check if variable is provided
+            if (!variables.hasOwnProperty(varName)) {
+                errors.push(`Variable '${varName}' not provided in variables object`);
+                continue;
+            }
+            
+            const varData = variables[varName];
+            if (typeof varData !== 'object') {
+                errors.push(`Variable '${varName}' must be an object`);
+                continue;
+            }
+            
+            const { type } = varData;
+            
+            // Validate type if provided
+            if (type && !VariableTypes.includes(type)) {
+                errors.push(`Invalid variable type '${type}' for variable '${varName}'`);
+            }
+        }
+        
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+
+    /**
+     * Prepare the template by replacing variables with their values
+     * Rebuilds from AST by iterating through children
+     * @param {Object} variables - Object mapping variable names to {value, type} objects
+     * @returns {string} The prepared rule string
+     */
+    prepare(variables){
+        if (!variables || typeof variables !== 'object') {
+            throw new Error('Variables must be provided as an object');
+        }
+
+        // Rebuild the rule string from AST
+        return this._rebuildFromAST(this.ast, variables);
+    }
+
+    /**
+     * Rebuild rule string from AST node, replacing template_value nodes with variable values
+     * @private
+     * @param {Object} node - AST node
+     * @param {Object} variables - Object mapping variable names to {value, type} objects
+     * @returns {string} Rebuilt string
+     */
+    _rebuildFromAST(node, variables) {
+        if (!node) return '';
+        
+        // If this is a template_value node, replace it with the computed value
+        if (node.type === 'template_value') {
+            return this._computeTemplateReplacement(node, variables);
+        }
+        
+        // If node has no children, it's a leaf - return its text
+        if (!node.children || node.children.length === 0) {
+            return node.text || '';
+        }
+        
+        // Node has children - rebuild by iterating through children and preserving gaps
+        let result = '';
+        const originalText = node.text || '';
+        let lastEnd = node.start || 0;
+        
+        for (const child of node.children) {
+            // Add any text between the last child's end and this child's start (gaps/syntax)
+            if (child.start !== undefined && child.start > lastEnd) {
+                result += originalText.substring(lastEnd - (node.start || 0), child.start - (node.start || 0));
+            }
+            
+            // Add the child's rebuilt text
+            result += this._rebuildFromAST(child, variables);
+            
+            // Update lastEnd to this child's end position
+            if (child.end !== undefined) {
+                lastEnd = child.end;
+            }
+        }
+        
+        // Add any remaining text after the last child
+        if (node.end !== undefined && lastEnd < node.end) {
+            result += originalText.substring(lastEnd - (node.start || 0), node.end - (node.start || 0));
+        }
+        
+        return result;
+    }
+
+    /**
+     * Compute the replacement value for a template_value node
+     * @private
+     * @param {Object} node - template_value AST node
+     * @param {Object} variables - Object mapping variable names to {value, type} objects
+     * @returns {string} Replacement string
+     */
+    _computeTemplateReplacement(node, variables) {
+        const templateInfo = this._extractVariableFromNode(node);
+        if (!templateInfo) {
+            throw new Error(`Failed to extract variable information from template node`);
+        }
+        
+        const varName = templateInfo.name;
+        
+        // Validate variable is provided
+        if (!variables.hasOwnProperty(varName)) {
+            throw new Error(`Variable '${varName}' not provided in variables object`);
+        }
+        
+        const varData = variables[varName];
+        if (typeof varData !== 'object' || !varData.hasOwnProperty('value')) {
+            throw new Error(`Variable '${varName}' must be an object with 'value' property`);
+        }
+        
+        let { value, type } = varData;
+        
+        // Require type property for all variables
+        if (!varData.hasOwnProperty('type')) {
+            throw new Error(`Variable '${varName}' must have a 'type' property`);
+        }
+        
+        // Validate type
+        if (!VariableTypes.includes(type)) {
+            throw new Error(`Invalid variable type '${type}' for variable '${varName}'`);
+        }
+        
+        // Apply filters if present
+        if (templateInfo.filters && templateInfo.filters.length > 0) {
+            for (const filterName of templateInfo.filters) {
+                if (!TemplateFilters[filterName]) {
+                    throw new Error(`Unknown filter '${filterName}'`);
+                }
+                value = TemplateFilters[filterName](value);
+            }
+            // After applying filters, the result is already a string representation
+            return String(value);
+        }
+        
+        // Convert value to string representation based on type
+        if (type === 'string') {
+            // Escape backslashes first, then quotes in string values.
+            // Order is critical: escaping backslashes first prevents double-escaping.
+            // E.g., "test\" becomes "test\\" then "test\\\"" (correct)
+            // If reversed, "test\" would become "test\\"" then "test\\\\"" (incorrect)
+            return `"${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+        } else if (type === 'number') {
+            return String(value);
+        } else if (type === 'boolean') {
+            return value ? 'true' : 'false';
+        } else {
+            // Default behavior - just insert the value as-is
+            return String(value);
+        }
+    }
+
+    /**
+     * Helper method to validate if an AST node matches a variable type
+     * @param {Object} astNode - The AST node to validate
+     * @param {string} variableType - The expected variable type
+     * @returns {boolean} True if valid, false otherwise
+     */
+    static validateVariableNode(astNode, variableType) {
+        if (!astNode || !astNode.type) {
+            return false;
+        }
+
+        const allowedTypes = AllowedTypeMapping[variableType];
+        if (!allowedTypes) {
+            return false;
+        }
+
+        return allowedTypes.includes(astNode.type);
+    }
+}
+
+// Export the class and parser rules
+module.exports = RuleTemplate;
+module.exports.ParserRules = ParserRules;
+module.exports.VariableTypes = VariableTypes;
+module.exports.TemplateFilters = TemplateFilters;
+},{"./RuleTemplate.production.ebnf.js":11,"./TemplateFilters":14,"@halleyassist/rule-parser/src/RuleParser.ebnf":1,"ebnf":10}],14:[function(require,module,exports){
+/*
+Template filters are functions that transform variable values.
+They are applied in the template syntax as ${variable|filter} or ${variable|filter1|filter2}
+*/
+const TemplateFilters = {
+    // Convert value to JSON string representation
+    string: value => JSON.stringify(String(value)),
+    
+    // Convert to uppercase
+    upper: value => String(value).toUpperCase(),
+    
+    // Convert to lowercase
+    lower: value => String(value).toLowerCase(),
+    
+    // Capitalize first letter
+    capitalize: value => {
+        const str = String(value);
+        return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+    },
+    
+    // Convert to title case
+    title: value => {
+        return String(value).split(' ')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join(' ');
+    },
+    
+    // Trim whitespace
+    trim: value => String(value).trim(),
+    
+    // Convert to number
+    number: value => Number(value),
+    
+    // Convert to boolean
+    boolean: value => {
+        if (typeof value === 'boolean') return value;
+        if (typeof value === 'string') {
+            const lower = value.toLowerCase();
+            if (lower === 'true' || lower === '1' || lower === 'yes') return true;
+            if (lower === 'false' || lower === '0' || lower === 'no') return false;
+        }
+        return Boolean(value);
+    },
+    
+    // Convert to absolute value (for numbers)
+    abs: value => Math.abs(Number(value)),
+    
+    // Round number
+    round: value => Math.round(Number(value)),
+    
+    // Floor number
+    floor: value => Math.floor(Number(value)),
+    
+    // Ceil number
+    ceil: value => Math.ceil(Number(value)),
+    
+    // Default value if empty/null/undefined
+    default: (value, defaultValue = '') => {
+        return (value === null || value === undefined || value === '') ? defaultValue : value;
+    }
+}
+
+module.exports = TemplateFilters;
+},{}]},{},[12])(12)
+});