@player-ui/async-node-plugin 0.7.5--canary.432.14776 → 0.7.5--canary.434.14940

package/dist/AsyncNodePlugin.native.js

@@ -453,8 +453,8 @@ var AsyncNodePlugin = function() {
             try {
                 for(var _iterator = Array.from(pairs)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                     var entry = _step.value;
-                    var _entry = _sliced_to_array(entry, 2), path = _entry[0], value = _entry[1];
-                    if (dlv_es_default(searchObj, path) !== value) {
+                    var _entry = _sliced_to_array(entry, 2), path2 = _entry[0], value = _entry[1];
+                    if (dlv_es_default(searchObj, path2) !== value) {
                         return false;
                     }
                 }
@@ -1030,17 +1030,17 @@ var AsyncNodePlugin = function() {
                     break;
                 }
             }
-            var identifier = expr.slice(start, index);
-            if (Object.prototype.hasOwnProperty.call(literals, identifier)) {
+            var identifier2 = expr.slice(start, index);
+            if (Object.prototype.hasOwnProperty.call(literals, identifier2)) {
                 return {
                     __id: ExpNodeOpaqueIdentifier,
                     type: "Literal",
-                    value: literals[identifier],
-                    raw: identifier,
+                    value: literals[identifier2],
+                    raw: identifier2,
                     location: getLocation(start)
                 };
             }
-            if (identifier === thisStr) {
+            if (identifier2 === thisStr) {
                 return {
                     __id: ExpNodeOpaqueIdentifier,
                     type: "ThisExpression",
@@ -1050,7 +1050,7 @@ var AsyncNodePlugin = function() {
             return {
                 __id: ExpNodeOpaqueIdentifier,
                 type: "Identifier",
-                name: identifier,
+                name: identifier2,
                 location: getLocation(start)
             };
         }
@@ -1190,19 +1190,19 @@ var AsyncNodePlugin = function() {
         }
         return typeof expr === "object" && expr !== null && !Array.isArray(expr) && "value" in expr;
     };
-    var parse2 = function parse2(schema) {
+    var parse4 = function parse4(schema) {
         var _loop = function() {
             var next = parseQueue.shift();
             if (!next) {
                 return "break";
             }
-            var node = next.node, path = next.path, visited = next.visited;
+            var node = next.node, path2 = next.path, visited = next.visited;
             Object.entries(node).forEach(function(param) {
                 var _param = _sliced_to_array(param, 2), prop = _param[0], type = _param[1];
-                var nestedPath = _to_consumable_array(path).concat([
+                var nestedPath2 = _to_consumable_array(path2).concat([
                     prop
                 ]);
-                var nestedPathStr = nestedPath.join(".");
+                var nestedPathStr = nestedPath2.join(".");
                 if (expandedPaths.has(nestedPathStr)) {
                     throw new Error("Path has already been processed. There's either a loop somewhere or a bug");
                 }
@@ -1211,14 +1211,14 @@ var AsyncNodePlugin = function() {
                 }
                 expandedPaths.set(nestedPathStr, type);
                 if (type.isArray) {
-                    nestedPath.push("[]");
+                    nestedPath2.push("[]");
                 }
                 if (type.isRecord) {
-                    nestedPath.push("{}");
+                    nestedPath2.push("{}");
                 }
                 if (type.type && schema[type.type]) {
                     parseQueue.push({
-                        path: nestedPath,
+                        path: nestedPath2,
                         node: schema[type.type],
                         visited: /* @__PURE__ */ new Set(_to_consumable_array(visited).concat([
                             type.type
@@ -1444,7 +1444,7 @@ var AsyncNodePlugin = function() {
         };
     };
     var objectToBatchSet = function objectToBatchSet(obj) {
-        var flattenedObj = flatten(obj);
+        var flattenedObj = flatten2(obj);
         var batchTxn = [];
         Object.keys(flattenedObj).forEach(function(key) {
             batchTxn.push([
@@ -1622,6 +1622,3588 @@ var AsyncNodePlugin = function() {
             exports.toError = toError;
         }
     });
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/arr-flatten@1.1.0/node_modules/arr-flatten/index.js
+    var require_arr_flatten = __commonJS({
+        "../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/arr-flatten@1.1.0/node_modules/arr-flatten/index.js": function(exports, module) {
+            "use strict";
+            module.exports = function(arr) {
+                return flat(arr, []);
+            };
+            function flat(arr, res) {
+                var i = 0, cur;
+                var len = arr.length;
+                for(; i < len; i++){
+                    cur = arr[i];
+                    Array.isArray(cur) ? flat(cur, res) : res.push(cur);
+                }
+                return res;
+            }
+        }
+    });
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/parsimmon@1.18.1/node_modules/parsimmon/src/parsimmon.js
+    var require_parsimmon = __commonJS({
+        "../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/parsimmon@1.18.1/node_modules/parsimmon/src/parsimmon.js": function(exports, module) {
+            "use strict";
+            function Parsimmon(action) {
+                if (!_instanceof(this, Parsimmon)) {
+                    return new Parsimmon(action);
+                }
+                this._ = action;
+            }
+            var _ = Parsimmon.prototype;
+            function times(n, f) {
+                var i = 0;
+                for(i; i < n; i++){
+                    f(i);
+                }
+            }
+            function forEach(f, arr) {
+                times(arr.length, function(i) {
+                    f(arr[i], i, arr);
+                });
+            }
+            function reduce(f, seed, arr) {
+                forEach(function(elem, i, arr2) {
+                    seed = f(seed, elem, i, arr2);
+                }, arr);
+                return seed;
+            }
+            function map(f, arr) {
+                return reduce(function(acc, elem, i, a) {
+                    return acc.concat([
+                        f(elem, i, a)
+                    ]);
+                }, [], arr);
+            }
+            function lshiftBuffer(input) {
+                var asTwoBytes = reduce(function(a, v, i, b) {
+                    return a.concat(i === b.length - 1 ? Buffer.from([
+                        v,
+                        0
+                    ]).readUInt16BE(0) : b.readUInt16BE(i));
+                }, [], input);
+                return Buffer.from(map(function(x) {
+                    return (x << 1 & 65535) >> 8;
+                }, asTwoBytes));
+            }
+            function consumeBitsFromBuffer(n, input) {
+                var state = {
+                    v: 0,
+                    buf: input
+                };
+                times(n, function() {
+                    state = {
+                        v: state.v << 1 | bitPeekBuffer(state.buf),
+                        buf: lshiftBuffer(state.buf)
+                    };
+                });
+                return state;
+            }
+            function bitPeekBuffer(input) {
+                return input[0] >> 7;
+            }
+            function sum(numArr) {
+                return reduce(function(x, y) {
+                    return x + y;
+                }, 0, numArr);
+            }
+            function find2(pred, arr) {
+                return reduce(function(found, elem) {
+                    return found || (pred(elem) ? elem : found);
+                }, null, arr);
+            }
+            function bufferExists() {
+                return typeof Buffer !== "undefined";
+            }
+            function setExists() {
+                if (Parsimmon._supportsSet !== void 0) {
+                    return Parsimmon._supportsSet;
+                }
+                var exists = typeof Set !== "undefined";
+                Parsimmon._supportsSet = exists;
+                return exists;
+            }
+            function ensureBuffer() {
+                if (!bufferExists()) {
+                    throw new Error("Buffer global does not exist; please use webpack if you need to parse Buffers in the browser.");
+                }
+            }
+            function bitSeq(alignments) {
+                ensureBuffer();
+                var totalBits = sum(alignments);
+                if (totalBits % 8 !== 0) {
+                    throw new Error("The bits [" + alignments.join(", ") + "] add up to " + totalBits + " which is not an even number of bytes; the total should be divisible by 8");
+                }
+                var bytes = totalBits / 8;
+                var tooBigRange = find2(function(x) {
+                    return x > 48;
+                }, alignments);
+                if (tooBigRange) {
+                    throw new Error(tooBigRange + " bit range requested exceeds 48 bit (6 byte) Number max.");
+                }
+                return new Parsimmon(function(input, i) {
+                    var newPos = bytes + i;
+                    if (newPos > input.length) {
+                        return makeFailure(i, bytes.toString() + " bytes");
+                    }
+                    return makeSuccess(newPos, reduce(function(acc, bits) {
+                        var state = consumeBitsFromBuffer(bits, acc.buf);
+                        return {
+                            coll: acc.coll.concat(state.v),
+                            buf: state.buf
+                        };
+                    }, {
+                        coll: [],
+                        buf: input.slice(i, newPos)
+                    }, alignments).coll);
+                });
+            }
+            function bitSeqObj(namedAlignments) {
+                ensureBuffer();
+                var seenKeys = {};
+                var totalKeys = 0;
+                var fullAlignments = map(function(item) {
+                    if (isArray(item)) {
+                        var pair = item;
+                        if (pair.length !== 2) {
+                            throw new Error("[" + pair.join(", ") + "] should be length 2, got length " + pair.length);
+                        }
+                        assertString(pair[0]);
+                        assertNumber(pair[1]);
+                        if (Object.prototype.hasOwnProperty.call(seenKeys, pair[0])) {
+                            throw new Error("duplicate key in bitSeqObj: " + pair[0]);
+                        }
+                        seenKeys[pair[0]] = true;
+                        totalKeys++;
+                        return pair;
+                    } else {
+                        assertNumber(item);
+                        return [
+                            null,
+                            item
+                        ];
+                    }
+                }, namedAlignments);
+                if (totalKeys < 1) {
+                    throw new Error("bitSeqObj expects at least one named pair, got [" + namedAlignments.join(", ") + "]");
+                }
+                var namesOnly = map(function(pair) {
+                    return pair[0];
+                }, fullAlignments);
+                var alignmentsOnly = map(function(pair) {
+                    return pair[1];
+                }, fullAlignments);
+                return bitSeq(alignmentsOnly).map(function(parsed) {
+                    var namedParsed = map(function(name, i) {
+                        return [
+                            name,
+                            parsed[i]
+                        ];
+                    }, namesOnly);
+                    return reduce(function(obj, kv) {
+                        if (kv[0] !== null) {
+                            obj[kv[0]] = kv[1];
+                        }
+                        return obj;
+                    }, {}, namedParsed);
+                });
+            }
+            function parseBufferFor(other, length) {
+                return new Parsimmon(function(input, i) {
+                    ensureBuffer();
+                    if (i + length > input.length) {
+                        return makeFailure(i, length + " bytes for " + other);
+                    }
+                    return makeSuccess(i + length, input.slice(i, i + length));
+                });
+            }
+            function parseBuffer(length) {
+                return parseBufferFor("buffer", length).map(function(unsafe) {
+                    return Buffer.from(unsafe);
+                });
+            }
+            function encodedString(encoding, length) {
+                return parseBufferFor("string", length).map(function(buff) {
+                    return buff.toString(encoding);
+                });
+            }
+            function isInteger(value) {
+                return typeof value === "number" && Math.floor(value) === value;
+            }
+            function assertValidIntegerByteLengthFor(who, length) {
+                if (!isInteger(length) || length < 0 || length > 6) {
+                    throw new Error(who + " requires integer length in range [0, 6].");
+                }
+            }
+            function uintBE(length) {
+                assertValidIntegerByteLengthFor("uintBE", length);
+                return parseBufferFor("uintBE(" + length + ")", length).map(function(buff) {
+                    return buff.readUIntBE(0, length);
+                });
+            }
+            function uintLE(length) {
+                assertValidIntegerByteLengthFor("uintLE", length);
+                return parseBufferFor("uintLE(" + length + ")", length).map(function(buff) {
+                    return buff.readUIntLE(0, length);
+                });
+            }
+            function intBE(length) {
+                assertValidIntegerByteLengthFor("intBE", length);
+                return parseBufferFor("intBE(" + length + ")", length).map(function(buff) {
+                    return buff.readIntBE(0, length);
+                });
+            }
+            function intLE(length) {
+                assertValidIntegerByteLengthFor("intLE", length);
+                return parseBufferFor("intLE(" + length + ")", length).map(function(buff) {
+                    return buff.readIntLE(0, length);
+                });
+            }
+            function floatBE() {
+                return parseBufferFor("floatBE", 4).map(function(buff) {
+                    return buff.readFloatBE(0);
+                });
+            }
+            function floatLE() {
+                return parseBufferFor("floatLE", 4).map(function(buff) {
+                    return buff.readFloatLE(0);
+                });
+            }
+            function doubleBE() {
+                return parseBufferFor("doubleBE", 8).map(function(buff) {
+                    return buff.readDoubleBE(0);
+                });
+            }
+            function doubleLE() {
+                return parseBufferFor("doubleLE", 8).map(function(buff) {
+                    return buff.readDoubleLE(0);
+                });
+            }
+            function toArray(arrLike) {
+                return Array.prototype.slice.call(arrLike);
+            }
+            function isParser(obj) {
+                return _instanceof(obj, Parsimmon);
+            }
+            function isArray(x) {
+                return ({}).toString.call(x) === "[object Array]";
+            }
+            function isBuffer(x) {
+                return bufferExists() && Buffer.isBuffer(x);
+            }
+            function makeSuccess(index2, value) {
+                return {
+                    status: true,
+                    index: index2,
+                    value: value,
+                    furthest: -1,
+                    expected: []
+                };
+            }
+            function makeFailure(index2, expected) {
+                if (!isArray(expected)) {
+                    expected = [
+                        expected
+                    ];
+                }
+                return {
+                    status: false,
+                    index: -1,
+                    value: null,
+                    furthest: index2,
+                    expected: expected
+                };
+            }
+            function mergeReplies(result, last) {
+                if (!last) {
+                    return result;
+                }
+                if (result.furthest > last.furthest) {
+                    return result;
+                }
+                var expected = result.furthest === last.furthest ? union(result.expected, last.expected) : last.expected;
+                return {
+                    status: result.status,
+                    index: result.index,
+                    value: result.value,
+                    furthest: last.furthest,
+                    expected: expected
+                };
+            }
+            var lineColumnIndex = {};
+            function makeLineColumnIndex(input, i) {
+                if (isBuffer(input)) {
+                    return {
+                        offset: i,
+                        line: -1,
+                        column: -1
+                    };
+                }
+                if (!(input in lineColumnIndex)) {
+                    lineColumnIndex[input] = {};
+                }
+                var inputIndex = lineColumnIndex[input];
+                var prevLine = 0;
+                var newLines = 0;
+                var lineStart = 0;
+                var j = i;
+                while(j >= 0){
+                    if (j in inputIndex) {
+                        prevLine = inputIndex[j].line;
+                        if (lineStart === 0) {
+                            lineStart = inputIndex[j].lineStart;
+                        }
+                        break;
+                    }
+                    if (// Unix LF (\n) or Windows CRLF (\r\n) line ending
+                    input.charAt(j) === "\n" || // Old Mac CR (\r) line ending
+                    input.charAt(j) === "\r" && input.charAt(j + 1) !== "\n") {
+                        newLines++;
+                        if (lineStart === 0) {
+                            lineStart = j + 1;
+                        }
+                    }
+                    j--;
+                }
+                var lineWeAreUpTo = prevLine + newLines;
+                var columnWeAreUpTo = i - lineStart;
+                inputIndex[i] = {
+                    line: lineWeAreUpTo,
+                    lineStart: lineStart
+                };
+                return {
+                    offset: i,
+                    line: lineWeAreUpTo + 1,
+                    column: columnWeAreUpTo + 1
+                };
+            }
+            function union(xs, ys) {
+                if (setExists() && Array.from) {
+                    var set2 = new Set(xs);
+                    for(var y = 0; y < ys.length; y++){
+                        set2.add(ys[y]);
+                    }
+                    var arr = Array.from(set2);
+                    arr.sort();
+                    return arr;
+                }
+                var obj = {};
+                for(var i = 0; i < xs.length; i++){
+                    obj[xs[i]] = true;
+                }
+                for(var j = 0; j < ys.length; j++){
+                    obj[ys[j]] = true;
+                }
+                var keys = [];
+                for(var k in obj){
+                    if (({}).hasOwnProperty.call(obj, k)) {
+                        keys.push(k);
+                    }
+                }
+                keys.sort();
+                return keys;
+            }
+            function assertParser(p) {
+                if (!isParser(p)) {
+                    throw new Error("not a parser: " + p);
+                }
+            }
+            function get(input, i) {
+                if (typeof input === "string") {
+                    return input.charAt(i);
+                }
+                return input[i];
+            }
+            function assertArray(x) {
+                if (!isArray(x)) {
+                    throw new Error("not an array: " + x);
+                }
+            }
+            function assertNumber(x) {
+                if (typeof x !== "number") {
+                    throw new Error("not a number: " + x);
+                }
+            }
+            function assertRegexp(x) {
+                if (!_instanceof(x, RegExp)) {
+                    throw new Error("not a regexp: " + x);
+                }
+                var f = flags(x);
+                for(var i = 0; i < f.length; i++){
+                    var c = f.charAt(i);
+                    if (c !== "i" && c !== "m" && c !== "u" && c !== "s") {
+                        throw new Error('unsupported regexp flag "' + c + '": ' + x);
+                    }
+                }
+            }
+            function assertFunction(x) {
+                if (typeof x !== "function") {
+                    throw new Error("not a function: " + x);
+                }
+            }
+            function assertString(x) {
+                if (typeof x !== "string") {
+                    throw new Error("not a string: " + x);
+                }
+            }
+            var linesBeforeStringError = 2;
+            var linesAfterStringError = 3;
+            var bytesPerLine = 8;
+            var bytesBefore = bytesPerLine * 5;
+            var bytesAfter = bytesPerLine * 4;
+            var defaultLinePrefix = "  ";
+            function repeat(string2, amount) {
+                return new Array(amount + 1).join(string2);
+            }
+            function formatExpected(expected) {
+                if (expected.length === 1) {
+                    return "Expected:\n\n" + expected[0];
+                }
+                return "Expected one of the following: \n\n" + expected.join(", ");
+            }
+            function leftPad(str, pad, char) {
+                var add = pad - str.length;
+                if (add <= 0) {
+                    return str;
+                }
+                return repeat(char, add) + str;
+            }
+            function toChunks(arr, chunkSize) {
+                var length = arr.length;
+                var chunks = [];
+                var chunkIndex = 0;
+                if (length <= chunkSize) {
+                    return [
+                        arr.slice()
+                    ];
+                }
+                for(var i = 0; i < length; i++){
+                    if (!chunks[chunkIndex]) {
+                        chunks.push([]);
+                    }
+                    chunks[chunkIndex].push(arr[i]);
+                    if ((i + 1) % chunkSize === 0) {
+                        chunkIndex++;
+                    }
+                }
+                return chunks;
+            }
+            function rangeFromIndexAndOffsets(i, before, after, length) {
+                return {
+                    // Guard against the negative upper bound for lines included in the output.
+                    from: i - before > 0 ? i - before : 0,
+                    to: i + after > length ? length : i + after
+                };
+            }
+            function byteRangeToRange(byteRange) {
+                if (byteRange.from === 0 && byteRange.to === 1) {
+                    return {
+                        from: byteRange.from,
+                        to: byteRange.to
+                    };
+                }
+                return {
+                    from: byteRange.from / bytesPerLine,
+                    // Round `to`, so we don't get float if the amount of bytes is not divisible by `bytesPerLine`
+                    to: Math.floor(byteRange.to / bytesPerLine)
+                };
+            }
+            function formatGot(input, error) {
+                var index2 = error.index;
+                var i = index2.offset;
+                var verticalMarkerLength = 1;
+                var column;
+                var lineWithErrorIndex;
+                var lines;
+                var lineRange;
+                var lastLineNumberLabelLength;
+                if (i === input.length) {
+                    return "Got the end of the input";
+                }
+                if (isBuffer(input)) {
+                    var byteLineWithErrorIndex = i - i % bytesPerLine;
+                    var columnByteIndex = i - byteLineWithErrorIndex;
+                    var byteRange = rangeFromIndexAndOffsets(byteLineWithErrorIndex, bytesBefore, bytesAfter + bytesPerLine, input.length);
+                    var bytes = input.slice(byteRange.from, byteRange.to);
+                    var bytesInChunks = toChunks(bytes.toJSON().data, bytesPerLine);
+                    var byteLines = map(function(byteRow) {
+                        return map(function(byteValue) {
+                            return leftPad(byteValue.toString(16), 2, "0");
+                        }, byteRow);
+                    }, bytesInChunks);
+                    lineRange = byteRangeToRange(byteRange);
+                    lineWithErrorIndex = byteLineWithErrorIndex / bytesPerLine;
+                    column = columnByteIndex * 3;
+                    if (columnByteIndex >= 4) {
+                        column += 1;
+                    }
+                    verticalMarkerLength = 2;
+                    lines = map(function(byteLine) {
+                        return byteLine.length <= 4 ? byteLine.join(" ") : byteLine.slice(0, 4).join(" ") + "  " + byteLine.slice(4).join(" ");
+                    }, byteLines);
+                    lastLineNumberLabelLength = ((lineRange.to > 0 ? lineRange.to - 1 : lineRange.to) * 8).toString(16).length;
+                    if (lastLineNumberLabelLength < 2) {
+                        lastLineNumberLabelLength = 2;
+                    }
+                } else {
+                    var inputLines = input.split(/\r\n|[\n\r\u2028\u2029]/);
+                    column = index2.column - 1;
+                    lineWithErrorIndex = index2.line - 1;
+                    lineRange = rangeFromIndexAndOffsets(lineWithErrorIndex, linesBeforeStringError, linesAfterStringError, inputLines.length);
+                    lines = inputLines.slice(lineRange.from, lineRange.to);
+                    lastLineNumberLabelLength = lineRange.to.toString().length;
+                }
+                var lineWithErrorCurrentIndex = lineWithErrorIndex - lineRange.from;
+                if (isBuffer(input)) {
+                    lastLineNumberLabelLength = ((lineRange.to > 0 ? lineRange.to - 1 : lineRange.to) * 8).toString(16).length;
+                    if (lastLineNumberLabelLength < 2) {
+                        lastLineNumberLabelLength = 2;
+                    }
+                }
+                var linesWithLineNumbers = reduce(function(acc, lineSource, index3) {
+                    var isLineWithError = index3 === lineWithErrorCurrentIndex;
+                    var prefix = isLineWithError ? "> " : defaultLinePrefix;
+                    var lineNumberLabel;
+                    if (isBuffer(input)) {
+                        lineNumberLabel = leftPad(((lineRange.from + index3) * 8).toString(16), lastLineNumberLabelLength, "0");
+                    } else {
+                        lineNumberLabel = leftPad((lineRange.from + index3 + 1).toString(), lastLineNumberLabelLength, " ");
+                    }
+                    return [].concat(acc, [
+                        prefix + lineNumberLabel + " | " + lineSource
+                    ], isLineWithError ? [
+                        defaultLinePrefix + repeat(" ", lastLineNumberLabelLength) + " | " + leftPad("", column, " ") + repeat("^", verticalMarkerLength)
+                    ] : []);
+                }, [], lines);
+                return linesWithLineNumbers.join("\n");
+            }
+            function formatError(input, error) {
+                return [
+                    "\n",
+                    "-- PARSING FAILED " + repeat("-", 50),
+                    "\n\n",
+                    formatGot(input, error),
+                    "\n\n",
+                    formatExpected(error.expected),
+                    "\n"
+                ].join("");
+            }
+            function flags(re) {
+                if (re.flags !== void 0) {
+                    return re.flags;
+                }
+                return [
+                    re.global ? "g" : "",
+                    re.ignoreCase ? "i" : "",
+                    re.multiline ? "m" : "",
+                    re.unicode ? "u" : "",
+                    re.sticky ? "y" : ""
+                ].join("");
+            }
+            function anchoredRegexp(re) {
+                return RegExp("^(?:" + re.source + ")", flags(re));
+            }
+            function seq() {
+                var parsers = [].slice.call(arguments);
+                var numParsers = parsers.length;
+                for(var j = 0; j < numParsers; j += 1){
+                    assertParser(parsers[j]);
+                }
+                return Parsimmon(function(input, i) {
+                    var result;
+                    var accum = new Array(numParsers);
+                    for(var j2 = 0; j2 < numParsers; j2 += 1){
+                        result = mergeReplies(parsers[j2]._(input, i), result);
+                        if (!result.status) {
+                            return result;
+                        }
+                        accum[j2] = result.value;
+                        i = result.index;
+                    }
+                    return mergeReplies(makeSuccess(i, accum), result);
+                });
+            }
+            function seqObj() {
+                var seenKeys = {};
+                var totalKeys = 0;
+                var parsers = toArray(arguments);
+                var numParsers = parsers.length;
+                for(var j = 0; j < numParsers; j += 1){
+                    var p = parsers[j];
+                    if (isParser(p)) {
+                        continue;
+                    }
+                    if (isArray(p)) {
+                        var isWellFormed = p.length === 2 && typeof p[0] === "string" && isParser(p[1]);
+                        if (isWellFormed) {
+                            var key = p[0];
+                            if (Object.prototype.hasOwnProperty.call(seenKeys, key)) {
+                                throw new Error("seqObj: duplicate key " + key);
+                            }
+                            seenKeys[key] = true;
+                            totalKeys++;
+                            continue;
+                        }
+                    }
+                    throw new Error("seqObj arguments must be parsers or [string, parser] array pairs.");
+                }
+                if (totalKeys === 0) {
+                    throw new Error("seqObj expects at least one named parser, found zero");
+                }
+                return Parsimmon(function(input, i) {
+                    var result;
+                    var accum = {};
+                    for(var j2 = 0; j2 < numParsers; j2 += 1){
+                        var name;
+                        var parser2;
+                        if (isArray(parsers[j2])) {
+                            name = parsers[j2][0];
+                            parser2 = parsers[j2][1];
+                        } else {
+                            name = null;
+                            parser2 = parsers[j2];
+                        }
+                        result = mergeReplies(parser2._(input, i), result);
+                        if (!result.status) {
+                            return result;
+                        }
+                        if (name) {
+                            accum[name] = result.value;
+                        }
+                        i = result.index;
+                    }
+                    return mergeReplies(makeSuccess(i, accum), result);
+                });
+            }
+            function seqMap() {
+                var args = [].slice.call(arguments);
+                if (args.length === 0) {
+                    throw new Error("seqMap needs at least one argument");
+                }
+                var mapper = args.pop();
+                assertFunction(mapper);
+                return seq.apply(null, args).map(function(results) {
+                    return mapper.apply(null, results);
+                });
+            }
+            function createLanguage(parsers) {
+                var language = {};
+                for(var key in parsers){
+                    if (({}).hasOwnProperty.call(parsers, key)) {
+                        (function(key2) {
+                            var func = function func() {
+                                return parsers[key2](language);
+                            };
+                            language[key2] = lazy(func);
+                        })(key);
+                    }
+                }
+                return language;
+            }
+            function alt() {
+                var parsers = [].slice.call(arguments);
+                var numParsers = parsers.length;
+                if (numParsers === 0) {
+                    return fail("zero alternates");
+                }
+                for(var j = 0; j < numParsers; j += 1){
+                    assertParser(parsers[j]);
+                }
+                return Parsimmon(function(input, i) {
+                    var result;
+                    for(var j2 = 0; j2 < parsers.length; j2 += 1){
+                        result = mergeReplies(parsers[j2]._(input, i), result);
+                        if (result.status) {
+                            return result;
+                        }
+                    }
+                    return result;
+                });
+            }
+            function sepBy(parser2, separator) {
+                return sepBy1(parser2, separator).or(succeed([]));
+            }
+            function sepBy1(parser2, separator) {
+                assertParser(parser2);
+                assertParser(separator);
+                var pairs = separator.then(parser2).many();
+                return seqMap(parser2, pairs, function(r, rs) {
+                    return [
+                        r
+                    ].concat(rs);
+                });
+            }
+            _.parse = function(input) {
+                if (typeof input !== "string" && !isBuffer(input)) {
+                    throw new Error(".parse must be called with a string or Buffer as its argument");
+                }
+                var parseResult = this.skip(eof)._(input, 0);
+                var result;
+                if (parseResult.status) {
+                    result = {
+                        status: true,
+                        value: parseResult.value
+                    };
+                } else {
+                    result = {
+                        status: false,
+                        index: makeLineColumnIndex(input, parseResult.furthest),
+                        expected: parseResult.expected
+                    };
+                }
+                delete lineColumnIndex[input];
+                return result;
+            };
+            _.tryParse = function(str) {
+                var result = this.parse(str);
+                if (result.status) {
+                    return result.value;
+                } else {
+                    var msg = formatError(str, result);
+                    var err = new Error(msg);
+                    err.type = "ParsimmonError";
+                    err.result = result;
+                    throw err;
+                }
+            };
+            _.assert = function(condition, errorMessage) {
+                return this.chain(function(value) {
+                    return condition(value) ? succeed(value) : fail(errorMessage);
+                });
+            };
+            _.or = function(alternative) {
+                return alt(this, alternative);
+            };
+            _.trim = function(parser2) {
+                return this.wrap(parser2, parser2);
+            };
+            _.wrap = function(leftParser, rightParser) {
+                return seqMap(leftParser, this, rightParser, function(left, middle) {
+                    return middle;
+                });
+            };
+            _.thru = function(wrapper) {
+                return wrapper(this);
+            };
+            _.then = function(next) {
+                assertParser(next);
+                return seq(this, next).map(function(results) {
+                    return results[1];
+                });
+            };
+            _.many = function() {
+                var self = this;
+                return Parsimmon(function(input, i) {
+                    var accum = [];
+                    var result = void 0;
+                    for(;;){
+                        result = mergeReplies(self._(input, i), result);
+                        if (result.status) {
+                            if (i === result.index) {
+                                throw new Error("infinite loop detected in .many() parser --- calling .many() on a parser which can accept zero characters is usually the cause");
+                            }
+                            i = result.index;
+                            accum.push(result.value);
+                        } else {
+                            return mergeReplies(makeSuccess(i, accum), result);
+                        }
+                    }
+                });
+            };
+            _.tieWith = function(separator) {
+                assertString(separator);
+                return this.map(function(args) {
+                    assertArray(args);
+                    if (args.length) {
+                        assertString(args[0]);
+                        var s = args[0];
+                        for(var i = 1; i < args.length; i++){
+                            assertString(args[i]);
+                            s += separator + args[i];
+                        }
+                        return s;
+                    } else {
+                        return "";
+                    }
+                });
+            };
+            _.tie = function() {
+                return this.tieWith("");
+            };
+            _.times = function(min, max) {
+                var self = this;
+                if (arguments.length < 2) {
+                    max = min;
+                }
+                assertNumber(min);
+                assertNumber(max);
+                return Parsimmon(function(input, i) {
+                    var accum = [];
+                    var result = void 0;
+                    var prevResult = void 0;
+                    for(var times2 = 0; times2 < min; times2 += 1){
+                        result = self._(input, i);
+                        prevResult = mergeReplies(result, prevResult);
+                        if (result.status) {
+                            i = result.index;
+                            accum.push(result.value);
+                        } else {
+                            return prevResult;
+                        }
+                    }
+                    for(; times2 < max; times2 += 1){
+                        result = self._(input, i);
+                        prevResult = mergeReplies(result, prevResult);
+                        if (result.status) {
+                            i = result.index;
+                            accum.push(result.value);
+                        } else {
+                            break;
+                        }
+                    }
+                    return mergeReplies(makeSuccess(i, accum), prevResult);
+                });
+            };
+            _.result = function(res) {
+                return this.map(function() {
+                    return res;
+                });
+            };
+            _.atMost = function(n) {
+                return this.times(0, n);
+            };
+            _.atLeast = function(n) {
+                return seqMap(this.times(n), this.many(), function(init, rest) {
+                    return init.concat(rest);
+                });
+            };
+            _.map = function(fn) {
+                assertFunction(fn);
+                var self = this;
+                return Parsimmon(function(input, i) {
+                    var result = self._(input, i);
+                    if (!result.status) {
+                        return result;
+                    }
+                    return mergeReplies(makeSuccess(result.index, fn(result.value)), result);
+                });
+            };
+            _.contramap = function(fn) {
+                assertFunction(fn);
+                var self = this;
+                return Parsimmon(function(input, i) {
+                    var result = self.parse(fn(input.slice(i)));
+                    if (!result.status) {
+                        return result;
+                    }
+                    return makeSuccess(i + input.length, result.value);
+                });
+            };
+            _.promap = function(f, g) {
+                assertFunction(f);
+                assertFunction(g);
+                return this.contramap(f).map(g);
+            };
+            _.skip = function(next) {
+                return seq(this, next).map(function(results) {
+                    return results[0];
+                });
+            };
+            _.mark = function() {
+                return seqMap(index, this, index, function(start, value, end2) {
+                    return {
+                        start: start,
+                        value: value,
+                        end: end2
+                    };
+                });
+            };
+            _.node = function(name) {
+                return seqMap(index, this, index, function(start, value, end2) {
+                    return {
+                        name: name,
+                        value: value,
+                        start: start,
+                        end: end2
+                    };
+                });
+            };
+            _.sepBy = function(separator) {
+                return sepBy(this, separator);
+            };
+            _.sepBy1 = function(separator) {
+                return sepBy1(this, separator);
+            };
+            _.lookahead = function(x) {
+                return this.skip(lookahead(x));
+            };
+            _.notFollowedBy = function(x) {
+                return this.skip(notFollowedBy(x));
+            };
+            _.desc = function(expected) {
+                if (!isArray(expected)) {
+                    expected = [
+                        expected
+                    ];
+                }
+                var self = this;
+                return Parsimmon(function(input, i) {
+                    var reply = self._(input, i);
+                    if (!reply.status) {
+                        reply.expected = expected;
+                    }
+                    return reply;
+                });
+            };
+            _.fallback = function(result) {
+                return this.or(succeed(result));
+            };
+            _.ap = function(other) {
+                return seqMap(other, this, function(f, x) {
+                    return f(x);
+                });
+            };
+            _.chain = function(f) {
+                var self = this;
+                return Parsimmon(function(input, i) {
+                    var result = self._(input, i);
+                    if (!result.status) {
+                        return result;
+                    }
+                    var nextParser = f(result.value);
+                    return mergeReplies(nextParser._(input, result.index), result);
+                });
+            };
+            function string(str) {
+                assertString(str);
+                var expected = "'" + str + "'";
+                return Parsimmon(function(input, i) {
+                    var j = i + str.length;
+                    var head = input.slice(i, j);
+                    if (head === str) {
+                        return makeSuccess(j, head);
+                    } else {
+                        return makeFailure(i, expected);
+                    }
+                });
+            }
+            function byte(b) {
+                ensureBuffer();
+                assertNumber(b);
+                if (b > 255) {
+                    throw new Error("Value specified to byte constructor (" + b + "=0x" + b.toString(16) + ") is larger in value than a single byte.");
+                }
+                var expected = (b > 15 ? "0x" : "0x0") + b.toString(16);
+                return Parsimmon(function(input, i) {
+                    var head = get(input, i);
+                    if (head === b) {
+                        return makeSuccess(i + 1, head);
+                    } else {
+                        return makeFailure(i, expected);
+                    }
+                });
+            }
+            function regexp(re, group) {
+                assertRegexp(re);
+                if (arguments.length >= 2) {
+                    assertNumber(group);
+                } else {
+                    group = 0;
+                }
+                var anchored = anchoredRegexp(re);
+                var expected = "" + re;
+                return Parsimmon(function(input, i) {
+                    var match = anchored.exec(input.slice(i));
+                    if (match) {
+                        if (0 <= group && group <= match.length) {
+                            var fullMatch = match[0];
+                            var groupMatch = match[group];
+                            return makeSuccess(i + fullMatch.length, groupMatch);
+                        }
+                        var message = "valid match group (0 to " + match.length + ") in " + expected;
+                        return makeFailure(i, message);
+                    }
+                    return makeFailure(i, expected);
+                });
+            }
+            function succeed(value) {
+                return Parsimmon(function(input, i) {
+                    return makeSuccess(i, value);
+                });
+            }
+            function fail(expected) {
+                return Parsimmon(function(input, i) {
+                    return makeFailure(i, expected);
+                });
+            }
+            function lookahead(x) {
+                if (isParser(x)) {
+                    return Parsimmon(function(input, i) {
+                        var result = x._(input, i);
+                        result.index = i;
+                        result.value = "";
+                        return result;
+                    });
+                } else if (typeof x === "string") {
+                    return lookahead(string(x));
+                } else if (_instanceof(x, RegExp)) {
+                    return lookahead(regexp(x));
+                }
+                throw new Error("not a string, regexp, or parser: " + x);
+            }
+            function notFollowedBy(parser2) {
+                assertParser(parser2);
+                return Parsimmon(function(input, i) {
+                    var result = parser2._(input, i);
+                    var text = input.slice(i, result.index);
+                    return result.status ? makeFailure(i, 'not "' + text + '"') : makeSuccess(i, null);
+                });
+            }
+            function test(predicate) {
+                assertFunction(predicate);
+                return Parsimmon(function(input, i) {
+                    var char = get(input, i);
+                    if (i < input.length && predicate(char)) {
+                        return makeSuccess(i + 1, char);
+                    } else {
+                        return makeFailure(i, "a character/byte matching " + predicate);
+                    }
+                });
+            }
+            function oneOf(str) {
+                var expected = str.split("");
+                for(var idx = 0; idx < expected.length; idx++){
+                    expected[idx] = "'" + expected[idx] + "'";
+                }
+                return test(function(ch) {
+                    return str.indexOf(ch) >= 0;
+                }).desc(expected);
+            }
+            function noneOf(str) {
+                return test(function(ch) {
+                    return str.indexOf(ch) < 0;
+                }).desc("none of '" + str + "'");
+            }
+            function custom(parsingFunction) {
+                return Parsimmon(parsingFunction(makeSuccess, makeFailure));
+            }
+            function range(begin, end2) {
+                return test(function(ch) {
+                    return begin <= ch && ch <= end2;
+                }).desc(begin + "-" + end2);
+            }
+            function takeWhile(predicate) {
+                assertFunction(predicate);
+                return Parsimmon(function(input, i) {
+                    var j = i;
+                    while(j < input.length && predicate(get(input, j))){
+                        j++;
+                    }
+                    return makeSuccess(j, input.slice(i, j));
+                });
+            }
+            function lazy(desc, f) {
+                if (arguments.length < 2) {
+                    f = desc;
+                    desc = void 0;
+                }
+                var parser2 = Parsimmon(function(input, i) {
+                    parser2._ = f()._;
+                    return parser2._(input, i);
+                });
+                if (desc) {
+                    return parser2.desc(desc);
+                } else {
+                    return parser2;
+                }
+            }
+            function empty() {
+                return fail("fantasy-land/empty");
+            }
+            _.concat = _.or;
+            _.empty = empty;
+            _.of = succeed;
+            _["fantasy-land/ap"] = _.ap;
+            _["fantasy-land/chain"] = _.chain;
+            _["fantasy-land/concat"] = _.concat;
+            _["fantasy-land/empty"] = _.empty;
+            _["fantasy-land/of"] = _.of;
+            _["fantasy-land/map"] = _.map;
+            var index = Parsimmon(function(input, i) {
+                return makeSuccess(i, makeLineColumnIndex(input, i));
+            });
+            var any = Parsimmon(function(input, i) {
+                if (i >= input.length) {
+                    return makeFailure(i, "any character/byte");
+                }
+                return makeSuccess(i + 1, get(input, i));
+            });
+            var all = Parsimmon(function(input, i) {
+                return makeSuccess(input.length, input.slice(i));
+            });
+            var eof = Parsimmon(function(input, i) {
+                if (i < input.length) {
+                    return makeFailure(i, "EOF");
+                }
+                return makeSuccess(i, null);
+            });
+            var digit = regexp(/[0-9]/).desc("a digit");
+            var digits = regexp(/[0-9]*/).desc("optional digits");
+            var letter = regexp(/[a-z]/i).desc("a letter");
+            var letters = regexp(/[a-z]*/i).desc("optional letters");
+            var optWhitespace = regexp(/\s*/).desc("optional whitespace");
+            var whitespace = regexp(/\s+/).desc("whitespace");
+            var cr = string("\r");
+            var lf = string("\n");
+            var crlf = string("\r\n");
+            var newline = alt(crlf, lf, cr).desc("newline");
+            var end = alt(newline, eof);
+            Parsimmon.all = all;
+            Parsimmon.alt = alt;
+            Parsimmon.any = any;
+            Parsimmon.cr = cr;
+            Parsimmon.createLanguage = createLanguage;
+            Parsimmon.crlf = crlf;
+            Parsimmon.custom = custom;
+            Parsimmon.digit = digit;
+            Parsimmon.digits = digits;
+            Parsimmon.empty = empty;
+            Parsimmon.end = end;
+            Parsimmon.eof = eof;
+            Parsimmon.fail = fail;
+            Parsimmon.formatError = formatError;
+            Parsimmon.index = index;
+            Parsimmon.isParser = isParser;
+            Parsimmon.lazy = lazy;
+            Parsimmon.letter = letter;
+            Parsimmon.letters = letters;
+            Parsimmon.lf = lf;
+            Parsimmon.lookahead = lookahead;
+            Parsimmon.makeFailure = makeFailure;
+            Parsimmon.makeSuccess = makeSuccess;
+            Parsimmon.newline = newline;
+            Parsimmon.noneOf = noneOf;
+            Parsimmon.notFollowedBy = notFollowedBy;
+            Parsimmon.of = succeed;
+            Parsimmon.oneOf = oneOf;
+            Parsimmon.optWhitespace = optWhitespace;
+            Parsimmon.Parser = Parsimmon;
+            Parsimmon.range = range;
+            Parsimmon.regex = regexp;
+            Parsimmon.regexp = regexp;
+            Parsimmon.sepBy = sepBy;
+            Parsimmon.sepBy1 = sepBy1;
+            Parsimmon.seq = seq;
+            Parsimmon.seqMap = seqMap;
+            Parsimmon.seqObj = seqObj;
+            Parsimmon.string = string;
+            Parsimmon.succeed = succeed;
+            Parsimmon.takeWhile = takeWhile;
+            Parsimmon.test = test;
+            Parsimmon.whitespace = whitespace;
+            Parsimmon["fantasy-land/empty"] = empty;
+            Parsimmon["fantasy-land/of"] = succeed;
+            Parsimmon.Binary = {
+                bitSeq: bitSeq,
+                bitSeqObj: bitSeqObj,
+                byte: byte,
+                buffer: parseBuffer,
+                encodedString: encodedString,
+                uintBE: uintBE,
+                uint8BE: uintBE(1),
+                uint16BE: uintBE(2),
+                uint32BE: uintBE(4),
+                uintLE: uintLE,
+                uint8LE: uintLE(1),
+                uint16LE: uintLE(2),
+                uint32LE: uintLE(4),
+                intBE: intBE,
+                int8BE: intBE(1),
+                int16BE: intBE(2),
+                int32BE: intBE(4),
+                intLE: intLE,
+                int8LE: intLE(1),
+                int16LE: intLE(2),
+                int32LE: intLE(4),
+                floatBE: floatBE(),
+                floatLE: floatLE(),
+                doubleBE: doubleBE(),
+                doubleLE: doubleLE()
+            };
+            module.exports = Parsimmon;
+        }
+    });
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/TokenError.js
+    var require_TokenError = __commonJS({
+        "../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/TokenError.js": function(exports) {
+            "use strict";
+            Object.defineProperty(exports, "__esModule", {
+                value: true
+            });
+            exports.TokenError = void 0;
+            var TokenError = /*#__PURE__*/ function(Error1) {
+                _inherits(TokenError, Error1);
+                var _super = _create_super(TokenError);
+                function TokenError(message, token) {
+                    _class_call_check(this, TokenError);
+                    var _this;
+                    _this = _super.call(this, message);
+                    _this.message = message;
+                    _this.token = token;
+                    if (token && token.errors) token.errors.push(_assert_this_initialized(_this));
+                    else throw _assert_this_initialized(_this);
+                    return _this;
+                }
+                _create_class(TokenError, [
+                    {
+                        key: "inspect",
+                        value: function inspect() {
+                            return "SyntaxError: " + this.message;
+                        }
+                    }
+                ]);
+                return TokenError;
+            }(_wrap_native_super(Error));
+            exports.TokenError = TokenError;
+        }
+    });
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/Parser.js
+    var require_Parser = __commonJS({
+        "../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/Parser.js": function(exports) {
+            "use strict";
+            Object.defineProperty(exports, "__esModule", {
+                value: true
+            });
+            exports.Parser = exports.findRuleByName = exports.parseRuleName = exports.escapeRegExp = exports.readToken = void 0;
+            var UPPER_SNAKE_RE = /^[A-Z0-9_]+$/;
+            var decorationRE = /(\?|\+|\*)$/;
+            var preDecorationRE = /^(@|&|!)/;
+            var WS_RULE = "WS";
+            var TokenError_1 = require_TokenError();
+            function readToken(txt, expr) {
+                var result = expr.exec(txt);
+                if (result && result.index == 0) {
+                    if (result[0].length == 0 && expr.source.length > 0) return null;
+                    return {
+                        type: null,
+                        text: result[0],
+                        rest: txt.substr(result[0].length),
+                        start: 0,
+                        end: result[0].length - 1,
+                        fullText: result[0],
+                        errors: [],
+                        children: [],
+                        parent: null
+                    };
+                }
+                return null;
+            }
+            exports.readToken = readToken;
+            function escapeRegExp(str) {
+                return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+            }
+            exports.escapeRegExp = escapeRegExp;
+            function fixRest(token) {
+                token.rest = "";
+                token.children && token.children.forEach(function(c) {
+                    return fixRest(c);
+                });
+            }
+            function fixPositions(token, start) {
+                token.start += start;
+                token.end += start;
+                token.children && token.children.forEach(function(c) {
+                    return fixPositions(c, token.start);
+                });
+            }
+            function agregateErrors(errors, token) {
+                if (token.errors && token.errors.length) token.errors.forEach(function(err) {
+                    return errors.push(err);
+                });
+                token.children && token.children.forEach(function(tok) {
+                    return agregateErrors(errors, tok);
+                });
+            }
+            function parseRuleName(name) {
+                var postDecoration = decorationRE.exec(name);
+                var preDecoration = preDecorationRE.exec(name);
+                var postDecorationText = postDecoration && postDecoration[0] || "";
+                var preDecorationText = preDecoration && preDecoration[0] || "";
+                var out = {
+                    raw: name,
+                    name: name.replace(decorationRE, "").replace(preDecorationRE, ""),
+                    isOptional: postDecorationText == "?" || postDecorationText == "*",
+                    allowRepetition: postDecorationText == "+" || postDecorationText == "*",
+                    atLeastOne: postDecorationText == "+",
+                    lookupPositive: preDecorationText == "&",
+                    lookupNegative: preDecorationText == "!",
+                    pinned: preDecorationText == "@",
+                    lookup: false,
+                    isLiteral: false
+                };
+                out.isLiteral = out.name[0] == "'" || out.name[0] == '"';
+                out.lookup = out.lookupNegative || out.lookupPositive;
+                return out;
+            }
+            exports.parseRuleName = parseRuleName;
+            function findRuleByName(name, parser2) {
+                var parsed = parseRuleName(name);
+                return parser2.cachedRules[parsed.name] || null;
+            }
+            exports.findRuleByName = findRuleByName;
+            function stripRules(token, re) {
+                if (token.children) {
+                    var localRules = token.children.filter(function(x) {
+                        return x.type && re.test(x.type);
+                    });
+                    for(var i = 0; i < localRules.length; i++){
+                        var indexOnChildren = token.children.indexOf(localRules[i]);
+                        if (indexOnChildren != -1) {
+                            token.children.splice(indexOnChildren, 1);
+                        }
+                    }
+                    token.children.forEach(function(c) {
+                        return stripRules(c, re);
+                    });
+                }
+            }
+            var ignoreMissingRules = [
+                "EOF"
+            ];
+            var Parser2 = /*#__PURE__*/ function() {
+                function Parser2(grammarRules, options) {
+                    var _this = this;
+                    _class_call_check(this, Parser2);
+                    this.grammarRules = grammarRules;
+                    this.options = options;
+                    this.cachedRules = {};
+                    this.debug = options ? options.debug === true : false;
+                    var errors = [];
+                    var neededRules = [];
+                    grammarRules.forEach(function(rule) {
+                        var parsedName = parseRuleName(rule.name);
+                        if (parsedName.name in _this.cachedRules) {
+                            errors.push("Duplicated rule " + parsedName.name);
+                            return;
+                        } else {
+                            _this.cachedRules[parsedName.name] = rule;
+                        }
+                        if (!rule.bnf || !rule.bnf.length) {
+                            var error = "Missing rule content, rule: " + rule.name;
+                            if (errors.indexOf(error) == -1) errors.push(error);
+                        } else {
+                            rule.bnf.forEach(function(options2) {
+                                if (typeof options2[0] === "string") {
+                                    var parsed = parseRuleName(options2[0]);
+                                    if (parsed.name == rule.name) {
+                                        var error = "Left recursion is not allowed, rule: " + rule.name;
+                                        if (errors.indexOf(error) == -1) errors.push(error);
+                                    }
+                                }
+                                options2.forEach(function(option) {
+                                    if (typeof option == "string") {
+                                        var name = parseRuleName(option);
+                                        if (!name.isLiteral && neededRules.indexOf(name.name) == -1 && ignoreMissingRules.indexOf(name.name) == -1) neededRules.push(name.name);
+                                    }
+                                });
+                            });
+                        }
+                        if (WS_RULE == rule.name) rule.implicitWs = false;
+                        if (rule.implicitWs) {
+                            if (neededRules.indexOf(WS_RULE) == -1) neededRules.push(WS_RULE);
+                        }
+                        if (rule.recover) {
+                            if (neededRules.indexOf(rule.recover) == -1) neededRules.push(rule.recover);
+                        }
+                    });
+                    neededRules.forEach(function(ruleName) {
+                        if (!(ruleName in _this.cachedRules)) {
+                            errors.push("Missing rule " + ruleName);
+                        }
+                    });
+                    if (errors.length) throw new Error(errors.join("\n"));
+                }
+                _create_class(Parser2, [
+                    {
+                        key: "getAST",
+                        value: function getAST(txt, target) {
+                            if (!target) {
+                                target = this.grammarRules.filter(function(x) {
+                                    return !x.fragment && x.name.indexOf("%") != 0;
+                                })[0].name;
+                            }
+                            var result = this.parse(txt, target);
+                            if (result) {
+                                agregateErrors(result.errors, result);
+                                fixPositions(result, 0);
+                                stripRules(result, /^%/);
+                                if (!this.options || !this.options.keepUpperRules) stripRules(result, UPPER_SNAKE_RE);
+                                var rest = result.rest;
+                                if (rest) {
+                                    new TokenError_1.TokenError("Unexpected end of input: \n" + rest, result);
+                                }
+                                fixRest(result);
+                                result.rest = rest;
+                            }
+                            return result;
+                        }
+                    },
+                    {
+                        key: "emitSource",
+                        value: function emitSource() {
+                            return "CANNOT EMIT SOURCE FROM BASE Parser";
+                        }
+                    },
+                    {
+                        key: "parse",
+                        value: function parse(txt, target) {
+                            var _this = this;
+                            var recursion = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
+                            var out = null;
+                            var type = parseRuleName(target);
+                            var expr;
+                            var printable = this.debug && /*!isLiteral &*/ !UPPER_SNAKE_RE.test(type.name);
+                            printable && console.log(new Array(recursion).join("\u2502  ") + "Trying to get " + target + " from " + JSON.stringify(txt.split("\n")[0]));
+                            var realType = type.name;
+                            var targetLex = findRuleByName(type.name, this);
+                            if (type.name == "EOF") {
+                                if (txt.length) {
+                                    return null;
+                                } else if (txt.length == 0) {
+                                    return {
+                                        type: "EOF",
+                                        text: "",
+                                        rest: "",
+                                        start: 0,
+                                        end: 0,
+                                        fullText: "",
+                                        errors: [],
+                                        children: [],
+                                        parent: null
+                                    };
+                                }
+                            }
+                            try {
+                                if (!targetLex && type.isLiteral) {
+                                    var src = type.name.trim();
+                                    if (src.startsWith('"')) {
+                                        src = JSON.parse(src);
+                                    } else if (src.startsWith("'")) {
+                                        src = src.replace(/^'(.+)'$/, "$1").replace(/\\'/g, "'");
+                                    }
+                                    if (src === "") {
+                                        return {
+                                            type: "%%EMPTY%%",
+                                            text: "",
+                                            rest: txt,
+                                            start: 0,
+                                            end: 0,
+                                            fullText: "",
+                                            errors: [],
+                                            children: [],
+                                            parent: null
+                                        };
+                                    }
+                                    expr = new RegExp(escapeRegExp(src));
+                                    realType = null;
+                                }
+                            } catch (e) {
+                                if (_instanceof(e, ReferenceError)) {
+                                    console.error(e);
+                                }
+                                return null;
+                            }
+                            if (expr) {
+                                var result = readToken(txt, expr);
+                                if (result) {
+                                    result.type = realType;
+                                    return result;
+                                }
+                            } else {
+                                var options = targetLex.bnf;
+                                if (_instanceof(options, Array)) {
+                                    options.forEach(function(phases) {
+                                        var _loop = function(i) {
+                                            if (typeof phases[i] == "string") {
+                                                var _loop = function() {
+                                                    got = null;
+                                                    if (targetLex.implicitWs) {
+                                                        got = _this.parse(tmpTxt, localTarget.name, recursion + 1);
+                                                        if (!got) {
+                                                            var WS = void 0;
+                                                            do {
+                                                                WS = _this.parse(tmpTxt, WS_RULE, recursion + 1);
+                                                                if (WS) {
+                                                                    tmp.text = tmp.text + WS.text;
+                                                                    tmp.end = tmp.text.length;
+                                                                    WS.parent = tmp;
+                                                                    tmp.children.push(WS);
+                                                                    tmpTxt = tmpTxt.substr(WS.text.length);
+                                                                    position += WS.text.length;
+                                                                } else {
+                                                                    break;
+                                                                }
+                                                            }while (WS && WS.text.length);
+                                                        }
+                                                    }
+                                                    got = got || _this.parse(tmpTxt, localTarget.name, recursion + 1);
+                                                    if (localTarget.lookupNegative) {
+                                                        if (got) return {
+                                                            v: void void 0
+                                                        };
+                                                        return "break";
+                                                    }
+                                                    if (localTarget.lookupPositive) {
+                                                        if (!got) return {
+                                                            v: void void 0
+                                                        };
+                                                    }
+                                                    if (!got) {
+                                                        if (localTarget.isOptional) return "break";
+                                                        if (localTarget.atLeastOne && foundAtLeastOne) return "break";
+                                                    }
+                                                    if (got && targetLex.pinned == i + 1) {
+                                                        pinned = got;
+                                                        printable && console.log(new Array(recursion + 1).join("\u2502  ") + "\u2514\u2500 " + got.type + " PINNED");
+                                                    }
+                                                    if (!got) got = _this.parseRecovery(targetLex, tmpTxt, recursion + 1);
+                                                    if (!got) {
+                                                        if (pinned) {
+                                                            out = tmp;
+                                                            got = {
+                                                                type: "SyntaxError",
+                                                                text: tmpTxt,
+                                                                children: [],
+                                                                end: tmpTxt.length,
+                                                                errors: [],
+                                                                fullText: "",
+                                                                parent: null,
+                                                                start: 0,
+                                                                rest: ""
+                                                            };
+                                                            if (tmpTxt.length) {
+                                                                new TokenError_1.TokenError("Unexpected end of input. Expecting ".concat(localTarget.name, " Got: ").concat(tmpTxt), got);
+                                                            } else {
+                                                                new TokenError_1.TokenError("Unexpected end of input. Missing ".concat(localTarget.name), got);
+                                                            }
+                                                            printable && console.log(new Array(recursion + 1).join("\u2502  ") + "\u2514\u2500 " + got.type + " " + JSON.stringify(got.text));
+                                                        } else {
+                                                            return {
+                                                                v: void void 0
+                                                            };
+                                                        }
+                                                    }
+                                                    foundAtLeastOne = true;
+                                                    foundSomething = true;
+                                                    if (got.type == "%%EMPTY%%") {
+                                                        return "break";
+                                                    }
+                                                    got.start += position;
+                                                    got.end += position;
+                                                    if (!localTarget.lookupPositive && got.type) {
+                                                        if (got.fragment) {
+                                                            got.children && got.children.forEach(function(x) {
+                                                                x.start += position;
+                                                                x.end += position;
+                                                                x.parent = tmp;
+                                                                tmp.children.push(x);
+                                                            });
+                                                        } else {
+                                                            got.parent = tmp;
+                                                            tmp.children.push(got);
+                                                        }
+                                                    }
+                                                    if (localTarget.lookup) got.lookup = true;
+                                                    printable && console.log(new Array(recursion + 1).join("\u2502  ") + "\u2514\u2500 " + got.type + " " + JSON.stringify(got.text));
+                                                    if (!localTarget.lookup && !got.lookup) {
+                                                        tmp.text = tmp.text + got.text;
+                                                        tmp.end = tmp.text.length;
+                                                        tmpTxt = tmpTxt.substr(got.text.length);
+                                                        position += got.text.length;
+                                                    }
+                                                    tmp.rest = tmpTxt;
+                                                };
+                                                var localTarget = parseRuleName(phases[i]);
+                                                allOptional = allOptional && localTarget.isOptional;
+                                                var got = void 0;
+                                                var foundAtLeastOne = false;
+                                                do {
+                                                    var _ret = _loop();
+                                                    if (_type_of(_ret) === "object") return {
+                                                        v: _ret.v
+                                                    };
+                                                    if (_ret === "break") break;
+                                                }while (got && localTarget.allowRepetition && tmpTxt.length && !got.lookup);
+                                            } else {
+                                                var got1 = readToken(tmpTxt, phases[i]);
+                                                if (!got1) {
+                                                    return {
+                                                        v: void void 0
+                                                    };
+                                                }
+                                                printable && console.log(new Array(recursion + 1).join("\u2502  ") + "\u2514> " + JSON.stringify(got1.text) + phases[i].source);
+                                                foundSomething = true;
+                                                got1.start += position;
+                                                got1.end += position;
+                                                tmp.text = tmp.text + got1.text;
+                                                tmp.end = tmp.text.length;
+                                                tmpTxt = tmpTxt.substr(got1.text.length);
+                                                position += got1.text.length;
+                                                tmp.rest = tmpTxt;
+                                            }
+                                        };
+                                        if (out) return;
+                                        var pinned = null;
+                                        var tmp = {
+                                            type: type.name,
+                                            text: "",
+                                            children: [],
+                                            end: 0,
+                                            errors: [],
+                                            fullText: "",
+                                            parent: null,
+                                            start: 0,
+                                            rest: txt
+                                        };
+                                        if (targetLex.fragment) tmp.fragment = true;
+                                        var tmpTxt = txt;
+                                        var position = 0;
+                                        var allOptional = phases.length > 0;
+                                        var foundSomething = false;
+                                        for(var i = 0; i < phases.length; i++){
+                                            var _ret = _loop(i);
+                                            if (_type_of(_ret) === "object") return _ret.v;
+                                        }
+                                        if (foundSomething) {
+                                            out = tmp;
+                                            printable && console.log(new Array(recursion).join("\u2502  ") + "\u251C<\u2500\u2534< PUSHING " + out.type + " " + JSON.stringify(out.text));
+                                        }
+                                    });
+                                }
+                                if (out && targetLex.simplifyWhenOneChildren && out.children.length == 1) {
+                                    out = out.children[0];
+                                }
+                            }
+                            if (!out) {
+                                printable && console.log(target + " NOT RESOLVED FROM " + txt);
+                            }
+                            return out;
+                        }
+                    },
+                    {
+                        key: "parseRecovery",
+                        value: function parseRecovery(recoverableToken, tmpTxt, recursion) {
+                            if (recoverableToken.recover && tmpTxt.length) {
+                                var printable = this.debug;
+                                printable && console.log(new Array(recursion + 1).join("\u2502  ") + "Trying to recover until token " + recoverableToken.recover + " from " + JSON.stringify(tmpTxt.split("\n")[0] + tmpTxt.split("\n")[1]));
+                                var tmp = {
+                                    type: "SyntaxError",
+                                    text: "",
+                                    children: [],
+                                    end: 0,
+                                    errors: [],
+                                    fullText: "",
+                                    parent: null,
+                                    start: 0,
+                                    rest: ""
+                                };
+                                var got;
+                                do {
+                                    got = this.parse(tmpTxt, recoverableToken.recover, recursion + 1);
+                                    if (got) {
+                                        new TokenError_1.TokenError('Unexpected input: "' + tmp.text + '" Expecting: '.concat(recoverableToken.name), tmp);
+                                        break;
+                                    } else {
+                                        tmp.text = tmp.text + tmpTxt[0];
+                                        tmp.end = tmp.text.length;
+                                        tmpTxt = tmpTxt.substr(1);
+                                    }
+                                }while (!got && tmpTxt.length > 0);
+                                if (tmp.text.length > 0 && got) {
+                                    printable && console.log(new Array(recursion + 1).join("\u2502  ") + "Recovered text: " + JSON.stringify(tmp.text));
+                                    return tmp;
+                                }
+                            }
+                            return null;
+                        }
+                    }
+                ]);
+                return Parser2;
+            }();
+            exports.Parser = Parser2;
+            exports.default = Parser2;
+        }
+    });
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/SemanticHelpers.js
+    var require_SemanticHelpers = __commonJS({
+        "../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/SemanticHelpers.js": function(exports) {
+            "use strict";
+            Object.defineProperty(exports, "__esModule", {
+                value: true
+            });
+            exports.findChildrenByType = void 0;
+            function findChildrenByType(token, type) {
+                return token.children ? token.children.filter(function(x) {
+                    return x.type == type;
+                }) : [];
+            }
+            exports.findChildrenByType = findChildrenByType;
+        }
+    });
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/Grammars/BNF.js
+    var require_BNF = __commonJS({
+        "../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/Grammars/BNF.js": function(exports) {
+            "use strict";
+            Object.defineProperty(exports, "__esModule", {
+                value: true
+            });
+            var SemanticHelpers_1 = require_SemanticHelpers();
+            var Parser_1 = require_Parser();
+            var BNF;
+            (function(BNF2) {
+                BNF2.RULES = [
+                    {
+                        name: "syntax",
+                        bnf: [
+                            [
+                                "RULE_EOL*",
+                                "rule+"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "rule",
+                        bnf: [
+                            [
+                                '" "*',
+                                '"<"',
+                                "rule-name",
+                                '">"',
+                                '" "*',
+                                '"::="',
+                                "firstExpression",
+                                "otherExpression*",
+                                '" "*',
+                                "RULE_EOL+",
+                                '" "*'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "firstExpression",
+                        bnf: [
+                            [
+                                '" "*',
+                                "list"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "otherExpression",
+                        bnf: [
+                            [
+                                '" "*',
+                                '"|"',
+                                '" "*',
+                                "list"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "RULE_EOL",
+                        bnf: [
+                            [
+                                '"\\r"'
+                            ],
+                            [
+                                '"\\n"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "list",
+                        bnf: [
+                            [
+                                "term",
+                                '" "*',
+                                "list"
+                            ],
+                            [
+                                "term"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "term",
+                        bnf: [
+                            [
+                                "literal"
+                            ],
+                            [
+                                '"<"',
+                                "rule-name",
+                                '">"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "literal",
+                        bnf: [
+                            [
+                                "'\"'",
+                                "RULE_CHARACTER1*",
+                                "'\"'"
+                            ],
+                            [
+                                '"\'"',
+                                "RULE_CHARACTER2*",
+                                '"\'"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "RULE_CHARACTER",
+                        bnf: [
+                            [
+                                '" "'
+                            ],
+                            [
+                                "RULE_LETTER"
+                            ],
+                            [
+                                "RULE_DIGIT"
+                            ],
+                            [
+                                "RULE_SYMBOL"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "RULE_LETTER",
+                        bnf: [
+                            [
+                                '"A"'
+                            ],
+                            [
+                                '"B"'
+                            ],
+                            [
+                                '"C"'
+                            ],
+                            [
+                                '"D"'
+                            ],
+                            [
+                                '"E"'
+                            ],
+                            [
+                                '"F"'
+                            ],
+                            [
+                                '"G"'
+                            ],
+                            [
+                                '"H"'
+                            ],
+                            [
+                                '"I"'
+                            ],
+                            [
+                                '"J"'
+                            ],
+                            [
+                                '"K"'
+                            ],
+                            [
+                                '"L"'
+                            ],
+                            [
+                                '"M"'
+                            ],
+                            [
+                                '"N"'
+                            ],
+                            [
+                                '"O"'
+                            ],
+                            [
+                                '"P"'
+                            ],
+                            [
+                                '"Q"'
+                            ],
+                            [
+                                '"R"'
+                            ],
+                            [
+                                '"S"'
+                            ],
+                            [
+                                '"T"'
+                            ],
+                            [
+                                '"U"'
+                            ],
+                            [
+                                '"V"'
+                            ],
+                            [
+                                '"W"'
+                            ],
+                            [
+                                '"X"'
+                            ],
+                            [
+                                '"Y"'
+                            ],
+                            [
+                                '"Z"'
+                            ],
+                            [
+                                '"a"'
+                            ],
+                            [
+                                '"b"'
+                            ],
+                            [
+                                '"c"'
+                            ],
+                            [
+                                '"d"'
+                            ],
+                            [
+                                '"e"'
+                            ],
+                            [
+                                '"f"'
+                            ],
+                            [
+                                '"g"'
+                            ],
+                            [
+                                '"h"'
+                            ],
+                            [
+                                '"i"'
+                            ],
+                            [
+                                '"j"'
+                            ],
+                            [
+                                '"k"'
+                            ],
+                            [
+                                '"l"'
+                            ],
+                            [
+                                '"m"'
+                            ],
+                            [
+                                '"n"'
+                            ],
+                            [
+                                '"o"'
+                            ],
+                            [
+                                '"p"'
+                            ],
+                            [
+                                '"q"'
+                            ],
+                            [
+                                '"r"'
+                            ],
+                            [
+                                '"s"'
+                            ],
+                            [
+                                '"t"'
+                            ],
+                            [
+                                '"u"'
+                            ],
+                            [
+                                '"v"'
+                            ],
+                            [
+                                '"w"'
+                            ],
+                            [
+                                '"x"'
+                            ],
+                            [
+                                '"y"'
+                            ],
+                            [
+                                '"z"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "RULE_DIGIT",
+                        bnf: [
+                            [
+                                '"0"'
+                            ],
+                            [
+                                '"1"'
+                            ],
+                            [
+                                '"2"'
+                            ],
+                            [
+                                '"3"'
+                            ],
+                            [
+                                '"4"'
+                            ],
+                            [
+                                '"5"'
+                            ],
+                            [
+                                '"6"'
+                            ],
+                            [
+                                '"7"'
+                            ],
+                            [
+                                '"8"'
+                            ],
+                            [
+                                '"9"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "RULE_SYMBOL",
+                        bnf: [
+                            [
+                                '"-"'
+                            ],
+                            [
+                                '"_"'
+                            ],
+                            [
+                                '"!"'
+                            ],
+                            [
+                                '"#"'
+                            ],
+                            [
+                                '"$"'
+                            ],
+                            [
+                                '"%"'
+                            ],
+                            [
+                                '"&"'
+                            ],
+                            [
+                                '"("'
+                            ],
+                            [
+                                '")"'
+                            ],
+                            [
+                                '"*"'
+                            ],
+                            [
+                                '"+"'
+                            ],
+                            [
+                                '","'
+                            ],
+                            [
+                                '"-"'
+                            ],
+                            [
+                                '"."'
+                            ],
+                            [
+                                '"/"'
+                            ],
+                            [
+                                '":"'
+                            ],
+                            [
+                                '";"'
+                            ],
+                            [
+                                '"<"'
+                            ],
+                            [
+                                '"="'
+                            ],
+                            [
+                                '">"'
+                            ],
+                            [
+                                '"?"'
+                            ],
+                            [
+                                '"@"'
+                            ],
+                            [
+                                '"["'
+                            ],
+                            [
+                                '"\\"'
+                            ],
+                            [
+                                '"]"'
+                            ],
+                            [
+                                '"^"'
+                            ],
+                            [
+                                '"_"'
+                            ],
+                            [
+                                '"`"'
+                            ],
+                            [
+                                '"{"'
+                            ],
+                            [
+                                '"|"'
+                            ],
+                            [
+                                '"}"'
+                            ],
+                            [
+                                '"~"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "RULE_CHARACTER1",
+                        bnf: [
+                            [
+                                "RULE_CHARACTER"
+                            ],
+                            [
+                                '"\'"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "RULE_CHARACTER2",
+                        bnf: [
+                            [
+                                "RULE_CHARACTER"
+                            ],
+                            [
+                                "'\"'"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "rule-name",
+                        bnf: [
+                            [
+                                "RULE_LETTER",
+                                "RULE_CHAR*"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "RULE_CHAR",
+                        bnf: [
+                            [
+                                "RULE_LETTER"
+                            ],
+                            [
+                                "RULE_DIGIT"
+                            ],
+                            [
+                                '"_"'
+                            ],
+                            [
+                                '"-"'
+                            ]
+                        ]
+                    }
+                ];
+                BNF2.defaultParser = new Parser_1.Parser(BNF2.RULES, {
+                    debug: false
+                });
+                function getAllTerms(expr) {
+                    var terms = SemanticHelpers_1.findChildrenByType(expr, "term").map(function(term) {
+                        return SemanticHelpers_1.findChildrenByType(term, "literal").concat(SemanticHelpers_1.findChildrenByType(term, "rule-name"))[0].text;
+                    });
+                    SemanticHelpers_1.findChildrenByType(expr, "list").forEach(function(expr2) {
+                        terms = terms.concat(getAllTerms(expr2));
+                    });
+                    return terms;
+                }
+                function getRules(source) {
+                    var parser2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : BNF2.defaultParser;
+                    var ast = parser2.getAST(source);
+                    if (!ast) throw new Error("Could not parse " + source);
+                    if (ast.errors && ast.errors.length) {
+                        throw ast.errors[0];
+                    }
+                    var rules = SemanticHelpers_1.findChildrenByType(ast, "rule");
+                    var ret = rules.map(function(rule) {
+                        var name = SemanticHelpers_1.findChildrenByType(rule, "rule-name")[0].text;
+                        var expressions = SemanticHelpers_1.findChildrenByType(rule, "firstExpression").concat(SemanticHelpers_1.findChildrenByType(rule, "otherExpression"));
+                        var bnf = [];
+                        expressions.forEach(function(expr) {
+                            bnf.push(getAllTerms(expr));
+                        });
+                        return {
+                            name: name,
+                            bnf: bnf
+                        };
+                    });
+                    if (!ret.some(function(x) {
+                        return x.name == "EOL";
+                    })) {
+                        ret.push({
+                            name: "EOL",
+                            bnf: [
+                                [
+                                    '"\\r\\n"',
+                                    '"\\r"',
+                                    '"\\n"'
+                                ]
+                            ]
+                        });
+                    }
+                    return ret;
+                }
+                BNF2.getRules = getRules;
+                function Transform(source) {
+                    var subParser = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : BNF2.defaultParser;
+                    return getRules(source.join(""), subParser);
+                }
+                BNF2.Transform = Transform;
+                var Parser2 = /*#__PURE__*/ function(_Parser_1_Parser) {
+                    _inherits(Parser2, _Parser_1_Parser);
+                    var _super = _create_super(Parser2);
+                    function Parser2(source, options) {
+                        _class_call_check(this, Parser2);
+                        var _this;
+                        var subParser = options && options.debugRulesParser === true ? new Parser_1.Parser(BNF2.RULES, {
+                            debug: true
+                        }) : BNF2.defaultParser;
+                        _this = _super.call(this, getRules(source, subParser), options);
+                        _this.source = source;
+                        return _this;
+                    }
+                    _create_class(Parser2, [
+                        {
+                            key: "emitSource",
+                            value: function emitSource() {
+                                return this.source;
+                            }
+                        }
+                    ]);
+                    return Parser2;
+                }(Parser_1.Parser);
+                BNF2.Parser = Parser2;
+            })(BNF || (BNF = {}));
+            exports.default = BNF;
+        }
+    });
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/Grammars/W3CEBNF.js
+    var require_W3CEBNF = __commonJS({
+        "../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/Grammars/W3CEBNF.js": function(exports) {
+            "use strict";
+            Object.defineProperty(exports, "__esModule", {
+                value: true
+            });
+            var Parser_1 = require_Parser();
+            var BNF;
+            (function(BNF2) {
+                BNF2.RULES = [
+                    {
+                        name: "Grammar",
+                        bnf: [
+                            [
+                                "RULE_S*",
+                                "%Atomic*",
+                                "EOF"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%Atomic",
+                        bnf: [
+                            [
+                                "Production",
+                                "RULE_S*"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "Production",
+                        bnf: [
+                            [
+                                "NCName",
+                                "RULE_S*",
+                                '"::="',
+                                "RULE_WHITESPACE*",
+                                "Choice",
+                                "RULE_WHITESPACE*",
+                                "RULE_EOL+",
+                                "RULE_S*"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "NCName",
+                        bnf: [
+                            [
+                                /[a-zA-Z][a-zA-Z_0-9]*/
+                            ]
+                        ]
+                    },
+                    {
+                        name: "Choice",
+                        bnf: [
+                            [
+                                "SequenceOrDifference",
+                                "%_Choice_1*"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "%_Choice_1",
+                        bnf: [
+                            [
+                                "RULE_WHITESPACE*",
+                                '"|"',
+                                "RULE_WHITESPACE*",
+                                "SequenceOrDifference"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "SequenceOrDifference",
+                        bnf: [
+                            [
+                                "Item",
+                                "RULE_WHITESPACE*",
+                                "%_Item_1?"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%_Item_1",
+                        bnf: [
+                            [
+                                "Minus",
+                                "Item"
+                            ],
+                            [
+                                "Item*"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "Minus",
+                        bnf: [
+                            [
+                                '"-"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "Item",
+                        bnf: [
+                            [
+                                "RULE_WHITESPACE*",
+                                "%Primary",
+                                "PrimaryDecoration?"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "PrimaryDecoration",
+                        bnf: [
+                            [
+                                '"?"'
+                            ],
+                            [
+                                '"*"'
+                            ],
+                            [
+                                '"+"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "DecorationName",
+                        bnf: [
+                            [
+                                '"ebnf://"',
+                                /[^\x5D#]+/
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%Primary",
+                        bnf: [
+                            [
+                                "NCName"
+                            ],
+                            [
+                                "StringLiteral"
+                            ],
+                            [
+                                "CharCode"
+                            ],
+                            [
+                                "CharClass"
+                            ],
+                            [
+                                "SubItem"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "SubItem",
+                        bnf: [
+                            [
+                                '"("',
+                                "RULE_WHITESPACE*",
+                                "Choice",
+                                "RULE_WHITESPACE*",
+                                '")"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "StringLiteral",
+                        bnf: [
+                            [
+                                "'\"'",
+                                /[^"]*/,
+                                "'\"'"
+                            ],
+                            [
+                                '"\'"',
+                                /[^']*/,
+                                '"\'"'
+                            ]
+                        ],
+                        pinned: 1
+                    },
+                    {
+                        name: "CharCode",
+                        bnf: [
+                            [
+                                '"#x"',
+                                /[0-9a-zA-Z]+/
+                            ]
+                        ]
+                    },
+                    {
+                        name: "CharClass",
+                        bnf: [
+                            [
+                                "'['",
+                                "'^'?",
+                                "%RULE_CharClass_1+",
+                                '"]"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%RULE_CharClass_1",
+                        bnf: [
+                            [
+                                "CharCodeRange"
+                            ],
+                            [
+                                "CharRange"
+                            ],
+                            [
+                                "CharCode"
+                            ],
+                            [
+                                "RULE_Char"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "RULE_Char",
+                        bnf: [
+                            [
+                                /\x09/
+                            ],
+                            [
+                                /\x0A/
+                            ],
+                            [
+                                /\x0D/
+                            ],
+                            [
+                                /[\x20-\x5c]/
+                            ],
+                            [
+                                /[\x5e-\uD7FF]/
+                            ],
+                            [
+                                /[\uE000-\uFFFD]/
+                            ]
+                        ]
+                    },
+                    {
+                        name: "CharRange",
+                        bnf: [
+                            [
+                                "RULE_Char",
+                                '"-"',
+                                "RULE_Char"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "CharCodeRange",
+                        bnf: [
+                            [
+                                "CharCode",
+                                '"-"',
+                                "CharCode"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "RULE_WHITESPACE",
+                        bnf: [
+                            [
+                                "%RULE_WHITESPACE_CHAR*"
+                            ],
+                            [
+                                "Comment",
+                                "RULE_WHITESPACE*"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "RULE_S",
+                        bnf: [
+                            [
+                                "RULE_WHITESPACE",
+                                "RULE_S*"
+                            ],
+                            [
+                                "RULE_EOL",
+                                "RULE_S*"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%RULE_WHITESPACE_CHAR",
+                        bnf: [
+                            [
+                                /\x09/
+                            ],
+                            [
+                                /\x20/
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "Comment",
+                        bnf: [
+                            [
+                                '"/*"',
+                                "%RULE_Comment_Body*",
+                                '"*/"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%RULE_Comment_Body",
+                        bnf: [
+                            [
+                                '!"*/"',
+                                /[^*]/
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "RULE_EOL",
+                        bnf: [
+                            [
+                                /\x0D/,
+                                /\x0A/
+                            ],
+                            [
+                                /\x0A/
+                            ],
+                            [
+                                /\x0D/
+                            ]
+                        ]
+                    },
+                    {
+                        name: "Link",
+                        bnf: [
+                            [
+                                "'['",
+                                "Url",
+                                "']'"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "Url",
+                        bnf: [
+                            [
+                                /[^\x5D:/?#]/,
+                                '"://"',
+                                /[^\x5D#]+/,
+                                "%Url1?"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%Url1",
+                        bnf: [
+                            [
+                                '"#"',
+                                "NCName"
+                            ]
+                        ],
+                        fragment: true
+                    }
+                ];
+                BNF2.defaultParser = new Parser_1.Parser(BNF2.RULES, {
+                    debug: false
+                });
+                var preDecorationRE = /^(!|&)/;
+                var decorationRE = /(\?|\+|\*)$/;
+                var subExpressionRE = /^%/;
+                function getBNFRule(name, parser2) {
+                    if (typeof name == "string") {
+                        if (preDecorationRE.test(name)) return "";
+                        var subexpression = subExpressionRE.test(name);
+                        if (subexpression) {
+                            var decoration = decorationRE.exec(name);
+                            var decorationText = decoration ? decoration[0] + " " : "";
+                            var lonely = isLonelyRule(name, parser2);
+                            if (lonely) return getBNFBody(name, parser2) + decorationText;
+                            return "(" + getBNFBody(name, parser2) + ")" + decorationText;
+                        }
+                        return name;
+                    } else {
+                        return name.source.replace(/\\(?:x|u)([a-zA-Z0-9]+)/g, "#x$1").replace(/\[\\(?:x|u)([a-zA-Z0-9]+)-\\(?:x|u)([a-zA-Z0-9]+)\]/g, "[#x$1-#x$2]");
+                    }
+                }
+                function isLonelyRule(name, parser2) {
+                    var rule = Parser_1.findRuleByName(name, parser2);
+                    return rule && rule.bnf.length == 1 && rule.bnf[0].length == 1 && (_instanceof(rule.bnf[0][0], RegExp) || rule.bnf[0][0][0] == '"' || rule.bnf[0][0][0] == "'");
+                }
+                function getBNFChoice(rules, parser2) {
+                    return rules.map(function(x) {
+                        return getBNFRule(x, parser2);
+                    }).join(" ");
+                }
+                function getBNFBody(name, parser2) {
+                    var rule = Parser_1.findRuleByName(name, parser2);
+                    if (rule) return rule.bnf.map(function(x) {
+                        return getBNFChoice(x, parser2);
+                    }).join(" | ");
+                    return "RULE_NOT_FOUND {" + name + "}";
+                }
+                function emit(parser2) {
+                    var acumulator = [];
+                    parser2.grammarRules.forEach(function(l) {
+                        if (!/^%/.test(l.name)) {
+                            var recover = l.recover ? " /* { recoverUntil=" + l.recover + " } */" : "";
+                            acumulator.push(l.name + " ::= " + getBNFBody(l.name, parser2) + recover);
+                        }
+                    });
+                    return acumulator.join("\n");
+                }
+                BNF2.emit = emit;
+                var subitems = 0;
+                function restar(total, resta) {
+                    console.log("reberia restar " + resta + " a " + total);
+                    throw new Error("Difference not supported yet");
+                }
+                function convertRegex(txt) {
+                    return new RegExp(txt.replace(/#x([a-zA-Z0-9]{4})/g, "\\u$1").replace(/#x([a-zA-Z0-9]{3})/g, "\\u0$1").replace(/#x([a-zA-Z0-9]{2})/g, "\\x$1").replace(/#x([a-zA-Z0-9]{1})/g, "\\x0$1"));
+                }
+                function getSubItems(tmpRules, seq, parentName) {
+                    var anterior = null;
+                    var bnfSeq = [];
+                    seq.children.forEach(function(x, i) {
+                        if (x.type == "Minus") {
+                            restar(anterior, x);
+                        } else {}
+                        var decoration = seq.children[i + 1];
+                        decoration = decoration && decoration.type == "PrimaryDecoration" && decoration.text || "";
+                        var preDecoration = "";
+                        switch(x.type){
+                            case "SubItem":
+                                var name = "%" + (parentName + subitems++);
+                                createRule(tmpRules, x, name);
+                                bnfSeq.push(preDecoration + name + decoration);
+                                break;
+                            case "NCName":
+                            case "StringLiteral":
+                                bnfSeq.push(preDecoration + x.text + decoration);
+                                break;
+                            case "CharCode":
+                            case "CharClass":
+                                if (decoration || preDecoration) {
+                                    var newRule = {
+                                        name: "%" + (parentName + subitems++),
+                                        bnf: [
+                                            [
+                                                convertRegex(x.text)
+                                            ]
+                                        ]
+                                    };
+                                    tmpRules.push(newRule);
+                                    bnfSeq.push(preDecoration + newRule.name + decoration);
+                                } else {
+                                    bnfSeq.push(convertRegex(x.text));
+                                }
+                                break;
+                            case "PrimaryDecoration":
+                                break;
+                            default:
+                                throw new Error(" HOW SHOULD I PARSE THIS? " + x.type + " -> " + JSON.stringify(x.text));
+                        }
+                        anterior = x;
+                    });
+                    return bnfSeq;
+                }
+                function createRule(tmpRules, token, name) {
+                    var bnf = token.children.filter(function(x) {
+                        return x.type == "SequenceOrDifference";
+                    }).map(function(s) {
+                        return getSubItems(tmpRules, s, name);
+                    });
+                    var rule = {
+                        name: name,
+                        bnf: bnf
+                    };
+                    var recover = null;
+                    bnf.forEach(function(x) {
+                        recover = recover || x["recover"];
+                        delete x["recover"];
+                    });
+                    if (name.indexOf("%") == 0) rule.fragment = true;
+                    if (recover) rule.recover = recover;
+                    tmpRules.push(rule);
+                }
+                function getRules(source) {
+                    var parser2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : BNF2.defaultParser;
+                    var ast = parser2.getAST(source);
+                    if (!ast) throw new Error("Could not parse " + source);
+                    if (ast.errors && ast.errors.length) {
+                        throw ast.errors[0];
+                    }
+                    var tmpRules = [];
+                    ast.children.filter(function(x) {
+                        return x.type == "Production";
+                    }).map(function(x) {
+                        var name = x.children.filter(function(x2) {
+                            return x2.type == "NCName";
+                        })[0].text;
+                        createRule(tmpRules, x, name);
+                    });
+                    return tmpRules;
+                }
+                BNF2.getRules = getRules;
+                function Transform(source) {
+                    var subParser = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : BNF2.defaultParser;
+                    return getRules(source.join(""), subParser);
+                }
+                BNF2.Transform = Transform;
+                var Parser2 = /*#__PURE__*/ function(_Parser_1_Parser) {
+                    _inherits(Parser2, _Parser_1_Parser);
+                    var _super = _create_super(Parser2);
+                    function Parser2(source, options) {
+                        _class_call_check(this, Parser2);
+                        var subParser = options && options.debugRulesParser === true ? new Parser_1.Parser(BNF2.RULES, {
+                            debug: true
+                        }) : BNF2.defaultParser;
+                        return _super.call(this, getRules(source, subParser), options);
+                    }
+                    _create_class(Parser2, [
+                        {
+                            key: "emitSource",
+                            value: function emitSource() {
+                                return emit(this);
+                            }
+                        }
+                    ]);
+                    return Parser2;
+                }(Parser_1.Parser);
+                BNF2.Parser = Parser2;
+            })(BNF || (BNF = {}));
+            exports.default = BNF;
+        }
+    });
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/Grammars/Custom.js
+    var require_Custom = __commonJS({
+        "../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/Grammars/Custom.js": function(exports) {
+            "use strict";
+            Object.defineProperty(exports, "__esModule", {
+                value: true
+            });
+            var TokenError_1 = require_TokenError();
+            var Parser_1 = require_Parser();
+            var BNF;
+            (function(BNF2) {
+                BNF2.RULES = [
+                    {
+                        name: "Grammar",
+                        bnf: [
+                            [
+                                "RULE_S*",
+                                "Attributes?",
+                                "RULE_S*",
+                                "%Atomic*",
+                                "EOF"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%Atomic",
+                        bnf: [
+                            [
+                                "Production",
+                                "RULE_S*"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "Production",
+                        bnf: [
+                            [
+                                "NCName",
+                                "RULE_S*",
+                                '"::="',
+                                "RULE_WHITESPACE*",
+                                "%Choice",
+                                "RULE_WHITESPACE*",
+                                "Attributes?",
+                                "RULE_EOL+",
+                                "RULE_S*"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "NCName",
+                        bnf: [
+                            [
+                                /[a-zA-Z][a-zA-Z_0-9]*/
+                            ]
+                        ]
+                    },
+                    {
+                        name: "Attributes",
+                        bnf: [
+                            [
+                                '"{"',
+                                "Attribute",
+                                "%Attributes*",
+                                "RULE_S*",
+                                '"}"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%Attributes",
+                        bnf: [
+                            [
+                                "RULE_S*",
+                                '","',
+                                "Attribute"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "Attribute",
+                        bnf: [
+                            [
+                                "RULE_S*",
+                                "NCName",
+                                "RULE_WHITESPACE*",
+                                '"="',
+                                "RULE_WHITESPACE*",
+                                "AttributeValue"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "AttributeValue",
+                        bnf: [
+                            [
+                                "NCName"
+                            ],
+                            [
+                                /[1-9][0-9]*/
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%Choice",
+                        bnf: [
+                            [
+                                "SequenceOrDifference",
+                                "%_Choice_1*"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "%_Choice_1",
+                        bnf: [
+                            [
+                                "RULE_S*",
+                                '"|"',
+                                "RULE_S*",
+                                "SequenceOrDifference"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "SequenceOrDifference",
+                        bnf: [
+                            [
+                                "%Item",
+                                "RULE_WHITESPACE*",
+                                "%_Item_1?"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%_Item_1",
+                        bnf: [
+                            [
+                                "Minus",
+                                "%Item"
+                            ],
+                            [
+                                "%Item*"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "Minus",
+                        bnf: [
+                            [
+                                '"-"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%Item",
+                        bnf: [
+                            [
+                                "RULE_WHITESPACE*",
+                                "PrimaryPreDecoration?",
+                                "%Primary",
+                                "PrimaryDecoration?"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "PrimaryDecoration",
+                        bnf: [
+                            [
+                                '"?"'
+                            ],
+                            [
+                                '"*"'
+                            ],
+                            [
+                                '"+"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "PrimaryPreDecoration",
+                        bnf: [
+                            [
+                                '"&"'
+                            ],
+                            [
+                                '"!"'
+                            ],
+                            [
+                                '"~"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%Primary",
+                        bnf: [
+                            [
+                                "NCName"
+                            ],
+                            [
+                                "StringLiteral"
+                            ],
+                            [
+                                "CharCode"
+                            ],
+                            [
+                                "CharClass"
+                            ],
+                            [
+                                "SubItem"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "SubItem",
+                        bnf: [
+                            [
+                                '"("',
+                                "RULE_S*",
+                                "%Choice",
+                                "RULE_S*",
+                                '")"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "StringLiteral",
+                        bnf: [
+                            [
+                                "'\"'",
+                                /[^"]*/,
+                                "'\"'"
+                            ],
+                            [
+                                '"\'"',
+                                /[^']*/,
+                                '"\'"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "CharCode",
+                        bnf: [
+                            [
+                                '"#x"',
+                                /[0-9a-zA-Z]+/
+                            ]
+                        ]
+                    },
+                    {
+                        name: "CharClass",
+                        bnf: [
+                            [
+                                "'['",
+                                "'^'?",
+                                "%RULE_CharClass_1+",
+                                '"]"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%RULE_CharClass_1",
+                        bnf: [
+                            [
+                                "CharCodeRange"
+                            ],
+                            [
+                                "CharRange"
+                            ],
+                            [
+                                "CharCode"
+                            ],
+                            [
+                                "RULE_Char"
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "RULE_Char",
+                        bnf: [
+                            [
+                                /\x09/
+                            ],
+                            [
+                                /\x0A/
+                            ],
+                            [
+                                /\x0D/
+                            ],
+                            [
+                                /[\x20-\x5c]/
+                            ],
+                            [
+                                /[\x5e-\uD7FF]/
+                            ],
+                            [
+                                /[\uE000-\uFFFD]/
+                            ]
+                        ]
+                    },
+                    {
+                        name: "CharRange",
+                        bnf: [
+                            [
+                                "RULE_Char",
+                                '"-"',
+                                "RULE_Char"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "CharCodeRange",
+                        bnf: [
+                            [
+                                "CharCode",
+                                '"-"',
+                                "CharCode"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "RULE_WHITESPACE",
+                        bnf: [
+                            [
+                                "%RULE_WHITESPACE_CHAR*"
+                            ],
+                            [
+                                "Comment",
+                                "RULE_WHITESPACE*"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "RULE_S",
+                        bnf: [
+                            [
+                                "RULE_WHITESPACE",
+                                "RULE_S*"
+                            ],
+                            [
+                                "RULE_EOL",
+                                "RULE_S*"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%RULE_WHITESPACE_CHAR",
+                        bnf: [
+                            [
+                                /\x09/
+                            ],
+                            [
+                                /\x20/
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "Comment",
+                        bnf: [
+                            [
+                                '"/*"',
+                                "%RULE_Comment_Body*",
+                                '"*/"'
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%RULE_Comment_Body",
+                        bnf: [
+                            [
+                                /[^*]/
+                            ],
+                            [
+                                '"*"+',
+                                /[^/]*/
+                            ]
+                        ],
+                        fragment: true
+                    },
+                    {
+                        name: "RULE_EOL",
+                        bnf: [
+                            [
+                                /\x0D/,
+                                /\x0A/
+                            ],
+                            [
+                                /\x0A/
+                            ],
+                            [
+                                /\x0D/
+                            ]
+                        ]
+                    },
+                    {
+                        name: "Link",
+                        bnf: [
+                            [
+                                "'['",
+                                "Url",
+                                "']'"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "Url",
+                        bnf: [
+                            [
+                                /[^\x5D:/?#]/,
+                                '"://"',
+                                /[^\x5D#]+/,
+                                "%Url1?"
+                            ]
+                        ]
+                    },
+                    {
+                        name: "%Url1",
+                        bnf: [
+                            [
+                                '"#"',
+                                "NCName"
+                            ]
+                        ],
+                        fragment: true
+                    }
+                ];
+                BNF2.defaultParser = new Parser_1.Parser(BNF2.RULES, {
+                    debug: false
+                });
+                var preDecorationRE = /^(!|&)/;
+                var decorationRE = /(\?|\+|\*)$/;
+                var subExpressionRE = /^%/;
+                function getBNFRule(name, parser2) {
+                    if (typeof name == "string") {
+                        var decoration = decorationRE.exec(name);
+                        var preDecoration = preDecorationRE.exec(name);
+                        var preDecorationText = preDecoration ? preDecoration[0] : "";
+                        var decorationText = decoration ? decoration[0] + " " : "";
+                        var subexpression = subExpressionRE.test(name);
+                        if (subexpression) {
+                            var lonely = isLonelyRule(name, parser2);
+                            if (lonely) return preDecorationText + getBNFBody(name, parser2) + decorationText;
+                            return preDecorationText + "(" + getBNFBody(name, parser2) + ")" + decorationText;
+                        }
+                        return name.replace(preDecorationRE, preDecorationText);
+                    } else {
+                        return name.source.replace(/\\(?:x|u)([a-zA-Z0-9]+)/g, "#x$1").replace(/\[\\(?:x|u)([a-zA-Z0-9]+)-\\(?:x|u)([a-zA-Z0-9]+)\]/g, "[#x$1-#x$2]");
+                    }
+                }
+                function isLonelyRule(name, parser2) {
+                    var rule = Parser_1.findRuleByName(name, parser2);
+                    return rule && rule.bnf.length == 1 && rule.bnf[0].length == 1 && (_instanceof(rule.bnf[0][0], RegExp) || rule.bnf[0][0][0] == '"' || rule.bnf[0][0][0] == "'");
+                }
+                function getBNFChoice(rules, parser2) {
+                    return rules.map(function(x) {
+                        return getBNFRule(x, parser2);
+                    }).join(" ");
+                }
+                function getBNFBody(name, parser2) {
+                    var rule = Parser_1.findRuleByName(name, parser2);
+                    if (rule) return rule.bnf.map(function(x) {
+                        return getBNFChoice(x, parser2);
+                    }).join(" | ");
+                    return "RULE_NOT_FOUND {" + name + "}";
+                }
+                function emit(parser2) {
+                    var acumulator = [];
+                    parser2.grammarRules.forEach(function(l) {
+                        if (!/^%/.test(l.name)) {
+                            var recover = l.recover ? " { recoverUntil=" + l.recover + " }" : "";
+                            acumulator.push(l.name + " ::= " + getBNFBody(l.name, parser2) + recover);
+                        }
+                    });
+                    return acumulator.join("\n");
+                }
+                BNF2.emit = emit;
+                var subitems = 0;
+                function restar(total, resta) {
+                    console.log("reberia restar " + resta + " a " + total);
+                    throw new Error("Difference not supported yet");
+                }
+                function convertRegex(txt) {
+                    return new RegExp(txt.replace(/#x([a-zA-Z0-9]{4})/g, "\\u$1").replace(/#x([a-zA-Z0-9]{3})/g, "\\u0$1").replace(/#x([a-zA-Z0-9]{2})/g, "\\x$1").replace(/#x([a-zA-Z0-9]{1})/g, "\\x0$1"));
+                }
+                function getSubItems(tmpRules, seq, parentName, parentAttributes) {
+                    var anterior = null;
+                    var bnfSeq = [];
+                    seq.children.forEach(function(x, i) {
+                        if (x.type == "Minus") {
+                            restar(anterior, x);
+                        } else {}
+                        var decoration = seq.children[i + 1];
+                        decoration = decoration && decoration.type == "PrimaryDecoration" && decoration.text || "";
+                        var preDecoration = "";
+                        if (anterior && anterior.type == "PrimaryPreDecoration") {
+                            preDecoration = anterior.text;
+                        }
+                        var pinned = preDecoration == "~" ? 1 : void 0;
+                        if (pinned) {
+                            preDecoration = "";
+                        }
+                        switch(x.type){
+                            case "SubItem":
+                                var name = "%" + (parentName + subitems++);
+                                createRule(tmpRules, x, name, parentAttributes);
+                                bnfSeq.push(preDecoration + name + decoration);
+                                break;
+                            case "NCName":
+                                bnfSeq.push(preDecoration + x.text + decoration);
+                                break;
+                            case "StringLiteral":
+                                if (decoration || preDecoration || !/^['"/()a-zA-Z0-9&_.:=,+*\-\^\\]+$/.test(x.text)) {
+                                    bnfSeq.push(preDecoration + x.text + decoration);
+                                } else {
+                                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                    try {
+                                        for(var _iterator = x.text.slice(1, -1)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                            var c = _step.value;
+                                            if (parentAttributes && parentAttributes["ignoreCase"] == "true" && /[a-zA-Z]/.test(c)) {
+                                                bnfSeq.push(new RegExp("[" + c.toUpperCase() + c.toLowerCase() + "]"));
+                                            } else {
+                                                bnfSeq.push(new RegExp(Parser_1.escapeRegExp(c)));
+                                            }
+                                        }
+                                    } catch (err) {
+                                        _didIteratorError = true;
+                                        _iteratorError = err;
+                                    } finally{
+                                        try {
+                                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                _iterator.return();
+                                            }
+                                        } finally{
+                                            if (_didIteratorError) {
+                                                throw _iteratorError;
+                                            }
+                                        }
+                                    }
+                                }
+                                break;
+                            case "CharCode":
+                            case "CharClass":
+                                if (decoration || preDecoration) {
+                                    var newRule = {
+                                        name: "%" + (parentName + subitems++),
+                                        bnf: [
+                                            [
+                                                convertRegex(x.text)
+                                            ]
+                                        ],
+                                        pinned: pinned
+                                    };
+                                    tmpRules.push(newRule);
+                                    bnfSeq.push(preDecoration + newRule.name + decoration);
+                                } else {
+                                    bnfSeq.push(convertRegex(x.text));
+                                }
+                                break;
+                            case "PrimaryPreDecoration":
+                            case "PrimaryDecoration":
+                                break;
+                            default:
+                                throw new Error(" HOW SHOULD I PARSE THIS? " + x.type + " -> " + JSON.stringify(x.text));
+                        }
+                        anterior = x;
+                    });
+                    return bnfSeq;
+                }
+                function createRule(tmpRules, token, name) {
+                    var parentAttributes = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : void 0;
+                    var attrNode = token.children.filter(function(x) {
+                        return x.type == "Attributes";
+                    })[0];
+                    var attributes = {};
+                    if (attrNode) {
+                        attrNode.children.forEach(function(x) {
+                            var name2 = x.children.filter(function(x2) {
+                                return x2.type == "NCName";
+                            })[0].text;
+                            if (name2 in attributes) {
+                                throw new TokenError_1.TokenError("Duplicated attribute " + name2, x);
+                            } else {
+                                attributes[name2] = x.children.filter(function(x2) {
+                                    return x2.type == "AttributeValue";
+                                })[0].text;
+                            }
+                        });
+                    }
+                    var bnf = token.children.filter(function(x) {
+                        return x.type == "SequenceOrDifference";
+                    }).map(function(s) {
+                        return getSubItems(tmpRules, s, name, parentAttributes ? parentAttributes : attributes);
+                    });
+                    var rule = {
+                        name: name,
+                        bnf: bnf
+                    };
+                    if (name.indexOf("%") == 0) rule.fragment = true;
+                    if (attributes["recoverUntil"]) {
+                        rule.recover = attributes["recoverUntil"];
+                        if (rule.bnf.length > 1) throw new TokenError_1.TokenError("only one-option productions are suitable for error recovering", token);
+                    }
+                    if ("pin" in attributes) {
+                        var num = parseInt(attributes["pin"]);
+                        if (!isNaN(num)) {
+                            rule.pinned = num;
+                        }
+                        if (rule.bnf.length > 1) throw new TokenError_1.TokenError("only one-option productions are suitable for pinning", token);
+                    }
+                    if ("ws" in attributes) {
+                        rule.implicitWs = attributes["ws"] != "explicit";
+                    } else {
+                        rule.implicitWs = null;
+                    }
+                    rule.fragment = rule.fragment || attributes["fragment"] == "true";
+                    rule.simplifyWhenOneChildren = attributes["simplifyWhenOneChildren"] == "true";
+                    tmpRules.push(rule);
+                }
+                function getRules(source) {
+                    var parser2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : BNF2.defaultParser;
+                    var ast = parser2.getAST(source);
+                    if (!ast) throw new Error("Could not parse " + source);
+                    if (ast.errors && ast.errors.length) {
+                        throw ast.errors[0];
+                    }
+                    var implicitWs = null;
+                    var attrNode = ast.children.filter(function(x) {
+                        return x.type == "Attributes";
+                    })[0];
+                    var attributes = {};
+                    if (attrNode) {
+                        attrNode.children.forEach(function(x) {
+                            var name = x.children.filter(function(x2) {
+                                return x2.type == "NCName";
+                            })[0].text;
+                            if (name in attributes) {
+                                throw new TokenError_1.TokenError("Duplicated attribute " + name, x);
+                            } else {
+                                attributes[name] = x.children.filter(function(x2) {
+                                    return x2.type == "AttributeValue";
+                                })[0].text;
+                            }
+                        });
+                    }
+                    implicitWs = attributes["ws"] == "implicit";
+                    var tmpRules = [];
+                    ast.children.filter(function(x) {
+                        return x.type == "Production";
+                    }).map(function(x) {
+                        var name = x.children.filter(function(x2) {
+                            return x2.type == "NCName";
+                        })[0].text;
+                        createRule(tmpRules, x, name);
+                    });
+                    tmpRules.forEach(function(rule) {
+                        if (rule.implicitWs === null) rule.implicitWs = implicitWs;
+                    });
+                    return tmpRules;
+                }
+                BNF2.getRules = getRules;
+                function Transform(source) {
+                    var subParser = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : BNF2.defaultParser;
+                    return getRules(source.join(""), subParser);
+                }
+                BNF2.Transform = Transform;
+                var Parser2 = /*#__PURE__*/ function(_Parser_1_Parser) {
+                    _inherits(Parser2, _Parser_1_Parser);
+                    var _super = _create_super(Parser2);
+                    function Parser2(source, options) {
+                        _class_call_check(this, Parser2);
+                        var subParser = options && options.debugRulesParser === true ? new Parser_1.Parser(BNF2.RULES, {
+                            debug: true
+                        }) : BNF2.defaultParser;
+                        return _super.call(this, getRules(source, subParser), options);
+                    }
+                    _create_class(Parser2, [
+                        {
+                            key: "emitSource",
+                            value: function emitSource() {
+                                return emit(this);
+                            }
+                        }
+                    ]);
+                    return Parser2;
+                }(Parser_1.Parser);
+                BNF2.Parser = Parser2;
+            })(BNF || (BNF = {}));
+            exports.default = BNF;
+        }
+    });
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/Grammars/index.js
+    var require_Grammars = __commonJS({
+        "../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/Grammars/index.js": function(exports) {
+            "use strict";
+            Object.defineProperty(exports, "__esModule", {
+                value: true
+            });
+            var BNF_1 = require_BNF();
+            Object.defineProperty(exports, "BNF", {
+                enumerable: true,
+                get: function get() {
+                    return BNF_1.default;
+                }
+            });
+            var W3CEBNF_1 = require_W3CEBNF();
+            Object.defineProperty(exports, "W3C", {
+                enumerable: true,
+                get: function get() {
+                    return W3CEBNF_1.default;
+                }
+            });
+            var Custom_1 = require_Custom();
+            Object.defineProperty(exports, "Custom", {
+                enumerable: true,
+                get: function get() {
+                    return Custom_1.default;
+                }
+            });
+        }
+    });
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/index.js
+    var require_dist = __commonJS({
+        "../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/ebnf@1.9.1/node_modules/ebnf/dist/index.js": function(exports) {
+            "use strict";
+            Object.defineProperty(exports, "__esModule", {
+                value: true
+            });
+            var Parser_1 = require_Parser();
+            Object.defineProperty(exports, "Parser", {
+                enumerable: true,
+                get: function get() {
+                    return Parser_1.Parser;
+                }
+            });
+            var TokenError_1 = require_TokenError();
+            Object.defineProperty(exports, "TokenError", {
+                enumerable: true,
+                get: function get() {
+                    return TokenError_1.TokenError;
+                }
+            });
+            exports.Grammars = require_Grammars();
+        }
+    });
     // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/timm@1.7.1/node_modules/timm/lib/timm.js
     var require_timm = __commonJS({
         "../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/timm@1.7.1/node_modules/timm/lib/timm.js": function(exports) {
@@ -1714,14 +5296,14 @@ var AsyncNodePlugin = function() {
                 result[idx] = newItem;
                 return result;
             }
-            function getIn(obj, path) {
-                if (!Array.isArray(path)) {
+            function getIn(obj, path2) {
+                if (!Array.isArray(path2)) {
                     throwStr(IS_DEV ? "A path array should be provided when calling getIn()" : INVALID_ARGS);
                 }
                 if (obj == null) return void 0;
                 var ptr = obj;
-                for(var i = 0; i < path.length; i++){
-                    var key = path[i];
+                for(var i = 0; i < path2.length; i++){
+                    var key = path2[i];
                     ptr = ptr != null ? ptr[key] : void 0;
                     if (ptr === void 0) return ptr;
                 }
@@ -1735,18 +5317,18 @@ var AsyncNodePlugin = function() {
                 obj2[key] = val;
                 return obj2;
             }
-            function setIn8(obj, path, val) {
-                if (!path.length) return val;
-                return doSetIn(obj, path, val, 0);
+            function setIn8(obj, path2, val) {
+                if (!path2.length) return val;
+                return doSetIn(obj, path2, val, 0);
             }
-            function doSetIn(obj, path, val, idx) {
+            function doSetIn(obj, path2, val, idx) {
                 var newValue;
-                var key = path[idx];
-                if (idx === path.length - 1) {
+                var key = path2[idx];
+                if (idx === path2.length - 1) {
                     newValue = val;
                 } else {
-                    var nestedObj = isObject(obj) && isObject(obj[key]) ? obj[key] : typeof path[idx + 1] === "number" ? [] : {};
-                    newValue = doSetIn(nestedObj, path, val, idx + 1);
+                    var nestedObj = isObject(obj) && isObject(obj[key]) ? obj[key] : typeof path2[idx + 1] === "number" ? [] : {};
+                    newValue = doSetIn(nestedObj, path2, val, idx + 1);
                 }
                 return set2(obj, key, newValue);
             }
@@ -1755,10 +5337,10 @@ var AsyncNodePlugin = function() {
                 var nextVal = fnUpdate(prevVal);
                 return set2(obj, key, nextVal);
             }
-            function updateIn(obj, path, fnUpdate) {
-                var prevVal = getIn(obj, path);
+            function updateIn(obj, path2, fnUpdate) {
+                var prevVal = getIn(obj, path2);
                 var nextVal = fnUpdate(prevVal);
-                return setIn8(obj, path, nextVal);
+                return setIn8(obj, path2, nextVal);
             }
             function merge(a, b, c, d, e, f) {
                 for(var _len = arguments.length, rest = new Array(_len > 6 ? _len - 6 : 0), _key = 6; _key < _len; _key++){
@@ -1794,11 +5376,11 @@ var AsyncNodePlugin = function() {
                     f
                 ].concat(_to_consumable_array(rest))) : doMerge(false, true, a, b, c, d, e, f);
             }
-            function mergeIn(a, path, b, c, d, e, f) {
+            function mergeIn(a, path2, b, c, d, e, f) {
                 for(var _len = arguments.length, rest = new Array(_len > 7 ? _len - 7 : 0), _key = 7; _key < _len; _key++){
                     rest[_key - 7] = arguments[_key];
                 }
-                var prevVal = getIn(a, path);
+                var prevVal = getIn(a, path2);
                 if (prevVal == null) prevVal = {};
                 var nextVal;
                 if (rest.length) {
@@ -1817,7 +5399,7 @@ var AsyncNodePlugin = function() {
                 } else {
                     nextVal = doMerge(false, false, prevVal, b, c, d, e, f);
                 }
-                return setIn8(a, path, nextVal);
+                return setIn8(a, path2, nextVal);
             }
             function omit5(obj, attrs) {
                 var omitList = Array.isArray(attrs) ? attrs : [
@@ -2383,6 +5965,9 @@ var AsyncNodePlugin = function() {
     }(Hook);
     // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/@player-ui+player@0.0.0/node_modules/@player-ui/player/dist/index.mjs
     var import_ts_nested_error = __toESM(require_nested_error(), 1);
+    var import_arr_flatten = __toESM(require_arr_flatten(), 1);
+    var import_parsimmon = __toESM(require_parsimmon(), 1);
+    var import_ebnf = __toESM(require_dist(), 1);
     var import_ts_nested_error2 = __toESM(require_nested_error(), 1);
     // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/@player-ui+player@0.0.0/node_modules/@player-ui/player/dist/index.mjs
     var import_timm = __toESM(require_timm(), 1);
@@ -2506,20 +6091,20 @@ var AsyncNodePlugin = function() {
     // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/@player-ui+partial-match-registry@0.0.0/node_modules/@player-ui/partial-match-registry/dist/index.mjs
     var import_sorted_array = __toESM(require_sorted_array(), 1);
     function traverseObj(object) {
-        var path = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [], pairs = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : /* @__PURE__ */ new Map();
+        var path2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [], pairs = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : /* @__PURE__ */ new Map();
         var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
         try {
             for(var _iterator = Object.keys(object)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                 var key = _step.value;
                 "";
                 var val = object[key];
-                var nestedPath = _to_consumable_array(path).concat([
+                var nestedPath2 = _to_consumable_array(path2).concat([
                     key
                 ]);
                 if (typeof val === "object") {
-                    traverseObj(val, nestedPath, pairs);
+                    traverseObj(val, nestedPath2, pairs);
                 } else {
-                    pairs.set(nestedPath, val);
+                    pairs.set(nestedPath2, val);
                 }
             }
         } catch (err) {
@@ -2567,12 +6152,12 @@ var AsyncNodePlugin = function() {
             },
             {
                 /** Fetch the best match in the registry */ key: "get",
-                value: function get(query) {
+                value: function get(query2) {
                     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                     try {
                         for(var _iterator = this.store.array[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                             var entry = _step.value;
-                            if (entry.matcher(query)) {
+                            if (entry.matcher(query2)) {
                                 return entry.value;
                             }
                         }
@@ -2646,10 +6231,10 @@ var AsyncNodePlugin = function() {
             value: value
         };
     };
-    var toPath = function(path) {
+    var toPath = function(path2) {
         return {
             name: "PathNode",
-            path: path
+            path: path2
         };
     };
     var toQuery = function(key, value) {
@@ -2668,6 +6253,30 @@ var AsyncNodePlugin = function() {
             value: values
         };
     };
+    var doubleQuote = import_parsimmon.default.string('"');
+    var singleQuote = import_parsimmon.default.string("'");
+    var backTick = import_parsimmon.default.string("`");
+    var identifier = import_parsimmon.default.regex(/[\w\-@]+/).desc("identifier").map(toValue);
+    var path;
+    var futurePath = import_parsimmon.default.lazy(function() {
+        return path;
+    });
+    var nestedPath = futurePath.trim(import_parsimmon.default.optWhitespace).wrap(import_parsimmon.default.string("{{"), import_parsimmon.default.string("}}")).map(toPath);
+    var nestedExpression = import_parsimmon.default.regex(/[^`]*/).wrap(backTick, backTick).map(toExpression);
+    var segment = import_parsimmon.default.alt(identifier, nestedPath, nestedExpression).atLeast(1).map(import_arr_flatten.default).map(toConcatenatedNode);
+    var optionallyQuotedSegment = import_parsimmon.default.alt(import_parsimmon.default.regex(/[^"]*/).wrap(doubleQuote, doubleQuote).map(toValue), import_parsimmon.default.regex(/[^']*/).wrap(singleQuote, singleQuote).map(toValue), segment);
+    var query = import_parsimmon.default.seq(optionallyQuotedSegment, import_parsimmon.default.string("=").times(1, 3).trim(import_parsimmon.default.optWhitespace), optionallyQuotedSegment).map(function(param) {
+        var _param = _sliced_to_array(param, 3), key = _param[0], value = _param[2];
+        return toQuery(key, value);
+    });
+    var brackets = import_parsimmon.default.alt(query, optionallyQuotedSegment).trim(import_parsimmon.default.optWhitespace).wrap(import_parsimmon.default.string("["), import_parsimmon.default.string("]")).many();
+    var segmentAndBrackets = import_parsimmon.default.seqMap(segment, brackets, function(s, bs) {
+        return [
+            s
+        ].concat(_to_consumable_array(bs));
+    });
+    path = import_parsimmon.default.sepBy(segmentAndBrackets, import_parsimmon.default.string(".")).map(import_arr_flatten.default);
+    var parser = new import_ebnf.Grammars.W3C.Parser('\nvalue                      ::= segment_and_bracket (SEGMENT_SEPARATOR segment_and_bracket)*\nsegment                    ::= concatenated | expression | modelRef | identifier  \nconcatenated               ::= (expression | modelRef | identifier)+ \nmodelRef                   ::= OPEN_CURL OPEN_CURL value CLOSE_CURL CLOSE_CURL \nidentifier                 ::= [\\w\\-@]+\nquery                      ::= WHITESPACE* optionally_quoted_segment WHITESPACE* EQUALS EQUALS? EQUALS? WHITESPACE* optionally_quoted_segment WHITESPACE*\nbrackets                   ::= OPEN_BRACKET WHITESPACE* (query | optionally_quoted_segment) WHITESPACE* CLOSE_BRACKET \nsegment_and_bracket        ::= segment brackets*\nquoted_value               ::= [^"\']*\noptionally_quoted_segment  ::= WHITESPACE* SINGLE_QUOTE quoted_value SINGLE_QUOTE WHITESPACE* | WHITESPACE* DOUBLE_QUOTE quoted_value DOUBLE_QUOTE WHITESPACE* | WHITESPACE* segment WHITESPACE*\nexpression_value           ::= [^`]*\nexpression                 ::= BACK_TICK expression_value BACK_TICK\n\nEQUALS                     ::= "="\nSEGMENT_SEPARATOR          ::= "."\nSINGLE_QUOTE               ::= "\'"\nDOUBLE_QUOTE               ::= \'"\'\nWHITESPACE                 ::= " "\nOPEN_CURL                  ::= "{"\nCLOSE_CURL                 ::= "}" \nOPEN_BRACKET               ::= "[" \nCLOSE_BRACKET              ::= "]"\nBACK_TICK                  ::= "`" \n');
     var SEGMENT_SEPARATOR = ".";
     var OPEN_CURL = "{";
     var CLOSE_CURL = "}";
@@ -2697,14 +6306,14 @@ var AsyncNodePlugin = function() {
         charCode === 125;
         return !matches;
     };
-    var parse = function(path) {
+    var parse = function(path2) {
         var index = 1;
-        var ch = path.charAt(0);
+        var ch = path2.charAt(0);
         var next = function(expected) {
             if (expected && ch !== expected) {
                 throw new Error("Expected char: ".concat(expected, " but got: ").concat(ch));
             }
-            ch = path.charAt(index);
+            ch = path2.charAt(index);
             index += 1;
             return ch;
         };
@@ -2713,7 +6322,7 @@ var AsyncNodePlugin = function() {
                 next();
             }
         };
-        var identifier = function() {
+        var identifier2 = function() {
             if (!isIdentifierChar(ch)) {
                 return;
             }
@@ -2759,7 +6368,7 @@ var AsyncNodePlugin = function() {
                 return toValue(value);
             }
         };
-        var nestedPath = function() {
+        var nestedPath2 = function() {
             if (ch === OPEN_CURL) {
                 next(OPEN_CURL);
                 next(OPEN_CURL);
@@ -2770,10 +6379,10 @@ var AsyncNodePlugin = function() {
             }
         };
         var simpleSegment = function() {
-            var _nestedPath, _ref;
-            return (_ref = (_nestedPath = nestedPath()) !== null && _nestedPath !== void 0 ? _nestedPath : expression()) !== null && _ref !== void 0 ? _ref : identifier();
+            var _nestedPath2, _ref;
+            return (_ref = (_nestedPath2 = nestedPath2()) !== null && _nestedPath2 !== void 0 ? _nestedPath2 : expression()) !== null && _ref !== void 0 ? _ref : identifier2();
         };
-        var segment = function() {
+        var segment2 = function() {
             var segments = [];
             var nextSegment = simpleSegment();
             while(nextSegment !== void 0){
@@ -2785,13 +6394,13 @@ var AsyncNodePlugin = function() {
             }
             return toConcatenatedNode(segments);
         };
-        var optionallyQuotedSegment = function() {
+        var optionallyQuotedSegment2 = function() {
             whitespace();
             if (ch === SINGLE_QUOTE || ch === DOUBLE_QUOTE) {
-                var singleQuote = ch === SINGLE_QUOTE;
-                next(singleQuote ? SINGLE_QUOTE : DOUBLE_QUOTE);
+                var singleQuote2 = ch === SINGLE_QUOTE;
+                next(singleQuote2 ? SINGLE_QUOTE : DOUBLE_QUOTE);
                 var id = regex(/[^'"]+/);
-                next(singleQuote ? SINGLE_QUOTE : DOUBLE_QUOTE);
+                next(singleQuote2 ? SINGLE_QUOTE : DOUBLE_QUOTE);
                 return id;
             }
             return simpleSegment();
@@ -2809,12 +6418,12 @@ var AsyncNodePlugin = function() {
             if (ch === OPEN_BRACKET) {
                 next(OPEN_BRACKET);
                 whitespace();
-                var value = optionallyQuotedSegment();
+                var value = optionallyQuotedSegment2();
                 if (value) {
                     whitespace();
                     if (equals()) {
                         whitespace();
-                        var second = optionallyQuotedSegment();
+                        var second = optionallyQuotedSegment2();
                         value = toQuery(value, second);
                         whitespace();
                     }
@@ -2829,7 +6438,7 @@ var AsyncNodePlugin = function() {
         };
         var parseSegmentAndBrackets = function() {
             var parsed = [];
-            var firstSegment = segment();
+            var firstSegment = segment2();
             if (firstSegment) {
                 parsed.push(firstSegment);
                 var bracketSegment = parseBracket();
@@ -2877,12 +6486,12 @@ var AsyncNodePlugin = function() {
             };
             _class_call_check(this, _BindingInstance);
             var split = Array.isArray(raw) ? raw : raw.split(".");
-            this.split = split.map(function(segment) {
-                if (typeof segment === "number") {
-                    return segment;
+            this.split = split.map(function(segment2) {
+                if (typeof segment2 === "number") {
+                    return segment2;
                 }
-                var tryNum = Number(segment);
-                return isNaN(tryNum) ? segment : tryNum;
+                var tryNum = Number(segment2);
+                return isNaN(tryNum) ? segment2 : tryNum;
             });
             Object.freeze(this.split);
             this.joined = this.split.join(".");
@@ -2980,13 +6589,13 @@ var AsyncNodePlugin = function() {
             }
             throw new Error("Unable to resolve value for node: ".concat(node.name));
         }
-        function appendPathSegments(segment) {
-            if (typeof segment === "string" && segment.indexOf(".") > -1) {
-                segment.split(".").forEach(function(i) {
+        function appendPathSegments(segment2) {
+            if (typeof segment2 === "string" && segment2.indexOf(".") > -1) {
+                segment2.split(".").forEach(function(i) {
                     context.path.push(maybeConvertToNum(i));
                 });
             } else {
-                context.path.push(segment);
+                context.path.push(segment2);
             }
         }
         function resolveNode(_node) {
@@ -3064,24 +6673,24 @@ var AsyncNodePlugin = function() {
      * Takes a binding path, parses it, and returns an equivalent, normalized
      * representation of that path.
      */ key: "normalizePath",
-                value: function normalizePath(path, resolveOptions) {
-                    if (!BINDING_BRACKETS_REGEX.test(path) && LAZY_BINDING_REGEX.test(path) && this.hooks.skipOptimization.call(path) !== true) {
+                value: function normalizePath(path2, resolveOptions) {
+                    if (!BINDING_BRACKETS_REGEX.test(path2) && LAZY_BINDING_REGEX.test(path2) && this.hooks.skipOptimization.call(path2) !== true) {
                         return {
-                            path: path.split("."),
+                            path: path2.split("."),
                             updates: void 0
                         };
                     }
-                    var _this_parseCache_path;
-                    var ast = (_this_parseCache_path = this.parseCache[path]) !== null && _this_parseCache_path !== void 0 ? _this_parseCache_path : parse(path);
-                    this.parseCache[path] = ast;
+                    var _this_parseCache_path2;
+                    var ast = (_this_parseCache_path2 = this.parseCache[path2]) !== null && _this_parseCache_path2 !== void 0 ? _this_parseCache_path2 : parse(path2);
+                    this.parseCache[path2] = ast;
                     if (typeof ast !== "object" || !(ast === null || ast === void 0 ? void 0 : ast.status)) {
                         var _ast_error;
-                        throw new TypeError('Cannot normalize path "'.concat(path, '": ').concat((_ast_error = ast === null || ast === void 0 ? void 0 : ast.error) !== null && _ast_error !== void 0 ? _ast_error : "Unknown Error."));
+                        throw new TypeError('Cannot normalize path "'.concat(path2, '": ').concat((_ast_error = ast === null || ast === void 0 ? void 0 : ast.error) !== null && _ast_error !== void 0 ? _ast_error : "Unknown Error."));
                     }
                     try {
                         return resolveBindingAST(ast.path, resolveOptions, this.hooks);
                     } catch (e) {
-                        throw new import_ts_nested_error.NestedError("Cannot resolve binding: ".concat(path), e);
+                        throw new import_ts_nested_error.NestedError("Cannot resolve binding: ".concat(path2), e);
                     }
                 }
             },
@@ -3109,21 +6718,21 @@ var AsyncNodePlugin = function() {
                     var updates = {};
                     var joined = Array.isArray(rawBinding) ? rawBinding.join(".") : String(rawBinding);
                     var normalizeConfig = {
-                        getValue: function(path) {
-                            var normalized2 = _this.normalizePath(path.join("."), normalizeConfig);
+                        getValue: function(path2) {
+                            var normalized2 = _this.normalizePath(path2.join("."), normalizeConfig);
                             return options.get(_this.getBindingForNormalizedResult(normalized2));
                         },
                         evaluate: function(exp) {
                             return options.evaluate(exp);
                         },
-                        convertToPath: function(path) {
-                            if (path === void 0) {
+                        convertToPath: function(path2) {
+                            if (path2 === void 0) {
                                 throw new Error("Attempted to convert undefined value to binding path");
                             }
-                            if (typeof path !== "string" && typeof path !== "number" && typeof path !== "boolean") {
-                                throw new Error("Attempting to convert ".concat(typeof path === "undefined" ? "undefined" : _type_of(path), " to a binding path."));
+                            if (typeof path2 !== "string" && typeof path2 !== "number" && typeof path2 !== "boolean") {
+                                throw new Error("Attempting to convert ".concat(typeof path2 === "undefined" ? "undefined" : _type_of(path2), " to a binding path."));
                             }
-                            var normalized2 = _this.normalizePath(String(path), normalizeConfig);
+                            var normalized2 = _this.normalizePath(String(path2), normalizeConfig);
                             if (normalized2.updates) {
                                 updates = _object_spread({}, updates, normalized2.updates);
                             }
@@ -4024,7 +7633,7 @@ var AsyncNodePlugin = function() {
             this.hooks = {
                 resolveTypeForBinding: new SyncWaterfallHook()
             };
-            this.schema = schema ? parse2(schema) : /* @__PURE__ */ new Map();
+            this.schema = schema ? parse4(schema) : /* @__PURE__ */ new Map();
         }
         _create_class(SchemaController, [
             {
@@ -4415,7 +8024,7 @@ var AsyncNodePlugin = function() {
                         }
                     }
                     var parseLocalObject = function(currentValue, objToParse) {
-                        var path = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
+                        var path2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
                         if (typeof objToParse !== "object" || objToParse === null) {
                             return {
                                 value: objToParse,
@@ -4452,7 +8061,7 @@ var AsyncNodePlugin = function() {
                                     return _object_spread_props(_object_spread({}, rest), {
                                         children: _to_consumable_array(children2).concat([
                                             {
-                                                path: _to_consumable_array(path).concat([
+                                                path: _to_consumable_array(path2).concat([
                                                     "asset"
                                                 ]),
                                                 value: assetAST
@@ -4477,7 +8086,7 @@ var AsyncNodePlugin = function() {
                                     }
                                     if (templateAST) {
                                         return {
-                                            path: _to_consumable_array(path).concat([
+                                            path: _to_consumable_array(path2).concat([
                                                 template.output
                                             ]),
                                             value: templateAST
@@ -4498,7 +8107,7 @@ var AsyncNodePlugin = function() {
                                     return _object_spread_props(_object_spread({}, rest), {
                                         children: _to_consumable_array(children2).concat([
                                             {
-                                                path: _to_consumable_array(path).concat([
+                                                path: _to_consumable_array(path2).concat([
                                                     localKey
                                                 ], _to_consumable_array(firstChild.path)),
                                                 value: firstChild.value
@@ -4510,7 +8119,7 @@ var AsyncNodePlugin = function() {
                                     return _object_spread_props(_object_spread({}, rest), {
                                         children: _to_consumable_array(children2).concat([
                                             {
-                                                path: _to_consumable_array(path).concat([
+                                                path: _to_consumable_array(path2).concat([
                                                     localKey
                                                 ]),
                                                 value: localSwitch
@@ -4522,7 +8131,7 @@ var AsyncNodePlugin = function() {
                                 var localAsync = _this.parseAsync(localValue, "value", options);
                                 if (localAsync) {
                                     children2.push({
-                                        path: _to_consumable_array(path).concat([
+                                        path: _to_consumable_array(path2).concat([
                                             localKey
                                         ]),
                                         value: localAsync
@@ -4549,7 +8158,7 @@ var AsyncNodePlugin = function() {
                                         return _object_spread_props(_object_spread({}, rest), {
                                             children: _to_consumable_array(children2).concat([
                                                 {
-                                                    path: _to_consumable_array(path).concat([
+                                                    path: _to_consumable_array(path2).concat([
                                                         localKey
                                                     ]),
                                                     value: multiNode
@@ -4566,7 +8175,7 @@ var AsyncNodePlugin = function() {
                                         return _object_spread_props(_object_spread({}, rest), {
                                             children: _to_consumable_array(children2).concat([
                                                 {
-                                                    path: _to_consumable_array(path).concat([
+                                                    path: _to_consumable_array(path2).concat([
                                                         localKey
                                                     ]),
                                                     value: parsedNode
@@ -4575,7 +8184,7 @@ var AsyncNodePlugin = function() {
                                         });
                                     }
                                 } else {
-                                    var result = parseLocalObject(accumulation.value, localValue, _to_consumable_array(path).concat([
+                                    var result = parseLocalObject(accumulation.value, localValue, _to_consumable_array(path2).concat([
                                         localKey
                                     ]));
                                     return {
@@ -4584,7 +8193,7 @@ var AsyncNodePlugin = function() {
                                     };
                                 }
                             } else {
-                                var value2 = (0, import_timm5.setIn)(accumulation.value, _to_consumable_array(path).concat([
+                                var value2 = (0, import_timm5.setIn)(accumulation.value, _to_consumable_array(path2).concat([
                                     localKey
                                 ]), localValue);
                                 return {
@@ -4889,17 +8498,17 @@ var AsyncNodePlugin = function() {
         return Resolver;
     }();
     var CrossfieldProvider = /*#__PURE__*/ function() {
-        function CrossfieldProvider(initialView, parser, logger) {
+        function CrossfieldProvider(initialView, parser2, logger) {
             _class_call_check(this, CrossfieldProvider);
             this.allValidations = /* @__PURE__ */ new Set();
             this.byBinding = /* @__PURE__ */ new Map();
             this.logger = logger;
-            this.parse(initialView, parser);
+            this.parse(initialView, parser2);
         }
         _create_class(CrossfieldProvider, [
             {
                 key: "parse",
-                value: function parse(contentView, parser) {
+                value: function parse(contentView, parser2) {
                     var _this = this;
                     var xfieldRefs = contentView.validation;
                     if (xfieldRefs === void 0) {
@@ -4918,7 +8527,7 @@ var AsyncNodePlugin = function() {
                         _this.allValidations.add(withDefaults);
                         var ref = vRef.ref;
                         if (ref) {
-                            var parsed = parser(ref);
+                            var parsed = parser2(ref);
                             if (_this.byBinding.has(parsed)) {
                                 var _this_byBinding_get;
                                 (_this_byBinding_get = _this.byBinding.get(parsed)) === null || _this_byBinding_get === void 0 ? void 0 : _this_byBinding_get.push(withDefaults);
@@ -4979,11 +8588,11 @@ var AsyncNodePlugin = function() {
                             var _this_resolverOptions_logger;
                             (_this_resolverOptions_logger = this.resolverOptions.logger) === null || _this_resolverOptions_logger === void 0 ? void 0 : _this_resolverOptions_logger.warn("templatePlugin not set for View, legacy templates may not work");
                         }
-                        var parser = new Parser();
-                        this.hooks.parser.call(parser);
-                        this.rootNode = parser.parseView(this.initialView);
+                        var parser2 = new Parser();
+                        this.hooks.parser.call(parser2);
+                        this.rootNode = parser2.parseView(this.initialView);
                         this.resolver = new Resolver(this.rootNode, _object_spread_props(_object_spread({}, this.resolverOptions), {
-                            parseNode: parser.parseObject.bind(parser)
+                            parseNode: parser2.parseObject.bind(parser2)
                         }));
                         this.hooks.resolver.call(this.resolver);
                     }
@@ -5081,23 +8690,23 @@ var AsyncNodePlugin = function() {
             },
             {
                 key: "applyParser",
-                value: function applyParser(parser) {
+                value: function applyParser(parser2) {
                     var _this = this;
-                    parser.hooks.onCreateASTNode.tap("template", function(node) {
+                    parser2.hooks.onCreateASTNode.tap("template", function(node) {
                         if (node && node.type === "template" && !node.dynamic) {
-                            return _this.parseTemplate(parser.parseObject.bind(parser), node, _this.options);
+                            return _this.parseTemplate(parser2.parseObject.bind(parser2), node, _this.options);
                         }
                         return node;
                     });
-                    parser.hooks.determineNodeType.tap("template", function(obj) {
+                    parser2.hooks.determineNodeType.tap("template", function(obj) {
                         if (obj === "template") {
                             return "template";
                         }
                     });
-                    parser.hooks.parseNode.tap("template", function(obj, _nodeType, options, determinedNodeType) {
+                    parser2.hooks.parseNode.tap("template", function(obj, _nodeType, options, determinedNodeType) {
                         if (determinedNodeType === "template") {
                             var _options_templateDepth, _obj_dynamic;
-                            var templateNode = parser.createASTNode({
+                            var templateNode = parser2.createASTNode({
                                 type: "template",
                                 depth: (_options_templateDepth = options.templateDepth) !== null && _options_templateDepth !== void 0 ? _options_templateDepth : 0,
                                 data: obj.data,
@@ -5225,8 +8834,8 @@ var AsyncNodePlugin = function() {
                                 ]);
                             }
                             var nodePath = findBasePath(node, resolver);
-                            if (nodePath.length > 0 && nodePath.some(function(segment) {
-                                return propsToSkip.has(segment.toString());
+                            if (nodePath.length > 0 && nodePath.some(function(segment2) {
+                                return propsToSkip.has(segment2.toString());
                             })) {
                                 return node.value;
                             }
@@ -5268,17 +8877,17 @@ var AsyncNodePlugin = function() {
             },
             {
                 key: "applyParser",
-                value: function applyParser(parser) {
-                    parser.hooks.determineNodeType.tap("applicability", function(obj) {
+                value: function applyParser(parser2) {
+                    parser2.hooks.determineNodeType.tap("applicability", function(obj) {
                         if (Object.prototype.hasOwnProperty.call(obj, "applicability")) {
                             return "applicability";
                         }
                     });
-                    parser.hooks.parseNode.tap("applicability", function(obj, nodeType, options, determinedNodeType) {
+                    parser2.hooks.parseNode.tap("applicability", function(obj, nodeType, options, determinedNodeType) {
                         if (determinedNodeType === "applicability") {
-                            var parsedApplicability = parser.parseObject((0, import_timm7.omit)(obj, "applicability"), nodeType, options);
+                            var parsedApplicability = parser2.parseObject((0, import_timm7.omit)(obj, "applicability"), nodeType, options);
                             if (parsedApplicability !== null) {
-                                var applicabilityNode = parser.createASTNode({
+                                var applicabilityNode = parser2.createASTNode({
                                     type: "applicability",
                                     expression: obj.applicability,
                                     value: parsedApplicability
@@ -5339,20 +8948,20 @@ var AsyncNodePlugin = function() {
             },
             {
                 key: "applyParser",
-                value: function applyParser(parser) {
+                value: function applyParser(parser2) {
                     var _this = this;
-                    parser.hooks.onCreateASTNode.tap("switch", function(node) {
+                    parser2.hooks.onCreateASTNode.tap("switch", function(node) {
                         if (node && node.type === "switch" && !node.dynamic) {
                             return _this.resolveSwitch(node, _this.options);
                         }
                         return node;
                     });
-                    parser.hooks.determineNodeType.tap("switch", function(obj) {
+                    parser2.hooks.determineNodeType.tap("switch", function(obj) {
                         if (Object.prototype.hasOwnProperty.call(obj, "dynamicSwitch") || Object.prototype.hasOwnProperty.call(obj, "staticSwitch")) {
                             return "switch";
                         }
                     });
-                    parser.hooks.parseNode.tap("switch", function(obj, _nodeType, options, determinedNodeType) {
+                    parser2.hooks.parseNode.tap("switch", function(obj, _nodeType, options, determinedNodeType) {
                         if (determinedNodeType === "switch") {
                             var dynamic = "dynamicSwitch" in obj;
                             var switchContent = "dynamicSwitch" in obj ? obj.dynamicSwitch : obj.staticSwitch;
@@ -5361,7 +8970,7 @@ var AsyncNodePlugin = function() {
                                 var switchCaseExpr = switchCase.case, switchBody = _object_without_properties(switchCase, [
                                     "case"
                                 ]);
-                                var value = parser.parseObject(switchBody, "value", options);
+                                var value = parser2.parseObject(switchBody, "value", options);
                                 if (value) {
                                     cases.push({
                                         case: switchCaseExpr,
@@ -5369,7 +8978,7 @@ var AsyncNodePlugin = function() {
                                     });
                                 }
                             });
-                            var switchAST = parser.hooks.onCreateASTNode.call({
+                            var switchAST = parser2.hooks.onCreateASTNode.call({
                                 type: "switch",
                                 dynamic: dynamic,
                                 cases: cases
@@ -6390,11 +9999,11 @@ var AsyncNodePlugin = function() {
             },
             {
                 key: "forView",
-                value: function forView(parser) {
+                value: function forView(parser2) {
                     var _this = this;
                     return {
                         _getValidationForBinding: function(binding) {
-                            return _this.getValidationForBinding(isBinding(binding) ? binding : parser(binding));
+                            return _this.getValidationForBinding(isBinding(binding) ? binding : parser2(binding));
                         },
                         getAll: function() {
                             var bindings = _this.getBindings();
@@ -6430,7 +10039,7 @@ var AsyncNodePlugin = function() {
                             throw new Error("Section functionality should be provided by the view plugin");
                         },
                         type: function(binding) {
-                            return _this.schema.getType(isBinding(binding) ? binding : parser(binding));
+                            return _this.schema.getType(isBinding(binding) ? binding : parser2(binding));
                         }
                     };
                 }
@@ -6930,11 +10539,11 @@ var AsyncNodePlugin = function() {
         ]);
         return DataController;
     }();
-    function flatten(obj) {
+    function flatten2(obj) {
         var roots = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [], sep = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : ".";
         return Object.keys(obj).reduce(function(memo, prop) {
             return _object_spread({}, memo, Object.prototype.toString.call(obj[prop]) === "[object Object]" ? // keep working if value is an object
-            flatten(obj[prop], roots.concat([
+            flatten2(obj[prop], roots.concat([
                 prop
             ])) : _define_property({}, roots.concat([
                 prop
@@ -6963,9 +10572,9 @@ var AsyncNodePlugin = function() {
                 key: "getConstants",
                 value: function getConstants(key, namespace, fallback) {
                     var _this_tempStore_get, _this_store_get;
-                    var path = new BindingInstance(key);
+                    var path2 = new BindingInstance(key);
                     var _this_tempStore_get_get, _ref;
-                    return (_ref = (_this_tempStore_get_get = (_this_tempStore_get = this.tempStore.get(namespace)) === null || _this_tempStore_get === void 0 ? void 0 : _this_tempStore_get.get(path)) !== null && _this_tempStore_get_get !== void 0 ? _this_tempStore_get_get : (_this_store_get = this.store.get(namespace)) === null || _this_store_get === void 0 ? void 0 : _this_store_get.get(path)) !== null && _ref !== void 0 ? _ref : fallback;
+                    return (_ref = (_this_tempStore_get_get = (_this_tempStore_get = this.tempStore.get(namespace)) === null || _this_tempStore_get === void 0 ? void 0 : _this_tempStore_get.get(path2)) !== null && _this_tempStore_get_get !== void 0 ? _this_tempStore_get_get : (_this_store_get = this.store.get(namespace)) === null || _this_store_get === void 0 ? void 0 : _this_store_get.get(path2)) !== null && _ref !== void 0 ? _ref : fallback;
                 }
             },
             {
@@ -7564,18 +11173,18 @@ var AsyncNodePlugin = function() {
             },
             {
                 key: "applyParser",
-                value: function applyParser(parser) {
-                    parser.hooks.determineNodeType.tap(this.name, function(obj) {
+                value: function applyParser(parser2) {
+                    parser2.hooks.determineNodeType.tap(this.name, function(obj) {
                         if (Object.prototype.hasOwnProperty.call(obj, "async")) {
                             return NodeType.Async;
                         }
                     });
-                    parser.hooks.parseNode.tap(this.name, function(obj, nodeType, options, determinedNodeType) {
+                    parser2.hooks.parseNode.tap(this.name, function(obj, nodeType, options, determinedNodeType) {
                         if (determinedNodeType === NodeType.Async) {
-                            var parsedAsync = parser.parseObject((0, import_timm10.omit)(obj, "async"), nodeType, options);
+                            var parsedAsync = parser2.parseObject((0, import_timm10.omit)(obj, "async"), nodeType, options);
                             var parsedNodeId = getNodeID(parsedAsync);
                             if (parsedAsync !== null && parsedNodeId) {
-                                return parser.createASTNode({
+                                return parser2.createASTNode({
                                     id: parsedNodeId,
                                     type: NodeType.Async,
                                     value: parsedAsync
@@ -7690,6 +11299,14 @@ var AsyncNodePlugin = function() {
     return __toCommonJS(src_exports);
 }(); /*! Bundled license information:
 
+arr-flatten/index.js:
+  (*!
+   * arr-flatten <https://github.com/jonschlinkert/arr-flatten>
+   *
+   * Copyright (c) 2014-2017, Jon Schlinkert.
+   * Released under the MIT License.
+   *)
+
 timm/lib/timm.js:
   (*!
    * Timm