@optionfactory/fml 8.0.0

package/dist/ftl.mjs

@@ -0,0 +1,4700 @@
+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;
+        }
+    }
+}
+
+export { Attributes, ExpressionEvaluator, Expressions, Fragments, LightSlots, Nodes, ParsedElement, Registry, RenderError, Rendering, Template, Templates, registry };
+//# sourceMappingURL=ftl.mjs.map