@optionfactory/fml 8.0.0

package/dist/ftl.iife.js

@@ -0,0 +1,4719 @@
+var ftl = (function (exports) {
+    'use strict';
+
+    const nodes = {
+        ter: Symbol('ternary'),
+        elv: Symbol('elvis'),
+        nullc: Symbol('null-coalescence'),
+        or: Symbol('or'),
+        and: Symbol('and'),
+        eq: Symbol('eq'),
+        cmp: Symbol('cmp'),
+        not: Symbol('not'),
+        access: Symbol('access'),
+        member: Symbol('access-member'),
+        subscript: Symbol('access-subscript'),
+        method: Symbol('access-method-call'),
+        call: Symbol('module-function-call'),
+        tstring: Symbol('tstring'),
+        literal: Symbol('literal'),
+        array: Symbol('array-literal'),
+        dict: Symbol('dict-literal'),
+        function: Symbol('module-function'),
+        symbol: Symbol('symbol'),
+        templated: {
+            ten: Symbol('templated-node'),
+            teh: Symbol('templated-html'),
+            tet: Symbol('templated-text'),
+            tel: Symbol('templated-literal'),
+        },
+        dom: {
+            t: Symbol('text'),
+            h: Symbol('html'),
+            n: Symbol('node'),
+        },
+    };
+
+    // @generated by Peggy 5.1.0.
+    //
+    // https://peggyjs.org/
+
+
+    class peg$SyntaxError extends SyntaxError {
+      constructor(message, expected, found, location) {
+        super(message);
+        this.expected = expected;
+        this.found = found;
+        this.location = location;
+        this.name = "SyntaxError";
+      }
+
+      format(sources) {
+        let str = "Error: " + this.message;
+        if (this.location) {
+          let src = null;
+          const st = sources.find(s => s.source === this.location.source);
+          if (st) {
+            src = st.text.split(/\r\n|\n|\r/g);
+          }
+          const s = this.location.start;
+          const offset_s = (this.location.source && (typeof this.location.source.offset === "function"))
+            ? this.location.source.offset(s)
+            : s;
+          const loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column;
+          if (src) {
+            const e = this.location.end;
+            const filler = "".padEnd(offset_s.line.toString().length, " ");
+            const line = src[s.line - 1];
+            const last = s.line === e.line ? e.column : line.length + 1;
+            const hatLen = (last - s.column) || 1;
+            str += "\n --> " + loc + "\n"
+                + filler + " |\n"
+                + offset_s.line + " | " + line + "\n"
+                + filler + " | " + "".padEnd(s.column - 1, " ")
+                + "".padEnd(hatLen, "^");
+          } else {
+            str += "\n at " + loc;
+          }
+        }
+        return str;
+      }
+
+      static buildMessage(expected, found) {
+        function hex(ch) {
+          return ch.codePointAt(0).toString(16).toUpperCase();
+        }
+
+        const nonPrintable = Object.prototype.hasOwnProperty.call(RegExp.prototype, "unicode")
+          ? new RegExp("[\\p{C}\\p{Mn}\\p{Mc}]", "gu")
+          : null;
+        function unicodeEscape(s) {
+          if (nonPrintable) {
+            return s.replace(nonPrintable,  ch => "\\u{" + hex(ch) + "}");
+          }
+          return s;
+        }
+
+        function literalEscape(s) {
+          return unicodeEscape(s
+            .replace(/\\/g, "\\\\")
+            .replace(/"/g,  "\\\"")
+            .replace(/\0/g, "\\0")
+            .replace(/\t/g, "\\t")
+            .replace(/\n/g, "\\n")
+            .replace(/\r/g, "\\r")
+            .replace(/[\x00-\x0F]/g,          ch => "\\x0" + hex(ch))
+            .replace(/[\x10-\x1F\x7F-\x9F]/g, ch => "\\x"  + hex(ch)));
+        }
+
+        function classEscape(s) {
+          return unicodeEscape(s
+            .replace(/\\/g, "\\\\")
+            .replace(/\]/g, "\\]")
+            .replace(/\^/g, "\\^")
+            .replace(/-/g,  "\\-")
+            .replace(/\0/g, "\\0")
+            .replace(/\t/g, "\\t")
+            .replace(/\n/g, "\\n")
+            .replace(/\r/g, "\\r")
+            .replace(/[\x00-\x0F]/g,          ch => "\\x0" + hex(ch))
+            .replace(/[\x10-\x1F\x7F-\x9F]/g, ch => "\\x"  + hex(ch)));
+        }
+
+        const DESCRIBE_EXPECTATION_FNS = {
+          literal(expectation) {
+            return "\"" + literalEscape(expectation.text) + "\"";
+          },
+
+          class(expectation) {
+            const escapedParts = expectation.parts.map(
+              part => (Array.isArray(part)
+                ? classEscape(part[0]) + "-" + classEscape(part[1])
+                : classEscape(part))
+            );
+
+            return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]" + (expectation.unicode ? "u" : "");
+          },
+
+          any() {
+            return "any character";
+          },
+
+          end() {
+            return "end of input";
+          },
+
+          other(expectation) {
+            return expectation.description;
+          },
+        };
+
+        function describeExpectation(expectation) {
+          return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
+        }
+
+        function describeExpected(expected) {
+          const descriptions = expected.map(describeExpectation);
+          descriptions.sort();
+
+          if (descriptions.length > 0) {
+            let j = 1;
+            for (let i = 1; i < descriptions.length; i++) {
+              if (descriptions[i - 1] !== descriptions[i]) {
+                descriptions[j] = descriptions[i];
+                j++;
+              }
+            }
+            descriptions.length = j;
+          }
+
+          switch (descriptions.length) {
+            case 1:
+              return descriptions[0];
+
+            case 2:
+              return descriptions[0] + " or " + descriptions[1];
+
+            default:
+              return descriptions.slice(0, -1).join(", ")
+                + ", or "
+                + descriptions[descriptions.length - 1];
+          }
+        }
+
+        function describeFound(found) {
+          return found ? "\"" + literalEscape(found) + "\"" : "end of input";
+        }
+
+        return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
+      }
+    }
+
+    function peg$parse(input, options) {
+      options = options !== undefined ? options : {};
+
+      const peg$FAILED = {};
+      const peg$source = options.grammarSource;
+
+      const peg$startRuleFunctions = {
+        TemplatedRoot: peg$parseTemplatedRoot,
+        ExpressionRoot: peg$parseExpressionRoot,
+      };
+      let peg$startRuleFunction = peg$parseTemplatedRoot;
+      const peg$c1 = "{{{{";
+      const peg$c2 = "}}}}";
+      const peg$c3 = "{{{";
+      const peg$c4 = "}}}";
+      const peg$c5 = "{{";
+      const peg$c6 = "}}";
+      const peg$c7 = "\\";
+      const peg$c9 = "{";
+      const peg$c13 = "?";
+      const peg$c15 = ":";
+      const peg$c17 = "?:";
+      const peg$c19 = "??";
+      const peg$c22 = "||";
+      const peg$c24 = "&&";
+      const peg$c26 = "!";
+      const peg$c28 = "?.";
+      const peg$c29 = ".";
+      const peg$c30 = "[";
+      const peg$c31 = "]";
+      const peg$c32 = "(";
+      const peg$c34 = ",";
+      const peg$c36 = ")";
+      const peg$c39 = "true";
+      const peg$c40 = "false";
+      const peg$c41 = "null";
+      const peg$c42 = "undefined";
+      const peg$c43 = "-";
+      const peg$c44 = "'";
+      const peg$c45 = "\"";
+      const peg$c46 = "`";
+      const peg$c47 = "}";
+      const peg$c49 = "#";
+      const peg$c53 = "==";
+      const peg$c54 = "!=";
+      const peg$c55 = ">=";
+      const peg$c56 = ">";
+      const peg$c57 = "<=";
+      const peg$c58 = "<";
+
+      const peg$r0 = /^[^\\{]/;
+      const peg$r1 = /^[0-9]/;
+      const peg$r2 = /^[^']/;
+      const peg$r3 = /^[^"]/;
+      const peg$r4 = /^[^\\`{]/;
+      const peg$r5 = /^[a-zA-Z$_]/;
+      const peg$r6 = /^[a-zA-Z$_0-9_]/;
+      const peg$r7 = /^[ \t\n\r]/;
+
+      const peg$e0 = peg$literalExpectation("{{{{", false);
+      const peg$e1 = peg$literalExpectation("}}}}", false);
+      const peg$e2 = peg$literalExpectation("{{{", false);
+      const peg$e3 = peg$literalExpectation("}}}", false);
+      const peg$e4 = peg$literalExpectation("{{", false);
+      const peg$e5 = peg$literalExpectation("}}", false);
+      const peg$e6 = peg$classExpectation(["\\", "{"], true, false, false);
+      const peg$e7 = peg$literalExpectation("\\", false);
+      const peg$e8 = peg$anyExpectation();
+      const peg$e9 = peg$literalExpectation("{", false);
+      const peg$e10 = peg$literalExpectation("?", false);
+      const peg$e11 = peg$literalExpectation(":", false);
+      const peg$e12 = peg$literalExpectation("?:", false);
+      const peg$e13 = peg$literalExpectation("??", false);
+      const peg$e14 = peg$literalExpectation("||", false);
+      const peg$e15 = peg$literalExpectation("&&", false);
+      const peg$e16 = peg$literalExpectation("!", false);
+      const peg$e17 = peg$otherExpectation("member");
+      const peg$e18 = peg$literalExpectation("?.", false);
+      const peg$e19 = peg$literalExpectation(".", false);
+      const peg$e20 = peg$otherExpectation("subscript");
+      const peg$e21 = peg$literalExpectation("[", false);
+      const peg$e22 = peg$literalExpectation("]", false);
+      const peg$e23 = peg$otherExpectation("method-call");
+      const peg$e24 = peg$literalExpectation("(", false);
+      const peg$e25 = peg$literalExpectation(",", false);
+      const peg$e26 = peg$literalExpectation(")", false);
+      const peg$e27 = peg$otherExpectation("module-function-call");
+      const peg$e28 = peg$otherExpectation("boolean-literal");
+      const peg$e29 = peg$literalExpectation("true", false);
+      const peg$e30 = peg$literalExpectation("false", false);
+      const peg$e31 = peg$otherExpectation("null-literal");
+      const peg$e32 = peg$literalExpectation("null", false);
+      const peg$e33 = peg$otherExpectation("undefined-literal");
+      const peg$e34 = peg$literalExpectation("undefined", false);
+      const peg$e35 = peg$otherExpectation("number-literal");
+      const peg$e36 = peg$literalExpectation("-", false);
+      const peg$e37 = peg$classExpectation([["0", "9"]], false, false, false);
+      const peg$e38 = peg$otherExpectation("string-literal");
+      const peg$e39 = peg$literalExpectation("'", false);
+      const peg$e40 = peg$classExpectation(["'"], true, false, false);
+      const peg$e41 = peg$literalExpectation("\"", false);
+      const peg$e42 = peg$classExpectation(["\""], true, false, false);
+      const peg$e43 = peg$literalExpectation("`", false);
+      const peg$e44 = peg$otherExpectation("tstring-expression");
+      const peg$e45 = peg$literalExpectation("}", false);
+      const peg$e46 = peg$otherExpectation("tstring-literal");
+      const peg$e47 = peg$classExpectation(["\\", "`", "{"], true, false, false);
+      const peg$e48 = peg$otherExpectation("array-literal");
+      const peg$e49 = peg$otherExpectation("dict-literal");
+      const peg$e50 = peg$otherExpectation("module-function");
+      const peg$e51 = peg$literalExpectation("#", false);
+      const peg$e52 = peg$classExpectation([["a", "z"], ["A", "Z"], "$", "_"], false, false, false);
+      const peg$e53 = peg$classExpectation([["a", "z"], ["A", "Z"], "$", "_", ["0", "9"], "_"], false, false, false);
+      const peg$e54 = peg$otherExpectation("symbol");
+      const peg$e55 = peg$literalExpectation("==", false);
+      const peg$e56 = peg$literalExpectation("!=", false);
+      const peg$e57 = peg$literalExpectation(">=", false);
+      const peg$e58 = peg$literalExpectation(">", false);
+      const peg$e59 = peg$literalExpectation("<=", false);
+      const peg$e60 = peg$literalExpectation("<", false);
+      const peg$e61 = peg$classExpectation([" ", "\t", "\n", "\r"], false, false, false);
+
+      function peg$f0(value) {    return {type:nodes.templated.ten, value}  }
+      function peg$f1(value) {    return {type:nodes.templated.teh, value}  }
+      function peg$f2(value) {    return {type:nodes.templated.tet, value}  }
+      function peg$f3(value) {    return {type:nodes.templated.tel, value}  }
+      function peg$f4(c) {    return c;  }
+      function peg$f5(parts) {    return parts.join('');  }
+      function peg$f6(r) {    return r;  }
+      function peg$f7(cond, ifTrue, ifFalse) {    return {type:nodes.ter, cond, ifTrue, ifFalse};  }
+      function peg$f8(cond, ifFalse) {return {type:nodes.elv, cond, ifFalse};  }
+      function peg$f9(lhs, rhs) {    return {type:nodes.nullc, lhs, rhs};  }
+      function peg$f10(head, tail) {
+        let result = head;
+        for (const rhs of tail) {
+            result = {type: nodes.or, lhs: result, rhs};
+        }
+        return result;
+      }
+      function peg$f11(head, tail) {    
+               let result = head;
+               for (const rhs of tail) {
+                   result = {type: nodes.and, lhs: result, rhs};
+               }
+               return result;
+      }
+      function peg$f12(head, op, rhs) {return {op, rhs};  }
+      function peg$f13(head, tail) {    
+               let result = head;
+               for (const element of tail) {
+                   result = {type: nodes.eq, op: element.op, lhs: result, rhs: element.rhs};
+               }
+               return result;
+      }
+      function peg$f14(head, op, rhs) {return {op, rhs};  }
+      function peg$f15(head, tail) {
+        let result = head;
+        for (const element of tail) {
+            result = {type: nodes.cmp, op: element.op, lhs: result, rhs: element.rhs};
+        }
+        return result;
+      }
+      function peg$f16(expr) {    return {type:nodes.not, expr}  }
+      function peg$f17(lhs, rhs) {    return {type: nodes.access, lhs, rhs}  }
+      function peg$f18(op, rhs) {    
+               return {type: nodes.member, ns: op === '?.', rhs: rhs.value}; 
+      }
+      function peg$f19(op, rhs) {    
+               return {type: nodes.subscript, ns: op !== null, rhs}; 
+      }
+      function peg$f20(op, h, t) {    
+               return {type: nodes.method, ns: op !== null, args: h === null ? [] : [h, ...t]}; 
+      }
+      function peg$f21(e) {    return e  }
+      function peg$f22(fn, h, t) {
+        const args = h === null ? [] : [h, ...t];
+        return {type: nodes.call, value: fn, args};
+      }
+      function peg$f23() {    
+               return {type: nodes.literal, value: true}; 
+      }
+      function peg$f24() {    
+               return {type: nodes.literal, value: false}; 
+      }
+      function peg$f25() {
+        return {type: nodes.literal, value: null};
+      }
+      function peg$f26() {
+        return {type: nodes.literal, value: undefined};
+      }
+      function peg$f27(value) {
+        return { type: nodes.literal, value: parseFloat(value) };
+      }
+      function peg$f28(value) {    return {type: nodes.literal, value};  }
+      function peg$f29(value) {    return {type: nodes.literal, value};  }
+      function peg$f30(parts) {    
+               return {type: nodes.tstring, parts}; 
+      }
+      function peg$f31(expr) {    
+               return expr; 
+      }
+      function peg$f32(c) {    return c;  }
+      function peg$f33(parts) {
+        return { type: nodes.literal, value: parts.join('') };
+      }
+      function peg$f34(char) {    
+               return { type: nodes.literal, value: char }; 
+      }
+      function peg$f35(h, t) {    
+               const value = h === null ? [] : [h, ...t];
+               return {type: nodes.array, value};
+      }
+      function peg$f36(h, t) {
+        var value = [];
+        if (h !== null){
+            value.push(h);
+        }
+        value.push.apply(value, t);
+        return {type: nodes.dict, value};   
+      }
+      function peg$f37(module, v) {
+        return {type: nodes.function, module, value: v}
+      }
+      function peg$f38(s) {    
+               return {type: nodes.symbol, value: s}; 
+      }
+      let peg$currPos = options.peg$currPos | 0;
+      const peg$posDetailsCache = [{ line: 1, column: 1 }];
+      let peg$maxFailPos = peg$currPos;
+      let peg$maxFailExpected = options.peg$maxFailExpected || [];
+      let peg$silentFails = options.peg$silentFails | 0;
+
+      let peg$resultsCache = {};
+
+      let peg$result;
+
+      if (options.startRule) {
+        if (!(options.startRule in peg$startRuleFunctions)) {
+          throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
+        }
+
+        peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
+      }
+
+      function peg$getUnicode(pos = peg$currPos) {
+        const cp = input.codePointAt(pos);
+        if (cp === undefined) {
+          return "";
+        }
+        return String.fromCodePoint(cp);
+      }
+
+      function peg$literalExpectation(text, ignoreCase) {
+        return { type: "literal", text, ignoreCase };
+      }
+
+      function peg$classExpectation(parts, inverted, ignoreCase, unicode) {
+        return { type: "class", parts, inverted, ignoreCase, unicode };
+      }
+
+      function peg$anyExpectation() {
+        return { type: "any" };
+      }
+
+      function peg$endExpectation() {
+        return { type: "end" };
+      }
+
+      function peg$otherExpectation(description) {
+        return { type: "other", description };
+      }
+
+      function peg$computePosDetails(pos) {
+        let details = peg$posDetailsCache[pos];
+        let p;
+
+        if (details) {
+          return details;
+        } else {
+          if (pos >= peg$posDetailsCache.length) {
+            p = peg$posDetailsCache.length - 1;
+          } else {
+            p = pos;
+            while (!peg$posDetailsCache[--p]) {}
+          }
+
+          details = peg$posDetailsCache[p];
+          details = {
+            line: details.line,
+            column: details.column,
+          };
+
+          while (p < pos) {
+            if (input.charCodeAt(p) === 10) {
+              details.line++;
+              details.column = 1;
+            } else {
+              details.column++;
+            }
+
+            p++;
+          }
+
+          peg$posDetailsCache[pos] = details;
+
+          return details;
+        }
+      }
+
+      function peg$computeLocation(startPos, endPos, offset) {
+        const startPosDetails = peg$computePosDetails(startPos);
+        const endPosDetails = peg$computePosDetails(endPos);
+
+        const res = {
+          source: peg$source,
+          start: {
+            offset: startPos,
+            line: startPosDetails.line,
+            column: startPosDetails.column,
+          },
+          end: {
+            offset: endPos,
+            line: endPosDetails.line,
+            column: endPosDetails.column,
+          },
+        };
+        return res;
+      }
+
+      function peg$fail(expected) {
+        if (peg$currPos < peg$maxFailPos) { return; }
+
+        if (peg$currPos > peg$maxFailPos) {
+          peg$maxFailPos = peg$currPos;
+          peg$maxFailExpected = [];
+        }
+
+        peg$maxFailExpected.push(expected);
+      }
+
+      function peg$buildStructuredError(expected, found, location) {
+        return new peg$SyntaxError(
+          peg$SyntaxError.buildMessage(expected, found),
+          expected,
+          found,
+          location
+        );
+      }
+
+      function peg$parseTemplatedRoot() {
+        let s0, s1;
+
+        const key = peg$currPos * 40 + 0;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = [];
+        s1 = peg$parseTemplatedExpression();
+        while (s1 !== peg$FAILED) {
+          s0.push(s1);
+          s1 = peg$parseTemplatedExpression();
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseTemplatedExpression() {
+        let s0, s1, s2, s3, s4;
+
+        const key = peg$currPos * 40 + 1;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$currPos;
+        s1 = peg$currPos;
+        s2 = peg$parseBeginNode();
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parseExpressionRoot();
+          if (s3 !== peg$FAILED) {
+            s4 = peg$parseEndNode();
+            if (s4 !== peg$FAILED) {
+              s1 = s3;
+            } else {
+              peg$currPos = s1;
+              s1 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s1;
+            s1 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s1;
+          s1 = peg$FAILED;
+        }
+        if (s1 !== peg$FAILED) {
+          s1 = peg$f0(s1);
+        }
+        s0 = s1;
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          s1 = peg$currPos;
+          s2 = peg$parseBeginHtml();
+          if (s2 !== peg$FAILED) {
+            s3 = peg$parseExpressionRoot();
+            if (s3 !== peg$FAILED) {
+              s4 = peg$parseEndHtml();
+              if (s4 !== peg$FAILED) {
+                s1 = s3;
+              } else {
+                peg$currPos = s1;
+                s1 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s1;
+              s1 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s1;
+            s1 = peg$FAILED;
+          }
+          if (s1 !== peg$FAILED) {
+            s1 = peg$f1(s1);
+          }
+          s0 = s1;
+          if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            s1 = peg$currPos;
+            s2 = peg$parseBeginText();
+            if (s2 !== peg$FAILED) {
+              s3 = peg$parseExpressionRoot();
+              if (s3 !== peg$FAILED) {
+                s4 = peg$parseEndText();
+                if (s4 !== peg$FAILED) {
+                  s1 = s3;
+                } else {
+                  peg$currPos = s1;
+                  s1 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s1;
+                s1 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s1;
+              s1 = peg$FAILED;
+            }
+            if (s1 !== peg$FAILED) {
+              s1 = peg$f2(s1);
+            }
+            s0 = s1;
+            if (s0 === peg$FAILED) {
+              s0 = peg$currPos;
+              s1 = peg$parseTemplatedText();
+              if (s1 !== peg$FAILED) {
+                s1 = peg$f3(s1);
+              }
+              s0 = s1;
+            }
+          }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseBeginNode() {
+        let s0;
+
+        const key = peg$currPos * 40 + 2;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        if (input.substr(peg$currPos, 4) === peg$c1) {
+          s0 = peg$c1;
+          peg$currPos += 4;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e0); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseEndNode() {
+        let s0;
+
+        const key = peg$currPos * 40 + 3;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        if (input.substr(peg$currPos, 4) === peg$c2) {
+          s0 = peg$c2;
+          peg$currPos += 4;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e1); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseBeginHtml() {
+        let s0;
+
+        const key = peg$currPos * 40 + 4;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        if (input.substr(peg$currPos, 3) === peg$c3) {
+          s0 = peg$c3;
+          peg$currPos += 3;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e2); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseEndHtml() {
+        let s0;
+
+        const key = peg$currPos * 40 + 5;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        if (input.substr(peg$currPos, 3) === peg$c4) {
+          s0 = peg$c4;
+          peg$currPos += 3;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e3); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseBeginText() {
+        let s0;
+
+        const key = peg$currPos * 40 + 6;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        if (input.substr(peg$currPos, 2) === peg$c5) {
+          s0 = peg$c5;
+          peg$currPos += 2;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e4); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseEndText() {
+        let s0;
+
+        const key = peg$currPos * 40 + 7;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        if (input.substr(peg$currPos, 2) === peg$c6) {
+          s0 = peg$c6;
+          peg$currPos += 2;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e5); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseTemplatedText() {
+        let s0, s1, s2, s3, s4, s5;
+
+        const key = peg$currPos * 40 + 8;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$currPos;
+        s1 = [];
+        s2 = peg$currPos;
+        s3 = [];
+        s4 = input.charAt(peg$currPos);
+        if (peg$r0.test(s4)) {
+          peg$currPos++;
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e6); }
+        }
+        if (s4 !== peg$FAILED) {
+          while (s4 !== peg$FAILED) {
+            s3.push(s4);
+            s4 = input.charAt(peg$currPos);
+            if (peg$r0.test(s4)) {
+              peg$currPos++;
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e6); }
+            }
+          }
+        } else {
+          s3 = peg$FAILED;
+        }
+        if (s3 !== peg$FAILED) {
+          s2 = input.substring(s2, peg$currPos);
+        } else {
+          s2 = s3;
+        }
+        if (s2 === peg$FAILED) {
+          s2 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 92) {
+            s3 = peg$c7;
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e7); }
+          }
+          if (s3 !== peg$FAILED) {
+            if (input.length > peg$currPos) {
+              s4 = input.charAt(peg$currPos);
+              peg$currPos++;
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e8); }
+            }
+            if (s4 !== peg$FAILED) {
+              s2 = peg$f4(s4);
+            } else {
+              peg$currPos = s2;
+              s2 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+          if (s2 === peg$FAILED) {
+            s2 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 123) {
+              s3 = peg$c9;
+              peg$currPos++;
+            } else {
+              s3 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e9); }
+            }
+            if (s3 !== peg$FAILED) {
+              s4 = peg$currPos;
+              peg$silentFails++;
+              if (input.charCodeAt(peg$currPos) === 123) {
+                s5 = peg$c9;
+                peg$currPos++;
+              } else {
+                s5 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e9); }
+              }
+              peg$silentFails--;
+              if (s5 === peg$FAILED) {
+                s4 = undefined;
+              } else {
+                peg$currPos = s4;
+                s4 = peg$FAILED;
+              }
+              if (s4 !== peg$FAILED) {
+                s3 = [s3, s4];
+                s2 = s3;
+              } else {
+                peg$currPos = s2;
+                s2 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s2;
+              s2 = peg$FAILED;
+            }
+          }
+        }
+        if (s2 !== peg$FAILED) {
+          while (s2 !== peg$FAILED) {
+            s1.push(s2);
+            s2 = peg$currPos;
+            s3 = [];
+            s4 = input.charAt(peg$currPos);
+            if (peg$r0.test(s4)) {
+              peg$currPos++;
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e6); }
+            }
+            if (s4 !== peg$FAILED) {
+              while (s4 !== peg$FAILED) {
+                s3.push(s4);
+                s4 = input.charAt(peg$currPos);
+                if (peg$r0.test(s4)) {
+                  peg$currPos++;
+                } else {
+                  s4 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e6); }
+                }
+              }
+            } else {
+              s3 = peg$FAILED;
+            }
+            if (s3 !== peg$FAILED) {
+              s2 = input.substring(s2, peg$currPos);
+            } else {
+              s2 = s3;
+            }
+            if (s2 === peg$FAILED) {
+              s2 = peg$currPos;
+              if (input.charCodeAt(peg$currPos) === 92) {
+                s3 = peg$c7;
+                peg$currPos++;
+              } else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e7); }
+              }
+              if (s3 !== peg$FAILED) {
+                if (input.length > peg$currPos) {
+                  s4 = input.charAt(peg$currPos);
+                  peg$currPos++;
+                } else {
+                  s4 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e8); }
+                }
+                if (s4 !== peg$FAILED) {
+                  s2 = peg$f4(s4);
+                } else {
+                  peg$currPos = s2;
+                  s2 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s2;
+                s2 = peg$FAILED;
+              }
+              if (s2 === peg$FAILED) {
+                s2 = peg$currPos;
+                if (input.charCodeAt(peg$currPos) === 123) {
+                  s3 = peg$c9;
+                  peg$currPos++;
+                } else {
+                  s3 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e9); }
+                }
+                if (s3 !== peg$FAILED) {
+                  s4 = peg$currPos;
+                  peg$silentFails++;
+                  if (input.charCodeAt(peg$currPos) === 123) {
+                    s5 = peg$c9;
+                    peg$currPos++;
+                  } else {
+                    s5 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$e9); }
+                  }
+                  peg$silentFails--;
+                  if (s5 === peg$FAILED) {
+                    s4 = undefined;
+                  } else {
+                    peg$currPos = s4;
+                    s4 = peg$FAILED;
+                  }
+                  if (s4 !== peg$FAILED) {
+                    s3 = [s3, s4];
+                    s2 = s3;
+                  } else {
+                    peg$currPos = s2;
+                    s2 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s2;
+                  s2 = peg$FAILED;
+                }
+              }
+            }
+          }
+        } else {
+          s1 = peg$FAILED;
+        }
+        if (s1 !== peg$FAILED) {
+          s1 = peg$f5(s1);
+        }
+        s0 = s1;
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseExpressionRoot() {
+        let s0, s2;
+
+        const key = peg$currPos * 40 + 9;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$currPos;
+        peg$parse_();
+        s2 = peg$parseTernaryExpression();
+        if (s2 !== peg$FAILED) {
+          peg$parse_();
+          s0 = peg$f6(s2);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseTernaryExpression() {
+        let s0, s1, s3, s5, s7, s9;
+
+        const key = peg$currPos * 40 + 10;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$currPos;
+        s1 = peg$parseElvisExpression();
+        if (s1 !== peg$FAILED) {
+          peg$parse_();
+          if (input.charCodeAt(peg$currPos) === 63) {
+            s3 = peg$c13;
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e10); }
+          }
+          if (s3 !== peg$FAILED) {
+            peg$parse_();
+            s5 = peg$parseTernaryExpression();
+            if (s5 !== peg$FAILED) {
+              peg$parse_();
+              if (input.charCodeAt(peg$currPos) === 58) {
+                s7 = peg$c15;
+                peg$currPos++;
+              } else {
+                s7 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e11); }
+              }
+              if (s7 !== peg$FAILED) {
+                peg$parse_();
+                s9 = peg$parseTernaryExpression();
+                if (s9 !== peg$FAILED) {
+                  s0 = peg$f7(s1, s5, s9);
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseElvisExpression();
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseElvisExpression() {
+        let s0, s1, s3, s5;
+
+        const key = peg$currPos * 40 + 11;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$currPos;
+        s1 = peg$parseNullCoalescingExpression();
+        if (s1 !== peg$FAILED) {
+          peg$parse_();
+          if (input.substr(peg$currPos, 2) === peg$c17) {
+            s3 = peg$c17;
+            peg$currPos += 2;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e12); }
+          }
+          if (s3 !== peg$FAILED) {
+            peg$parse_();
+            s5 = peg$parseElvisExpression();
+            if (s5 !== peg$FAILED) {
+              s0 = peg$f8(s1, s5);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseNullCoalescingExpression();
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseNullCoalescingExpression() {
+        let s0, s1, s3, s5;
+
+        const key = peg$currPos * 40 + 12;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$currPos;
+        s1 = peg$parseOrExpression();
+        if (s1 !== peg$FAILED) {
+          peg$parse_();
+          if (input.substr(peg$currPos, 2) === peg$c19) {
+            s3 = peg$c19;
+            peg$currPos += 2;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e13); }
+          }
+          if (s3 !== peg$FAILED) {
+            peg$parse_();
+            s5 = peg$parseNullCoalescingExpression();
+            if (s5 !== peg$FAILED) {
+              s0 = peg$f9(s1, s5);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseOrExpression();
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseOrExpression() {
+        let s0, s1, s2, s3, s5, s7;
+
+        const key = peg$currPos * 40 + 13;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$currPos;
+        s1 = peg$parseAndExpression();
+        if (s1 !== peg$FAILED) {
+          s2 = [];
+          s3 = peg$currPos;
+          peg$parse_();
+          if (input.substr(peg$currPos, 2) === peg$c22) {
+            s5 = peg$c22;
+            peg$currPos += 2;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e14); }
+          }
+          if (s5 !== peg$FAILED) {
+            peg$parse_();
+            s7 = peg$parseAndExpression();
+            if (s7 !== peg$FAILED) {
+              s3 = s7;
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+          while (s3 !== peg$FAILED) {
+            s2.push(s3);
+            s3 = peg$currPos;
+            peg$parse_();
+            if (input.substr(peg$currPos, 2) === peg$c22) {
+              s5 = peg$c22;
+              peg$currPos += 2;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e14); }
+            }
+            if (s5 !== peg$FAILED) {
+              peg$parse_();
+              s7 = peg$parseAndExpression();
+              if (s7 !== peg$FAILED) {
+                s3 = s7;
+              } else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          }
+          s0 = peg$f10(s1, s2);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseAndExpression() {
+        let s0, s1, s2, s3, s5, s7;
+
+        const key = peg$currPos * 40 + 14;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$currPos;
+        s1 = peg$parseEqExpression();
+        if (s1 !== peg$FAILED) {
+          s2 = [];
+          s3 = peg$currPos;
+          peg$parse_();
+          if (input.substr(peg$currPos, 2) === peg$c24) {
+            s5 = peg$c24;
+            peg$currPos += 2;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e15); }
+          }
+          if (s5 !== peg$FAILED) {
+            peg$parse_();
+            s7 = peg$parseEqExpression();
+            if (s7 !== peg$FAILED) {
+              s3 = s7;
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+          while (s3 !== peg$FAILED) {
+            s2.push(s3);
+            s3 = peg$currPos;
+            peg$parse_();
+            if (input.substr(peg$currPos, 2) === peg$c24) {
+              s5 = peg$c24;
+              peg$currPos += 2;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e15); }
+            }
+            if (s5 !== peg$FAILED) {
+              peg$parse_();
+              s7 = peg$parseEqExpression();
+              if (s7 !== peg$FAILED) {
+                s3 = s7;
+              } else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          }
+          s0 = peg$f11(s1, s2);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseEqExpression() {
+        let s0, s1, s2, s3, s5, s7;
+
+        const key = peg$currPos * 40 + 15;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$currPos;
+        s1 = peg$parseRelExpression();
+        if (s1 !== peg$FAILED) {
+          s2 = [];
+          s3 = peg$currPos;
+          peg$parse_();
+          s5 = peg$parseEqualityOp();
+          if (s5 !== peg$FAILED) {
+            peg$parse_();
+            s7 = peg$parseRelExpression();
+            if (s7 !== peg$FAILED) {
+              s3 = peg$f12(s1, s5, s7);
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+          while (s3 !== peg$FAILED) {
+            s2.push(s3);
+            s3 = peg$currPos;
+            peg$parse_();
+            s5 = peg$parseEqualityOp();
+            if (s5 !== peg$FAILED) {
+              peg$parse_();
+              s7 = peg$parseRelExpression();
+              if (s7 !== peg$FAILED) {
+                s3 = peg$f12(s1, s5, s7);
+              } else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          }
+          s0 = peg$f13(s1, s2);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseRelExpression() {
+        let s0, s1, s2, s3, s5, s7;
+
+        const key = peg$currPos * 40 + 16;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$currPos;
+        s1 = peg$parseNotExpression();
+        if (s1 !== peg$FAILED) {
+          s2 = [];
+          s3 = peg$currPos;
+          peg$parse_();
+          s5 = peg$parseRelationalOp();
+          if (s5 !== peg$FAILED) {
+            peg$parse_();
+            s7 = peg$parseNotExpression();
+            if (s7 !== peg$FAILED) {
+              s3 = peg$f14(s1, s5, s7);
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+          while (s3 !== peg$FAILED) {
+            s2.push(s3);
+            s3 = peg$currPos;
+            peg$parse_();
+            s5 = peg$parseRelationalOp();
+            if (s5 !== peg$FAILED) {
+              peg$parse_();
+              s7 = peg$parseNotExpression();
+              if (s7 !== peg$FAILED) {
+                s3 = peg$f14(s1, s5, s7);
+              } else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          }
+          s0 = peg$f15(s1, s2);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseNotExpression() {
+        let s0, s1, s3;
+
+        const key = peg$currPos * 40 + 17;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 33) {
+          s1 = peg$c26;
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e16); }
+        }
+        if (s1 !== peg$FAILED) {
+          peg$parse_();
+          s3 = peg$parseNotExpression();
+          if (s3 !== peg$FAILED) {
+            s0 = peg$f16(s3);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseAccess();
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseAccess() {
+        let s0, s1, s3, s4, s5;
+
+        const key = peg$currPos * 40 + 18;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$currPos;
+        s1 = peg$parseGroupingExpression();
+        if (s1 !== peg$FAILED) {
+          peg$parse_();
+          s3 = [];
+          s4 = peg$currPos;
+          s5 = peg$parseAccessExpression();
+          if (s5 !== peg$FAILED) {
+            peg$parse_();
+            s4 = s5;
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+          if (s4 !== peg$FAILED) {
+            while (s4 !== peg$FAILED) {
+              s3.push(s4);
+              s4 = peg$currPos;
+              s5 = peg$parseAccessExpression();
+              if (s5 !== peg$FAILED) {
+                peg$parse_();
+                s4 = s5;
+              } else {
+                peg$currPos = s4;
+                s4 = peg$FAILED;
+              }
+            }
+          } else {
+            s3 = peg$FAILED;
+          }
+          if (s3 !== peg$FAILED) {
+            s0 = peg$f17(s1, s3);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseGroupingExpression();
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseAccessExpression() {
+        let s0;
+
+        const key = peg$currPos * 40 + 19;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$parseAccessMember();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseAccessSubscript();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseAccessMethodCall();
+          }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseAccessMember() {
+        let s0, s1, s3;
+
+        const key = peg$currPos * 40 + 20;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 2) === peg$c28) {
+          s1 = peg$c28;
+          peg$currPos += 2;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e18); }
+        }
+        if (s1 === peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 46) {
+            s1 = peg$c29;
+            peg$currPos++;
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e19); }
+          }
+        }
+        if (s1 !== peg$FAILED) {
+          peg$parse_();
+          s3 = peg$parseSymbol();
+          if (s3 !== peg$FAILED) {
+            s0 = peg$f18(s1, s3);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e17); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseAccessSubscript() {
+        let s0, s1, s2, s4, s6;
+
+        const key = peg$currPos * 40 + 21;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 2) === peg$c28) {
+          s1 = peg$c28;
+          peg$currPos += 2;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e18); }
+        }
+        if (s1 === peg$FAILED) {
+          s1 = null;
+        }
+        if (input.charCodeAt(peg$currPos) === 91) {
+          s2 = peg$c30;
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e21); }
+        }
+        if (s2 !== peg$FAILED) {
+          peg$parse_();
+          s4 = peg$parseTernaryExpression();
+          if (s4 !== peg$FAILED) {
+            peg$parse_();
+            if (input.charCodeAt(peg$currPos) === 93) {
+              s6 = peg$c31;
+              peg$currPos++;
+            } else {
+              s6 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e22); }
+            }
+            if (s6 !== peg$FAILED) {
+              s0 = peg$f19(s1, s4);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e20); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseAccessMethodCall() {
+        let s0, s1, s2, s4, s5, s6, s7, s9;
+
+        const key = peg$currPos * 40 + 22;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 2) === peg$c28) {
+          s1 = peg$c28;
+          peg$currPos += 2;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e18); }
+        }
+        if (s1 === peg$FAILED) {
+          s1 = null;
+        }
+        if (input.charCodeAt(peg$currPos) === 40) {
+          s2 = peg$c32;
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e24); }
+        }
+        if (s2 !== peg$FAILED) {
+          peg$parse_();
+          s4 = peg$currPos;
+          s5 = peg$parseTernaryExpression();
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parse_();
+            s4 = s5;
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+          if (s4 === peg$FAILED) {
+            s4 = null;
+          }
+          s5 = [];
+          s6 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 44) {
+            s7 = peg$c34;
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          }
+          if (s7 !== peg$FAILED) {
+            peg$parse_();
+            s9 = peg$parseTernaryExpression();
+            if (s9 !== peg$FAILED) {
+              peg$parse_();
+              s6 = s9;
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          while (s6 !== peg$FAILED) {
+            s5.push(s6);
+            s6 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 44) {
+              s7 = peg$c34;
+              peg$currPos++;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            }
+            if (s7 !== peg$FAILED) {
+              peg$parse_();
+              s9 = peg$parseTernaryExpression();
+              if (s9 !== peg$FAILED) {
+                peg$parse_();
+                s6 = s9;
+              } else {
+                peg$currPos = s6;
+                s6 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+          }
+          if (input.charCodeAt(peg$currPos) === 41) {
+            s6 = peg$c36;
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e26); }
+          }
+          if (s6 !== peg$FAILED) {
+            s0 = peg$f20(s1, s4, s5);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e23); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseGroupingExpression() {
+        let s0, s1, s3, s5;
+
+        const key = peg$currPos * 40 + 23;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 40) {
+          s1 = peg$c32;
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e24); }
+        }
+        if (s1 !== peg$FAILED) {
+          peg$parse_();
+          s3 = peg$parseTernaryExpression();
+          if (s3 !== peg$FAILED) {
+            peg$parse_();
+            if (input.charCodeAt(peg$currPos) === 41) {
+              s5 = peg$c36;
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+            }
+            if (s5 !== peg$FAILED) {
+              s0 = peg$f21(s3);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseModuleFunctionCall();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseAnyLiteral();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseSymbol();
+            }
+          }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseModuleFunctionCall() {
+        let s0, s1, s2, s4, s5, s6, s7, s9;
+
+        const key = peg$currPos * 40 + 24;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        s1 = peg$parseModuleFunction();
+        if (s1 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 40) {
+            s2 = peg$c32;
+            peg$currPos++;
+          } else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e24); }
+          }
+          if (s2 !== peg$FAILED) {
+            peg$parse_();
+            s4 = peg$currPos;
+            s5 = peg$parseTernaryExpression();
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parse_();
+              s4 = s5;
+            } else {
+              peg$currPos = s4;
+              s4 = peg$FAILED;
+            }
+            if (s4 === peg$FAILED) {
+              s4 = null;
+            }
+            s5 = [];
+            s6 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 44) {
+              s7 = peg$c34;
+              peg$currPos++;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            }
+            if (s7 !== peg$FAILED) {
+              peg$parse_();
+              s9 = peg$parseTernaryExpression();
+              if (s9 !== peg$FAILED) {
+                peg$parse_();
+                s6 = s9;
+              } else {
+                peg$currPos = s6;
+                s6 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+            while (s6 !== peg$FAILED) {
+              s5.push(s6);
+              s6 = peg$currPos;
+              if (input.charCodeAt(peg$currPos) === 44) {
+                s7 = peg$c34;
+                peg$currPos++;
+              } else {
+                s7 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e25); }
+              }
+              if (s7 !== peg$FAILED) {
+                peg$parse_();
+                s9 = peg$parseTernaryExpression();
+                if (s9 !== peg$FAILED) {
+                  peg$parse_();
+                  s6 = s9;
+                } else {
+                  peg$currPos = s6;
+                  s6 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s6;
+                s6 = peg$FAILED;
+              }
+            }
+            if (input.charCodeAt(peg$currPos) === 41) {
+              s6 = peg$c36;
+              peg$currPos++;
+            } else {
+              s6 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e26); }
+            }
+            if (s6 !== peg$FAILED) {
+              s0 = peg$f22(s1, s4, s5);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e27); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseAnyLiteral() {
+        let s0;
+
+        const key = peg$currPos * 40 + 25;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        s0 = peg$parseNumberLiteral();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseBooleanLiteral();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseNullLiteral();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseUndefinedLiteral();
+              if (s0 === peg$FAILED) {
+                s0 = peg$parseStringLiteral();
+                if (s0 === peg$FAILED) {
+                  s0 = peg$parseArrayLiteral();
+                  if (s0 === peg$FAILED) {
+                    s0 = peg$parseDictLiteral();
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseBooleanLiteral() {
+        let s0, s1;
+
+        const key = peg$currPos * 40 + 26;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 4) === peg$c39) {
+          s1 = peg$c39;
+          peg$currPos += 4;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e29); }
+        }
+        if (s1 !== peg$FAILED) {
+          s1 = peg$f23();
+        }
+        s0 = s1;
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          if (input.substr(peg$currPos, 5) === peg$c40) {
+            s1 = peg$c40;
+            peg$currPos += 5;
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e30); }
+          }
+          if (s1 !== peg$FAILED) {
+            s1 = peg$f24();
+          }
+          s0 = s1;
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e28); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseNullLiteral() {
+        let s0, s1;
+
+        const key = peg$currPos * 40 + 27;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 4) === peg$c41) {
+          s1 = peg$c41;
+          peg$currPos += 4;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e32); }
+        }
+        if (s1 !== peg$FAILED) {
+          s1 = peg$f25();
+        }
+        s0 = s1;
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e31); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseUndefinedLiteral() {
+        let s0, s1;
+
+        const key = peg$currPos * 40 + 28;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 9) === peg$c42) {
+          s1 = peg$c42;
+          peg$currPos += 9;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e34); }
+        }
+        if (s1 !== peg$FAILED) {
+          s1 = peg$f26();
+        }
+        s0 = s1;
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e33); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseNumberLiteral() {
+        let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+        const key = peg$currPos * 40 + 29;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        s1 = peg$currPos;
+        s2 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 45) {
+          s3 = peg$c43;
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e36); }
+        }
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        s4 = peg$currPos;
+        s5 = [];
+        s6 = input.charAt(peg$currPos);
+        if (peg$r1.test(s6)) {
+          peg$currPos++;
+        } else {
+          s6 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e37); }
+        }
+        if (s6 !== peg$FAILED) {
+          while (s6 !== peg$FAILED) {
+            s5.push(s6);
+            s6 = input.charAt(peg$currPos);
+            if (peg$r1.test(s6)) {
+              peg$currPos++;
+            } else {
+              s6 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e37); }
+            }
+          }
+        } else {
+          s5 = peg$FAILED;
+        }
+        if (s5 !== peg$FAILED) {
+          s6 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 46) {
+            s7 = peg$c29;
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e19); }
+          }
+          if (s7 !== peg$FAILED) {
+            s8 = [];
+            s9 = input.charAt(peg$currPos);
+            if (peg$r1.test(s9)) {
+              peg$currPos++;
+            } else {
+              s9 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e37); }
+            }
+            while (s9 !== peg$FAILED) {
+              s8.push(s9);
+              s9 = input.charAt(peg$currPos);
+              if (peg$r1.test(s9)) {
+                peg$currPos++;
+              } else {
+                s9 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e37); }
+              }
+            }
+            s7 = [s7, s8];
+            s6 = s7;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          if (s6 === peg$FAILED) {
+            s6 = null;
+          }
+          s5 = [s5, s6];
+          s4 = s5;
+        } else {
+          peg$currPos = s4;
+          s4 = peg$FAILED;
+        }
+        if (s4 === peg$FAILED) {
+          s4 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 46) {
+            s5 = peg$c29;
+            peg$currPos++;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e19); }
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = [];
+            s7 = input.charAt(peg$currPos);
+            if (peg$r1.test(s7)) {
+              peg$currPos++;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e37); }
+            }
+            if (s7 !== peg$FAILED) {
+              while (s7 !== peg$FAILED) {
+                s6.push(s7);
+                s7 = input.charAt(peg$currPos);
+                if (peg$r1.test(s7)) {
+                  peg$currPos++;
+                } else {
+                  s7 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e37); }
+                }
+              }
+            } else {
+              s6 = peg$FAILED;
+            }
+            if (s6 !== peg$FAILED) {
+              s5 = [s5, s6];
+              s4 = s5;
+            } else {
+              peg$currPos = s4;
+              s4 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+        }
+        if (s4 !== peg$FAILED) {
+          s3 = [s3, s4];
+          s2 = s3;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s1 = input.substring(s1, peg$currPos);
+        } else {
+          s1 = s2;
+        }
+        if (s1 !== peg$FAILED) {
+          s1 = peg$f27(s1);
+        }
+        s0 = s1;
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e35); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseStringLiteral() {
+        let s0, s1, s2, s3, s4;
+
+        const key = peg$currPos * 40 + 30;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 39) {
+          s1 = peg$c44;
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e39); }
+        }
+        if (s1 !== peg$FAILED) {
+          s2 = peg$currPos;
+          s3 = [];
+          s4 = input.charAt(peg$currPos);
+          if (peg$r2.test(s4)) {
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e40); }
+          }
+          while (s4 !== peg$FAILED) {
+            s3.push(s4);
+            s4 = input.charAt(peg$currPos);
+            if (peg$r2.test(s4)) {
+              peg$currPos++;
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e40); }
+            }
+          }
+          s2 = input.substring(s2, peg$currPos);
+          if (input.charCodeAt(peg$currPos) === 39) {
+            s3 = peg$c44;
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e39); }
+          }
+          if (s3 !== peg$FAILED) {
+            s0 = peg$f28(s2);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 34) {
+            s1 = peg$c45;
+            peg$currPos++;
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e41); }
+          }
+          if (s1 !== peg$FAILED) {
+            s2 = peg$currPos;
+            s3 = [];
+            s4 = input.charAt(peg$currPos);
+            if (peg$r3.test(s4)) {
+              peg$currPos++;
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e42); }
+            }
+            while (s4 !== peg$FAILED) {
+              s3.push(s4);
+              s4 = input.charAt(peg$currPos);
+              if (peg$r3.test(s4)) {
+                peg$currPos++;
+              } else {
+                s4 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e42); }
+              }
+            }
+            s2 = input.substring(s2, peg$currPos);
+            if (input.charCodeAt(peg$currPos) === 34) {
+              s3 = peg$c45;
+              peg$currPos++;
+            } else {
+              s3 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e41); }
+            }
+            if (s3 !== peg$FAILED) {
+              s0 = peg$f29(s2);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+          if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 96) {
+              s1 = peg$c46;
+              peg$currPos++;
+            } else {
+              s1 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e43); }
+            }
+            if (s1 !== peg$FAILED) {
+              s2 = [];
+              s3 = peg$parseTemplateStringExpression();
+              if (s3 === peg$FAILED) {
+                s3 = peg$parseTemplateStringLiteral();
+              }
+              while (s3 !== peg$FAILED) {
+                s2.push(s3);
+                s3 = peg$parseTemplateStringExpression();
+                if (s3 === peg$FAILED) {
+                  s3 = peg$parseTemplateStringLiteral();
+                }
+              }
+              if (input.charCodeAt(peg$currPos) === 96) {
+                s3 = peg$c46;
+                peg$currPos++;
+              } else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e43); }
+              }
+              if (s3 !== peg$FAILED) {
+                s0 = peg$f30(s2);
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          }
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e38); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseTemplateStringExpression() {
+        let s0, s1, s3, s5;
+
+        const key = peg$currPos * 40 + 31;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 123) {
+          s1 = peg$c9;
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e9); }
+        }
+        if (s1 !== peg$FAILED) {
+          peg$parse_();
+          s3 = peg$parseTernaryExpression();
+          if (s3 !== peg$FAILED) {
+            peg$parse_();
+            if (input.charCodeAt(peg$currPos) === 125) {
+              s5 = peg$c47;
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e45); }
+            }
+            if (s5 !== peg$FAILED) {
+              s0 = peg$f31(s3);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e44); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseTemplateStringLiteral() {
+        let s0, s1, s2, s3, s4;
+
+        const key = peg$currPos * 40 + 32;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        s1 = [];
+        s2 = peg$currPos;
+        s3 = [];
+        s4 = input.charAt(peg$currPos);
+        if (peg$r4.test(s4)) {
+          peg$currPos++;
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e47); }
+        }
+        if (s4 !== peg$FAILED) {
+          while (s4 !== peg$FAILED) {
+            s3.push(s4);
+            s4 = input.charAt(peg$currPos);
+            if (peg$r4.test(s4)) {
+              peg$currPos++;
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e47); }
+            }
+          }
+        } else {
+          s3 = peg$FAILED;
+        }
+        if (s3 !== peg$FAILED) {
+          s2 = input.substring(s2, peg$currPos);
+        } else {
+          s2 = s3;
+        }
+        if (s2 === peg$FAILED) {
+          s2 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 92) {
+            s3 = peg$c7;
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e7); }
+          }
+          if (s3 !== peg$FAILED) {
+            if (input.length > peg$currPos) {
+              s4 = input.charAt(peg$currPos);
+              peg$currPos++;
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e8); }
+            }
+            if (s4 !== peg$FAILED) {
+              s2 = peg$f32(s4);
+            } else {
+              peg$currPos = s2;
+              s2 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+        }
+        if (s2 !== peg$FAILED) {
+          while (s2 !== peg$FAILED) {
+            s1.push(s2);
+            s2 = peg$currPos;
+            s3 = [];
+            s4 = input.charAt(peg$currPos);
+            if (peg$r4.test(s4)) {
+              peg$currPos++;
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e47); }
+            }
+            if (s4 !== peg$FAILED) {
+              while (s4 !== peg$FAILED) {
+                s3.push(s4);
+                s4 = input.charAt(peg$currPos);
+                if (peg$r4.test(s4)) {
+                  peg$currPos++;
+                } else {
+                  s4 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e47); }
+                }
+              }
+            } else {
+              s3 = peg$FAILED;
+            }
+            if (s3 !== peg$FAILED) {
+              s2 = input.substring(s2, peg$currPos);
+            } else {
+              s2 = s3;
+            }
+            if (s2 === peg$FAILED) {
+              s2 = peg$currPos;
+              if (input.charCodeAt(peg$currPos) === 92) {
+                s3 = peg$c7;
+                peg$currPos++;
+              } else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e7); }
+              }
+              if (s3 !== peg$FAILED) {
+                if (input.length > peg$currPos) {
+                  s4 = input.charAt(peg$currPos);
+                  peg$currPos++;
+                } else {
+                  s4 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e8); }
+                }
+                if (s4 !== peg$FAILED) {
+                  s2 = peg$f32(s4);
+                } else {
+                  peg$currPos = s2;
+                  s2 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s2;
+                s2 = peg$FAILED;
+              }
+            }
+          }
+        } else {
+          s1 = peg$FAILED;
+        }
+        if (s1 !== peg$FAILED) {
+          s1 = peg$f33(s1);
+        }
+        s0 = s1;
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 123) {
+            s1 = peg$c9;
+            peg$currPos++;
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e9); }
+          }
+          if (s1 !== peg$FAILED) {
+            s1 = peg$f34(s1);
+          }
+          s0 = s1;
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e46); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseArrayLiteral() {
+        let s0, s1, s3, s5, s6, s7, s9;
+
+        const key = peg$currPos * 40 + 33;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 91) {
+          s1 = peg$c30;
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e21); }
+        }
+        if (s1 !== peg$FAILED) {
+          peg$parse_();
+          s3 = peg$parseTernaryExpression();
+          if (s3 === peg$FAILED) {
+            s3 = null;
+          }
+          peg$parse_();
+          s5 = [];
+          s6 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 44) {
+            s7 = peg$c34;
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          }
+          if (s7 !== peg$FAILED) {
+            peg$parse_();
+            s9 = peg$parseTernaryExpression();
+            if (s9 !== peg$FAILED) {
+              peg$parse_();
+              s6 = s9;
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          while (s6 !== peg$FAILED) {
+            s5.push(s6);
+            s6 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 44) {
+              s7 = peg$c34;
+              peg$currPos++;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            }
+            if (s7 !== peg$FAILED) {
+              peg$parse_();
+              s9 = peg$parseTernaryExpression();
+              if (s9 !== peg$FAILED) {
+                peg$parse_();
+                s6 = s9;
+              } else {
+                peg$currPos = s6;
+                s6 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+          }
+          if (input.charCodeAt(peg$currPos) === 93) {
+            s6 = peg$c31;
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e22); }
+          }
+          if (s6 !== peg$FAILED) {
+            s0 = peg$f35(s3, s5);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e48); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseDictLiteral() {
+        let s0, s1, s3, s4, s5, s6, s7, s8, s9, s11, s13;
+
+        const key = peg$currPos * 40 + 34;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 123) {
+          s1 = peg$c9;
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e9); }
+        }
+        if (s1 !== peg$FAILED) {
+          peg$parse_();
+          s3 = peg$currPos;
+          s4 = peg$parseStringLiteral();
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parse_();
+            if (input.charCodeAt(peg$currPos) === 58) {
+              s6 = peg$c15;
+              peg$currPos++;
+            } else {
+              s6 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e11); }
+            }
+            if (s6 !== peg$FAILED) {
+              s7 = peg$parse_();
+              s8 = peg$parseTernaryExpression();
+              if (s8 !== peg$FAILED) {
+                s3 = [ s4, s8 ];
+              } else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+          if (s3 === peg$FAILED) {
+            s3 = null;
+          }
+          s4 = peg$parse_();
+          s5 = [];
+          s6 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 44) {
+            s7 = peg$c34;
+            peg$currPos++;
+          } else {
+            s7 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e25); }
+          }
+          if (s7 !== peg$FAILED) {
+            s8 = peg$parse_();
+            s9 = peg$parseStringLiteral();
+            if (s9 !== peg$FAILED) {
+              peg$parse_();
+              if (input.charCodeAt(peg$currPos) === 58) {
+                s11 = peg$c15;
+                peg$currPos++;
+              } else {
+                s11 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e11); }
+              }
+              if (s11 !== peg$FAILED) {
+                peg$parse_();
+                s13 = peg$parseTernaryExpression();
+                if (s13 !== peg$FAILED) {
+                  peg$parse_();
+                  s6 = [ s9, s13 ];
+                } else {
+                  peg$currPos = s6;
+                  s6 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s6;
+                s6 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          while (s6 !== peg$FAILED) {
+            s5.push(s6);
+            s6 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 44) {
+              s7 = peg$c34;
+              peg$currPos++;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e25); }
+            }
+            if (s7 !== peg$FAILED) {
+              s8 = peg$parse_();
+              s9 = peg$parseStringLiteral();
+              if (s9 !== peg$FAILED) {
+                peg$parse_();
+                if (input.charCodeAt(peg$currPos) === 58) {
+                  s11 = peg$c15;
+                  peg$currPos++;
+                } else {
+                  s11 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e11); }
+                }
+                if (s11 !== peg$FAILED) {
+                  peg$parse_();
+                  s13 = peg$parseTernaryExpression();
+                  if (s13 !== peg$FAILED) {
+                    peg$parse_();
+                    s6 = [ s9, s13 ];
+                  } else {
+                    peg$currPos = s6;
+                    s6 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s6;
+                  s6 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s6;
+                s6 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s6;
+              s6 = peg$FAILED;
+            }
+          }
+          if (input.charCodeAt(peg$currPos) === 125) {
+            s6 = peg$c47;
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e45); }
+          }
+          if (s6 !== peg$FAILED) {
+            s0 = peg$f36(s3, s5);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e49); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseModuleFunction() {
+        let s0, s1, s2, s3, s4, s5, s6, s7;
+
+        const key = peg$currPos * 40 + 35;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 35) {
+          s1 = peg$c49;
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e51); }
+        }
+        if (s1 !== peg$FAILED) {
+          s2 = peg$currPos;
+          s3 = peg$currPos;
+          s4 = peg$currPos;
+          s5 = input.charAt(peg$currPos);
+          if (peg$r5.test(s5)) {
+            peg$currPos++;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e52); }
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = [];
+            s7 = input.charAt(peg$currPos);
+            if (peg$r6.test(s7)) {
+              peg$currPos++;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e53); }
+            }
+            while (s7 !== peg$FAILED) {
+              s6.push(s7);
+              s7 = input.charAt(peg$currPos);
+              if (peg$r6.test(s7)) {
+                peg$currPos++;
+              } else {
+                s7 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e53); }
+              }
+            }
+            s5 = [s5, s6];
+            s4 = s5;
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+          if (s4 !== peg$FAILED) {
+            s3 = input.substring(s3, peg$currPos);
+          } else {
+            s3 = s4;
+          }
+          if (s3 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 58) {
+              s4 = peg$c15;
+              peg$currPos++;
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e11); }
+            }
+            if (s4 !== peg$FAILED) {
+              s2 = s3;
+            } else {
+              peg$currPos = s2;
+              s2 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+          if (s2 === peg$FAILED) {
+            s2 = null;
+          }
+          s3 = peg$currPos;
+          s4 = peg$currPos;
+          s5 = input.charAt(peg$currPos);
+          if (peg$r5.test(s5)) {
+            peg$currPos++;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e52); }
+          }
+          if (s5 !== peg$FAILED) {
+            s6 = [];
+            s7 = input.charAt(peg$currPos);
+            if (peg$r6.test(s7)) {
+              peg$currPos++;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e53); }
+            }
+            while (s7 !== peg$FAILED) {
+              s6.push(s7);
+              s7 = input.charAt(peg$currPos);
+              if (peg$r6.test(s7)) {
+                peg$currPos++;
+              } else {
+                s7 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e53); }
+              }
+            }
+            s5 = [s5, s6];
+            s4 = s5;
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+          if (s4 !== peg$FAILED) {
+            s3 = input.substring(s3, peg$currPos);
+          } else {
+            s3 = s4;
+          }
+          if (s3 !== peg$FAILED) {
+            s0 = peg$f37(s2, s3);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e50); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseSymbol() {
+        let s0, s1, s2, s3, s4, s5;
+
+        const key = peg$currPos * 40 + 36;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = peg$currPos;
+        s1 = peg$currPos;
+        s2 = peg$currPos;
+        s3 = input.charAt(peg$currPos);
+        if (peg$r5.test(s3)) {
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e52); }
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = [];
+          s5 = input.charAt(peg$currPos);
+          if (peg$r6.test(s5)) {
+            peg$currPos++;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e53); }
+          }
+          while (s5 !== peg$FAILED) {
+            s4.push(s5);
+            s5 = input.charAt(peg$currPos);
+            if (peg$r6.test(s5)) {
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e53); }
+            }
+          }
+          s3 = [s3, s4];
+          s2 = s3;
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s1 = input.substring(s1, peg$currPos);
+        } else {
+          s1 = s2;
+        }
+        if (s1 !== peg$FAILED) {
+          s1 = peg$f38(s1);
+        }
+        s0 = s1;
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e54); }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseEqualityOp() {
+        let s0;
+
+        const key = peg$currPos * 40 + 37;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        if (input.substr(peg$currPos, 2) === peg$c53) {
+          s0 = peg$c53;
+          peg$currPos += 2;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e55); }
+        }
+        if (s0 === peg$FAILED) {
+          if (input.substr(peg$currPos, 2) === peg$c54) {
+            s0 = peg$c54;
+            peg$currPos += 2;
+          } else {
+            s0 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e56); }
+          }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parseRelationalOp() {
+        let s0;
+
+        const key = peg$currPos * 40 + 38;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        if (input.substr(peg$currPos, 2) === peg$c55) {
+          s0 = peg$c55;
+          peg$currPos += 2;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e57); }
+        }
+        if (s0 === peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 62) {
+            s0 = peg$c56;
+            peg$currPos++;
+          } else {
+            s0 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e58); }
+          }
+          if (s0 === peg$FAILED) {
+            if (input.substr(peg$currPos, 2) === peg$c57) {
+              s0 = peg$c57;
+              peg$currPos += 2;
+            } else {
+              s0 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e59); }
+            }
+            if (s0 === peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 60) {
+                s0 = peg$c58;
+                peg$currPos++;
+              } else {
+                s0 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e60); }
+              }
+            }
+          }
+        }
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      function peg$parse_() {
+        let s0, s1;
+
+        const key = peg$currPos * 40 + 39;
+        const cached = peg$resultsCache[key];
+
+        if (cached) {
+          peg$currPos = cached.nextPos;
+
+          return cached.result;
+        }
+
+        peg$silentFails++;
+        s0 = [];
+        s1 = input.charAt(peg$currPos);
+        if (peg$r7.test(s1)) {
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$e61); }
+        }
+        while (s1 !== peg$FAILED) {
+          s0.push(s1);
+          s1 = input.charAt(peg$currPos);
+          if (peg$r7.test(s1)) {
+            peg$currPos++;
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$e61); }
+          }
+        }
+        peg$silentFails--;
+
+        peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
+
+        return s0;
+      }
+
+      peg$result = peg$startRuleFunction();
+
+      const peg$success = (peg$result !== peg$FAILED && peg$currPos === input.length);
+      function peg$throw() {
+        if (peg$result !== peg$FAILED && peg$currPos < input.length) {
+          peg$fail(peg$endExpectation());
+        }
+
+        throw peg$buildStructuredError(
+          peg$maxFailExpected,
+          peg$maxFailPos < input.length ? peg$getUnicode(peg$maxFailPos) : null,
+          peg$maxFailPos < input.length
+            ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
+            : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
+        );
+      }
+      if (options.peg$library) {
+        return /** @type {any} */ ({
+          peg$result,
+          peg$currPos,
+          peg$FAILED,
+          peg$maxFailExpected,
+          peg$maxFailPos,
+          peg$success,
+          peg$throw: peg$success ? undefined : peg$throw,
+        });
+      }
+      if (peg$success) {
+        return peg$result;
+      } else {
+        peg$throw();
+      }
+    }
+
+    class EvaluatingVisitor {
+        #modules;
+        #dataStack;
+        constructor(modules, dataStack) {
+            this.#modules = modules;
+            this.#dataStack = dataStack;
+        }
+        #resolve(prop) {
+            if (prop === 'self') {
+                return this.#dataStack[this.#dataStack.length - 1];
+            }
+            for (let i = this.#dataStack.length - 1; i >= 0; i--) {
+                const overlay = this.#dataStack[i];
+                if (overlay != null && (typeof overlay === 'object' || typeof overlay === 'function')) {
+                    if (prop in overlay) {
+                        return overlay[prop];
+                    }
+                }
+            }
+            return undefined;
+        }
+
+        #cached_resolve_proxy;
+        #resolve_proxy() {
+            if (!this.#cached_resolve_proxy) {
+                this.#cached_resolve_proxy = new Proxy(this.#dataStack, {
+                    get: (target, prop) => this.#resolve(prop)
+                });
+            }
+            return this.#cached_resolve_proxy;
+        }
+        [nodes.and](node) {
+            return this.visit(node.lhs) && this.visit(node.rhs);
+        }
+        [nodes.or](node) {
+            return this.visit(node.lhs) || this.visit(node.rhs);
+        }
+        [nodes.nullc](node) {
+            const lhs = this.visit(node.lhs);
+            return lhs !== null && lhs !== undefined ? lhs : this.visit(node.rhs);
+        }
+        [nodes.not](node) {
+            return !this.visit(node.expr);
+        }
+        [nodes.eq](node) {
+            const lhs = this.visit(node.lhs);
+            const rhs = this.visit(node.rhs);
+            const eq = lhs === rhs;
+            return node.op === '==' ? eq : !eq;
+        }
+        [nodes.cmp](node) {
+            const lhs = this.visit(node.lhs);
+            const rhs = this.visit(node.rhs);
+            switch (node.op) {
+                case '>':
+                    return lhs > rhs;
+                case '<':
+                    return lhs < rhs;
+                case '>=':
+                    return lhs >= rhs;
+                case '<=':
+                    return lhs <= rhs;
+                default:
+                    throw new Error('unknown cmp op ' + node.op);
+            }
+        }
+        [nodes.call](node) {
+            const fnRef = node.value;
+            const module = fnRef.module === null ? this.#modules : this.#modules?.[fnRef.module];
+            if (!module) {
+                throw new Error(`Module "${fnRef.module}" not found`);
+            }
+            const fn = module[fnRef.value];
+            if (!fn) {
+                throw new Error(`Function "#${fnRef.module === null ? '' : fnRef.module + ':'}${fnRef.value}" not found`);
+            }
+            const args = node.args.map((arg) => this.visit(arg));
+            return fn.apply(this.#resolve_proxy(), args);
+        }
+        [nodes.literal](node) {
+            return node.value;
+        }
+        [nodes.tstring](node) {
+            let result = '';
+            const parts = node.parts;
+            for (let i = 0, len = parts.length; i < len; i++) {
+                const evaluated = this.visit(parts[i]);
+                if (evaluated !== null && evaluated !== undefined) {
+                    result += evaluated;
+                }
+            }
+            return result;
+        }
+        [nodes.symbol](node) {
+            return this.#resolve(node.value);
+        }
+        [nodes.dict](node) {
+            return Object.fromEntries(node.value.map((entry) => [entry[0].value, this.visit(entry[1])]));
+        }
+        [nodes.array](node) {
+            return node.value.map((v) => this.visit(v));
+        }
+        [nodes.ter](node) {
+            return this.visit(node.cond) ? this.visit(node.ifTrue) : this.visit(node.ifFalse);
+        }
+        [nodes.elv](node) {
+            const cond = this.visit(node.cond);
+            return cond ? cond : this.visit(node.ifFalse);
+        }
+        [nodes.access](node) {
+            let prev = undefined;
+            let cur = this.visit(node.lhs);
+            for (let i = 0; i !== node.rhs.length; ++i) {
+                const rhs = node.rhs[i];
+                if (rhs.ns && cur == null) {
+                    return undefined;
+                }
+                let value = undefined;
+                switch (rhs.type) {
+                    case nodes.member: {
+                        value = cur[rhs.rhs];
+                        break;
+                    }
+                    case nodes.subscript: {
+                        value = cur[this.visit(rhs.rhs)];
+                        break;
+                    }
+                    case nodes.method: {
+                        if (!cur) {
+                            throw new Error(`Method missing "${node.rhs[i - 1].rhs}"`);
+                        }
+                        const args = rhs.args.map((arg) => this.visit(arg));
+                        value = cur.apply(prev, args);
+                        break;
+                    }
+                }
+                prev = cur;
+                cur = value;
+            }
+            return cur;
+        }
+        visit(node, ...args) {
+            return this[node.type](node, ...args);
+        }
+        visitRoot(ast, templated) {
+            return !templated
+                ? this.visit(ast)
+                : ast.map((node) => {
+                    switch (node.type) {
+                        case nodes.templated.tel:
+                            return { type: nodes.dom.t, value: node.value };
+                        case nodes.templated.tet:
+                            return { type: nodes.dom.t, value: this.visit(node.value) };
+                        case nodes.templated.teh:
+                            return { type: nodes.dom.h, value: this.visit(node.value) };
+                        case nodes.templated.ten:
+                            return { type: nodes.dom.n, value: this.visit(node.value) };
+                        default:
+                            throw new Error('unknown node type ' + node.type.toString());
+                    }
+                });
+        }
+    }
+
+    class Expressions {
+        static MODE_EXPRESSION = Symbol('MODE_EXPRESSION');
+        static MODE_TEMPLATED = Symbol('MODE_TEMPLATED');
+
+        static #astCache = new Map();
+        static #MAX_CACHE_SIZE = 1000;
+
+        /**
+         * Parses an expression.
+         * @param {string} expression
+         * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
+         * @returns the ast
+         */
+        static parse(expression, mode) {
+            const key = mode?.toString() + expression;
+
+            if (!this.#astCache.has(key)) {
+                if (this.#astCache.size >= this.#MAX_CACHE_SIZE) {
+                    const oldestKey = this.#astCache.keys().next().value;
+                    this.#astCache.delete(oldestKey);
+                }
+                this.#astCache.set(key, peg$parse(expression, {
+                    startRule: mode === Expressions.MODE_TEMPLATED ? 'TemplatedRoot' : 'ExpressionRoot',
+                }));
+            }
+
+            return this.#astCache.get(key);
+        }
+        /**
+         * Evaluates an expression.
+         * @param {{[k: string]: any } | null | undefined } modules
+         * @param {any[]} dataStack
+         * @param {any} ast
+         * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
+         * @returns the result
+         */
+        static evaluate(modules, dataStack, ast, mode) {
+            return new EvaluatingVisitor(modules, dataStack).visitRoot(ast, mode === Expressions.MODE_TEMPLATED);
+        }
+        /**
+         * Parses and evaluates an expression.
+         * @param {{ [x: string]: any; } | null | undefined} modules
+         * @param {any[]} dataStack
+         * @param {string} expression
+         * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
+         * @returns the result
+         */
+        static interpret(modules, dataStack, expression, mode) {
+            return Expressions.evaluate(modules, dataStack, Expressions.parse(expression, mode), mode);
+        }
+    }
+
+    class ExpressionEvaluator {
+        #modules;
+        #dataStack;
+        constructor(modules, dataStack) {
+            this.#modules = modules;
+            this.#dataStack = dataStack;
+        }
+        withModule(name, value) {
+            const module = name ? { [name]: value } : value;
+            return new ExpressionEvaluator({ ...this.#modules, ...module }, this.#dataStack);
+        }
+        withOverlay(...data) {
+            return new ExpressionEvaluator(
+                this.#modules,
+                data.length === 0 ? this.#dataStack : [...this.#dataStack, ...data],
+            );
+        }
+        evaluate(expression, mode) {
+            return Expressions.interpret(this.#modules, this.#dataStack, expression, mode);
+        }
+        evaluateExpression(expression) {
+            return this.evaluate(expression, Expressions.MODE_EXPRESSION);
+        }
+        evaluateTemplated(expression) {
+            return this.evaluate(expression, Expressions.MODE_TEMPLATED);
+        }
+    }
+
+    class Fragments {
+        /**
+         * Creates a DocumentFragment from an string.
+         * @param  {...string} html
+         * @returns {DocumentFragment} the fragment
+         */
+        static fromHtml(...html) {
+            const el = document.createElement('template');
+            el.innerHTML = html.map((h) => h.trim()).join('');
+            return document.adoptNode(el.content);
+        }
+        /**
+         * Creates a string representation (HTML) of a DocumentFragment.
+         * @param {DocumentFragment} fragment
+         * @returns {string} the html
+         */
+        static toHtml(fragment) {
+            var el = document.createElement('template');
+            el.content.appendChild(fragment);
+            return el.innerHTML;
+        }
+        /**
+         * Checks if a fragment contains only blank text nodes
+         * @param {DocumentFragment} fragment
+         * @returns {boolean} true if the fragment is blank
+         */
+        static isBlank(fragment) {
+            return fragment.childElementCount === 0 && fragment.textContent.trim() === '';
+        }
+        /**
+         * Creates a DocumentFragment from nodes.
+         * @param  {...Node} nodes
+         * @returns {DocumentFragment} the fragment
+         */
+        static from(...nodes) {
+            const fragment = new DocumentFragment();
+            for (const node of nodes) {
+                fragment.appendChild(node);
+            }
+            return fragment;
+        }
+        /**
+         * Creates a DocumentFragment from childNodes of an element.
+         * @param {Node} el
+         * @returns {DocumentFragment} the fragment
+         */
+        static fromChildNodes(el) {
+            const fragment = new DocumentFragment();
+            while (el.firstChild) {
+                fragment.appendChild(el.firstChild);
+            }
+            return fragment;
+        }
+    }
+
+    class Attributes {
+        static id = 0;
+        /**
+         * Creates a unique id with the given prefix.
+         * @param {string} prefix
+         * @returns
+         */
+        static uid(prefix) {
+            return `${prefix}-${++Attributes.id}`;
+        }
+        /**
+         * Sets an attribute if not present.
+         * @param {Element} el
+         * @param {string} k
+         * @param {string} v
+         * @returns
+         */
+        static defaultValue(el, k, v) {
+            if (!el.hasAttribute(k)) {
+                el.setAttribute(k, v);
+            }
+            return el.getAttribute(k);
+        }
+        /**
+         * Forwards prefixed attributes from an element to another (removing the prefix).
+         * @param {string} prefix
+         * @param {Element} from
+         * @param {Element} to
+         */
+        static forward(prefix, from, to) {
+            from.getAttributeNames()
+                .filter((a) => a.startsWith(prefix))
+                .forEach((a) => {
+                    const target = a.substring(prefix.length);
+                    if (target === 'class') {
+                        const classes = from.getAttribute(prefix + 'class')?.split(/\s+/).filter((a) => a.length) ?? [];
+                        to.classList.add(...classes);
+                        return;
+                    }
+                    to.setAttribute(target, /** @type {string} */(from.getAttribute(a)));
+                });
+        }
+        /**
+         * Changes the presence of an attribute.
+         * @param {Element} el
+         * @param {string} attr
+         * @param {boolean} value
+         */
+        static toggle(el, attr, value) {
+            if (value) {
+                el.setAttribute(attr, '');
+            } else {
+                el.removeAttribute(attr);
+            }
+        }
+        /**
+         * Changes the presence of an attribute based on its current state.
+         * @param {Element} el
+         * @param {string} attr
+         */
+        static flip(el, attr) {
+            if (el.hasAttribute(attr)) {
+                el.removeAttribute(attr);
+            } else {
+                el.setAttribute(attr, '');
+            }
+        }
+        /**
+         * Sets the value of an attribute. nullish values remove the attribute.
+         * @param {Element} el
+         * @param {string} attr
+         * @param {string | null | undefined} value
+         */
+        static set(el, attr, value) {
+            if (value == null) {
+                el.removeAttribute(attr);
+            } else {
+                el.setAttribute(attr, value);
+            }
+        }
+    }
+
+    class LightSlots {
+        /**
+         * Extracts light slots from an element. For non default slots in a template tag, the content is extracted.
+         * @param {Element} el
+         * @returns the slots
+         */
+        static from(el) {
+            /** @type [string, Element|DocumentFragment][] */
+            const namedSlots = Array.from(el.children)
+                .filter((el) => el.matches('[slot]'))
+                .map((el) => {
+                    el.remove();
+                    const slot = el.getAttribute('slot') || 'unnamed';
+                    el.removeAttribute('slot');
+                    return [slot, LightSlots.slotFromNode(el)];
+                });
+            const slots = {};
+            slots.default = new DocumentFragment();
+            slots.default.append(...el.childNodes);
+            for (const [name, el] of namedSlots) {
+                if (!(name in slots)) {
+                    slots[name] = new DocumentFragment();
+                }
+                slots[name].append(el);
+            }
+            return slots;
+        }
+        static slotFromNode(el) {
+            if (el instanceof HTMLTemplateElement) {
+                return document.adoptNode(el.content);
+            }
+            if (el instanceof HTMLScriptElement && el.type !== '' && el.type !== 'text/javascript') {
+                return Fragments.fromHtml(el.innerHTML);
+            }
+            return el;
+        }
+    }
+
+    class Nodes {
+        /**
+         * Checks if an element is already parsed.
+         * @param {Element} el
+         * @returns
+         */
+        static isParsed(el) {
+            //@ts-ignore
+            for (let c = el; c; c = c.parentNode) {
+                if (c.nextSibling) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        static waitParsed(el) {
+            if (el.ownerDocument.readyState === 'complete' || Nodes.isParsed(el)) {
+                return Promise.resolve(el);
+            }
+            return new Promise((resolve) => {
+                const ac = new AbortController();
+                const clearAndQueue = () => {
+                    ac.abort();
+                    observer.disconnect();
+                    resolve(el);
+                };
+                el.ownerDocument.addEventListener('DOMContentLoaded', clearAndQueue, { signal: ac.signal });
+                const observer = new MutationObserver(() => {
+                    if (!Nodes.isParsed(el)) {
+                        return;
+                    }
+                    clearAndQueue();
+                });
+                const parent = /** @type {Node} */ (el.parentNode);
+                observer.observe(parent, { childList: true });
+            });
+        }
+
+        /**
+         * Returns the first child of the element element (if exists) matching the selector.
+         * @param {Element} el
+         * @param {string} selector
+         * @returns
+         */
+        static queryChildren(el, selector) {
+            for (const c of el.children) {
+                if (c.matches(selector)) {
+                    return c;
+                }
+            }
+            return null;
+        }
+        /**
+         * Returns all children of the element matching the selector.
+         * @param {Element} el
+         * @param {string} selector
+         * @returns
+         */
+        static queryChildrenAll(el, selector) {
+            const r = [];
+            for (const c of el.children) {
+                if (c.matches(selector)) {
+                    r.push(c);
+                }
+            }
+            return r;
+        }
+    }
+
+    class NodeOperations {
+        #forRemoval;
+        constructor() {
+            this.#forRemoval = [];
+        }
+        removed(node) {
+            return this.#forRemoval.includes(node);
+        }
+        remove(node) {
+            node.replaceChildren?.();
+            Object.keys(node.dataset || {})
+                .filter((k) => k.startsWith('tpl'))
+                .forEach((k) => delete node.dataset[k]);
+            this.#forRemoval.push(node);
+        }
+        popData(node, key) {
+            const v = node.dataset[key];
+            delete node.dataset[key];
+            return v;
+        }
+        prepend(ref, node) {
+            ref.parentNode.insertBefore(node, ref);
+        }
+        append(ref, node) {
+            ref.parentNode.insertBefore(node, ref.nextSibling);
+        }
+        replace(ref, node) {
+            this.prepend(ref, node);
+            this.remove(ref);
+        }
+        cleanup() {
+            while (this.#forRemoval.length) {
+                this.#forRemoval.pop().remove();
+            }
+        }
+    }
+
+    class CommandsHandler {
+        static ORDERED_COMMANDS = [
+            'tplIf',
+            'tplWith',
+            'tplEach',
+            'tplWhen',
+            'tplClassAppend',
+            'tplAttrAppend',
+            'tplText',
+            'tplHtml',
+            'tplRemove',
+            'tplVerbatim',
+        ];
+        static tplIf(node, expression, ops, modules, dataStack) {
+            const accept = Expressions.interpret(modules, dataStack, expression);
+            if (!accept) {
+                ops.remove(node);
+            }
+        }
+        static tplWith(node, expression, ops, modules, dataStack) {
+            const evaluated = Expressions.interpret(modules, dataStack, expression);
+            const varName = ops.popData(node, 'tplVar');
+            const newNode = new Template(node, modules, dataStack)
+                .withOverlay(varName ? { [varName]: evaluated } : evaluated)
+                .render();
+            ops.replace(node, newNode);
+        }
+        static tplEach(node, expression, ops, modules, dataStack) {
+            const varName = ops.popData(node, 'tplVar');
+            const template = new Template(node, modules, dataStack);
+            const evaluated = Expressions.interpret(modules, dataStack, expression);
+            if (!evaluated?.[Symbol.iterator]) {
+                throw new Error(`Expected an iterable got '${evaluated}'`);
+            }
+            for (const v of evaluated) {
+                ops.prepend(node, template.withOverlay(varName ? { [varName]: v } : v).render());
+            }
+            ops.remove(node);
+        }
+        static tplWhen(node, expression, ops, modules, dataStack) {
+            const accept = Expressions.interpret(modules, dataStack, expression);
+            if (!accept) {
+                ops.remove(node);
+            }
+        }
+        static tplVerbatim(node, expression, ops, modules, dataStack) {
+            const newNode = node.cloneNode(true);
+            ops.replace(node, newNode);
+        }
+        static tplRemove(node, value, ops, modules, dataStack) {
+            switch (value.toLowerCase()) {
+                case 'tag':
+                    const fragment = new DocumentFragment();
+                    while (node.firstChild) {
+                        fragment.appendChild(node.firstChild);
+                    }
+                    if ('tplVerbatim' in node.dataset) {
+                        //we are removing the parent element so we have to handle the lower priority commands
+                        ops.popData(node, 'tplVerbatim');
+                        ops.replace(node, fragment);
+                    } else {
+                        ops.append(node, fragment);
+                        ops.remove(node);
+                    }
+                    break;
+                case 'body':
+                    node.replaceChildren();
+                    break;
+                case 'all':
+                    ops.remove(node);
+                    break;
+            }
+        }
+        static tplText(node, expression, ops, modules, dataStack) {
+            const text = Expressions.interpret(modules, dataStack, expression);
+            const newNode = node.cloneNode();
+            newNode.replaceChildren(text == null ? '' : text);
+            ops.replace(node, newNode);
+        }
+        static tplHtml(node, expression, ops, modules, dataStack) {
+            const html = Expressions.interpret(modules, dataStack, expression);
+            const newNode = node.cloneNode();
+            newNode.innerHTML = html == null ? '' : html;
+            ops.replace(node, newNode);
+        }
+        static tplClassAppend(node, expression, ops, modules, dataStack) {
+            const classes = Expressions.interpret(modules, dataStack, expression);
+            if (!classes) {
+                return;
+            }
+            const classesAsArray = Array.isArray(classes) ? classes : [classes];
+            const cleanClasses = classesAsArray
+                .flatMap(c => typeof c === 'string' ? c.split(' ') : c)
+                .filter(Boolean);
+            if (cleanClasses.length === 0) {
+                return;
+            }
+            node.classList.add(...cleanClasses);
+        }
+        static tplAttrAppend(node, expression, ops, modules, dataStack) {
+            const attributesAndValues = Expressions.interpret(modules, dataStack, expression);
+            if (!attributesAndValues || attributesAndValues.length === 0) {
+                return;
+            }
+            const tuples = Array.isArray(attributesAndValues[0]) ? attributesAndValues : [attributesAndValues];
+            tuples.forEach(([k, v]) => {
+                node.setAttribute(k, v);
+            });
+        }
+        static textNode(node, expression, ops, modules, dataStack) {
+            for (const v of Expressions.interpret(modules, dataStack, expression, Expressions.MODE_TEMPLATED)) {
+                if (v.value == null) {
+                    continue;
+                }
+                switch (v.type) {
+                    case nodes.dom.t:
+                        ops.prepend(node, document.createTextNode(v.value));
+                        break;
+                    case nodes.dom.h:
+                        ops.prepend(node, Fragments.fromHtml(v.value));
+                        break;
+                    case nodes.dom.n:
+                        ops.prepend(node, v.value);
+                        break;
+                }
+            }
+            ops.remove(node);
+        }
+    }
+
+    // Module-isolated string cache for dataset-to-attribute conversions
+    const attributeCache = new Map();
+
+    /**
+     * Converts a tpl camelCase dataset key into a kebab-case attribute name.
+     * Uses a cache lookup to avoid repetitive regex/string splitting.
+     * @param {string} dataSetKey
+     * @returns {string}
+     */
+    function toAttr(dataSetKey) {
+        let cached = attributeCache.get(dataSetKey);
+        if (!cached) {
+            cached = dataSetKey
+                .substring(3)
+                .split(/(?=[A-Z])/)
+                .join('-')
+                .toLowerCase();
+            attributeCache.set(dataSetKey, cached);
+        }
+        return cached;
+    }
+
+    class Template {
+        /**
+         * Creates a template from a string.
+         * @param {string} html
+         * @param {{ [k: string] : any }?} [modules]
+         * @param {...*} data
+         * @returns the template
+         */
+        static fromHtml(html, modules, ...data) {
+            return new Template(Fragments.fromHtml(html), modules, data);
+        }
+
+        /**
+         * Creates a template from the content of the first template element matching the selector.
+         * @param {string} selector for an HTMLTemplateElement
+         * @param {{ [k: string] : any }?} [modules]
+         * @param {...*} data
+         * @returns the template
+         */
+        static fromSelector(selector, modules, ...data) {
+            const templateEl = document.querySelector(selector);
+            if (!(templateEl instanceof HTMLTemplateElement)) {
+                throw new Error('template selector does not match any template tag');
+            }
+            const fragment = document.adoptNode(templateEl.content);
+            return new Template(fragment, modules, data);
+        }
+
+        /**
+         * Creates a template from the content of an HTMLTemplateElement.
+         * @param {HTMLTemplateElement} templateEl
+         * @param {{ [k: string] : any }?} [modules]
+         * @param {...*} data
+         * @returns the template
+         */
+        static fromTemplate(templateEl, modules, ...data) {
+            const fragment = document.adoptNode(templateEl.content);
+            return new Template(fragment, modules, data);
+        }
+
+        /**
+         * Creates a template from a DocumentFragment.
+         * @param {DocumentFragment} fragment
+         * @param { { [k: string] : any }? } [modules]
+         * @param {...*} data
+         * @returns the template
+         */
+        static fromFragment(fragment, modules, ...data) {
+            return new Template(fragment, modules, data);
+        }
+        #fragment;
+        #modules;
+        #dataStack;
+        /**
+         * Creates a template.
+         * @param {DocumentFragment} fragment
+         * @param {{ [x: string]: any; } | null | undefined} modules
+         * @param {any[]} dataStack
+         */
+        constructor(fragment, modules, dataStack) {
+            this.#fragment = fragment;
+            this.#modules = modules;
+            this.#dataStack = dataStack;
+        }
+        /**
+         * Creates a new Template replacing the modules and dataStack from a context.
+         * @param {{modules: { [x: string]: any; } | null | undefined, data: any[]}} context
+         */
+        withContext({ modules, data }) {
+            return new Template(this.#fragment, modules, data);
+        }
+        /**
+         * Creates a new Template replacing the modules and dataStack from a registry.
+         * @param any registry
+         */
+        withContextFrom(registry) {
+            return this.withContext(registry.context());
+        }
+        /**
+         * Creates a new Template replacing the fragment.
+         * @param {DocumentFragment} fragment
+         */
+        withFragment(fragment) {
+            return new Template(fragment, this.#modules, this.#dataStack);
+        }
+        /**
+         * Creates a new Template with a new module added.
+         * @param {string?} name
+         * @param {{[k: string]: any}} value
+         */
+        withModule(name, value) {
+            const module = name ? { [name]: value } : value;
+            return new Template(this.#fragment, { ...this.#modules, ...module }, this.#dataStack);
+        }
+        /**
+         * Creates a new Template replacing the modules.
+         * @param {{ [x: string]: any; }?} modules
+         */
+        withModules(modules) {
+            return new Template(this.#fragment, modules, this.#dataStack);
+        }
+        /**
+         * Creates a new Template replacing the data stack.
+         * @param {any[]} dataStack the dataStack
+         */
+        withData(dataStack) {
+            return new Template(this.#fragment, this.#modules, dataStack);
+        }
+        /**
+         * Creates a new Template with new a data overlay added to the stack.
+         * @param {...*} data
+         */
+        withOverlay(...data) {
+            return new Template(
+                this.#fragment,
+                this.#modules,
+                data.length === 0 ? this.#dataStack : [...this.#dataStack, ...data],
+            );
+        }
+        /**
+         * Evaluates an expression using the configured modules and data.
+         * @param {string} expression
+         * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
+         * @param {...*} data
+         */
+        evaluate(expression, mode, ...data) {
+            new ExpressionEvaluator(this.#modules, this.#dataStack).withOverlay(...data).evaluate(expression, mode);
+        }
+        /**
+         * Returns an expression evaluator with bound modules and dataStack.
+         */
+        evaluator() {
+            return new ExpressionEvaluator(this.#modules, this.#dataStack);
+        }
+        /**
+         * Renders the template.
+         * @returns a DocumentFragment
+         */
+        render() {
+            try {
+                const ops = new NodeOperations();
+                const imported = document.importNode(this.#fragment, true);
+                const fragment =
+                    imported.nodeType === Node.DOCUMENT_FRAGMENT_NODE
+                        ? imported
+                        : (() => {
+                            const d = new DocumentFragment();
+                            d.appendChild(imported);
+                            return d;
+                        })();
+                const iterator = document.createNodeIterator(
+                    fragment,
+                    NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT,
+                    Template.#NODE_FILTER,
+                );
+                let node;
+                while ((node = iterator.nextNode()) !== null) {
+                    ops.cleanup();
+                    if (node.nodeType === Node.TEXT_NODE) {
+                        try {
+                            CommandsHandler.textNode(node, node.nodeValue, ops, this.#modules, this.#dataStack);
+                        } catch (ex) {
+                            throw new RenderError('Error evaluating text node', node, ex);
+                        }
+                        continue;
+                    }
+                    const el = /** @type {HTMLElement} */ (node);
+                    for (const command of CommandsHandler.ORDERED_COMMANDS) {
+                        if (!(command in el.dataset)) {
+                            continue;
+                        }
+                        const value = ops.popData(el, command);
+                        try {
+                            CommandsHandler[command](el, value, ops, this.#modules, this.#dataStack);
+                        } catch (ex) {
+                            throw new RenderError(`Error evaluating command ${command}`, el, ex);
+                        }
+                        if (ops.removed(el)) {
+                            break;
+                        }
+                    }
+                    for (const dataSetKey of Object.keys(el.dataset || {})) {
+                        if (!dataSetKey.startsWith('tpl')) {
+                            continue;
+                        }
+                        const attributeName = toAttr(dataSetKey);
+                        try {
+                            const expression = ops.popData(el, dataSetKey);
+                            const evaluated = Expressions.interpret(this.#modules, this.#dataStack, expression);
+                            if (typeof evaluated === 'boolean') {
+                                Attributes.toggle(el, attributeName, evaluated);
+                                continue;
+                            }
+                            if (evaluated !== null && evaluated !== undefined) {
+                                el.setAttribute(attributeName, evaluated);
+                            }
+                        } catch (ex) {
+                            throw new RenderError(`Error evaluating command ${dataSetKey}`, el, ex);
+                        }
+                    }
+                }
+                ops.cleanup();
+                return fragment;
+            } catch (ex) {
+                throw new RenderError('Error rendering template', this.#fragment, ex);
+            }
+        }
+        /**
+         * Renders this template on the Element (replacing children).
+         * @param {Element} el
+         */
+        renderTo(el) {
+            el.replaceChildren(this.render());
+        }
+        /**
+         * Renders this template appending the resulting fragment to the Element.
+         * @param {Element} el
+         */
+        appendTo(el) {
+            el.appendChild(this.render());
+        }
+        /**
+         * Renders this template appending the resulting fragment to the first Element maching the selector, if exists.
+         * @param {string} selector
+         */
+        renderToSelector(selector) {
+            const el = document.querySelector(selector);
+            if (el) {
+                this.renderTo(el);
+            }
+        }
+        /**
+         * Renders this template appending the resulting fragment to the Element maching the selector, if exists.
+         * @param {string} selector
+         */
+        appendToSelector(selector) {
+            const el = document.querySelector(selector);
+            if (el) {
+                this.appendTo(el);
+            }
+        }
+        static #NODE_FILTER(node) {
+            if (node.nodeType === Node.TEXT_NODE) {
+                return node.nodeValue.includes('{{') && node.nodeValue.includes('}}')
+                    ? NodeFilter.FILTER_ACCEPT
+                    : NodeFilter.FILTER_REJECT;
+            }
+            for (const attr of node.attributes) {
+                if (attr.name.startsWith('data-tpl-')) {
+                    return NodeFilter.FILTER_ACCEPT;
+                }
+            }
+            return NodeFilter.FILTER_SKIP;
+        }
+    }
+
+    class RenderError extends Error {
+        constructor(message, nodeOrFragment, cause) {
+            super(`${message} in \`${RenderError.stringify(nodeOrFragment)}\``, { cause });
+            this.name = 'RenderError';
+            this.node = nodeOrFragment.cloneNode(true);
+        }
+        static stringify(nodeOrFragment) {
+            const t = document.createElement('template');
+            t.content.appendChild(RenderError.#cleanup(nodeOrFragment.cloneNode(true)));
+            return t.innerHTML;
+        }
+        static #cleanup(node) {
+            if (node.nodeType === Node.TEXT_NODE) {
+                node.nodeValue = node.nodeValue.trim();
+            }
+            for (var n = 0; n < node.childNodes.length; n++) {
+                var child = node.childNodes[n];
+                if (child.nodeType === Node.TEXT_NODE) {
+                    child.nodeValue = child.nodeValue.trim();
+                    if (child.nodeValue.length === 0) {
+                        node.removeChild(child);
+                        n--;
+                    }
+                } else if (child.nodeType === Node.ELEMENT_NODE) {
+                    RenderError.#cleanup(child);
+                }
+            }
+            return node;
+        }
+    }
+
+    class UpgradeQueue {
+        #q = new Map();
+        constructor() {
+            document.addEventListener('DOMContentLoaded', async () => {
+                const pending = Array.from(this.entries).map(([child, promise]) => promise);
+                await Promise.all(pending);
+                document.dispatchEvent(
+                    new CustomEvent('ftl:ready', {
+                        bubbles: false,
+                        cancelable: false,
+                    }),
+                );
+            });
+        }
+        enqueue(el) {
+            if (this.#q.has(el)) {
+                //already upgrading, can happen when disconnecting an element
+                //while it's already queued for upgrade (e.g.: ful-form)
+                return;
+            }
+            const promise = Nodes.waitParsed(el)
+                .then(() => el.upgrade())
+                .finally(() => this.#q.delete(el));
+            this.#q.set(el, promise);
+        }
+        get entries() {
+            return this.#q.entries();
+        }
+    }
+
+
+    class Registry {
+        #tagToClass = {};
+        #configured = false;
+        #mappers = {
+            string: {
+                unmarshal(str, name, el) {
+                    return str;
+                },
+                marshal(value, name, el) {
+                    return value == null ? null : String(value);
+                },
+            },
+            number: {
+                unmarshal(str, name, el) {
+                    return str === null ? null : Number(str);
+                },
+                marshal(value, name, el) {
+                    return value == null ? null : String(value);
+                },
+            },
+            presence: {
+                unmarshal(str, name, el) {
+                    return str !== null;
+                },
+                marshal(value, name, el) {
+                    return value ? '' : null;
+                },
+            },
+            bool: {
+                unmarshal(str, name, el) {
+                    return str === 'true';
+                },
+                marshal(value, name, el) {
+                    return value == null ? null : String(value === true);
+                },
+            },
+            json: {
+                unmarshal(str, name, el) {
+                    return str === null ? null : JSON.parse(str);
+                },
+                marshal(value, name, el) {
+                    return value == null ? null : JSON.stringify(value);
+                },
+            },
+            csv: {
+                unmarshal(str, name, el) {
+                    return str === null
+                        ? []
+                        : str
+                              .split(',')
+                              .map((e) => e.trim())
+                              .filter((e) => e);
+                },
+                marshal(value, name, el) {
+                    return value == null ? null : value.join(',');
+                },
+            },
+            csvm: {
+                unmarshal(str, name, el) {
+                    if (el.hasAttribute('multiple')) {
+                        return str === null
+                            ? []
+                            : str
+                                  .split(',')
+                                  .map((e) => e.trim())
+                                  .filter((e) => e);
+                    }
+                    return str === null || str === '' ? null : str;
+                },
+                marshal(value, name, el) {
+                    if (el.hasAttribute('multiple')) {
+                        return value === null ? null : value.join(',');
+                    }
+                    return value == null ? null : String(value);
+                },
+            },
+        };
+        #components = {};
+        #modules;
+        #data = [];
+        #upgradeQueue = new UpgradeQueue();
+        defineElement(tag, klass) {
+            if (!this.#configured) {
+                this.#tagToClass[tag] = klass;
+                return this;
+            }
+            this.#augmentAndDefineElement(tag, klass);
+            return this;
+        }
+        #augmentAndDefineElement(tag, klass) {
+            const { observed, attributes, template, templates, slots, mappers } = klass;
+            const observedNames = (observed ?? []).map((a) => a.split(':')[0]);
+            const attrToMapper = [...(attributes ?? []), ...(observed ?? [])].reduce((acc, a) => {
+                const [attr, maybeType] = a.split(':');
+                const type = maybeType?.trim() ?? 'string';
+                if (!(type in this.#mappers) && !(type in (mappers ?? {}))) {
+                    throw new Error(`unsupported attribute type: ${type}`);
+                }
+                acc[attr.trim()] = mappers?.[type] ?? this.#mappers[type];
+                return acc;
+            }, {});
+
+            const namesAndTemplates = Object.entries(
+                Object.assign({}, templates, template ? { default: template } : {}),
+            ).map(([k, v]) => [k, Template.fromHtml(v)]);
+            const nameToTemplate = Object.fromEntries(namesAndTemplates);
+
+            klass.BITS = {
+                enqueue: (el) => this.#upgradeQueue.enqueue(el),
+                SLOTS: slots,
+                OBSERVED: observedNames,
+                ATTR_TO_MAPPER: attrToMapper,
+                TEMPLATES: nameToTemplate,
+            };
+            customElements.define(tag, klass);
+        }
+        defineModule(name, value) {
+            const module = name ? { [name]: value } : value;
+            this.#modules = { ...this.#modules, ...module };
+            return this;
+        }
+        defineModules(ms) {
+            this.#modules = ms;
+            return this;
+        }
+        defineComponent(name, value) {
+            this.#components[name] = value;
+            return this;
+        }
+        defineData(...data) {
+            this.#data = data;
+            return this;
+        }
+        defineOverlay(...data) {
+            this.#data = [...this.#data, ...data];
+            return this;
+        }
+        defineMapper(k, v) {
+            this.#mappers[k] = v;
+            return this;
+        }
+        plugin(p) {
+            p.configure(this);
+            return this;
+        }
+        configure() {
+            for (const [tag, klass] of Object.entries(this.#tagToClass)) {
+                this.#augmentAndDefineElement(tag, klass);
+                delete this.#tagToClass[tag];
+            }
+            this.#configured = true;
+            return this;
+        }
+        get upgrades() {
+            return this.#upgradeQueue.entries;
+        }
+        context() {
+            return { modules: this.#modules, data: this.#data };
+        }
+        evaluator() {
+            return new ExpressionEvaluator(this.#modules, this.#data);
+        }
+        component(name) {
+            return this.#components[name];
+        }
+    }
+
+    const registry = new Registry();
+
+    class Templates {
+        static fromHtml(html) {
+            const { modules, data } = registry.context();
+            return Template.fromHtml(html, modules, ...data);
+        }
+        static fromSelector(selector) {
+            const { modules, data } = registry.context();
+            return Template.fromSelector(selector, modules, ...data);
+        }
+        static fromTemplate(templateEl) {
+            const { modules, data } = registry.context();
+            return Template.fromTemplate(templateEl, modules, ...data);
+        }
+        static fromFragment(fragment) {
+            const { modules, data } = registry.context();
+            return Template.fromFragment(fragment, modules, ...data);
+        }
+    }
+
+    class Rendering {
+        static async waitFor(el) {
+            const pending = Array.from(registry.upgrades)
+                .filter(([child, promise]) => el.contains(child))
+                .map(([child, promise]) => promise);
+            await Promise.all(pending);
+        }
+        static async waitForChildren(el) {
+            const pending = Array.from(registry.upgrades)
+                .filter(([child, promise]) => el !== child && el.contains(child))
+                .map(([child, promise]) => promise);
+            await Promise.all(pending);
+        }
+    }
+
+    /**
+     * An attribute Mapper.
+     *
+     * @typedef {object} Mapper
+     * @property {(val: string|null|undefined, name: string, el: Element) => any} unmarshal
+     * @property {(val: any, name: string, el: Element) => string|null} marshal
+     */
+
+
+    class ParsedElement extends HTMLElement {
+        static BITS = {
+            enqueue: (el) => {},
+            SLOTS: false,
+            OBSERVED: [],
+            /** @type {Record<string, Mapper>} */
+            ATTR_TO_MAPPER: {},
+            TEMPLATES: {},
+        };
+        static get observedAttributes() {
+            return this.BITS.OBSERVED;
+        }
+        #parsed = false;
+        #reflecting = 0;
+        #bits() {
+            return /** @type {typeof ParsedElement} */ (this.constructor).BITS;
+        }
+        unmarshal(attr, str) {
+            return this.#bits().ATTR_TO_MAPPER[attr].unmarshal(str, attr, this);
+        }
+        marshal(attr, value) {
+            return this.#bits().ATTR_TO_MAPPER[attr].marshal(value, attr, this);
+        }
+        /**
+         * @param {string} [name] - The name of the template target, defaults to 'default'
+         */
+        template(name) {
+            const { modules, data } = registry.context();
+            let t = this.#bits().TEMPLATES[name ?? 'default'].withData(data).withModules(modules);
+            for (let k of ['l10n', 'config']) {
+                const v = this.constructor[k];
+                if (v) {
+                    t = t.withOverlay({ [k]: v });
+                }
+            }
+            return t;
+        }
+        connectedCallback() {
+            if (this.#parsed) {
+                return;
+            }
+            this.#bits().enqueue(this);
+        }
+        attributeChangedCallback(attr, oldValue, newValue) {
+            if (!this.#parsed || oldValue === newValue) {
+                return;
+            }
+            if (this.#reflecting > 0) {
+                return;
+            }
+            this[attr] = this.unmarshal(attr, newValue);
+        }
+        #disabledBeforeParsed = null;
+        formDisabledCallback(disabled) {
+            if (!this.#parsed) {
+                this.#disabledBeforeParsed = disabled;
+                return;
+            }
+            Reflect.set(this, 'disabled', disabled);
+        }
+        async upgrade() {
+            if (this.#parsed) {
+                return;
+            }
+            this.#parsed = true;
+            const slots = this.#bits().SLOTS ? LightSlots.from(this) : undefined;
+            const observed = Object.fromEntries(
+                this.#bits().OBSERVED.map((attribute) => [
+                    attribute,
+                    this.unmarshal(attribute, this.getAttribute(attribute)),
+                ]),
+            );
+            const disabled = this.#disabledBeforeParsed ?? false;
+            await this.render({ slots, observed, disabled });
+        }
+        render(c) {}
+        reflect(fn) {
+            ++this.#reflecting;
+            try {
+                fn();
+            } finally {
+                --this.#reflecting;
+            }
+        }
+        reflectTo(attr, value) {
+            ++this.#reflecting;
+            try {
+                Attributes.set(this, attr, this.marshal(attr, value));
+            } finally {
+                --this.#reflecting;
+            }
+        }
+    }
+
+    exports.Attributes = Attributes;
+    exports.ExpressionEvaluator = ExpressionEvaluator;
+    exports.Expressions = Expressions;
+    exports.Fragments = Fragments;
+    exports.LightSlots = LightSlots;
+    exports.Nodes = Nodes;
+    exports.ParsedElement = ParsedElement;
+    exports.Registry = Registry;
+    exports.RenderError = RenderError;
+    exports.Rendering = Rendering;
+    exports.Template = Template;
+    exports.Templates = Templates;
+    exports.registry = registry;
+
+    return exports;
+
+})({});
+//# sourceMappingURL=ftl.iife.js.map